drivers/isdn/hardware/eicon/message.c

   1 /*
   2  *
   3   Copyright (c) Eicon Networks, 2002.
   4  *
   5   This source file is supplied for the use with
   6   Eicon Networks range of DIVA Server Adapters.
   7  *
   8   Eicon File Revision :    2.1
   9  *
  10   This program is free software; you can redistribute it and/or modify
  11   it under the terms of the GNU General Public License as published by
  12   the Free Software Foundation; either version 2, or (at your option)
  13   any later version.
  14  *
  15   This program is distributed in the hope that it will be useful,
  16   but WITHOUT ANY WARRANTY OF ANY KIND WHATSOEVER INCLUDING ANY
  17   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  18   See the GNU General Public License for more details.
  19  *
  20   You should have received a copy of the GNU General Public License
  21   along with this program; if not, write to the Free Software
  22   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  *
  24  */
  25
  26
  27
  28
  29
  30 #include "platform.h"
  31 #include "di_defs.h"
  32 #include "pc.h"
  33 #include "capi20.h"
  34 #include "divacapi.h"
  35 #include "mdm_msg.h"
  36 #include "divasync.h"
  37
  38
  39
  40 #define FILE_ "MESSAGE.C"
  41 #define dprintf
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51 /*------------------------------------------------------------------*/
  52 /* This is options supported for all adapters that are server by    */
  53 /* XDI driver. Allo it is not necessary to ask it from every adapter*/
  54 /* and it is not necessary to save it separate for every adapter    */
  55 /* Macrose defined here have only local meaning                     */
  56 /*------------------------------------------------------------------*/
  57 static dword diva_xdi_extended_features = 0;
  58
  59 #define DIVA_CAPI_USE_CMA                 0x00000001
  60 #define DIVA_CAPI_XDI_PROVIDES_SDRAM_BAR  0x00000002
  61 #define DIVA_CAPI_XDI_PROVIDES_NO_CANCEL  0x00000004
  62 #define DIVA_CAPI_XDI_PROVIDES_RX_DMA     0x00000008
  63
  64 /*
  65   CAPI can request to process all return codes self only if:
  66   protocol code supports this && xdi supports this
  67  */
  68 #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))
  69
  70 /*------------------------------------------------------------------*/
  71 /* local function prototypes                                        */
  72 /*------------------------------------------------------------------*/
  73
  74 static void group_optimization(DIVA_CAPI_ADAPTER   * a, PLCI   * plci);
  75 static void set_group_ind_mask (PLCI   *plci);
  76 static void clear_group_ind_mask_bit (PLCI   *plci, word b);
  77 static byte test_group_ind_mask_bit (PLCI   *plci, word b);
  78 void AutomaticLaw(DIVA_CAPI_ADAPTER   *);
  79 word CapiRelease(word);
  80 word CapiRegister(word);
  81 word api_put(APPL   *, CAPI_MSG   *);
  82 static word api_parse(byte   *, word, byte *, API_PARSE *);
  83 static void api_save_msg(API_PARSE   *in, byte *format, API_SAVE   *out);
  84 static void api_load_msg(API_SAVE   *in, API_PARSE   *out);
  85
  86 word api_remove_start(void);
  87 void api_remove_complete(void);
  88
  89 static void plci_remove(PLCI   *);
  90 static void diva_get_extended_adapter_features (DIVA_CAPI_ADAPTER  * a);
  91 static void diva_ask_for_xdi_sdram_bar (DIVA_CAPI_ADAPTER  *, IDI_SYNC_REQ  *);
  92
  93 void   callback(ENTITY   *);
  94
  95 static void control_rc(PLCI   *, byte, byte, byte, byte, byte);
  96 static void data_rc(PLCI   *, byte);
  97 static void data_ack(PLCI   *, byte);
  98 static void sig_ind(PLCI   *);
  99 static void SendInfo(PLCI   *, dword, byte   * *, byte);
 100 static void SendSetupInfo(APPL   *, PLCI   *, dword, byte   * *, byte);
 101 static void SendSSExtInd(APPL   *, PLCI   * plci, dword Id, byte   * * parms);
 102
 103 static void VSwitchReqInd(PLCI   *plci, dword Id, byte   **parms);
 104
 105 static void nl_ind(PLCI   *);
 106
 107 static byte connect_req(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 108 static byte connect_res(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 109 static byte connect_a_res(dword,word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 110 static byte disconnect_req(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 111 static byte disconnect_res(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 112 static byte listen_req(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 113 static byte info_req(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 114 static byte info_res(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 115 static byte alert_req(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 116 static byte facility_req(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 117 static byte facility_res(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 118 static byte connect_b3_req(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 119 static byte connect_b3_res(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 120 static byte connect_b3_a_res(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 121 static byte disconnect_b3_req(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 122 static byte disconnect_b3_res(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 123 static byte data_b3_req(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 124 static byte data_b3_res(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 125 static byte reset_b3_req(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 126 static byte reset_b3_res(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 127 static byte connect_b3_t90_a_res(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 128 static byte select_b_req(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 129 static byte manufacturer_req(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 130 static byte manufacturer_res(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 131
 132 static word get_plci(DIVA_CAPI_ADAPTER   *);
 133 static void add_p(PLCI   *, byte, byte   *);
 134 static void add_s(PLCI   * plci, byte code, API_PARSE * p);
 135 static void add_ss(PLCI   * plci, byte code, API_PARSE * p);
 136 static void add_ie(PLCI   * plci, byte code, byte   * p, word p_length);
 137 static void add_d(PLCI   *, word, byte   *);
 138 static void add_ai(PLCI   *, API_PARSE *);
 139 static word add_b1(PLCI   *, API_PARSE *, word, word);
 140 static word add_b23(PLCI   *, API_PARSE *);
 141 static word add_modem_b23 (PLCI  * plci, API_PARSE* bp_parms);
 142 static void sig_req(PLCI   *, byte, byte);
 143 static void nl_req_ncci(PLCI   *, byte, byte);
 144 static void send_req(PLCI   *);
 145 static void send_data(PLCI   *);
 146 static word plci_remove_check(PLCI   *);
 147 static void listen_check(DIVA_CAPI_ADAPTER   *);
 148 static byte AddInfo(byte   **, byte   **, byte   *, byte *);
 149 static byte getChannel(API_PARSE *);
 150 static void IndParse(PLCI   *, word *, byte   **, byte);
 151 static byte ie_compare(byte   *, byte *);
 152 static word find_cip(DIVA_CAPI_ADAPTER   *, byte   *, byte   *);
 153 static word CPN_filter_ok(byte   *cpn,DIVA_CAPI_ADAPTER   *,word);
 154
 155 /*
 156   XON protocol helpers
 157   */
 158 static void channel_flow_control_remove (PLCI   * plci);
 159 static void channel_x_off (PLCI   * plci, byte ch, byte flag);
 160 static void channel_x_on (PLCI   * plci, byte ch);
 161 static void channel_request_xon (PLCI   * plci, byte ch);
 162 static void channel_xmit_xon (PLCI   * plci);
 163 static int channel_can_xon (PLCI   * plci, byte ch);
 164 static void channel_xmit_extended_xon (PLCI   * plci);
 165
 166 static byte SendMultiIE(PLCI   * plci, dword Id, byte   * * parms, byte ie_type, dword info_mask, byte setupParse);
 167 static word AdvCodecSupport(DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, byte);
 168 static void CodecIdCheck(DIVA_CAPI_ADAPTER   *, PLCI   *);
 169 static void SetVoiceChannel(PLCI   *, byte   *, DIVA_CAPI_ADAPTER   * );
 170 static void VoiceChannelOff(PLCI   *plci);
 171 static void adv_voice_write_coefs (PLCI   *plci, word write_command);
 172 static void adv_voice_clear_config (PLCI   *plci);
 173
 174 static word get_b1_facilities (PLCI   * plci, byte b1_resource);
 175 static byte add_b1_facilities (PLCI   * plci, byte b1_resource, word b1_facilities);
 176 static void adjust_b1_facilities (PLCI   *plci, byte new_b1_resource, word new_b1_facilities);
 177 static word adjust_b_process (dword Id, PLCI   *plci, byte Rc);
 178 static void adjust_b1_resource (dword Id, PLCI   *plci, API_SAVE   *bp_msg, word b1_facilities, word internal_command);
 179 static void adjust_b_restore (dword Id, PLCI   *plci, byte Rc);
 180 static void reset_b3_command (dword Id, PLCI   *plci, byte Rc);
 181 static void select_b_command (dword Id, PLCI   *plci, byte Rc);
 182 static void fax_connect_ack_command (dword Id, PLCI   *plci, byte Rc);
 183 static void fax_edata_ack_command (dword Id, PLCI   *plci, byte Rc);
 184 static void fax_connect_info_command (dword Id, PLCI   *plci, byte Rc);
 185 static void fax_adjust_b23_command (dword Id, PLCI   *plci, byte Rc);
 186 static void fax_disconnect_command (dword Id, PLCI   *plci, byte Rc);
 187 static void hold_save_command (dword Id, PLCI   *plci, byte Rc);
 188 static void retrieve_restore_command (dword Id, PLCI   *plci, byte Rc);
 189 static void init_b1_config (PLCI   *plci);
 190 static void clear_b1_config (PLCI   *plci);
 191
 192 static void dtmf_command (dword Id, PLCI   *plci, byte Rc);
 193 static byte dtmf_request (dword Id, word Number, DIVA_CAPI_ADAPTER   *a, PLCI   *plci, APPL   *appl, API_PARSE *msg);
 194 static void dtmf_confirmation (dword Id, PLCI   *plci);
 195 static void dtmf_indication (dword Id, PLCI   *plci, byte   *msg, word length);
 196 static void dtmf_parameter_write (PLCI   *plci);
 197
 198
 199 static void mixer_set_bchannel_id_esc (PLCI   *plci, byte bchannel_id);
 200 static void mixer_set_bchannel_id (PLCI   *plci, byte   *chi);
 201 static void mixer_clear_config (PLCI   *plci);
 202 static void mixer_notify_update (PLCI   *plci, byte others);
 203 static void mixer_command (dword Id, PLCI   *plci, byte Rc);
 204 static byte mixer_request (dword Id, word Number, DIVA_CAPI_ADAPTER   *a, PLCI   *plci, APPL   *appl, API_PARSE *msg);
 205 static void mixer_indication_coefs_set (dword Id, PLCI   *plci);
 206 static void mixer_indication_xconnect_from (dword Id, PLCI   *plci, byte   *msg, word length);
 207 static void mixer_indication_xconnect_to (dword Id, PLCI   *plci, byte   *msg, word length);
 208 static void mixer_remove (PLCI   *plci);
 209
 210
 211 static void ec_command (dword Id, PLCI   *plci, byte Rc);
 212 static byte ec_request (dword Id, word Number, DIVA_CAPI_ADAPTER   *a, PLCI   *plci, APPL   *appl, API_PARSE *msg);
 213 static void ec_indication (dword Id, PLCI   *plci, byte   *msg, word length);
 214
 215
 216 static void rtp_connect_b3_req_command (dword Id, PLCI   *plci, byte Rc);
 217 static void rtp_connect_b3_res_command (dword Id, PLCI   *plci, byte Rc);
 218
 219
 220 static int  diva_get_dma_descriptor  (PLCI   *plci, dword   *dma_magic);
 221 static void diva_free_dma_descriptor (PLCI   *plci, int nr);
 222
 223 /*------------------------------------------------------------------*/
 224 /* external function prototypes                                     */
 225 /*------------------------------------------------------------------*/
 226
 227 extern byte MapController (byte);
 228 extern byte UnMapController (byte);
 229 #define MapId(Id) (((Id) & 0xffffff00L) | MapController ((byte)(Id)))
 230 #define UnMapId(Id) (((Id) & 0xffffff00L) | UnMapController ((byte)(Id)))
 231
 232 void   sendf(APPL   *, word, dword, word, byte *, ...);
 233 void   * TransmitBufferSet(APPL   * appl, dword ref);
 234 void   * TransmitBufferGet(APPL   * appl, void   * p);
 235 void TransmitBufferFree(APPL   * appl, void   * p);
 236 void   * ReceiveBufferGet(APPL   * appl, int Num);
 237
 238 int fax_head_line_time (char *buffer);
 239
 240
 241 /*------------------------------------------------------------------*/
 242 /* Global data definitions                                          */
 243 /*------------------------------------------------------------------*/
 244 extern byte max_adapter;
 245 extern byte max_appl;
 246 extern DIVA_CAPI_ADAPTER   * adapter;
 247 extern APPL   * application;
 248
 249
 250
 251
 252
 253
 254
 255 static byte remove_started = false;
 256 static PLCI dummy_plci;
 257
 258
 259 static struct _ftable {
 260   word command;
 261   byte * format;
 262   byte (* function)(dword, word, DIVA_CAPI_ADAPTER   *, PLCI   *, APPL   *, API_PARSE *);
 263 } ftable[] = {
 264   {_DATA_B3_R,                          "dwww",         data_b3_req},
 265   {_DATA_B3_I|RESPONSE,                 "w",            data_b3_res},
 266   {_INFO_R,                             "ss",           info_req},
 267   {_INFO_I|RESPONSE,                    "",             info_res},
 268   {_CONNECT_R,                          "wsssssssss",   connect_req},
 269   {_CONNECT_I|RESPONSE,                 "wsssss",       connect_res},
 270   {_CONNECT_ACTIVE_I|RESPONSE,          "",             connect_a_res},
 271   {_DISCONNECT_R,                       "s",            disconnect_req},
 272   {_DISCONNECT_I|RESPONSE,              "",             disconnect_res},
 273   {_LISTEN_R,                           "dddss",        listen_req},
 274   {_ALERT_R,                            "s",            alert_req},
 275   {_FACILITY_R,                         "ws",           facility_req},
 276   {_FACILITY_I|RESPONSE,                "ws",           facility_res},
 277   {_CONNECT_B3_R,                       "s",            connect_b3_req},
 278   {_CONNECT_B3_I|RESPONSE,              "ws",           connect_b3_res},
 279   {_CONNECT_B3_ACTIVE_I|RESPONSE,       "",             connect_b3_a_res},
 280   {_DISCONNECT_B3_R,                    "s",            disconnect_b3_req},
 281   {_DISCONNECT_B3_I|RESPONSE,           "",             disconnect_b3_res},
 282   {_RESET_B3_R,                         "s",            reset_b3_req},
 283   {_RESET_B3_I|RESPONSE,                "",             reset_b3_res},
 284   {_CONNECT_B3_T90_ACTIVE_I|RESPONSE,   "ws",           connect_b3_t90_a_res},
 285   {_CONNECT_B3_T90_ACTIVE_I|RESPONSE,   "",             connect_b3_t90_a_res},
 286   {_SELECT_B_REQ,                       "s",            select_b_req},
 287   {_MANUFACTURER_R,                     "dws",          manufacturer_req},
 288   {_MANUFACTURER_I|RESPONSE,            "dws",          manufacturer_res},
 289   {_MANUFACTURER_I|RESPONSE,            "",             manufacturer_res}
 290 };
 291
 292 static byte * cip_bc[29][2] = {
 293   { "",                     ""                     }, /* 0 */
 294   { "\x03\x80\x90\xa3",     "\x03\x80\x90\xa2"     }, /* 1 */
 295   { "\x02\x88\x90",         "\x02\x88\x90"         }, /* 2 */
 296   { "\x02\x89\x90",         "\x02\x89\x90"         }, /* 3 */
 297   { "\x03\x90\x90\xa3",     "\x03\x90\x90\xa2"     }, /* 4 */
 298   { "\x03\x91\x90\xa5",     "\x03\x91\x90\xa5"     }, /* 5 */
 299   { "\x02\x98\x90",         "\x02\x98\x90"         }, /* 6 */
 300   { "\x04\x88\xc0\xc6\xe6", "\x04\x88\xc0\xc6\xe6" }, /* 7 */
 301   { "\x04\x88\x90\x21\x8f", "\x04\x88\x90\x21\x8f" }, /* 8 */
 302   { "\x03\x91\x90\xa5",     "\x03\x91\x90\xa5"     }, /* 9 */
 303   { "",                     ""                     }, /* 10 */
 304   { "",                     ""                     }, /* 11 */
 305   { "",                     ""                     }, /* 12 */
 306   { "",                     ""                     }, /* 13 */
 307   { "",                     ""                     }, /* 14 */
 308   { "",                     ""                     }, /* 15 */
 309
 310   { "\x03\x80\x90\xa3",     "\x03\x80\x90\xa2"     }, /* 16 */
 311   { "\x03\x90\x90\xa3",     "\x03\x90\x90\xa2"     }, /* 17 */
 312   { "\x02\x88\x90",         "\x02\x88\x90"         }, /* 18 */
 313   { "\x02\x88\x90",         "\x02\x88\x90"         }, /* 19 */
 314   { "\x02\x88\x90",         "\x02\x88\x90"         }, /* 20 */
 315   { "\x02\x88\x90",         "\x02\x88\x90"         }, /* 21 */
 316   { "\x02\x88\x90",         "\x02\x88\x90"         }, /* 22 */
 317   { "\x02\x88\x90",         "\x02\x88\x90"         }, /* 23 */
 318   { "\x02\x88\x90",         "\x02\x88\x90"         }, /* 24 */
 319   { "\x02\x88\x90",         "\x02\x88\x90"         }, /* 25 */
 320   { "\x03\x91\x90\xa5",     "\x03\x91\x90\xa5"     }, /* 26 */
 321   { "\x03\x91\x90\xa5",     "\x03\x91\x90\xa5"     }, /* 27 */
 322   { "\x02\x88\x90",         "\x02\x88\x90"         }  /* 28 */
 323 };
 324
 325 static byte * cip_hlc[29] = {
 326   "",                           /* 0 */
 327   "",                           /* 1 */
 328   "",                           /* 2 */
 329   "",                           /* 3 */
 330   "",                           /* 4 */
 331   "",                           /* 5 */
 332   "",                           /* 6 */
 333   "",                           /* 7 */
 334   "",                           /* 8 */
 335   "",                           /* 9 */
 336   "",                           /* 10 */
 337   "",                           /* 11 */
 338   "",                           /* 12 */
 339   "",                           /* 13 */
 340   "",                           /* 14 */
 341   "",                           /* 15 */
 342
 343   "\x02\x91\x81",               /* 16 */
 344   "\x02\x91\x84",               /* 17 */
 345   "\x02\x91\xa1",               /* 18 */
 346   "\x02\x91\xa4",               /* 19 */
 347   "\x02\x91\xa8",               /* 20 */
 348   "\x02\x91\xb1",               /* 21 */
 349   "\x02\x91\xb2",               /* 22 */
 350   "\x02\x91\xb5",               /* 23 */
 351   "\x02\x91\xb8",               /* 24 */
 352   "\x02\x91\xc1",               /* 25 */
 353   "\x02\x91\x81",               /* 26 */
 354   "\x03\x91\xe0\x01",           /* 27 */
 355   "\x03\x91\xe0\x02"            /* 28 */
 356 };
 357
 358 /*------------------------------------------------------------------*/
 359
 360 #define V120_HEADER_LENGTH 1
 361 #define V120_HEADER_EXTEND_BIT  0x80
 362 #define V120_HEADER_BREAK_BIT   0x40
 363 #define V120_HEADER_C1_BIT      0x04
 364 #define V120_HEADER_C2_BIT      0x08
 365 #define V120_HEADER_FLUSH_COND  (V120_HEADER_BREAK_BIT | V120_HEADER_C1_BIT | V120_HEADER_C2_BIT)
 366
 367 static byte v120_default_header[] =
 368 {
 369
 370   0x83                          /*  Ext, BR , res, res, C2 , C1 , B  , F   */
 371
 372 };
 373
 374 static byte v120_break_header[] =
 375 {
 376
 377   0xc3 | V120_HEADER_BREAK_BIT  /*  Ext, BR , res, res, C2 , C1 , B  , F   */
 378
 379 };
 380
 381
 382 /*------------------------------------------------------------------*/
 383 /* API_PUT function                                                 */
 384 /*------------------------------------------------------------------*/
 385
 386 word api_put(APPL   * appl, CAPI_MSG   * msg)
 387 {
 388   word i, j, k, l, n;
 389   word ret;
 390   byte c;
 391   byte controller;
 392   DIVA_CAPI_ADAPTER   * a;
 393   PLCI   * plci;
 394   NCCI   * ncci_ptr;
 395   word ncci;
 396   CAPI_MSG   *m;
 397     API_PARSE msg_parms[MAX_MSG_PARMS+1];
 398
 399   if (msg->header.length < sizeof (msg->header) ||
 400       msg->header.length > MAX_MSG_SIZE) {
 401     dbug(1,dprintf("bad len"));
 402     return _BAD_MSG;
 403   }
 404
 405   controller = (byte)((msg->header.controller &0x7f)-1);
 406
 407   /* controller starts with 0 up to (max_adapter - 1) */
 408   if ( controller >= max_adapter )
 409   {
 410     dbug(1,dprintf("invalid ctrl"));
 411     return _BAD_MSG;
 412   }
 413
 414   a = &adapter[controller];
 415   plci = NULL;
 416   if ((msg->header.plci != 0) && (msg->header.plci <= a->max_plci) && !a->adapter_disabled)
 417   {
 418     dbug(1,dprintf("plci=%x",msg->header.plci));
 419     plci = &a->plci[msg->header.plci-1];
 420     ncci = GET_WORD(&msg->header.ncci);
 421     if (plci->Id
 422      && (plci->appl
 423       || (plci->State == INC_CON_PENDING)
 424       || (plci->State == INC_CON_ALERT)
 425       || (msg->header.command == (_DISCONNECT_I|RESPONSE)))
 426      && ((ncci == 0)
 427       || (msg->header.command == (_DISCONNECT_B3_I|RESPONSE))
 428       || ((ncci < MAX_NCCI+1) && (a->ncci_plci[ncci] == plci->Id))))
 429     {
 430       i = plci->msg_in_read_pos;
 431       j = plci->msg_in_write_pos;
 432       if (j >= i)
 433       {
 434         if (j + msg->header.length + MSG_IN_OVERHEAD <= MSG_IN_QUEUE_SIZE)
 435           i += MSG_IN_QUEUE_SIZE - j;
 436         else
 437           j = 0;
 438       }
 439       else
 440       {
 441
 442         n = (((CAPI_MSG   *)(plci->msg_in_queue))->header.length + MSG_IN_OVERHEAD + 3) & 0xfffc;
 443
 444         if (i > MSG_IN_QUEUE_SIZE - n)
 445           i = MSG_IN_QUEUE_SIZE - n + 1;
 446         i -= j;
 447       }
 448
 449       if (i <= ((msg->header.length + MSG_IN_OVERHEAD + 3) & 0xfffc))
 450
 451       {
 452         dbug(0,dprintf("Q-FULL1(msg) - len=%d write=%d read=%d wrap=%d free=%d",
 453           msg->header.length, plci->msg_in_write_pos,
 454           plci->msg_in_read_pos, plci->msg_in_wrap_pos, i));
 455
 456         return _QUEUE_FULL;
 457       }
 458       c = false;
 459       if ((((byte   *) msg) < ((byte   *)(plci->msg_in_queue)))
 460        || (((byte   *) msg) >= ((byte   *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
 461       {
 462         if (plci->msg_in_write_pos != plci->msg_in_read_pos)
 463           c = true;
 464       }
 465       if (msg->header.command == _DATA_B3_R)
 466       {
 467         if (msg->header.length < 20)
 468         {
 469           dbug(1,dprintf("DATA_B3 REQ wrong length %d", msg->header.length));
 470           return _BAD_MSG;
 471         }
 472         ncci_ptr = &(a->ncci[ncci]);
 473         n = ncci_ptr->data_pending;
 474         l = ncci_ptr->data_ack_pending;
 475         k = plci->msg_in_read_pos;
 476         while (k != plci->msg_in_write_pos)
 477         {
 478           if (k == plci->msg_in_wrap_pos)
 479             k = 0;
 480           if ((((CAPI_MSG   *)(&((byte   *)(plci->msg_in_queue))[k]))->header.command == _DATA_B3_R)
 481            && (((CAPI_MSG   *)(&((byte   *)(plci->msg_in_queue))[k]))->header.ncci == ncci))
 482           {
 483             n++;
 484             if (((CAPI_MSG   *)(&((byte   *)(plci->msg_in_queue))[k]))->info.data_b3_req.Flags & 0x0004)
 485               l++;
 486           }
 487
 488           k += (((CAPI_MSG   *)(&((byte   *)(plci->msg_in_queue))[k]))->header.length +
 489             MSG_IN_OVERHEAD + 3) & 0xfffc;
 490
 491         }
 492         if ((n >= MAX_DATA_B3) || (l >= MAX_DATA_ACK))
 493         {
 494           dbug(0,dprintf("Q-FULL2(data) - pending=%d/%d ack_pending=%d/%d",
 495                           ncci_ptr->data_pending, n, ncci_ptr->data_ack_pending, l));
 496
 497           return _QUEUE_FULL;
 498         }
 499         if (plci->req_in || plci->internal_command)
 500         {
 501           if ((((byte   *) msg) >= ((byte   *)(plci->msg_in_queue)))
 502            && (((byte   *) msg) < ((byte   *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
 503           {
 504             dbug(0,dprintf("Q-FULL3(requeue)"));
 505
 506             return _QUEUE_FULL;
 507           }
 508           c = true;
 509         }
 510       }
 511       else
 512       {
 513         if (plci->req_in || plci->internal_command)
 514           c = true;
 515         else
 516         {
 517           plci->command = msg->header.command;
 518           plci->number = msg->header.number;
 519         }
 520       }
 521       if (c)
 522       {
 523         dbug(1,dprintf("enqueue msg(0x%04x,0x%x,0x%x) - len=%d write=%d read=%d wrap=%d free=%d",
 524           msg->header.command, plci->req_in, plci->internal_command,
 525           msg->header.length, plci->msg_in_write_pos,
 526           plci->msg_in_read_pos, plci->msg_in_wrap_pos, i));
 527         if (j == 0)
 528           plci->msg_in_wrap_pos = plci->msg_in_write_pos;
 529         m = (CAPI_MSG   *)(&((byte   *)(plci->msg_in_queue))[j]);
 530         for (i = 0; i < msg->header.length; i++)
 531           ((byte   *)(plci->msg_in_queue))[j++] = ((byte   *) msg)[i];
 532         if (m->header.command == _DATA_B3_R)
 533         {
 534
 535           m->info.data_b3_req.Data = (dword)(long)(TransmitBufferSet (appl, m->info.data_b3_req.Data));
 536
 537         }
 538
 539         j = (j + 3) & 0xfffc;
 540
 541         *((APPL   *   *)(&((byte   *)(plci->msg_in_queue))[j])) = appl;
 542         plci->msg_in_write_pos = j + MSG_IN_OVERHEAD;
 543         return 0;
 544       }
 545     }
 546     else
 547     {
 548       plci = NULL;
 549     }
 550   }
 551   dbug(1,dprintf("com=%x",msg->header.command));
 552
 553   for(j=0;j<MAX_MSG_PARMS+1;j++) msg_parms[j].length = 0;
 554   for(i=0, ret = _BAD_MSG; i < ARRAY_SIZE(ftable); i++) {
 555
 556     if(ftable[i].command==msg->header.command) {
 557       /* break loop if the message is correct, otherwise continue scan  */
 558       /* (for example: CONNECT_B3_T90_ACT_RES has two specifications)   */
 559       if(!api_parse(msg->info.b,(word)(msg->header.length-12),ftable[i].format,msg_parms)) {
 560         ret = 0;
 561         break;
 562       }
 563       for(j=0;j<MAX_MSG_PARMS+1;j++) msg_parms[j].length = 0;
 564     }
 565   }
 566   if(ret) {
 567     dbug(1,dprintf("BAD_MSG"));
 568     if(plci) plci->command = 0;
 569     return ret;
 570   }
 571
 572
 573   c = ftable[i].function(GET_DWORD(&msg->header.controller),
 574                          msg->header.number,
 575                          a,
 576                          plci,
 577                          appl,
 578                          msg_parms);
 579
 580   channel_xmit_extended_xon (plci);
 581
 582   if(c==1) send_req(plci);
 583   if(c==2 && plci) plci->req_in = plci->req_in_start = plci->req_out = 0;
 584   if(plci && !plci->req_in) plci->command = 0;
 585   return 0;
 586 }
 587
 588
 589 /*------------------------------------------------------------------*/
 590 /* api_parse function, check the format of api messages             */
 591 /*------------------------------------------------------------------*/
 592
 593 static word api_parse(byte *msg, word length, byte *format, API_PARSE *parms)
 594 {
 595   word i;
 596   word p;
 597
 598   for(i=0,p=0; format[i]; i++) {
 599     if(parms)
 600     {
 601       parms[i].info = &msg[p];
 602     }
 603     switch(format[i]) {
 604     case 'b':
 605       p +=1;
 606       break;
 607     case 'w':
 608       p +=2;
 609       break;
 610     case 'd':
 611       p +=4;
 612       break;
 613     case 's':
 614       if(msg[p]==0xff) {
 615         parms[i].info +=2;
 616         parms[i].length = msg[p+1] + (msg[p+2]<<8);
 617         p +=(parms[i].length +3);
 618       }
 619       else {
 620         parms[i].length = msg[p];
 621         p +=(parms[i].length +1);
 622       }
 623       break;
 624     }
 625
 626     if(p>length) return true;
 627   }
 628   if(parms) parms[i].info = NULL;
 629   return false;
 630 }
 631
 632 static void api_save_msg(API_PARSE *in, byte *format, API_SAVE *out)
 633 {
 634   word i, j, n = 0;
 635   byte   *p;
 636
 637   p = out->info;
 638   for (i = 0; format[i] != '\0'; i++)
 639   {
 640     out->parms[i].info = p;
 641     out->parms[i].length = in[i].length;
 642     switch (format[i])
 643     {
 644     case 'b':
 645       n = 1;
 646       break;
 647     case 'w':
 648       n = 2;
 649       break;
 650     case 'd':
 651       n = 4;
 652       break;
 653     case 's':
 654       n = in[i].length + 1;
 655       break;
 656     }
 657     for (j = 0; j < n; j++)
 658       *(p++) = in[i].info[j];
 659   }
 660   out->parms[i].info = NULL;
 661   out->parms[i].length = 0;
 662 }
 663
 664 static void api_load_msg(API_SAVE *in, API_PARSE *out)
 665 {
 666   word i;
 667
 668   i = 0;
 669   do
 670   {
 671     out[i].info = in->parms[i].info;
 672     out[i].length = in->parms[i].length;
 673   } while (in->parms[i++].info);
 674 }
 675
 676
 677 /*------------------------------------------------------------------*/
 678 /* CAPI remove function                                             */
 679 /*------------------------------------------------------------------*/
 680
 681 word api_remove_start(void)
 682 {
 683   word i;
 684   word j;
 685
 686   if(!remove_started) {
 687     remove_started = true;
 688     for(i=0;i<max_adapter;i++) {
 689       if(adapter[i].request) {
 690         for(j=0;j<adapter[i].max_plci;j++) {
 691           if(adapter[i].plci[j].Sig.Id) plci_remove(&adapter[i].plci[j]);
 692         }
 693       }
 694     }
 695     return 1;
 696   }
 697   else {
 698     for(i=0;i<max_adapter;i++) {
 699       if(adapter[i].request) {
 700         for(j=0;j<adapter[i].max_plci;j++) {
 701           if(adapter[i].plci[j].Sig.Id) return 1;
 702         }
 703       }
 704     }
 705   }
 706   api_remove_complete();
 707   return 0;
 708 }
 709
 710
 711 /*------------------------------------------------------------------*/
 712 /* internal command queue                                           */
 713 /*------------------------------------------------------------------*/
 714
 715 static void init_internal_command_queue (PLCI   *plci)
 716 {
 717   word i;
 718
 719   dbug (1, dprintf ("%s,%d: init_internal_command_queue",
 720     (char   *)(FILE_), __LINE__));
 721
 722   plci->internal_command = 0;
 723   for (i = 0; i < MAX_INTERNAL_COMMAND_LEVELS; i++)
 724     plci->internal_command_queue[i] = NULL;
 725 }
 726
 727
 728 static void start_internal_command (dword Id, PLCI   *plci, t_std_internal_command command_function)
 729 {
 730   word i;
 731
 732   dbug (1, dprintf ("[%06lx] %s,%d: start_internal_command",
 733     UnMapId (Id), (char   *)(FILE_), __LINE__));
 734
 735   if (plci->internal_command == 0)
 736   {
 737     plci->internal_command_queue[0] = command_function;
 738     (* command_function)(Id, plci, OK);
 739   }
 740   else
 741   {
 742     i = 1;
 743     while (plci->internal_command_queue[i] != NULL)
 744       i++;
 745     plci->internal_command_queue[i] = command_function;
 746   }
 747 }
 748
 749
 750 static void next_internal_command (dword Id, PLCI   *plci)
 751 {
 752   word i;
 753
 754   dbug (1, dprintf ("[%06lx] %s,%d: next_internal_command",
 755     UnMapId (Id), (char   *)(FILE_), __LINE__));
 756
 757   plci->internal_command = 0;
 758   plci->internal_command_queue[0] = NULL;
 759   while (plci->internal_command_queue[1] != NULL)
 760   {
 761     for (i = 0; i < MAX_INTERNAL_COMMAND_LEVELS - 1; i++)
 762       plci->internal_command_queue[i] = plci->internal_command_queue[i+1];
 763     plci->internal_command_queue[MAX_INTERNAL_COMMAND_LEVELS - 1] = NULL;
 764     (*(plci->internal_command_queue[0]))(Id, plci, OK);
 765     if (plci->internal_command != 0)
 766       return;
 767     plci->internal_command_queue[0] = NULL;
 768   }
 769 }
 770
 771
 772 /*------------------------------------------------------------------*/
 773 /* NCCI allocate/remove function                                    */
 774 /*------------------------------------------------------------------*/
 775
 776 static dword ncci_mapping_bug = 0;
 777
 778 static word get_ncci (PLCI   *plci, byte ch, word force_ncci)
 779 {
 780   DIVA_CAPI_ADAPTER   *a;
 781   word ncci, i, j, k;
 782
 783   a = plci->adapter;
 784   if (!ch || a->ch_ncci[ch])
 785   {
 786     ncci_mapping_bug++;
 787     dbug(1,dprintf("NCCI mapping exists %ld %02x %02x %02x-%02x",
 788       ncci_mapping_bug, ch, force_ncci, a->ncci_ch[a->ch_ncci[ch]], a->ch_ncci[ch]));
 789     ncci = ch;
 790   }
 791   else
 792   {
 793     if (force_ncci)
 794       ncci = force_ncci;
 795     else
 796     {
 797       if ((ch < MAX_NCCI+1) && !a->ncci_ch[ch])
 798         ncci = ch;
 799       else
 800       {
 801         ncci = 1;
 802         while ((ncci < MAX_NCCI+1) && a->ncci_ch[ncci])
 803           ncci++;
 804         if (ncci == MAX_NCCI+1)
 805         {
 806           ncci_mapping_bug++;
 807           i = 1;
 808           do
 809           {
 810             j = 1;
 811             while ((j < MAX_NCCI+1) && (a->ncci_ch[j] != i))
 812               j++;
 813             k = j;
 814             if (j < MAX_NCCI+1)
 815             {
 816               do
 817               {
 818                 j++;
 819               } while ((j < MAX_NCCI+1) && (a->ncci_ch[j] != i));
 820             }
 821           } while ((i < MAX_NL_CHANNEL+1) && (j < MAX_NCCI+1));
 822           if (i < MAX_NL_CHANNEL+1)
 823           {
 824             dbug(1,dprintf("NCCI mapping overflow %ld %02x %02x %02x-%02x-%02x",
 825               ncci_mapping_bug, ch, force_ncci, i, k, j));
 826           }
 827           else
 828           {
 829             dbug(1,dprintf("NCCI mapping overflow %ld %02x %02x",
 830               ncci_mapping_bug, ch, force_ncci));
 831           }
 832           ncci = ch;
 833         }
 834       }
 835       a->ncci_plci[ncci] = plci->Id;
 836       a->ncci_state[ncci] = IDLE;
 837       if (!plci->ncci_ring_list)
 838         plci->ncci_ring_list = ncci;
 839       else
 840         a->ncci_next[ncci] = a->ncci_next[plci->ncci_ring_list];
 841       a->ncci_next[plci->ncci_ring_list] = (byte) ncci;
 842     }
 843     a->ncci_ch[ncci] = ch;
 844     a->ch_ncci[ch] = (byte) ncci;
 845     dbug(1,dprintf("NCCI mapping established %ld %02x %02x %02x-%02x",
 846       ncci_mapping_bug, ch, force_ncci, ch, ncci));
 847   }
 848   return (ncci);
 849 }
 850
 851
 852 static void ncci_free_receive_buffers (PLCI   *plci, word ncci)
 853 {
 854   DIVA_CAPI_ADAPTER   *a;
 855   APPL   *appl;
 856   word i, ncci_code;
 857   dword Id;
 858
 859   a = plci->adapter;
 860   Id = (((dword) ncci) << 16) | (((word)(plci->Id)) << 8) | a->Id;
 861   if (ncci)
 862   {
 863     if (a->ncci_plci[ncci] == plci->Id)
 864     {
 865       if (!plci->appl)
 866       {
 867         ncci_mapping_bug++;
 868         dbug(1,dprintf("NCCI mapping appl expected %ld %08lx",
 869           ncci_mapping_bug, Id));
 870       }
 871       else
 872       {
 873         appl = plci->appl;
 874         ncci_code = ncci | (((word) a->Id) << 8);
 875         for (i = 0; i < appl->MaxBuffer; i++)
 876         {
 877           if ((appl->DataNCCI[i] == ncci_code)
 878            && (((byte)(appl->DataFlags[i] >> 8)) == plci->Id))
 879           {
 880             appl->DataNCCI[i] = 0;
 881           }
 882         }
 883       }
 884     }
 885   }
 886   else
 887   {
 888     for (ncci = 1; ncci < MAX_NCCI+1; ncci++)
 889     {
 890       if (a->ncci_plci[ncci] == plci->Id)
 891       {
 892         if (!plci->appl)
 893         {
 894           ncci_mapping_bug++;
 895           dbug(1,dprintf("NCCI mapping no appl %ld %08lx",
 896             ncci_mapping_bug, Id));
 897         }
 898         else
 899         {
 900           appl = plci->appl;
 901           ncci_code = ncci | (((word) a->Id) << 8);
 902           for (i = 0; i < appl->MaxBuffer; i++)
 903           {
 904             if ((appl->DataNCCI[i] == ncci_code)
 905              && (((byte)(appl->DataFlags[i] >> 8)) == plci->Id))
 906             {
 907               appl->DataNCCI[i] = 0;
 908             }
 909           }
 910         }
 911       }
 912     }
 913   }
 914 }
 915
 916
 917 static void cleanup_ncci_data (PLCI   *plci, word ncci)
 918 {
 919   NCCI   *ncci_ptr;
 920
 921   if (ncci && (plci->adapter->ncci_plci[ncci] == plci->Id))
 922   {
 923     ncci_ptr = &(plci->adapter->ncci[ncci]);
 924     if (plci->appl)
 925     {
 926       while (ncci_ptr->data_pending != 0)
 927       {
 928         if (!plci->data_sent || (ncci_ptr->DBuffer[ncci_ptr->data_out].P != plci->data_sent_ptr))
 929           TransmitBufferFree (plci->appl, ncci_ptr->DBuffer[ncci_ptr->data_out].P);
 930         (ncci_ptr->data_out)++;
 931         if (ncci_ptr->data_out == MAX_DATA_B3)
 932           ncci_ptr->data_out = 0;
 933         (ncci_ptr->data_pending)--;
 934       }
 935     }
 936     ncci_ptr->data_out = 0;
 937     ncci_ptr->data_pending = 0;
 938     ncci_ptr->data_ack_out = 0;
 939     ncci_ptr->data_ack_pending = 0;
 940   }
 941 }
 942
 943
 944 static void ncci_remove (PLCI   *plci, word ncci, byte preserve_ncci)
 945 {
 946   DIVA_CAPI_ADAPTER   *a;
 947   dword Id;
 948   word i;
 949
 950   a = plci->adapter;
 951   Id = (((dword) ncci) << 16) | (((word)(plci->Id)) << 8) | a->Id;
 952   if (!preserve_ncci)
 953     ncci_free_receive_buffers (plci, ncci);
 954   if (ncci)
 955   {
 956     if (a->ncci_plci[ncci] != plci->Id)
 957     {
 958       ncci_mapping_bug++;
 959       dbug(1,dprintf("NCCI mapping doesn't exist %ld %08lx %02x",
 960         ncci_mapping_bug, Id, preserve_ncci));
 961     }
 962     else
 963     {
 964       cleanup_ncci_data (plci, ncci);
 965       dbug(1,dprintf("NCCI mapping released %ld %08lx %02x %02x-%02x",
 966         ncci_mapping_bug, Id, preserve_ncci, a->ncci_ch[ncci], ncci));
 967       a->ch_ncci[a->ncci_ch[ncci]] = 0;
 968       if (!preserve_ncci)
 969       {
 970         a->ncci_ch[ncci] = 0;
 971         a->ncci_plci[ncci] = 0;
 972         a->ncci_state[ncci] = IDLE;
 973         i = plci->ncci_ring_list;
 974         while ((i != 0) && (a->ncci_next[i] != plci->ncci_ring_list) && (a->ncci_next[i] != ncci))
 975           i = a->ncci_next[i];
 976         if ((i != 0) && (a->ncci_next[i] == ncci))
 977         {
 978           if (i == ncci)
 979             plci->ncci_ring_list = 0;
 980           else if (plci->ncci_ring_list == ncci)
 981             plci->ncci_ring_list = i;
 982           a->ncci_next[i] = a->ncci_next[ncci];
 983         }
 984         a->ncci_next[ncci] = 0;
 985       }
 986     }
 987   }
 988   else
 989   {
 990     for (ncci = 1; ncci < MAX_NCCI+1; ncci++)
 991     {
 992       if (a->ncci_plci[ncci] == plci->Id)
 993       {
 994         cleanup_ncci_data (plci, ncci);
 995         dbug(1,dprintf("NCCI mapping released %ld %08lx %02x %02x-%02x",
 996           ncci_mapping_bug, Id, preserve_ncci, a->ncci_ch[ncci], ncci));
 997         a->ch_ncci[a->ncci_ch[ncci]] = 0;
 998         if (!preserve_ncci)
 999         {
1000           a->ncci_ch[ncci] = 0;
1001           a->ncci_plci[ncci] = 0;
1002           a->ncci_state[ncci] = IDLE;
1003           a->ncci_next[ncci] = 0;
1004         }
1005       }
1006     }
1007     if (!preserve_ncci)
1008       plci->ncci_ring_list = 0;
1009   }
1010 }
1011
1012
1013 /*------------------------------------------------------------------*/
1014 /* PLCI remove function                                             */
1015 /*------------------------------------------------------------------*/
1016
1017 static void plci_free_msg_in_queue (PLCI   *plci)
1018 {
1019   word i;
1020
1021   if (plci->appl)
1022   {
1023     i = plci->msg_in_read_pos;
1024     while (i != plci->msg_in_write_pos)
1025     {
1026       if (i == plci->msg_in_wrap_pos)
1027         i = 0;
1028       if (((CAPI_MSG   *)(&((byte   *)(plci->msg_in_queue))[i]))->header.command == _DATA_B3_R)
1029       {
1030
1031         TransmitBufferFree (plci->appl,
1032           (byte *)(long)(((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[i]))->info.data_b3_req.Data));
1033
1034       }
1035
1036       i += (((CAPI_MSG   *)(&((byte   *)(plci->msg_in_queue))[i]))->header.length +
1037         MSG_IN_OVERHEAD + 3) & 0xfffc;
1038
1039     }
1040   }
1041   plci->msg_in_write_pos = MSG_IN_QUEUE_SIZE;
1042   plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
1043   plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
1044 }
1045
1046
1047 static void plci_remove(PLCI   * plci)
1048 {
1049
1050   if(!plci) {
1051     dbug(1,dprintf("plci_remove(no plci)"));
1052     return;
1053   }
1054   init_internal_command_queue (plci);
1055   dbug(1,dprintf("plci_remove(%x,tel=%x)",plci->Id,plci->tel));
1056   if(plci_remove_check(plci))
1057   {
1058     return;
1059   }
1060   if (plci->Sig.Id == 0xff)
1061   {
1062     dbug(1,dprintf("D-channel X.25 plci->NL.Id:%0x", plci->NL.Id));
1063     if (plci->NL.Id && !plci->nl_remove_id)
1064     {
1065       nl_req_ncci(plci,REMOVE,0);
1066       send_req(plci);
1067     }
1068   }
1069   else
1070   {
1071     if (!plci->sig_remove_id
1072      && (plci->Sig.Id
1073       || (plci->req_in!=plci->req_out)
1074       || (plci->nl_req || plci->sig_req)))
1075     {
1076       sig_req(plci,HANGUP,0);
1077       send_req(plci);
1078     }
1079   }
1080   ncci_remove (plci, 0, false);
1081   plci_free_msg_in_queue (plci);
1082
1083   plci->channels = 0;
1084   plci->appl = NULL;
1085   if ((plci->State == INC_CON_PENDING) || (plci->State == INC_CON_ALERT))
1086     plci->State = OUTG_DIS_PENDING;
1087 }
1088
1089 /*------------------------------------------------------------------*/
1090 /* Application Group function helpers                               */
1091 /*------------------------------------------------------------------*/
1092
1093 static void set_group_ind_mask (PLCI   *plci)
1094 {
1095   word i;
1096
1097   for (i = 0; i < C_IND_MASK_DWORDS; i++)
1098     plci->group_optimization_mask_table[i] = 0xffffffffL;
1099 }
1100
1101 static void clear_group_ind_mask_bit (PLCI   *plci, word b)
1102 {
1103   plci->group_optimization_mask_table[b >> 5] &= ~(1L << (b & 0x1f));
1104 }
1105
1106 static byte test_group_ind_mask_bit (PLCI   *plci, word b)
1107 {
1108   return ((plci->group_optimization_mask_table[b >> 5] & (1L << (b & 0x1f))) != 0);
1109 }
1110
1111 /*------------------------------------------------------------------*/
1112 /* c_ind_mask operations for arbitrary MAX_APPL                     */
1113 /*------------------------------------------------------------------*/
1114
1115 static void clear_c_ind_mask (PLCI   *plci)
1116 {
1117   word i;
1118
1119   for (i = 0; i < C_IND_MASK_DWORDS; i++)
1120     plci->c_ind_mask_table[i] = 0;
1121 }
1122
1123 static byte c_ind_mask_empty (PLCI   *plci)
1124 {
1125   word i;
1126
1127   i = 0;
1128   while ((i < C_IND_MASK_DWORDS) && (plci->c_ind_mask_table[i] == 0))
1129     i++;
1130   return (i == C_IND_MASK_DWORDS);
1131 }
1132
1133 static void set_c_ind_mask_bit (PLCI   *plci, word b)
1134 {
1135   plci->c_ind_mask_table[b >> 5] |= (1L << (b & 0x1f));
1136 }
1137
1138 static void clear_c_ind_mask_bit (PLCI   *plci, word b)
1139 {
1140   plci->c_ind_mask_table[b >> 5] &= ~(1L << (b & 0x1f));
1141 }
1142
1143 static byte test_c_ind_mask_bit (PLCI   *plci, word b)
1144 {
1145   return ((plci->c_ind_mask_table[b >> 5] & (1L << (b & 0x1f))) != 0);
1146 }
1147
1148 static void dump_c_ind_mask (PLCI   *plci)
1149 {
1150 static char hex_digit_table[0x10] =
1151   {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
1152   word i, j, k;
1153   dword d;
1154     char *p;
1155     char buf[40];
1156
1157   for (i = 0; i < C_IND_MASK_DWORDS; i += 4)
1158   {
1159     p = buf + 36;
1160     *p = '\0';
1161     for (j = 0; j < 4; j++)
1162     {
1163       if (i+j < C_IND_MASK_DWORDS)
1164       {
1165         d = plci->c_ind_mask_table[i+j];
1166         for (k = 0; k < 8; k++)
1167         {
1168           *(--p) = hex_digit_table[d & 0xf];
1169           d >>= 4;
1170         }
1171       }
1172       else if (i != 0)
1173       {
1174         for (k = 0; k < 8; k++)
1175           *(--p) = ' ';
1176       }
1177       *(--p) = ' ';
1178     }
1179     dbug(1,dprintf ("c_ind_mask =%s", (char   *) p));
1180   }
1181 }
1182
1183
1184
1185
1186
1187 #define dump_plcis(a)
1188
1189
1190
1191 /*------------------------------------------------------------------*/
1192 /* translation function for each message                            */
1193 /*------------------------------------------------------------------*/
1194
1195 static byte connect_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1196                         PLCI *plci, APPL *appl, API_PARSE *parms)
1197 {
1198   word ch;
1199   word i;
1200   word Info;
1201   word CIP;
1202   byte LinkLayer;
1203   API_PARSE * ai;
1204   API_PARSE * bp;
1205     API_PARSE ai_parms[5];
1206   word channel = 0;
1207   dword ch_mask;
1208   byte m;
1209   static byte esc_chi[35] = {0x02,0x18,0x01};
1210   static byte lli[2] = {0x01,0x00};
1211   byte noCh = 0;
1212   word dir = 0;
1213   byte   *p_chi = "";
1214
1215   for(i=0;i<5;i++) ai_parms[i].length = 0;
1216
1217   dbug(1,dprintf("connect_req(%d)",parms->length));
1218   Info = _WRONG_IDENTIFIER;
1219   if(a)
1220   {
1221     if(a->adapter_disabled)
1222     {
1223       dbug(1,dprintf("adapter disabled"));
1224       Id = ((word)1<<8)|a->Id;
1225       sendf(appl,_CONNECT_R|CONFIRM,Id,Number,"w",0);
1226       sendf(appl, _DISCONNECT_I, Id, 0, "w", _L1_ERROR);
1227       return false;
1228     }
1229     Info = _OUT_OF_PLCI;
1230     if((i=get_plci(a)))
1231     {
1232       Info = 0;
1233       plci = &a->plci[i-1];
1234       plci->appl = appl;
1235       plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
1236       /* check 'external controller' bit for codec support */
1237       if(Id & EXT_CONTROLLER)
1238       {
1239         if(AdvCodecSupport(a, plci, appl, 0) )
1240         {
1241           plci->Id = 0;
1242           sendf(appl, _CONNECT_R|CONFIRM, Id, Number, "w", _WRONG_IDENTIFIER);
1243           return 2;
1244         }
1245       }
1246       ai = &parms[9];
1247       bp = &parms[5];
1248       ch = 0;
1249       if(bp->length)LinkLayer = bp->info[3];
1250       else LinkLayer = 0;
1251       if(ai->length)
1252       {
1253         ch=0xffff;
1254         if(!api_parse(&ai->info[1],(word)ai->length,"ssss",ai_parms))
1255         {
1256           ch = 0;
1257           if(ai_parms[0].length)
1258           {
1259             ch = GET_WORD(ai_parms[0].info+1);
1260             if(ch>4) ch=0; /* safety -> ignore ChannelID */
1261             if(ch==4) /* explizit CHI in message */
1262             {
1263               /* check length of B-CH struct */
1264               if((ai_parms[0].info)[3]>=1)
1265               {
1266                 if((ai_parms[0].info)[4]==CHI)
1267                 {
1268                   p_chi = &((ai_parms[0].info)[5]);
1269                 }
1270                 else
1271                 {
1272                   p_chi = &((ai_parms[0].info)[3]);
1273                 }
1274                 if(p_chi[0]>35) /* check length of channel ID */
1275                 {
1276                   Info = _WRONG_MESSAGE_FORMAT;
1277                 }
1278               }
1279               else Info = _WRONG_MESSAGE_FORMAT;
1280             }
1281
1282             if(ch==3 && ai_parms[0].length>=7 && ai_parms[0].length<=36)
1283             {
1284               dir = GET_WORD(ai_parms[0].info+3);
1285               ch_mask = 0;
1286               m = 0x3f;
1287               for(i=0; i+5<=ai_parms[0].length; i++)
1288               {
1289                 if(ai_parms[0].info[i+5]!=0)
1290                 {
1291                   if((ai_parms[0].info[i+5] | m) != 0xff)
1292                     Info = _WRONG_MESSAGE_FORMAT;
1293                   else
1294                   {
1295                     if (ch_mask == 0)
1296                       channel = i;
1297                     ch_mask |= 1L << i;
1298                   }
1299                 }
1300                 m = 0;
1301               }
1302               if (ch_mask == 0)
1303                 Info = _WRONG_MESSAGE_FORMAT;
1304               if (!Info)
1305               {
1306                 if ((ai_parms[0].length == 36) || (ch_mask != ((dword)(1L << channel))))
1307                 {
1308                   esc_chi[0] = (byte)(ai_parms[0].length - 2);
1309                   for(i=0; i+5<=ai_parms[0].length; i++)
1310                     esc_chi[i+3] = ai_parms[0].info[i+5];
1311                 }
1312                 else
1313                   esc_chi[0] = 2;
1314                 esc_chi[2] = (byte)channel;
1315                 plci->b_channel = (byte)channel; /* not correct for ETSI ch 17..31 */
1316                 add_p(plci,LLI,lli);
1317                 add_p(plci,ESC,esc_chi);
1318                 plci->State = LOCAL_CONNECT;
1319                 if(!dir) plci->call_dir |= CALL_DIR_FORCE_OUTG_NL;     /* dir 0=DTE, 1=DCE */
1320               }
1321             }
1322           }
1323         }
1324         else  Info = _WRONG_MESSAGE_FORMAT;
1325       }
1326
1327       dbug(1,dprintf("ch=%x,dir=%x,p_ch=%d",ch,dir,channel));
1328       plci->command = _CONNECT_R;
1329       plci->number = Number;
1330       /* x.31 or D-ch free SAPI in LinkLayer? */
1331       if(ch==1 && LinkLayer!=3 && LinkLayer!=12) noCh = true;
1332       if((ch==0 || ch==2 || noCh || ch==3 || ch==4) && !Info)
1333       {
1334         /* B-channel used for B3 connections (ch==0), or no B channel    */
1335         /* is used (ch==2) or perm. connection (3) is used  do a CALL    */
1336         if(noCh) Info = add_b1(plci,&parms[5],2,0);    /* no resource    */
1337         else     Info = add_b1(plci,&parms[5],ch,0);
1338         add_s(plci,OAD,&parms[2]);
1339         add_s(plci,OSA,&parms[4]);
1340         add_s(plci,BC,&parms[6]);
1341         add_s(plci,LLC,&parms[7]);
1342         add_s(plci,HLC,&parms[8]);
1343         CIP = GET_WORD(parms[0].info);
1344         if (a->Info_Mask[appl->Id-1] & 0x200)
1345         {
1346           /* early B3 connect (CIP mask bit 9) no release after a disc */
1347           add_p(plci,LLI,"\x01\x01");
1348         }
1349         if(GET_WORD(parms[0].info)<29) {
1350           add_p(plci,BC,cip_bc[GET_WORD(parms[0].info)][a->u_law]);
1351           add_p(plci,HLC,cip_hlc[GET_WORD(parms[0].info)]);
1352         }
1353         add_p(plci,UID,"\x06\x43\x61\x70\x69\x32\x30");
1354         sig_req(plci,ASSIGN,DSIG_ID);
1355       }
1356       else if(ch==1) {
1357
1358         /* D-Channel used for B3 connections */
1359         plci->Sig.Id = 0xff;
1360         Info = 0;
1361       }
1362
1363       if(!Info && ch!=2 && !noCh ) {
1364         Info = add_b23(plci,&parms[5]);
1365         if(!Info) {
1366           if(!(plci->tel && !plci->adv_nl))nl_req_ncci(plci,ASSIGN,0);
1367         }
1368       }
1369
1370       if(!Info)
1371       {
1372         if(ch==0 || ch==2 || ch==3 || noCh || ch==4)
1373         {
1374           if(plci->spoofed_msg==SPOOFING_REQUIRED)
1375           {
1376             api_save_msg(parms, "wsssssssss", &plci->saved_msg);
1377             plci->spoofed_msg = CALL_REQ;
1378             plci->internal_command = BLOCK_PLCI;
1379             plci->command = 0;
1380             dbug(1,dprintf("Spoof"));
1381             send_req(plci);
1382             return false;
1383           }
1384           if(ch==4)add_p(plci,CHI,p_chi);
1385           add_s(plci,CPN,&parms[1]);
1386           add_s(plci,DSA,&parms[3]);
1387           if(noCh) add_p(plci,ESC,"\x02\x18\xfd");  /* D-channel, no B-L3 */
1388           add_ai(plci,&parms[9]);
1389           if(!dir)sig_req(plci,CALL_REQ,0);
1390           else
1391           {
1392             plci->command = PERM_LIST_REQ;
1393             plci->appl = appl;
1394             sig_req(plci,LISTEN_REQ,0);
1395             send_req(plci);
1396             return false;
1397           }
1398         }
1399         send_req(plci);
1400         return false;
1401       }
1402       plci->Id = 0;
1403     }
1404   }
1405   sendf(appl,
1406         _CONNECT_R|CONFIRM,
1407         Id,
1408         Number,
1409         "w",Info);
1410   return 2;
1411 }
1412
1413 static byte connect_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1414                         PLCI *plci, APPL *appl, API_PARSE *parms)
1415 {
1416   word i, Info;
1417   word Reject;
1418   static byte cau_t[] = {0,0,0x90,0x91,0xac,0x9d,0x86,0xd8,0x9b};
1419   static byte esc_t[] = {0x03,0x08,0x00,0x00};
1420   API_PARSE * ai;
1421     API_PARSE ai_parms[5];
1422   word ch=0;
1423
1424   if(!plci) {
1425     dbug(1,dprintf("connect_res(no plci)"));
1426     return 0;  /* no plci, no send */
1427   }
1428
1429   dbug(1,dprintf("connect_res(State=0x%x)",plci->State));
1430   for(i=0;i<5;i++) ai_parms[i].length = 0;
1431   ai = &parms[5];
1432   dbug(1,dprintf("ai->length=%d",ai->length));
1433
1434   if(ai->length)
1435   {
1436     if(!api_parse(&ai->info[1],(word)ai->length,"ssss",ai_parms))
1437     {
1438       dbug(1,dprintf("ai_parms[0].length=%d/0x%x",ai_parms[0].length,GET_WORD(ai_parms[0].info+1)));
1439       ch = 0;
1440       if(ai_parms[0].length)
1441       {
1442         ch = GET_WORD(ai_parms[0].info+1);
1443         dbug(1,dprintf("BCH-I=0x%x",ch));
1444       }
1445     }
1446   }
1447
1448   if(plci->State==INC_CON_CONNECTED_ALERT)
1449   {
1450     dbug(1,dprintf("Connected Alert Call_Res"));
1451     if (a->Info_Mask[appl->Id-1] & 0x200)
1452     {
1453     /* early B3 connect (CIP mask bit 9) no release after a disc */
1454       add_p(plci,LLI,"\x01\x01");
1455     }
1456     add_s(plci, CONN_NR, &parms[2]);
1457     add_s(plci, LLC, &parms[4]);
1458     add_ai(plci, &parms[5]);
1459     plci->State = INC_CON_ACCEPT;
1460     sig_req(plci, CALL_RES,0);
1461     return 1;
1462   }
1463   else if(plci->State==INC_CON_PENDING || plci->State==INC_CON_ALERT) {
1464     clear_c_ind_mask_bit (plci, (word)(appl->Id-1));
1465     dump_c_ind_mask (plci);
1466     Reject = GET_WORD(parms[0].info);
1467     dbug(1,dprintf("Reject=0x%x",Reject));
1468     if(Reject)
1469     {
1470       if(c_ind_mask_empty (plci))
1471       {
1472         if((Reject&0xff00)==0x3400)
1473         {
1474           esc_t[2] = ((byte)(Reject&0x00ff)) | 0x80;
1475           add_p(plci,ESC,esc_t);
1476           add_ai(plci, &parms[5]);
1477           sig_req(plci,REJECT,0);
1478         }
1479         else if(Reject==1 || Reject>9)
1480         {
1481           add_ai(plci, &parms[5]);
1482           sig_req(plci,HANGUP,0);
1483         }
1484         else
1485         {
1486           esc_t[2] = cau_t[(Reject&0x000f)];
1487           add_p(plci,ESC,esc_t);
1488           add_ai(plci, &parms[5]);
1489           sig_req(plci,REJECT,0);
1490         }
1491         plci->appl = appl;
1492       }
1493       else
1494       {
1495         sendf(appl, _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED);
1496       }
1497     }
1498     else {
1499       plci->appl = appl;
1500       if(Id & EXT_CONTROLLER){
1501         if(AdvCodecSupport(a, plci, appl, 0)){
1502           dbug(1,dprintf("connect_res(error from AdvCodecSupport)"));
1503           sig_req(plci,HANGUP,0);
1504           return 1;
1505         }
1506         if(plci->tel == ADV_VOICE && a->AdvCodecPLCI)
1507         {
1508           Info = add_b23(plci, &parms[1]);
1509           if (Info)
1510           {
1511             dbug(1,dprintf("connect_res(error from add_b23)"));
1512             sig_req(plci,HANGUP,0);
1513             return 1;
1514           }
1515           if(plci->adv_nl)
1516           {
1517             nl_req_ncci(plci, ASSIGN, 0);
1518           }
1519         }
1520       }
1521       else
1522       {
1523         plci->tel = 0;
1524         if(ch!=2)
1525         {
1526           Info = add_b23(plci, &parms[1]);
1527           if (Info)
1528           {
1529             dbug(1,dprintf("connect_res(error from add_b23 2)"));
1530             sig_req(plci,HANGUP,0);
1531             return 1;
1532           }
1533         }
1534         nl_req_ncci(plci, ASSIGN, 0);
1535       }
1536
1537       if(plci->spoofed_msg==SPOOFING_REQUIRED)
1538       {
1539         api_save_msg(parms, "wsssss", &plci->saved_msg);
1540         plci->spoofed_msg = CALL_RES;
1541         plci->internal_command = BLOCK_PLCI;
1542         plci->command = 0;
1543         dbug(1,dprintf("Spoof"));
1544       }
1545       else
1546       {
1547         add_b1 (plci, &parms[1], ch, plci->B1_facilities);
1548         if (a->Info_Mask[appl->Id-1] & 0x200)
1549         {
1550           /* early B3 connect (CIP mask bit 9) no release after a disc */
1551           add_p(plci,LLI,"\x01\x01");
1552         }
1553         add_s(plci, CONN_NR, &parms[2]);
1554         add_s(plci, LLC, &parms[4]);
1555         add_ai(plci, &parms[5]);
1556         plci->State = INC_CON_ACCEPT;
1557         sig_req(plci, CALL_RES,0);
1558       }
1559
1560       for(i=0; i<max_appl; i++) {
1561         if(test_c_ind_mask_bit (plci, i)) {
1562           sendf(&application[i], _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED);
1563         }
1564       }
1565     }
1566   }
1567   return 1;
1568 }
1569
1570 static byte connect_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1571                           PLCI *plci, APPL *appl, API_PARSE *msg)
1572 {
1573   dbug(1,dprintf("connect_a_res"));
1574   return false;
1575 }
1576
1577 static byte disconnect_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1578                            PLCI *plci, APPL *appl, API_PARSE *msg)
1579 {
1580   word Info;
1581   word i;
1582
1583   dbug(1,dprintf("disconnect_req"));
1584
1585   Info = _WRONG_IDENTIFIER;
1586
1587   if(plci)
1588   {
1589     if(plci->State==INC_CON_PENDING || plci->State==INC_CON_ALERT)
1590     {
1591       clear_c_ind_mask_bit (plci, (word)(appl->Id-1));
1592       plci->appl = appl;
1593       for(i=0; i<max_appl; i++)
1594       {
1595         if(test_c_ind_mask_bit (plci, i))
1596           sendf(&application[i], _DISCONNECT_I, Id, 0, "w", 0);
1597       }
1598       plci->State = OUTG_DIS_PENDING;
1599     }
1600     if(plci->Sig.Id && plci->appl)
1601     {
1602       Info = 0;
1603         if(plci->Sig.Id!=0xff)
1604         {
1605           if(plci->State!=INC_DIS_PENDING)
1606           {
1607             add_ai(plci, &msg[0]);
1608             sig_req(plci,HANGUP,0);
1609             plci->State = OUTG_DIS_PENDING;
1610             return 1;
1611           }
1612         }
1613         else
1614         {
1615           if (plci->NL.Id && !plci->nl_remove_id)
1616           {
1617             mixer_remove (plci);
1618             nl_req_ncci(plci,REMOVE,0);
1619           sendf(appl,_DISCONNECT_R|CONFIRM,Id,Number,"w",0);
1620           sendf(appl, _DISCONNECT_I, Id, 0, "w", 0);
1621           plci->State = INC_DIS_PENDING;
1622           }
1623           return 1;
1624         }
1625       }
1626     }
1627
1628   if(!appl)  return false;
1629   sendf(appl, _DISCONNECT_R|CONFIRM, Id, Number, "w",Info);
1630   return false;
1631 }
1632
1633 static byte disconnect_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1634                            PLCI *plci, APPL *appl, API_PARSE *msg)
1635 {
1636   dbug(1,dprintf("disconnect_res"));
1637   if(plci)
1638   {
1639         /* clear ind mask bit, just in case of collsion of          */
1640         /* DISCONNECT_IND and CONNECT_RES                           */
1641     clear_c_ind_mask_bit (plci, (word)(appl->Id-1));
1642     ncci_free_receive_buffers (plci, 0);
1643     if(plci_remove_check(plci))
1644     {
1645       return 0;
1646     }
1647     if(plci->State==INC_DIS_PENDING
1648     || plci->State==SUSPENDING) {
1649       if(c_ind_mask_empty (plci)) {
1650         if(plci->State!=SUSPENDING)plci->State = IDLE;
1651         dbug(1,dprintf("chs=%d",plci->channels));
1652         if(!plci->channels) {
1653           plci_remove(plci);
1654         }
1655       }
1656     }
1657   }
1658   return 0;
1659 }
1660
1661 static byte listen_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1662                        PLCI *plci, APPL *appl, API_PARSE *parms)
1663 {
1664   word Info;
1665   byte i;
1666
1667   dbug(1,dprintf("listen_req(Appl=0x%x)",appl->Id));
1668
1669   Info = _WRONG_IDENTIFIER;
1670   if(a) {
1671     Info = 0;
1672     a->Info_Mask[appl->Id-1] = GET_DWORD(parms[0].info);
1673     a->CIP_Mask[appl->Id-1] = GET_DWORD(parms[1].info);
1674     dbug(1,dprintf("CIP_MASK=0x%lx",GET_DWORD(parms[1].info)));
1675     if (a->Info_Mask[appl->Id-1] & 0x200){ /* early B3 connect provides */
1676       a->Info_Mask[appl->Id-1] |=  0x10;   /* call progression infos    */
1677     }
1678
1679     /* check if external controller listen and switch listen on or off*/
1680     if(Id&EXT_CONTROLLER && GET_DWORD(parms[1].info)){
1681       if(a->profile.Global_Options & ON_BOARD_CODEC) {
1682         dummy_plci.State = IDLE;
1683         a->codec_listen[appl->Id-1] = &dummy_plci;
1684         a->TelOAD[0] = (byte)(parms[3].length);
1685         for(i=1;parms[3].length>=i && i<22;i++) {
1686           a->TelOAD[i] = parms[3].info[i];
1687         }
1688         a->TelOAD[i] = 0;
1689         a->TelOSA[0] = (byte)(parms[4].length);
1690         for(i=1;parms[4].length>=i && i<22;i++) {
1691           a->TelOSA[i] = parms[4].info[i];
1692         }
1693         a->TelOSA[i] = 0;
1694       }
1695       else Info = 0x2002; /* wrong controller, codec not supported */
1696     }
1697     else{               /* clear listen */
1698       a->codec_listen[appl->Id-1] = (PLCI   *)0;
1699     }
1700   }
1701   sendf(appl,
1702         _LISTEN_R|CONFIRM,
1703         Id,
1704         Number,
1705         "w",Info);
1706
1707   if (a) listen_check(a);
1708   return false;
1709 }
1710
1711 static byte info_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1712                      PLCI *plci, APPL *appl, API_PARSE *msg)
1713 {
1714   word i;
1715   API_PARSE * ai;
1716   PLCI   * rc_plci = NULL;
1717     API_PARSE ai_parms[5];
1718   word Info = 0;
1719
1720   dbug(1,dprintf("info_req"));
1721   for(i=0;i<5;i++) ai_parms[i].length = 0;
1722
1723   ai = &msg[1];
1724
1725   if(ai->length)
1726   {
1727     if(api_parse(&ai->info[1],(word)ai->length,"ssss",ai_parms))
1728     {
1729       dbug(1,dprintf("AddInfo wrong"));
1730       Info = _WRONG_MESSAGE_FORMAT;
1731     }
1732   }
1733   if(!a) Info = _WRONG_STATE;
1734
1735   if(!Info && plci)
1736   {                /* no fac, with CPN, or KEY */
1737     rc_plci = plci;
1738     if(!ai_parms[3].length && plci->State && (msg[0].length || ai_parms[1].length) )
1739     {
1740       /* overlap sending option */
1741       dbug(1,dprintf("OvlSnd"));
1742       add_s(plci,CPN,&msg[0]);
1743       add_s(plci,KEY,&ai_parms[1]);
1744       sig_req(plci,INFO_REQ,0);
1745       send_req(plci);
1746       return false;
1747     }
1748
1749     if(plci->State && ai_parms[2].length)
1750     {
1751       /* User_Info option */
1752       dbug(1,dprintf("UUI"));
1753       add_s(plci,UUI,&ai_parms[2]);
1754       sig_req(plci,USER_DATA,0);
1755     }
1756     else if(plci->State && ai_parms[3].length)
1757     {
1758       /* Facility option */
1759       dbug(1,dprintf("FAC"));
1760       add_s(plci,CPN,&msg[0]);
1761       add_ai(plci, &msg[1]);
1762       sig_req(plci,FACILITY_REQ,0);
1763     }
1764     else
1765     {
1766       Info = _WRONG_STATE;
1767     }
1768   }
1769   else if((ai_parms[1].length || ai_parms[2].length || ai_parms[3].length) && !Info)
1770   {
1771     /* NCR_Facility option -> send UUI and Keypad too */
1772     dbug(1,dprintf("NCR_FAC"));
1773     if((i=get_plci(a)))
1774     {
1775       rc_plci = &a->plci[i-1];
1776       appl->NullCREnable  = true;
1777       rc_plci->internal_command = C_NCR_FAC_REQ;
1778       rc_plci->appl = appl;
1779       add_p(rc_plci,CAI,"\x01\x80");
1780       add_p(rc_plci,UID,"\x06\x43\x61\x70\x69\x32\x30");
1781       sig_req(rc_plci,ASSIGN,DSIG_ID);
1782       send_req(rc_plci);
1783     }
1784     else
1785     {
1786       Info = _OUT_OF_PLCI;
1787     }
1788
1789     if(!Info)
1790     {
1791       add_s(rc_plci,CPN,&msg[0]);
1792       add_ai(rc_plci, &msg[1]);
1793       sig_req(rc_plci,NCR_FACILITY,0);
1794       send_req(rc_plci);
1795       return false;
1796      /* for application controlled supplementary services    */
1797     }
1798   }
1799
1800   if (!rc_plci)
1801   {
1802     Info = _WRONG_MESSAGE_FORMAT;
1803   }
1804
1805   if(!Info)
1806   {
1807     send_req(rc_plci);
1808   }
1809   else
1810   {  /* appl is not assigned to a PLCI or error condition */
1811     dbug(1,dprintf("localInfoCon"));
1812     sendf(appl,
1813           _INFO_R|CONFIRM,
1814           Id,
1815           Number,
1816           "w",Info);
1817   }
1818   return false;
1819 }
1820
1821 static byte info_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1822                      PLCI *plci, APPL *appl, API_PARSE *msg)
1823 {
1824   dbug(1,dprintf("info_res"));
1825   return false;
1826 }
1827
1828 static byte alert_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1829                       PLCI *plci, APPL *appl, API_PARSE *msg)
1830 {
1831   word Info;
1832   byte ret;
1833
1834   dbug(1,dprintf("alert_req"));
1835
1836   Info = _WRONG_IDENTIFIER;
1837   ret = false;
1838   if(plci) {
1839     Info = _ALERT_IGNORED;
1840     if(plci->State!=INC_CON_ALERT) {
1841       Info = _WRONG_STATE;
1842       if(plci->State==INC_CON_PENDING) {
1843         Info = 0;
1844         plci->State=INC_CON_ALERT;
1845         add_ai(plci, &msg[0]);
1846         sig_req(plci,CALL_ALERT,0);
1847         ret = 1;
1848       }
1849     }
1850   }
1851   sendf(appl,
1852         _ALERT_R|CONFIRM,
1853         Id,
1854         Number,
1855         "w",Info);
1856   return ret;
1857 }
1858
1859 static byte facility_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1860                          PLCI *plci, APPL *appl, API_PARSE *msg)
1861 {
1862   word Info = 0;
1863   word i    = 0;
1864
1865   word selector;
1866   word SSreq;
1867   long relatedPLCIvalue;
1868   DIVA_CAPI_ADAPTER   * relatedadapter;
1869   byte * SSparms  = "";
1870     byte RCparms[]  = "\x05\x00\x00\x02\x00\x00";
1871     byte SSstruct[] = "\x09\x00\x00\x06\x00\x00\x00\x00\x00\x00";
1872   API_PARSE * parms;
1873     API_PARSE ss_parms[11];
1874   PLCI   *rplci;
1875     byte cai[15];
1876   dword d;
1877     API_PARSE dummy;
1878
1879   dbug(1,dprintf("facility_req"));
1880   for(i=0;i<9;i++) ss_parms[i].length = 0;
1881
1882   parms = &msg[1];
1883
1884   if(!a)
1885   {
1886     dbug(1,dprintf("wrong Ctrl"));
1887     Info = _WRONG_IDENTIFIER;
1888   }
1889
1890   selector = GET_WORD(msg[0].info);
1891
1892   if(!Info)
1893   {
1894     switch(selector)
1895     {
1896       case SELECTOR_HANDSET:
1897         Info = AdvCodecSupport(a, plci, appl, HOOK_SUPPORT);
1898         break;
1899
1900       case SELECTOR_SU_SERV:
1901         if(!msg[1].length)
1902         {
1903           Info = _WRONG_MESSAGE_FORMAT;
1904           break;
1905         }
1906         SSreq = GET_WORD(&(msg[1].info[1]));
1907         PUT_WORD(&RCparms[1],SSreq);
1908         SSparms = RCparms;
1909         switch(SSreq)
1910         {
1911           case S_GET_SUPPORTED_SERVICES:
1912             if((i=get_plci(a)))
1913             {
1914               rplci = &a->plci[i-1];
1915               rplci->appl = appl;
1916               add_p(rplci,CAI,"\x01\x80");
1917               add_p(rplci,UID,"\x06\x43\x61\x70\x69\x32\x30");
1918               sig_req(rplci,ASSIGN,DSIG_ID);
1919               send_req(rplci);
1920             }
1921             else
1922             {
1923               PUT_DWORD(&SSstruct[6], MASK_TERMINAL_PORTABILITY);
1924               SSparms = (byte *)SSstruct;
1925               break;
1926             }
1927             rplci->internal_command = GETSERV_REQ_PEND;
1928             rplci->number = Number;
1929             rplci->appl = appl;
1930             sig_req(rplci,S_SUPPORTED,0);
1931             send_req(rplci);
1932             return false;
1933             break;
1934
1935           case S_LISTEN:
1936             if(parms->length==7)
1937             {
1938               if(api_parse(&parms->info[1],(word)parms->length,"wbd",ss_parms))
1939               {
1940                 dbug(1,dprintf("format wrong"));
1941                 Info = _WRONG_MESSAGE_FORMAT;
1942                 break;
1943               }
1944             }
1945             else
1946             {
1947               Info = _WRONG_MESSAGE_FORMAT;
1948               break;
1949             }
1950             a->Notification_Mask[appl->Id-1] = GET_DWORD(ss_parms[2].info);
1951             if(a->Notification_Mask[appl->Id-1] & SMASK_MWI) /* MWI active? */
1952             {
1953               if((i=get_plci(a)))
1954               {
1955                 rplci = &a->plci[i-1];
1956                 rplci->appl = appl;
1957                 add_p(rplci,CAI,"\x01\x80");
1958                 add_p(rplci,UID,"\x06\x43\x61\x70\x69\x32\x30");
1959                 sig_req(rplci,ASSIGN,DSIG_ID);
1960                 send_req(rplci);
1961               }
1962               else
1963               {
1964                 break;
1965               }
1966               rplci->internal_command = GET_MWI_STATE;
1967               rplci->number = Number;
1968               sig_req(rplci,MWI_POLL,0);
1969               send_req(rplci);
1970             }
1971             break;
1972
1973           case S_HOLD:
1974             api_parse(&parms->info[1],(word)parms->length,"ws",ss_parms);
1975             if(plci && plci->State && plci->SuppState==IDLE)
1976             {
1977               plci->SuppState = HOLD_REQUEST;
1978               plci->command = C_HOLD_REQ;
1979               add_s(plci,CAI,&ss_parms[1]);
1980               sig_req(plci,CALL_HOLD,0);
1981               send_req(plci);
1982               return false;
1983             }
1984             else Info = 0x3010;                    /* wrong state           */
1985             break;
1986           case S_RETRIEVE:
1987             if(plci && plci->State && plci->SuppState==CALL_HELD)
1988             {
1989               if(Id & EXT_CONTROLLER)
1990               {
1991                 if(AdvCodecSupport(a, plci, appl, 0))
1992                 {
1993                   Info = 0x3010;                    /* wrong state           */
1994                   break;
1995                 }
1996               }
1997               else plci->tel = 0;
1998
1999               plci->SuppState = RETRIEVE_REQUEST;
2000               plci->command = C_RETRIEVE_REQ;
2001               if(plci->spoofed_msg==SPOOFING_REQUIRED)
2002               {
2003                 plci->spoofed_msg = CALL_RETRIEVE;
2004                 plci->internal_command = BLOCK_PLCI;
2005                 plci->command = 0;
2006                 dbug(1,dprintf("Spoof"));
2007                 return false;
2008               }
2009               else
2010               {
2011                 sig_req(plci,CALL_RETRIEVE,0);
2012                 send_req(plci);
2013                 return false;
2014               }
2015             }
2016             else Info = 0x3010;                    /* wrong state           */
2017             break;
2018           case S_SUSPEND:
2019             if(parms->length)
2020             {
2021               if(api_parse(&parms->info[1],(word)parms->length,"wbs",ss_parms))
2022               {
2023                 dbug(1,dprintf("format wrong"));
2024                 Info = _WRONG_MESSAGE_FORMAT;
2025                 break;
2026               }
2027             }
2028             if(plci && plci->State)
2029             {
2030               add_s(plci,CAI,&ss_parms[2]);
2031               plci->command = SUSPEND_REQ;
2032               sig_req(plci,SUSPEND,0);
2033               plci->State = SUSPENDING;
2034               send_req(plci);
2035             }
2036             else Info = 0x3010;                    /* wrong state           */
2037             break;
2038
2039           case S_RESUME:
2040             if(!(i=get_plci(a)) )
2041             {
2042               Info = _OUT_OF_PLCI;
2043               break;
2044             }
2045             rplci = &a->plci[i-1];
2046             rplci->appl = appl;
2047             rplci->number = Number;
2048             rplci->tel = 0;
2049             rplci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
2050             /* check 'external controller' bit for codec support */
2051             if(Id & EXT_CONTROLLER)
2052             {
2053               if(AdvCodecSupport(a, rplci, appl, 0) )
2054               {
2055                 rplci->Id = 0;
2056                 Info = 0x300A;
2057                 break;
2058               }
2059             }
2060             if(parms->length)
2061             {
2062               if(api_parse(&parms->info[1],(word)parms->length,"wbs",ss_parms))
2063               {
2064                 dbug(1,dprintf("format wrong"));
2065                 rplci->Id = 0;
2066                 Info = _WRONG_MESSAGE_FORMAT;
2067                 break;
2068               }
2069             }
2070             dummy.length = 0;
2071             dummy.info = "\x00";
2072             add_b1(rplci, &dummy, 0, 0);
2073             if (a->Info_Mask[appl->Id-1] & 0x200)
2074             {
2075               /* early B3 connect (CIP mask bit 9) no release after a disc */
2076               add_p(rplci,LLI,"\x01\x01");
2077             }
2078             add_p(rplci,UID,"\x06\x43\x61\x70\x69\x32\x30");
2079             sig_req(rplci,ASSIGN,DSIG_ID);
2080             send_req(rplci);
2081             add_s(rplci,CAI,&ss_parms[2]);
2082             rplci->command = RESUME_REQ;
2083             sig_req(rplci,RESUME,0);
2084             rplci->State = RESUMING;
2085             send_req(rplci);
2086             break;
2087
2088           case S_CONF_BEGIN: /* Request */
2089           case S_CONF_DROP:
2090           case S_CONF_ISOLATE:
2091           case S_CONF_REATTACH:
2092             if(api_parse(&parms->info[1],(word)parms->length,"wbd",ss_parms))
2093             {
2094               dbug(1,dprintf("format wrong"));
2095               Info = _WRONG_MESSAGE_FORMAT;
2096               break;
2097             }
2098             if(plci && plci->State && ((plci->SuppState==IDLE)||(plci->SuppState==CALL_HELD)))
2099             {
2100               d = GET_DWORD(ss_parms[2].info);
2101               if(d>=0x80)
2102               {
2103                 dbug(1,dprintf("format wrong"));
2104                 Info = _WRONG_MESSAGE_FORMAT;
2105                 break;
2106               }
2107               plci->ptyState = (byte)SSreq;
2108               plci->command = 0;
2109               cai[0] = 2;
2110               switch(SSreq)
2111               {
2112               case S_CONF_BEGIN:
2113                   cai[1] = CONF_BEGIN;
2114                   plci->internal_command = CONF_BEGIN_REQ_PEND;
2115                   break;
2116               case S_CONF_DROP:
2117                   cai[1] = CONF_DROP;
2118                   plci->internal_command = CONF_DROP_REQ_PEND;
2119                   break;
2120               case S_CONF_ISOLATE:
2121                   cai[1] = CONF_ISOLATE;
2122                   plci->internal_command = CONF_ISOLATE_REQ_PEND;
2123                   break;
2124               case S_CONF_REATTACH:
2125                   cai[1] = CONF_REATTACH;
2126                   plci->internal_command = CONF_REATTACH_REQ_PEND;
2127                   break;
2128               }
2129               cai[2] = (byte)d; /* Conference Size resp. PartyId */
2130               add_p(plci,CAI,cai);
2131               sig_req(plci,S_SERVICE,0);
2132               send_req(plci);
2133               return false;
2134             }
2135             else Info = 0x3010;                    /* wrong state           */
2136             break;
2137
2138           case S_ECT:
2139           case S_3PTY_BEGIN:
2140           case S_3PTY_END:
2141           case S_CONF_ADD:
2142             if(parms->length==7)
2143             {
2144               if(api_parse(&parms->info[1],(word)parms->length,"wbd",ss_parms))
2145               {
2146                 dbug(1,dprintf("format wrong"));
2147                 Info = _WRONG_MESSAGE_FORMAT;
2148                 break;
2149               }
2150             }
2151             else if(parms->length==8) /* workaround for the T-View-S */
2152             {
2153               if(api_parse(&parms->info[1],(word)parms->length,"wbdb",ss_parms))
2154               {
2155                 dbug(1,dprintf("format wrong"));
2156                 Info = _WRONG_MESSAGE_FORMAT;
2157                 break;
2158               }
2159             }
2160             else
2161             {
2162               Info = _WRONG_MESSAGE_FORMAT;
2163               break;
2164             }
2165             if(!msg[1].length)
2166             {
2167               Info = _WRONG_MESSAGE_FORMAT;
2168               break;
2169             }
2170             if (!plci)
2171             {
2172               Info = _WRONG_IDENTIFIER;
2173               break;
2174             }
2175             relatedPLCIvalue = GET_DWORD(ss_parms[2].info);
2176             relatedPLCIvalue &= 0x0000FFFF;
2177             dbug(1,dprintf("PTY/ECT/addCONF,relPLCI=%lx",relatedPLCIvalue));
2178             /* controller starts with 0 up to (max_adapter - 1) */
2179             if (((relatedPLCIvalue & 0x7f) == 0)
2180              || (MapController ((byte)(relatedPLCIvalue & 0x7f)) == 0)
2181              || (MapController ((byte)(relatedPLCIvalue & 0x7f)) > max_adapter))
2182             {
2183               if(SSreq==S_3PTY_END)
2184               {
2185                 dbug(1, dprintf("wrong Controller use 2nd PLCI=PLCI"));
2186                 rplci = plci;
2187               }
2188               else
2189               {
2190                 Info = 0x3010;                    /* wrong state           */
2191                 break;
2192               }
2193             }
2194             else
2195             {
2196               relatedadapter = &adapter[MapController ((byte)(relatedPLCIvalue & 0x7f))-1];
2197               relatedPLCIvalue >>=8;
2198               /* find PLCI PTR*/
2199               for(i=0,rplci=NULL;i<relatedadapter->max_plci;i++)
2200               {
2201                 if(relatedadapter->plci[i].Id == (byte)relatedPLCIvalue)
2202                 {
2203                   rplci = &relatedadapter->plci[i];
2204                 }
2205               }
2206               if(!rplci || !relatedPLCIvalue)
2207               {
2208                 if(SSreq==S_3PTY_END)
2209                 {
2210                   dbug(1, dprintf("use 2nd PLCI=PLCI"));
2211                   rplci = plci;
2212                 }
2213                 else
2214                 {
2215                   Info = 0x3010;                    /* wrong state           */
2216                   break;
2217                 }
2218               }
2219             }
2220 /*
2221             dbug(1,dprintf("rplci:%x",rplci));
2222             dbug(1,dprintf("plci:%x",plci));
2223             dbug(1,dprintf("rplci->ptyState:%x",rplci->ptyState));
2224             dbug(1,dprintf("plci->ptyState:%x",plci->ptyState));
2225             dbug(1,dprintf("SSreq:%x",SSreq));
2226             dbug(1,dprintf("rplci->internal_command:%x",rplci->internal_command));
2227             dbug(1,dprintf("rplci->appl:%x",rplci->appl));
2228             dbug(1,dprintf("rplci->Id:%x",rplci->Id));
2229 */
2230             /* send PTY/ECT req, cannot check all states because of US stuff */
2231             if( !rplci->internal_command && rplci->appl )
2232             {
2233               plci->command = 0;
2234               rplci->relatedPTYPLCI = plci;
2235               plci->relatedPTYPLCI = rplci;
2236               rplci->ptyState = (byte)SSreq;
2237               if(SSreq==S_ECT)
2238               {
2239                 rplci->internal_command = ECT_REQ_PEND;
2240                 cai[1] = ECT_EXECUTE;
2241
2242                 rplci->vswitchstate=0;
2243                 rplci->vsprot=0;
2244                 rplci->vsprotdialect=0;
2245                 plci->vswitchstate=0;
2246                 plci->vsprot=0;
2247                 plci->vsprotdialect=0;
2248
2249               }
2250               else if(SSreq==S_CONF_ADD)
2251               {
2252                 rplci->internal_command = CONF_ADD_REQ_PEND;
2253                 cai[1] = CONF_ADD;
2254               }
2255               else
2256               {
2257                 rplci->internal_command = PTY_REQ_PEND;
2258                 cai[1] = (byte)(SSreq-3);
2259               }
2260               rplci->number = Number;
2261               if(plci!=rplci) /* explicit invocation */
2262               {
2263                 cai[0] = 2;
2264                 cai[2] = plci->Sig.Id;
2265                 dbug(1,dprintf("explicit invocation"));
2266               }
2267               else
2268               {
2269                 dbug(1,dprintf("implicit invocation"));
2270                 cai[0] = 1;
2271               }
2272               add_p(rplci,CAI,cai);
2273               sig_req(rplci,S_SERVICE,0);
2274               send_req(rplci);
2275               return false;
2276             }
2277             else
2278             {
2279               dbug(0,dprintf("Wrong line"));
2280               Info = 0x3010;                    /* wrong state           */
2281               break;
2282             }
2283             break;
2284
2285           case S_CALL_DEFLECTION:
2286             if(api_parse(&parms->info[1],(word)parms->length,"wbwss",ss_parms))
2287             {
2288               dbug(1,dprintf("format wrong"));
2289               Info = _WRONG_MESSAGE_FORMAT;
2290               break;
2291             }
2292             if (!plci)
2293             {
2294               Info = _WRONG_IDENTIFIER;
2295               break;
2296             }
2297             /* reuse unused screening indicator */
2298             ss_parms[3].info[3] = (byte)GET_WORD(&(ss_parms[2].info[0]));
2299             plci->command = 0;
2300             plci->internal_command = CD_REQ_PEND;
2301             appl->CDEnable = true;
2302             cai[0] = 1;
2303             cai[1] = CALL_DEFLECTION;
2304             add_p(plci,CAI,cai);
2305             add_p(plci,CPN,ss_parms[3].info);
2306             sig_req(plci,S_SERVICE,0);
2307             send_req(plci);
2308             return false;
2309             break;
2310
2311           case S_CALL_FORWARDING_START:
2312             if(api_parse(&parms->info[1],(word)parms->length,"wbdwwsss",ss_parms))
2313             {
2314               dbug(1,dprintf("format wrong"));
2315               Info = _WRONG_MESSAGE_FORMAT;
2316               break;
2317             }
2318
2319             if((i=get_plci(a)))
2320             {
2321               rplci = &a->plci[i-1];
2322               rplci->appl = appl;
2323               add_p(rplci,CAI,"\x01\x80");
2324               add_p(rplci,UID,"\x06\x43\x61\x70\x69\x32\x30");
2325               sig_req(rplci,ASSIGN,DSIG_ID);
2326               send_req(rplci);
2327             }
2328             else
2329             {
2330               Info = _OUT_OF_PLCI;
2331               break;
2332             }
2333
2334             /* reuse unused screening indicator */
2335             rplci->internal_command = CF_START_PEND;
2336             rplci->appl = appl;
2337             rplci->number = Number;
2338             appl->S_Handle = GET_DWORD(&(ss_parms[2].info[0]));
2339             cai[0] = 2;
2340             cai[1] = 0x70|(byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */
2341             cai[2] = (byte)GET_WORD(&(ss_parms[4].info[0])); /* Basic Service */
2342             add_p(rplci,CAI,cai);
2343             add_p(rplci,OAD,ss_parms[5].info);
2344             add_p(rplci,CPN,ss_parms[6].info);
2345             sig_req(rplci,S_SERVICE,0);
2346             send_req(rplci);
2347             return false;
2348             break;
2349
2350           case S_INTERROGATE_DIVERSION:
2351           case S_INTERROGATE_NUMBERS:
2352           case S_CALL_FORWARDING_STOP:
2353           case S_CCBS_REQUEST:
2354           case S_CCBS_DEACTIVATE:
2355           case S_CCBS_INTERROGATE:
2356             switch(SSreq)
2357             {
2358             case S_INTERROGATE_NUMBERS:
2359                 if(api_parse(&parms->info[1],(word)parms->length,"wbd",ss_parms))
2360                 {
2361                   dbug(0,dprintf("format wrong"));
2362                   Info = _WRONG_MESSAGE_FORMAT;
2363                 }
2364                 break;
2365             case S_CCBS_REQUEST:
2366             case S_CCBS_DEACTIVATE:
2367                 if(api_parse(&parms->info[1],(word)parms->length,"wbdw",ss_parms))
2368                 {
2369                   dbug(0,dprintf("format wrong"));
2370                   Info = _WRONG_MESSAGE_FORMAT;
2371                 }
2372                 break;
2373             case S_CCBS_INTERROGATE:
2374                 if(api_parse(&parms->info[1],(word)parms->length,"wbdws",ss_parms))
2375                 {
2376                   dbug(0,dprintf("format wrong"));
2377                   Info = _WRONG_MESSAGE_FORMAT;
2378                 }
2379                 break;
2380             default:
2381             if(api_parse(&parms->info[1],(word)parms->length,"wbdwws",ss_parms))
2382             {
2383               dbug(0,dprintf("format wrong"));
2384               Info = _WRONG_MESSAGE_FORMAT;
2385               break;
2386             }
2387                 break;
2388             }
2389
2390             if(Info) break;
2391             if((i=get_plci(a)))
2392             {
2393               rplci = &a->plci[i-1];
2394               switch(SSreq)
2395               {
2396                 case S_INTERROGATE_DIVERSION: /* use cai with S_SERVICE below */
2397                   cai[1] = 0x60|(byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */
2398                   rplci->internal_command = INTERR_DIVERSION_REQ_PEND; /* move to rplci if assigned */
2399                   break;
2400                 case S_INTERROGATE_NUMBERS: /* use cai with S_SERVICE below */
2401                   cai[1] = DIVERSION_INTERROGATE_NUM; /* Function */
2402                   rplci->internal_command = INTERR_NUMBERS_REQ_PEND; /* move to rplci if assigned */
2403                   break;
2404                 case S_CALL_FORWARDING_STOP:
2405                   rplci->internal_command = CF_STOP_PEND;
2406                   cai[1] = 0x80|(byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */
2407                   break;
2408                 case S_CCBS_REQUEST:
2409                   cai[1] = CCBS_REQUEST;
2410                   rplci->internal_command = CCBS_REQUEST_REQ_PEND;
2411                   break;
2412                 case S_CCBS_DEACTIVATE:
2413                   cai[1] = CCBS_DEACTIVATE;
2414                   rplci->internal_command = CCBS_DEACTIVATE_REQ_PEND;
2415                   break;
2416                 case S_CCBS_INTERROGATE:
2417                   cai[1] = CCBS_INTERROGATE;
2418                   rplci->internal_command = CCBS_INTERROGATE_REQ_PEND;
2419                   break;
2420                 default:
2421                   cai[1] = 0;
2422                 break;
2423               }
2424               rplci->appl = appl;
2425               rplci->number = Number;
2426               add_p(rplci,CAI,"\x01\x80");
2427               add_p(rplci,UID,"\x06\x43\x61\x70\x69\x32\x30");
2428               sig_req(rplci,ASSIGN,DSIG_ID);
2429               send_req(rplci);
2430             }
2431             else
2432             {
2433               Info = _OUT_OF_PLCI;
2434               break;
2435             }
2436
2437             appl->S_Handle = GET_DWORD(&(ss_parms[2].info[0]));
2438             switch(SSreq)
2439             {
2440             case S_INTERROGATE_NUMBERS:
2441                 cai[0] = 1;
2442                 add_p(rplci,CAI,cai);
2443                 break;
2444             case S_CCBS_REQUEST:
2445             case S_CCBS_DEACTIVATE:
2446                 cai[0] = 3;
2447                 PUT_WORD(&cai[2],GET_WORD(&(ss_parms[3].info[0])));
2448                 add_p(rplci,CAI,cai);
2449                 break;
2450             case S_CCBS_INTERROGATE:
2451                 cai[0] = 3;
2452                 PUT_WORD(&cai[2],GET_WORD(&(ss_parms[3].info[0])));
2453                 add_p(rplci,CAI,cai);
2454                 add_p(rplci,OAD,ss_parms[4].info);
2455                 break;
2456             default:
2457             cai[0] = 2;
2458             cai[2] = (byte)GET_WORD(&(ss_parms[4].info[0])); /* Basic Service */
2459             add_p(rplci,CAI,cai);
2460             add_p(rplci,OAD,ss_parms[5].info);
2461                 break;
2462             }
2463
2464             sig_req(rplci,S_SERVICE,0);
2465             send_req(rplci);
2466             return false;
2467             break;
2468
2469           case S_MWI_ACTIVATE:
2470             if(api_parse(&parms->info[1],(word)parms->length,"wbwdwwwssss",ss_parms))
2471             {
2472               dbug(1,dprintf("format wrong"));
2473               Info = _WRONG_MESSAGE_FORMAT;
2474               break;
2475             }
2476             if(!plci)
2477             {
2478               if((i=get_plci(a)))
2479               {
2480                 rplci = &a->plci[i-1];
2481                 rplci->appl = appl;
2482                 rplci->cr_enquiry=true;
2483                 add_p(rplci,CAI,"\x01\x80");
2484                 add_p(rplci,UID,"\x06\x43\x61\x70\x69\x32\x30");
2485                 sig_req(rplci,ASSIGN,DSIG_ID);
2486                 send_req(rplci);
2487               }
2488               else
2489               {
2490                 Info = _OUT_OF_PLCI;
2491                 break;
2492               }
2493             }
2494             else
2495             {
2496               rplci = plci;
2497               rplci->cr_enquiry=false;
2498             }
2499
2500             rplci->command = 0;
2501             rplci->internal_command = MWI_ACTIVATE_REQ_PEND;
2502             rplci->appl = appl;
2503             rplci->number = Number;
2504
2505             cai[0] = 13;
2506             cai[1] = ACTIVATION_MWI; /* Function */
2507             PUT_WORD(&cai[2],GET_WORD(&(ss_parms[2].info[0]))); /* Basic Service */
2508             PUT_DWORD(&cai[4],GET_DWORD(&(ss_parms[3].info[0]))); /* Number of Messages */
2509             PUT_WORD(&cai[8],GET_WORD(&(ss_parms[4].info[0]))); /* Message Status */
2510             PUT_WORD(&cai[10],GET_WORD(&(ss_parms[5].info[0]))); /* Message Reference */
2511             PUT_WORD(&cai[12],GET_WORD(&(ss_parms[6].info[0]))); /* Invocation Mode */
2512             add_p(rplci,CAI,cai);
2513             add_p(rplci,CPN,ss_parms[7].info); /* Receiving User Number */
2514             add_p(rplci,OAD,ss_parms[8].info); /* Controlling User Number */
2515             add_p(rplci,OSA,ss_parms[9].info); /* Controlling User Provided Number */
2516             add_p(rplci,UID,ss_parms[10].info); /* Time */
2517             sig_req(rplci,S_SERVICE,0);
2518             send_req(rplci);
2519             return false;
2520
2521           case S_MWI_DEACTIVATE:
2522             if(api_parse(&parms->info[1],(word)parms->length,"wbwwss",ss_parms))
2523             {
2524               dbug(1,dprintf("format wrong"));
2525               Info = _WRONG_MESSAGE_FORMAT;
2526               break;
2527             }
2528             if(!plci)
2529             {
2530               if((i=get_plci(a)))
2531               {
2532                 rplci = &a->plci[i-1];
2533                 rplci->appl = appl;
2534                 rplci->cr_enquiry=true;
2535                 add_p(rplci,CAI,"\x01\x80");
2536                 add_p(rplci,UID,"\x06\x43\x61\x70\x69\x32\x30");
2537                 sig_req(rplci,ASSIGN,DSIG_ID);
2538                 send_req(rplci);
2539               }
2540               else
2541               {
2542                 Info = _OUT_OF_PLCI;
2543                 break;
2544               }
2545             }
2546             else
2547             {
2548               rplci = plci;
2549               rplci->cr_enquiry=false;
2550             }
2551
2552             rplci->command = 0;
2553             rplci->internal_command = MWI_DEACTIVATE_REQ_PEND;
2554             rplci->appl = appl;
2555             rplci->number = Number;
2556
2557             cai[0] = 5;
2558             cai[1] = DEACTIVATION_MWI; /* Function */
2559             PUT_WORD(&cai[2],GET_WORD(&(ss_parms[2].info[0]))); /* Basic Service */
2560             PUT_WORD(&cai[4],GET_WORD(&(ss_parms[3].info[0]))); /* Invocation Mode */
2561             add_p(rplci,CAI,cai);
2562             add_p(rplci,CPN,ss_parms[4].info); /* Receiving User Number */
2563             add_p(rplci,OAD,ss_parms[5].info); /* Controlling User Number */
2564             sig_req(rplci,S_SERVICE,0);
2565             send_req(rplci);
2566             return false;
2567
2568           default:
2569             Info = 0x300E;  /* not supported */
2570             break;
2571         }
2572         break; /* case SELECTOR_SU_SERV: end */
2573
2574
2575       case SELECTOR_DTMF:
2576         return (dtmf_request (Id, Number, a, plci, appl, msg));
2577
2578
2579
2580       case SELECTOR_LINE_INTERCONNECT:
2581         return (mixer_request (Id, Number, a, plci, appl, msg));
2582
2583
2584
2585       case PRIV_SELECTOR_ECHO_CANCELLER:
2586         appl->appl_flags |= APPL_FLAG_PRIV_EC_SPEC;
2587         return (ec_request (Id, Number, a, plci, appl, msg));
2588
2589       case SELECTOR_ECHO_CANCELLER:
2590         appl->appl_flags &= ~APPL_FLAG_PRIV_EC_SPEC;
2591         return (ec_request (Id, Number, a, plci, appl, msg));
2592
2593
2594       case SELECTOR_V42BIS:
2595       default:
2596         Info = _FACILITY_NOT_SUPPORTED;
2597         break;
2598     } /* end of switch(selector) */
2599   }
2600
2601   dbug(1,dprintf("SendFacRc"));
2602   sendf(appl,
2603         _FACILITY_R|CONFIRM,
2604         Id,
2605         Number,
2606         "wws",Info,selector,SSparms);
2607   return false;
2608 }
2609
2610 static byte facility_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2611                          PLCI *plci, APPL *appl, API_PARSE *msg)
2612 {
2613   dbug(1,dprintf("facility_res"));
2614   return false;
2615 }
2616
2617 static byte connect_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2618                            PLCI *plci, APPL *appl, API_PARSE *parms)
2619 {
2620   word Info = 0;
2621   byte req;
2622   byte len;
2623   word w;
2624   word fax_control_bits, fax_feature_bits, fax_info_change;
2625   API_PARSE * ncpi;
2626     byte pvc[2];
2627
2628     API_PARSE fax_parms[9];
2629   word i;
2630
2631
2632   dbug(1,dprintf("connect_b3_req"));
2633   if(plci)
2634   {
2635     if ((plci->State == IDLE) || (plci->State == OUTG_DIS_PENDING)
2636      || (plci->State == INC_DIS_PENDING) || (plci->SuppState != IDLE))
2637     {
2638       Info = _WRONG_STATE;
2639     }
2640     else
2641     {
2642       /* local reply if assign unsuccessful
2643          or B3 protocol allows only one layer 3 connection
2644            and already connected
2645              or B2 protocol not any LAPD
2646                and connect_b3_req contradicts originate/answer direction */
2647       if (!plci->NL.Id
2648        || (((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE))
2649         && ((plci->channels != 0)
2650          || (((plci->B2_prot != B2_SDLC) && (plci->B2_prot != B2_LAPD) && (plci->B2_prot != B2_LAPD_FREE_SAPI_SEL))
2651           && ((plci->call_dir & CALL_DIR_ANSWER) && !(plci->call_dir & CALL_DIR_FORCE_OUTG_NL))))))
2652       {
2653         dbug(1,dprintf("B3 already connected=%d or no NL.Id=0x%x, dir=%d sstate=0x%x",
2654                        plci->channels,plci->NL.Id,plci->call_dir,plci->SuppState));
2655         Info = _WRONG_STATE;
2656         sendf(appl,
2657               _CONNECT_B3_R|CONFIRM,
2658               Id,
2659               Number,
2660               "w",Info);
2661         return false;
2662       }
2663       plci->requested_options_conn = 0;
2664
2665       req = N_CONNECT;
2666       ncpi = &parms[0];
2667       if(plci->B3_prot==2 || plci->B3_prot==3)
2668       {
2669         if(ncpi->length>2)
2670         {
2671           /* check for PVC */
2672           if(ncpi->info[2] || ncpi->info[3])
2673           {
2674             pvc[0] = ncpi->info[3];
2675             pvc[1] = ncpi->info[2];
2676             add_d(plci,2,pvc);
2677             req = N_RESET;
2678           }
2679           else
2680           {
2681             if(ncpi->info[1] &1) req = N_CONNECT | N_D_BIT;
2682             add_d(plci,(word)(ncpi->length-3),&ncpi->info[4]);
2683           }
2684         }
2685       }
2686       else if(plci->B3_prot==5)
2687       {
2688         if (plci->NL.Id && !plci->nl_remove_id)
2689         {
2690           fax_control_bits = GET_WORD(&((T30_INFO   *)plci->fax_connect_info_buffer)->control_bits_low);
2691           fax_feature_bits = GET_WORD(&((T30_INFO   *)plci->fax_connect_info_buffer)->feature_bits_low);
2692           if (!(fax_control_bits & T30_CONTROL_BIT_MORE_DOCUMENTS)
2693            || (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS))
2694           {
2695             len = offsetof(T30_INFO, universal_6);
2696             fax_info_change = false;
2697             if (ncpi->length >= 4)
2698             {
2699               w = GET_WORD(&ncpi->info[3]);
2700               if ((w & 0x0001) != ((word)(((T30_INFO   *)(plci->fax_connect_info_buffer))->resolution & 0x0001)))
2701               {
2702                 ((T30_INFO   *)(plci->fax_connect_info_buffer))->resolution =
2703                   (byte)((((T30_INFO   *)(plci->fax_connect_info_buffer))->resolution & ~T30_RESOLUTION_R8_0770_OR_200) |
2704                   ((w & 0x0001) ? T30_RESOLUTION_R8_0770_OR_200 : 0));
2705                 fax_info_change = true;
2706               }
2707               fax_control_bits &= ~(T30_CONTROL_BIT_REQUEST_POLLING | T30_CONTROL_BIT_MORE_DOCUMENTS);
2708               if (w & 0x0002)  /* Fax-polling request */
2709                 fax_control_bits |= T30_CONTROL_BIT_REQUEST_POLLING;
2710               if ((w & 0x0004) /* Request to send / poll another document */
2711                && (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_MORE_DOCUMENTS))
2712               {
2713                 fax_control_bits |= T30_CONTROL_BIT_MORE_DOCUMENTS;
2714               }
2715               if (ncpi->length >= 6)
2716               {
2717                 w = GET_WORD(&ncpi->info[5]);
2718                 if (((byte) w) != ((T30_INFO   *)(plci->fax_connect_info_buffer))->data_format)
2719                 {
2720                   ((T30_INFO   *)(plci->fax_connect_info_buffer))->data_format = (byte) w;
2721                   fax_info_change = true;
2722                 }
2723
2724                 if ((a->man_profile.private_options & (1L << PRIVATE_FAX_SUB_SEP_PWD))
2725                  && (GET_WORD(&ncpi->info[5]) & 0x8000)) /* Private SEP/SUB/PWD enable */
2726                 {
2727                   plci->requested_options_conn |= (1L << PRIVATE_FAX_SUB_SEP_PWD);
2728                 }
2729                 if ((a->man_profile.private_options & (1L << PRIVATE_FAX_NONSTANDARD))
2730                  && (GET_WORD(&ncpi->info[5]) & 0x4000)) /* Private non-standard facilities enable */
2731                 {
2732                   plci->requested_options_conn |= (1L << PRIVATE_FAX_NONSTANDARD);
2733                 }
2734                 fax_control_bits &= ~(T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_SEL_POLLING |
2735                   T30_CONTROL_BIT_ACCEPT_PASSWORD);
2736                 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id-1])
2737                   & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
2738                 {
2739                   if (api_parse (&ncpi->info[1], ncpi->length, "wwwwsss", fax_parms))
2740                     Info = _WRONG_MESSAGE_FORMAT;
2741                   else
2742                   {
2743                     if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id-1])
2744                       & (1L << PRIVATE_FAX_SUB_SEP_PWD))
2745       {
2746                     fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_PASSWORD;
2747                     if (fax_control_bits & T30_CONTROL_BIT_ACCEPT_POLLING)
2748                       fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SEL_POLLING;
2749       }
2750                     w = fax_parms[4].length;
2751                     if (w > 20)
2752                       w = 20;
2753                     ((T30_INFO   *)(plci->fax_connect_info_buffer))->station_id_len = (byte) w;
2754                     for (i = 0; i < w; i++)
2755                       ((T30_INFO   *)(plci->fax_connect_info_buffer))->station_id[i] = fax_parms[4].info[1+i];
2756                     ((T30_INFO   *)(plci->fax_connect_info_buffer))->head_line_len = 0;
2757                     len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
2758                     w = fax_parms[5].length;
2759                     if (w > 20)
2760                       w = 20;
2761                     plci->fax_connect_info_buffer[len++] = (byte) w;
2762                     for (i = 0; i < w; i++)
2763                       plci->fax_connect_info_buffer[len++] = fax_parms[5].info[1+i];
2764                     w = fax_parms[6].length;
2765                     if (w > 20)
2766                       w = 20;
2767                     plci->fax_connect_info_buffer[len++] = (byte) w;
2768                     for (i = 0; i < w; i++)
2769                       plci->fax_connect_info_buffer[len++] = fax_parms[6].info[1+i];
2770                     if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id-1])
2771                       & (1L << PRIVATE_FAX_NONSTANDARD))
2772       {
2773                       if (api_parse (&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms))
2774         {
2775                         dbug(1,dprintf("non-standard facilities info missing or wrong format"));
2776                         plci->fax_connect_info_buffer[len++] = 0;
2777         }
2778                       else
2779                       {
2780           if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2))
2781             plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]);
2782    plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length);
2783           for (i = 0; i < fax_parms[7].length; i++)
2784      plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1+i];
2785                       }
2786                     }
2787                   }
2788                 }
2789                 else
2790                 {
2791                   len = offsetof(T30_INFO, universal_6);
2792                 }
2793                 fax_info_change = true;
2794
2795               }
2796               if (fax_control_bits != GET_WORD(&((T30_INFO   *)plci->fax_connect_info_buffer)->control_bits_low))
2797               {
2798                 PUT_WORD (&((T30_INFO   *)plci->fax_connect_info_buffer)->control_bits_low, fax_control_bits);
2799                 fax_info_change = true;
2800               }
2801             }
2802             if (Info == GOOD)
2803             {
2804               plci->fax_connect_info_length = len;
2805               if (fax_info_change)
2806               {
2807                 if (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS)
2808                 {
2809                   start_internal_command (Id, plci, fax_connect_info_command);
2810                   return false;
2811                 }
2812                 else
2813                 {
2814                   start_internal_command (Id, plci, fax_adjust_b23_command);
2815                   return false;
2816                 }
2817               }
2818             }
2819           }
2820           else  Info = _WRONG_STATE;
2821         }
2822         else  Info = _WRONG_STATE;
2823       }
2824
2825       else if (plci->B3_prot == B3_RTP)
2826       {
2827         plci->internal_req_buffer[0] = ncpi->length + 1;
2828         plci->internal_req_buffer[1] = UDATA_REQUEST_RTP_RECONFIGURE;
2829         for (w = 0; w < ncpi->length; w++)
2830           plci->internal_req_buffer[2+w] = ncpi->info[1+w];
2831         start_internal_command (Id, plci, rtp_connect_b3_req_command);
2832         return false;
2833       }
2834
2835       if(!Info)
2836       {
2837         nl_req_ncci(plci,req,0);
2838         return 1;
2839       }
2840     }
2841   }
2842   else Info = _WRONG_IDENTIFIER;
2843
2844   sendf(appl,
2845         _CONNECT_B3_R|CONFIRM,
2846         Id,
2847         Number,
2848         "w",Info);
2849   return false;
2850 }
2851
2852 static byte connect_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2853                            PLCI *plci, APPL *appl, API_PARSE *parms)
2854 {
2855   word ncci;
2856   API_PARSE * ncpi;
2857   byte req;
2858
2859   word w;
2860
2861
2862     API_PARSE fax_parms[9];
2863   word i;
2864   byte len;
2865
2866
2867   dbug(1,dprintf("connect_b3_res"));
2868
2869   ncci = (word)(Id>>16);
2870   if(plci && ncci) {
2871     if(a->ncci_state[ncci]==INC_CON_PENDING) {
2872       if (GET_WORD (&parms[0].info[0]) != 0)
2873       {
2874         a->ncci_state[ncci] = OUTG_REJ_PENDING;
2875         channel_request_xon (plci, a->ncci_ch[ncci]);
2876         channel_xmit_xon (plci);
2877         cleanup_ncci_data (plci, ncci);
2878         nl_req_ncci(plci,N_DISC,(byte)ncci);
2879         return 1;
2880       }
2881       a->ncci_state[ncci] = INC_ACT_PENDING;
2882
2883       req = N_CONNECT_ACK;
2884       ncpi = &parms[1];
2885       if ((plci->B3_prot == 4) || (plci->B3_prot == 5) || (plci->B3_prot == 7))
2886       {
2887
2888         if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id-1])
2889           & (1L << PRIVATE_FAX_NONSTANDARD))
2890  {
2891    if (((plci->B3_prot == 4) || (plci->B3_prot == 5))
2892     && (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF)
2893     && (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP))
2894    {
2895             len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
2896             if (plci->fax_connect_info_length < len)
2897             {
2898               ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id_len = 0;
2899               ((T30_INFO *)(plci->fax_connect_info_buffer))->head_line_len = 0;
2900             }
2901             if (api_parse (&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms))
2902             {
2903               dbug(1,dprintf("non-standard facilities info missing or wrong format"));
2904             }
2905             else
2906             {
2907               if (plci->fax_connect_info_length <= len)
2908                 plci->fax_connect_info_buffer[len] = 0;
2909               len += 1 + plci->fax_connect_info_buffer[len];
2910               if (plci->fax_connect_info_length <= len)
2911                 plci->fax_connect_info_buffer[len] = 0;
2912               len += 1 + plci->fax_connect_info_buffer[len];
2913               if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2))
2914                 plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]);
2915               plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length);
2916               for (i = 0; i < fax_parms[7].length; i++)
2917                 plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1+i];
2918             }
2919             plci->fax_connect_info_length = len;
2920             ((T30_INFO *)(plci->fax_connect_info_buffer))->code = 0;
2921             start_internal_command (Id, plci, fax_connect_ack_command);
2922      return false;
2923           }
2924         }
2925
2926         nl_req_ncci(plci,req,(byte)ncci);
2927         if ((plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
2928          && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
2929         {
2930           if (plci->B3_prot == 4)
2931             sendf(appl,_CONNECT_B3_ACTIVE_I,Id,0,"s","");
2932           else
2933             sendf(appl,_CONNECT_B3_ACTIVE_I,Id,0,"S",plci->ncpi_buffer);
2934           plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
2935         }
2936       }
2937
2938       else if (plci->B3_prot == B3_RTP)
2939       {
2940         plci->internal_req_buffer[0] = ncpi->length + 1;
2941         plci->internal_req_buffer[1] = UDATA_REQUEST_RTP_RECONFIGURE;
2942         for (w = 0; w < ncpi->length; w++)
2943           plci->internal_req_buffer[2+w] = ncpi->info[1+w];
2944         start_internal_command (Id, plci, rtp_connect_b3_res_command);
2945         return false;
2946       }
2947
2948       else
2949       {
2950         if(ncpi->length>2) {
2951           if(ncpi->info[1] &1) req = N_CONNECT_ACK | N_D_BIT;
2952           add_d(plci,(word)(ncpi->length-3),&ncpi->info[4]);
2953         }
2954         nl_req_ncci(plci,req,(byte)ncci);
2955         sendf(appl,_CONNECT_B3_ACTIVE_I,Id,0,"s","");
2956         if (plci->adjust_b_restore)
2957         {
2958           plci->adjust_b_restore = false;
2959           start_internal_command (Id, plci, adjust_b_restore);
2960         }
2961       }
2962       return 1;
2963     }
2964   }
2965   return false;
2966 }
2967
2968 static byte connect_b3_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2969                              PLCI *plci, APPL *appl, API_PARSE *parms)
2970 {
2971   word ncci;
2972
2973   ncci = (word)(Id>>16);
2974   dbug(1,dprintf("connect_b3_a_res(ncci=0x%x)",ncci));
2975
2976   if (plci && ncci && (plci->State != IDLE) && (plci->State != INC_DIS_PENDING)
2977    && (plci->State != OUTG_DIS_PENDING))
2978   {
2979     if(a->ncci_state[ncci]==INC_ACT_PENDING) {
2980       a->ncci_state[ncci] = CONNECTED;
2981       if(plci->State!=INC_CON_CONNECTED_ALERT) plci->State = CONNECTED;
2982       channel_request_xon (plci, a->ncci_ch[ncci]);
2983       channel_xmit_xon (plci);
2984     }
2985   }
2986   return false;
2987 }
2988
2989 static byte disconnect_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2990                               PLCI *plci, APPL *appl, API_PARSE *parms)
2991 {
2992   word Info;
2993   word ncci;
2994   API_PARSE * ncpi;
2995
2996   dbug(1,dprintf("disconnect_b3_req"));
2997
2998   Info = _WRONG_IDENTIFIER;
2999   ncci = (word)(Id>>16);
3000   if (plci && ncci)
3001   {
3002     Info = _WRONG_STATE;
3003     if ((a->ncci_state[ncci] == CONNECTED)
3004      || (a->ncci_state[ncci] == OUTG_CON_PENDING)
3005      || (a->ncci_state[ncci] == INC_CON_PENDING)
3006      || (a->ncci_state[ncci] == INC_ACT_PENDING))
3007     {
3008       a->ncci_state[ncci] = OUTG_DIS_PENDING;
3009       channel_request_xon (plci, a->ncci_ch[ncci]);
3010       channel_xmit_xon (plci);
3011
3012       if (a->ncci[ncci].data_pending
3013        && ((plci->B3_prot == B3_TRANSPARENT)
3014         || (plci->B3_prot == B3_T30)
3015         || (plci->B3_prot == B3_T30_WITH_EXTENSIONS)))
3016       {
3017         plci->send_disc = (byte)ncci;
3018         plci->command = 0;
3019         return false;
3020       }
3021       else
3022       {
3023         cleanup_ncci_data (plci, ncci);
3024
3025         if(plci->B3_prot==2 || plci->B3_prot==3)
3026         {
3027           ncpi = &parms[0];
3028           if(ncpi->length>3)
3029           {
3030             add_d(plci, (word)(ncpi->length - 3) ,(byte   *)&(ncpi->info[4]));
3031           }
3032         }
3033         nl_req_ncci(plci,N_DISC,(byte)ncci);
3034       }
3035       return 1;
3036     }
3037   }
3038   sendf(appl,
3039         _DISCONNECT_B3_R|CONFIRM,
3040         Id,
3041         Number,
3042         "w",Info);
3043   return false;
3044 }
3045
3046 static byte disconnect_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3047                               PLCI *plci, APPL *appl, API_PARSE *parms)
3048 {
3049   word ncci;
3050   word i;
3051
3052   ncci = (word)(Id>>16);
3053   dbug(1,dprintf("disconnect_b3_res(ncci=0x%x",ncci));
3054   if(plci && ncci) {
3055     plci->requested_options_conn = 0;
3056     plci->fax_connect_info_length = 0;
3057     plci->ncpi_state = 0x00;
3058     if (((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE))
3059       && ((plci->B2_prot != B2_LAPD) && (plci->B2_prot != B2_LAPD_FREE_SAPI_SEL)))
3060     {
3061       plci->call_dir |= CALL_DIR_FORCE_OUTG_NL;
3062     }
3063     for(i=0; i<MAX_CHANNELS_PER_PLCI && plci->inc_dis_ncci_table[i]!=(byte)ncci; i++);
3064     if(i<MAX_CHANNELS_PER_PLCI) {
3065       if(plci->channels)plci->channels--;
3066       for(; i<MAX_CHANNELS_PER_PLCI-1; i++) plci->inc_dis_ncci_table[i] = plci->inc_dis_ncci_table[i+1];
3067       plci->inc_dis_ncci_table[MAX_CHANNELS_PER_PLCI-1] = 0;
3068
3069       ncci_free_receive_buffers (plci, ncci);
3070
3071       if((plci->State==IDLE || plci->State==SUSPENDING) && !plci->channels){
3072         if(plci->State == SUSPENDING){
3073           sendf(plci->appl,
3074                 _FACILITY_I,
3075                 Id & 0xffffL,
3076                 0,
3077                 "ws", (word)3, "\x03\x04\x00\x00");
3078           sendf(plci->appl, _DISCONNECT_I, Id & 0xffffL, 0, "w", 0);
3079         }
3080         plci_remove(plci);
3081         plci->State=IDLE;
3082       }
3083     }
3084     else
3085     {
3086       if ((a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
3087        && ((plci->B3_prot == 4) || (plci->B3_prot == 5))
3088        && (a->ncci_state[ncci] == INC_DIS_PENDING))
3089       {
3090         ncci_free_receive_buffers (plci, ncci);
3091
3092         nl_req_ncci(plci,N_EDATA,(byte)ncci);
3093
3094         plci->adapter->ncci_state[ncci] = IDLE;
3095         start_internal_command (Id, plci, fax_disconnect_command);
3096         return 1;
3097       }
3098     }
3099   }
3100   return false;
3101 }
3102
3103 static byte data_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3104                         PLCI *plci, APPL *appl, API_PARSE *parms)
3105 {
3106   NCCI   *ncci_ptr;
3107   DATA_B3_DESC   *data;
3108   word Info;
3109   word ncci;
3110   word i;
3111
3112   dbug(1,dprintf("data_b3_req"));
3113
3114   Info = _WRONG_IDENTIFIER;
3115   ncci = (word)(Id>>16);
3116   dbug(1,dprintf("ncci=0x%x, plci=0x%x",ncci,plci));
3117
3118   if (plci && ncci)
3119   {
3120     Info = _WRONG_STATE;
3121     if ((a->ncci_state[ncci] == CONNECTED)
3122      || (a->ncci_state[ncci] == INC_ACT_PENDING))
3123     {
3124         /* queue data */
3125       ncci_ptr = &(a->ncci[ncci]);
3126       i = ncci_ptr->data_out + ncci_ptr->data_pending;
3127       if (i >= MAX_DATA_B3)
3128         i -= MAX_DATA_B3;
3129       data = &(ncci_ptr->DBuffer[i]);
3130       data->Number = Number;
3131       if ((((byte   *)(parms[0].info)) >= ((byte   *)(plci->msg_in_queue)))
3132        && (((byte   *)(parms[0].info)) < ((byte   *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
3133       {
3134
3135         data->P = (byte *)(long)(*((dword *)(parms[0].info)));
3136
3137       }
3138       else
3139         data->P = TransmitBufferSet(appl,*(dword *)parms[0].info);
3140       data->Length = GET_WORD(parms[1].info);
3141       data->Handle = GET_WORD(parms[2].info);
3142       data->Flags = GET_WORD(parms[3].info);
3143       (ncci_ptr->data_pending)++;
3144
3145         /* check for delivery confirmation */
3146       if (data->Flags & 0x0004)
3147       {
3148         i = ncci_ptr->data_ack_out + ncci_ptr->data_ack_pending;
3149         if (i >= MAX_DATA_ACK)
3150           i -= MAX_DATA_ACK;
3151         ncci_ptr->DataAck[i].Number = data->Number;
3152         ncci_ptr->DataAck[i].Handle = data->Handle;
3153         (ncci_ptr->data_ack_pending)++;
3154       }
3155
3156       send_data(plci);
3157       return false;
3158     }
3159   }
3160   if (appl)
3161   {
3162     if (plci)
3163     {
3164       if ((((byte   *)(parms[0].info)) >= ((byte   *)(plci->msg_in_queue)))
3165        && (((byte   *)(parms[0].info)) < ((byte   *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
3166       {
3167
3168         TransmitBufferFree (appl, (byte *)(long)(*((dword *)(parms[0].info))));
3169
3170       }
3171     }
3172     sendf(appl,
3173           _DATA_B3_R|CONFIRM,
3174           Id,
3175           Number,
3176           "ww",GET_WORD(parms[2].info),Info);
3177   }
3178   return false;
3179 }
3180
3181 static byte data_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3182                         PLCI *plci, APPL *appl, API_PARSE *parms)
3183 {
3184   word n;
3185   word ncci;
3186   word NCCIcode;
3187
3188   dbug(1,dprintf("data_b3_res"));
3189
3190   ncci = (word)(Id>>16);
3191   if(plci && ncci) {
3192     n = GET_WORD(parms[0].info);
3193     dbug(1,dprintf("free(%d)",n));
3194     NCCIcode = ncci | (((word) a->Id) << 8);
3195     if(n<appl->MaxBuffer &&
3196        appl->DataNCCI[n]==NCCIcode &&
3197        (byte)(appl->DataFlags[n]>>8)==plci->Id) {
3198       dbug(1,dprintf("found"));
3199       appl->DataNCCI[n] = 0;
3200
3201       if (channel_can_xon (plci, a->ncci_ch[ncci])) {
3202         channel_request_xon (plci, a->ncci_ch[ncci]);
3203       }
3204       channel_xmit_xon (plci);
3205
3206       if(appl->DataFlags[n] &4) {
3207         nl_req_ncci(plci,N_DATA_ACK,(byte)ncci);
3208         return 1;
3209       }
3210     }
3211   }
3212   return false;
3213 }
3214
3215 static byte reset_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3216                          PLCI *plci, APPL *appl, API_PARSE *parms)
3217 {
3218   word Info;
3219   word ncci;
3220
3221   dbug(1,dprintf("reset_b3_req"));
3222
3223   Info = _WRONG_IDENTIFIER;
3224   ncci = (word)(Id>>16);
3225   if(plci && ncci)
3226   {
3227     Info = _WRONG_STATE;
3228     switch (plci->B3_prot)
3229     {
3230     case B3_ISO8208:
3231     case B3_X25_DCE:
3232       if(a->ncci_state[ncci]==CONNECTED)
3233       {
3234         nl_req_ncci(plci,N_RESET,(byte)ncci);
3235         send_req(plci);
3236         Info = GOOD;
3237       }
3238       break;
3239     case B3_TRANSPARENT:
3240       if(a->ncci_state[ncci]==CONNECTED)
3241       {
3242         start_internal_command (Id, plci, reset_b3_command);
3243         Info = GOOD;
3244       }
3245       break;
3246     }
3247   }
3248   /* reset_b3 must result in a reset_b3_con & reset_b3_Ind */
3249   sendf(appl,
3250         _RESET_B3_R|CONFIRM,
3251         Id,
3252         Number,
3253         "w",Info);
3254   return false;
3255 }
3256
3257 static byte reset_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3258                          PLCI *plci, APPL *appl, API_PARSE *parms)
3259 {
3260   word ncci;
3261
3262   dbug(1,dprintf("reset_b3_res"));
3263
3264   ncci = (word)(Id>>16);
3265   if(plci && ncci) {
3266     switch (plci->B3_prot)
3267     {
3268     case B3_ISO8208:
3269     case B3_X25_DCE:
3270       if(a->ncci_state[ncci]==INC_RES_PENDING)
3271       {
3272         a->ncci_state[ncci] = CONNECTED;
3273         nl_req_ncci(plci,N_RESET_ACK,(byte)ncci);
3274         return true;
3275       }
3276     break;
3277     }
3278   }
3279   return false;
3280 }
3281
3282 static byte connect_b3_t90_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3283                                  PLCI *plci, APPL *appl, API_PARSE *parms)
3284 {
3285   word ncci;
3286   API_PARSE * ncpi;
3287   byte req;
3288
3289   dbug(1,dprintf("connect_b3_t90_a_res"));
3290
3291   ncci = (word)(Id>>16);
3292   if(plci && ncci) {
3293     if(a->ncci_state[ncci]==INC_ACT_PENDING) {
3294       a->ncci_state[ncci] = CONNECTED;
3295     }
3296     else if(a->ncci_state[ncci]==INC_CON_PENDING) {
3297       a->ncci_state[ncci] = CONNECTED;
3298
3299       req = N_CONNECT_ACK;
3300
3301         /* parms[0]==0 for CAPI original message definition! */
3302       if(parms[0].info) {
3303         ncpi = &parms[1];
3304         if(ncpi->length>2) {
3305           if(ncpi->info[1] &1) req = N_CONNECT_ACK | N_D_BIT;
3306           add_d(plci,(word)(ncpi->length-3),&ncpi->info[4]);
3307         }
3308       }
3309       nl_req_ncci(plci,req,(byte)ncci);
3310       return 1;
3311     }
3312   }
3313   return false;
3314 }
3315
3316
3317 static byte select_b_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3318                          PLCI *plci, APPL *appl, API_PARSE *msg)
3319 {
3320   word Info=0;
3321   word i;
3322   byte tel;
3323     API_PARSE bp_parms[7];
3324
3325   if(!plci || !msg)
3326   {
3327     Info = _WRONG_IDENTIFIER;
3328   }
3329   else
3330   {
3331     dbug(1,dprintf("select_b_req[%d],PLCI=0x%x,Tel=0x%x,NL=0x%x,appl=0x%x,sstate=0x%x",
3332                    msg->length,plci->Id,plci->tel,plci->NL.Id,plci->appl,plci->SuppState));
3333     dbug(1,dprintf("PlciState=0x%x",plci->State));
3334     for(i=0;i<7;i++) bp_parms[i].length = 0;
3335
3336     /* check if no channel is open, no B3 connected only */
3337     if((plci->State == IDLE) || (plci->State == OUTG_DIS_PENDING) || (plci->State == INC_DIS_PENDING)
3338      || (plci->SuppState != IDLE) || plci->channels || plci->nl_remove_id)
3339     {
3340       Info = _WRONG_STATE;
3341     }
3342     /* check message format and fill bp_parms pointer */
3343     else if(msg->length && api_parse(&msg->info[1], (word)msg->length, "wwwsss", bp_parms))
3344     {
3345       Info = _WRONG_MESSAGE_FORMAT;
3346     }
3347     else
3348     {
3349       if((plci->State==INC_CON_PENDING) || (plci->State==INC_CON_ALERT)) /* send alert tone inband to the network, */
3350       {                                                                  /* e.g. Qsig or RBS or Cornet-N or xess PRI */
3351         if(Id & EXT_CONTROLLER)
3352         {
3353           sendf(appl, _SELECT_B_REQ|CONFIRM, Id, Number, "w", 0x2002); /* wrong controller */
3354           return 0;
3355         }
3356         plci->State=INC_CON_CONNECTED_ALERT;
3357         plci->appl = appl;
3358         clear_c_ind_mask_bit (plci, (word)(appl->Id-1));
3359         dump_c_ind_mask (plci);
3360         for(i=0; i<max_appl; i++) /* disconnect the other appls */
3361         {                         /* its quasi a connect        */
3362           if(test_c_ind_mask_bit (plci, i))
3363             sendf(&application[i], _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED);
3364         }
3365       }
3366
3367       api_save_msg(msg, "s", &plci->saved_msg);
3368       tel = plci->tel;
3369       if(Id & EXT_CONTROLLER)
3370       {
3371         if(tel) /* external controller in use by this PLCI */
3372         {
3373           if(a->AdvSignalAppl && a->AdvSignalAppl!=appl)
3374           {
3375             dbug(1,dprintf("Ext_Ctrl in use 1"));
3376             Info = _WRONG_STATE;
3377           }
3378         }
3379         else  /* external controller NOT in use by this PLCI ? */
3380         {
3381           if(a->AdvSignalPLCI)
3382           {
3383             dbug(1,dprintf("Ext_Ctrl in use 2"));
3384             Info = _WRONG_STATE;
3385           }
3386           else /* activate the codec */
3387           {
3388             dbug(1,dprintf("Ext_Ctrl start"));
3389             if(AdvCodecSupport(a, plci, appl, 0) )
3390             {
3391               dbug(1,dprintf("Error in codec procedures"));
3392               Info = _WRONG_STATE;
3393             }
3394             else if(plci->spoofed_msg==SPOOFING_REQUIRED) /* wait until codec is active */
3395             {
3396               plci->spoofed_msg = AWAITING_SELECT_B;
3397               plci->internal_command = BLOCK_PLCI; /* lock other commands */
3398               plci->command = 0;
3399               dbug(1,dprintf("continue if codec loaded"));
3400               return false;
3401             }
3402           }
3403         }
3404       }
3405       else /* external controller bit is OFF */
3406       {
3407         if(tel) /* external controller in use, need to switch off */
3408         {
3409           if(a->AdvSignalAppl==appl)
3410           {
3411             CodecIdCheck(a, plci);
3412             plci->tel = 0;
3413             plci->adv_nl = 0;
3414             dbug(1,dprintf("Ext_Ctrl disable"));
3415           }
3416           else
3417           {
3418             dbug(1,dprintf("Ext_Ctrl not requested"));
3419           }
3420         }
3421       }
3422       if (!Info)
3423       {
3424         if (plci->call_dir & CALL_DIR_OUT)
3425           plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
3426         else if (plci->call_dir & CALL_DIR_IN)
3427           plci->call_dir = CALL_DIR_IN | CALL_DIR_ANSWER;
3428         start_internal_command (Id, plci, select_b_command);
3429         return false;
3430       }
3431     }
3432   }
3433   sendf(appl, _SELECT_B_REQ|CONFIRM, Id, Number, "w", Info);
3434   return false;
3435 }
3436
3437 static byte manufacturer_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3438                              PLCI *plci, APPL *appl, API_PARSE *parms)
3439 {
3440   word command;
3441   word i;
3442   word ncci;
3443   API_PARSE * m;
3444     API_PARSE m_parms[5];
3445   word codec;
3446   byte req;
3447   byte ch;
3448   byte dir;
3449   static byte chi[2] = {0x01,0x00};
3450   static byte lli[2] = {0x01,0x00};
3451   static byte codec_cai[2] = {0x01,0x01};
3452   static byte null_msg = {0};
3453   static API_PARSE null_parms = { 0, &null_msg };
3454   PLCI   * v_plci;
3455   word Info=0;
3456
3457   dbug(1,dprintf("manufacturer_req"));
3458   for(i=0;i<5;i++) m_parms[i].length = 0;
3459
3460   if(GET_DWORD(parms[0].info)!=_DI_MANU_ID) {
3461     Info = _WRONG_MESSAGE_FORMAT;
3462   }
3463   command = GET_WORD(parms[1].info);
3464   m = &parms[2];
3465   if (!Info)
3466   {
3467     switch(command) {
3468     case _DI_ASSIGN_PLCI:
3469       if(api_parse(&m->info[1],(word)m->length,"wbbs",m_parms)) {
3470         Info = _WRONG_MESSAGE_FORMAT;
3471         break;
3472       }
3473       codec = GET_WORD(m_parms[0].info);
3474       ch = m_parms[1].info[0];
3475       dir = m_parms[2].info[0];
3476       if((i=get_plci(a))) {
3477         plci = &a->plci[i-1];
3478         plci->appl = appl;
3479         plci->command = _MANUFACTURER_R;
3480         plci->m_command = command;
3481         plci->number = Number;
3482         plci->State = LOCAL_CONNECT;
3483         Id = ( ((word)plci->Id<<8)|plci->adapter->Id|0x80);
3484         dbug(1,dprintf("ManCMD,plci=0x%x",Id));
3485
3486         if((ch==1 || ch==2) && (dir<=2)) {
3487           chi[1] = (byte)(0x80|ch);
3488           lli[1] = 0;
3489           plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
3490           switch(codec)
3491           {
3492           case 0:
3493             Info = add_b1(plci,&m_parms[3],0,0);
3494             break;
3495           case 1:
3496             add_p(plci,CAI,codec_cai);
3497             break;
3498           /* manual 'swich on' to the codec support without signalling */
3499           /* first 'assign plci' with this function, then use */
3500           case 2:
3501             if(AdvCodecSupport(a, plci, appl, 0) ) {
3502               Info = _RESOURCE_ERROR;
3503             }
3504             else {
3505               Info = add_b1(plci,&null_parms,0,B1_FACILITY_LOCAL);
3506               lli[1] = 0x10; /* local call codec stream */
3507             }
3508             break;
3509           }
3510
3511           plci->State = LOCAL_CONNECT;
3512           plci->manufacturer = true;
3513           plci->command = _MANUFACTURER_R;
3514           plci->m_command = command;
3515           plci->number = Number;
3516
3517           if(!Info)
3518           {
3519             add_p(plci,LLI,lli);
3520             add_p(plci,CHI,chi);
3521             add_p(plci,UID,"\x06\x43\x61\x70\x69\x32\x30");
3522             sig_req(plci,ASSIGN,DSIG_ID);
3523
3524             if(!codec)
3525             {
3526               Info = add_b23(plci,&m_parms[3]);
3527               if(!Info)
3528               {
3529                 nl_req_ncci(plci,ASSIGN,0);
3530                 send_req(plci);
3531               }
3532             }
3533             if(!Info)
3534             {
3535               dbug(1,dprintf("dir=0x%x,spoof=0x%x",dir,plci->spoofed_msg));
3536               if (plci->spoofed_msg==SPOOFING_REQUIRED)
3537               {
3538                 api_save_msg (m_parms, "wbbs", &plci->saved_msg);
3539                 plci->spoofed_msg = AWAITING_MANUF_CON;
3540                 plci->internal_command = BLOCK_PLCI; /* reject other req meanwhile */
3541                 plci->command = 0;
3542                 send_req(plci);
3543                 return false;
3544               }
3545               if(dir==1) {
3546                 sig_req(plci,CALL_REQ,0);
3547               }
3548               else if(!dir){
3549                 sig_req(plci,LISTEN_REQ,0);
3550               }
3551               send_req(plci);
3552             }
3553             else
3554             {
3555               sendf(appl,
3556                     _MANUFACTURER_R|CONFIRM,
3557                     Id,
3558                     Number,
3559                     "dww",_DI_MANU_ID,command,Info);
3560               return 2;
3561             }
3562           }
3563         }
3564       }
3565       else  Info = _OUT_OF_PLCI;
3566       break;
3567
3568     case _DI_IDI_CTRL:
3569       if(!plci)
3570       {
3571         Info = _WRONG_IDENTIFIER;
3572         break;
3573       }
3574       if(api_parse(&m->info[1],(word)m->length,"bs",m_parms)) {
3575         Info = _WRONG_MESSAGE_FORMAT;
3576         break;
3577       }
3578       req = m_parms[0].info[0];
3579       plci->command = _MANUFACTURER_R;
3580       plci->m_command = command;
3581       plci->number = Number;
3582       if(req==CALL_REQ)
3583       {
3584         plci->b_channel = getChannel(&m_parms[1]);
3585         mixer_set_bchannel_id_esc (plci, plci->b_channel);
3586         if(plci->spoofed_msg==SPOOFING_REQUIRED)
3587         {
3588           plci->spoofed_msg = CALL_REQ | AWAITING_MANUF_CON;
3589           plci->internal_command = BLOCK_PLCI; /* reject other req meanwhile */
3590           plci->command = 0;
3591           break;
3592         }
3593       }
3594       else if(req==LAW_REQ)
3595       {
3596         plci->cr_enquiry = true;
3597       }
3598       add_ss(plci,FTY,&m_parms[1]);
3599       sig_req(plci,req,0);
3600       send_req(plci);
3601       if(req==HANGUP)
3602       {
3603         if (plci->NL.Id && !plci->nl_remove_id)
3604         {
3605           if (plci->channels)
3606           {
3607             for (ncci = 1; ncci < MAX_NCCI+1; ncci++)
3608             {
3609               if ((a->ncci_plci[ncci] == plci->Id) && (a->ncci_state[ncci] == CONNECTED))
3610               {
3611                 a->ncci_state[ncci] = OUTG_DIS_PENDING;
3612                 cleanup_ncci_data (plci, ncci);
3613                 nl_req_ncci(plci,N_DISC,(byte)ncci);
3614               }
3615             }
3616           }
3617           mixer_remove (plci);
3618           nl_req_ncci(plci,REMOVE,0);
3619           send_req(plci);
3620         }
3621       }
3622       break;
3623
3624     case _DI_SIG_CTRL:
3625     /* signalling control for loop activation B-channel */
3626       if(!plci)
3627       {
3628         Info = _WRONG_IDENTIFIER;
3629         break;
3630       }
3631       if(m->length){
3632         plci->command = _MANUFACTURER_R;
3633         plci->number = Number;
3634         add_ss(plci,FTY,m);
3635         sig_req(plci,SIG_CTRL,0);
3636         send_req(plci);
3637       }
3638       else Info = _WRONG_MESSAGE_FORMAT;
3639       break;
3640
3641     case _DI_RXT_CTRL:
3642     /* activation control for receiver/transmitter B-channel */
3643       if(!plci)
3644       {
3645         Info = _WRONG_IDENTIFIER;
3646         break;
3647       }
3648       if(m->length){
3649         plci->command = _MANUFACTURER_R;
3650         plci->number = Number;
3651         add_ss(plci,FTY,m);
3652         sig_req(plci,DSP_CTRL,0);
3653         send_req(plci);
3654       }
3655       else Info = _WRONG_MESSAGE_FORMAT;
3656       break;
3657
3658     case _DI_ADV_CODEC:
3659     case _DI_DSP_CTRL:
3660       /* TEL_CTRL commands to support non standard adjustments: */
3661       /* Ring on/off, Handset micro volume, external micro vol. */
3662       /* handset+external speaker volume, receiver+transm. gain,*/
3663       /* handsfree on (hookinfo off), set mixer command         */
3664
3665       if(command == _DI_ADV_CODEC)
3666       {
3667         if(!a->AdvCodecPLCI) {
3668           Info = _WRONG_STATE;
3669           break;
3670         }
3671         v_plci = a->AdvCodecPLCI;
3672       }
3673       else
3674       {
3675         if (plci
3676          && (m->length >= 3)
3677          && (m->info[1] == 0x1c)
3678          && (m->info[2] >= 1))
3679         {
3680           if (m->info[3] == DSP_CTRL_OLD_SET_MIXER_COEFFICIENTS)
3681           {
3682             if ((plci->tel != ADV_VOICE) || (plci != a->AdvSignalPLCI))
3683             {
3684               Info = _WRONG_STATE;
3685               break;
3686             }
3687             a->adv_voice_coef_length = m->info[2] - 1;
3688             if (a->adv_voice_coef_length > m->length - 3)
3689               a->adv_voice_coef_length = (byte)(m->length - 3);
3690             if (a->adv_voice_coef_length > ADV_VOICE_COEF_BUFFER_SIZE)
3691               a->adv_voice_coef_length = ADV_VOICE_COEF_BUFFER_SIZE;
3692             for (i = 0; i < a->adv_voice_coef_length; i++)
3693               a->adv_voice_coef_buffer[i] = m->info[4 + i];
3694             if (plci->B1_facilities & B1_FACILITY_VOICE)
3695               adv_voice_write_coefs (plci, ADV_VOICE_WRITE_UPDATE);
3696             break;
3697           }
3698           else if (m->info[3] == DSP_CTRL_SET_DTMF_PARAMETERS)
3699           {
3700             if (!(a->manufacturer_features & MANUFACTURER_FEATURE_DTMF_PARAMETERS))
3701             {
3702               Info = _FACILITY_NOT_SUPPORTED;
3703               break;
3704             }
3705
3706             plci->dtmf_parameter_length = m->info[2] - 1;
3707             if (plci->dtmf_parameter_length > m->length - 3)
3708               plci->dtmf_parameter_length = (byte)(m->length - 3);
3709             if (plci->dtmf_parameter_length > DTMF_PARAMETER_BUFFER_SIZE)
3710               plci->dtmf_parameter_length = DTMF_PARAMETER_BUFFER_SIZE;
3711             for (i = 0; i < plci->dtmf_parameter_length; i++)
3712               plci->dtmf_parameter_buffer[i] = m->info[4+i];
3713             if (plci->B1_facilities & B1_FACILITY_DTMFR)
3714               dtmf_parameter_write (plci);
3715             break;
3716
3717           }
3718         }
3719         v_plci = plci;
3720       }
3721
3722       if(!v_plci)
3723       {
3724         Info = _WRONG_IDENTIFIER;
3725         break;
3726       }
3727       if(m->length){
3728         add_ss(v_plci,FTY,m);
3729         sig_req(v_plci,TEL_CTRL,0);
3730         send_req(v_plci);
3731       }
3732       else Info = _WRONG_MESSAGE_FORMAT;
3733
3734       break;
3735
3736     case _DI_OPTIONS_REQUEST:
3737       if(api_parse(&m->info[1],(word)m->length,"d",m_parms)) {
3738         Info = _WRONG_MESSAGE_FORMAT;
3739         break;
3740       }
3741       if (GET_DWORD (m_parms[0].info) & ~a->man_profile.private_options)
3742       {
3743         Info = _FACILITY_NOT_SUPPORTED;
3744         break;
3745       }
3746       a->requested_options_table[appl->Id-1] = GET_DWORD (m_parms[0].info);
3747       break;
3748
3749
3750
3751     default:
3752       Info = _WRONG_MESSAGE_FORMAT;
3753       break;
3754     }
3755   }
3756
3757   sendf(appl,
3758         _MANUFACTURER_R|CONFIRM,
3759         Id,
3760         Number,
3761         "dww",_DI_MANU_ID,command,Info);
3762   return false;
3763 }
3764
3765
3766 static byte manufacturer_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3767                              PLCI *plci, APPL *appl, API_PARSE *msg)
3768 {
3769   word indication;
3770
3771     API_PARSE m_parms[3];
3772   API_PARSE *ncpi;
3773     API_PARSE fax_parms[9];
3774   word i;
3775   byte len;
3776
3777
3778   dbug(1,dprintf("manufacturer_res"));
3779
3780   if ((msg[0].length == 0)
3781    || (msg[1].length == 0)
3782    || (GET_DWORD(msg[0].info)!=_DI_MANU_ID))
3783   {
3784     return false;
3785   }
3786   indication = GET_WORD(msg[1].info);
3787   switch (indication)
3788   {
3789
3790   case _DI_NEGOTIATE_B3:
3791     if(!plci)
3792       break;
3793     if (((plci->B3_prot != 4) && (plci->B3_prot != 5))
3794      || !(plci->ncpi_state & NCPI_NEGOTIATE_B3_SENT))
3795     {
3796       dbug(1,dprintf("wrong state for NEGOTIATE_B3 parameters"));
3797       break;
3798     }
3799     if (api_parse (&msg[2].info[1], msg[2].length, "ws", m_parms))
3800     {
3801       dbug(1,dprintf("wrong format in NEGOTIATE_B3 parameters"));
3802       break;
3803     }
3804     ncpi = &m_parms[1];
3805     len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
3806     if (plci->fax_connect_info_length < len)
3807     {
3808       ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id_len = 0;
3809       ((T30_INFO *)(plci->fax_connect_info_buffer))->head_line_len = 0;
3810     }
3811     if (api_parse (&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms))
3812     {
3813       dbug(1,dprintf("non-standard facilities info missing or wrong format"));
3814     }
3815     else
3816     {
3817       if (plci->fax_connect_info_length <= len)
3818         plci->fax_connect_info_buffer[len] = 0;
3819       len += 1 + plci->fax_connect_info_buffer[len];
3820       if (plci->fax_connect_info_length <= len)
3821         plci->fax_connect_info_buffer[len] = 0;
3822       len += 1 + plci->fax_connect_info_buffer[len];
3823       if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2))
3824         plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]);
3825       plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length);
3826       for (i = 0; i < fax_parms[7].length; i++)
3827         plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1+i];
3828     }
3829     plci->fax_connect_info_length = len;
3830     plci->fax_edata_ack_length = plci->fax_connect_info_length;
3831     start_internal_command (Id, plci, fax_edata_ack_command);
3832     break;
3833
3834   }
3835   return false;
3836 }
3837
3838 /*------------------------------------------------------------------*/
3839 /* IDI callback function                                            */
3840 /*------------------------------------------------------------------*/
3841
3842 void   callback(ENTITY   * e)
3843 {
3844   DIVA_CAPI_ADAPTER   * a;
3845   APPL   * appl;
3846   PLCI   * plci;
3847   CAPI_MSG   *m;
3848   word i, j;
3849   byte rc;
3850   byte ch;
3851   byte req;
3852   byte global_req;
3853   int no_cancel_rc;
3854
3855   dbug(1,dprintf("%x:CB(%x:Req=%x,Rc=%x,Ind=%x)",
3856                  (e->user[0]+1)&0x7fff,e->Id,e->Req,e->Rc,e->Ind));
3857
3858   a = &(adapter[(byte)e->user[0]]);
3859   plci = &(a->plci[e->user[1]]);
3860   no_cancel_rc = DIVA_CAPI_SUPPORTS_NO_CANCEL(a);
3861
3862   /*
3863      If new protocol code and new XDI is used then CAPI should work
3864      fully in accordance with IDI cpec an look on callback field instead
3865      of Rc field for return codes.
3866    */
3867   if (((e->complete == 0xff) && no_cancel_rc) ||
3868       (e->Rc && !no_cancel_rc)) {
3869     rc = e->Rc;
3870     ch = e->RcCh;
3871     req = e->Req;
3872     e->Rc = 0;
3873
3874     if (e->user[0] & 0x8000)
3875     {
3876       /*
3877          If REMOVE request was sent then we have to wait until
3878          return code with Id set to zero arrives.
3879          All other return codes should be ignored.
3880          */
3881       if (req == REMOVE)
3882       {
3883         if (e->Id)
3884         {
3885           dbug(1,dprintf("cancel RC in REMOVE state"));
3886           return;
3887         }
3888         channel_flow_control_remove (plci);
3889         for (i = 0; i < 256; i++)
3890         {
3891           if (a->FlowControlIdTable[i] == plci->nl_remove_id)
3892             a->FlowControlIdTable[i] = 0;
3893         }
3894         plci->nl_remove_id = 0;
3895         if (plci->rx_dma_descriptor > 0) {
3896           diva_free_dma_descriptor (plci, plci->rx_dma_descriptor - 1);
3897           plci->rx_dma_descriptor = 0;
3898         }
3899       }
3900       if (rc == OK_FC)
3901       {
3902         a->FlowControlIdTable[ch] = e->Id;
3903         a->FlowControlSkipTable[ch] = 0;
3904
3905         a->ch_flow_control[ch] |= N_OK_FC_PENDING;
3906         a->ch_flow_plci[ch] = plci->Id;
3907         plci->nl_req = 0;
3908       }
3909       else
3910       {
3911         /*
3912           Cancel return codes self, if feature was requested
3913           */
3914         if (no_cancel_rc && (a->FlowControlIdTable[ch] == e->Id) && e->Id) {
3915           a->FlowControlIdTable[ch] = 0;
3916           if ((rc == OK) && a->FlowControlSkipTable[ch]) {
3917             dbug(3,dprintf ("XDI CAPI: RC cancelled Id:0x02, Ch:%02x",                              e->Id, ch));
3918             return;
3919           }
3920         }
3921
3922         if (a->ch_flow_control[ch] & N_OK_FC_PENDING)
3923         {
3924           a->ch_flow_control[ch] &= ~N_OK_FC_PENDING;
3925           if (ch == e->ReqCh)
3926             plci->nl_req = 0;
3927         }
3928         else
3929           plci->nl_req = 0;
3930       }
3931       if (plci->nl_req)
3932         control_rc (plci, 0, rc, ch, 0, true);
3933       else
3934       {
3935         if (req == N_XON)
3936         {
3937           channel_x_on (plci, ch);
3938           if (plci->internal_command)
3939             control_rc (plci, req, rc, ch, 0, true);
3940         }
3941         else
3942         {
3943           if (plci->nl_global_req)
3944           {
3945             global_req = plci->nl_global_req;
3946             plci->nl_global_req = 0;
3947             if (rc != ASSIGN_OK) {
3948               e->Id = 0;
3949               if (plci->rx_dma_descriptor > 0) {
3950                 diva_free_dma_descriptor (plci, plci->rx_dma_descriptor - 1);
3951                 plci->rx_dma_descriptor = 0;
3952               }
3953             }
3954             channel_xmit_xon (plci);
3955             control_rc (plci, 0, rc, ch, global_req, true);
3956           }
3957           else if (plci->data_sent)
3958           {
3959             channel_xmit_xon (plci);
3960             plci->data_sent = false;
3961             plci->NL.XNum = 1;
3962             data_rc (plci, ch);
3963             if (plci->internal_command)
3964               control_rc (plci, req, rc, ch, 0, true);
3965           }
3966           else
3967           {
3968             channel_xmit_xon (plci);
3969             control_rc (plci, req, rc, ch, 0, true);
3970           }
3971         }
3972       }
3973     }
3974     else
3975     {
3976       /*
3977          If REMOVE request was sent then we have to wait until
3978          return code with Id set to zero arrives.
3979          All other return codes should be ignored.
3980          */
3981       if (req == REMOVE)
3982       {
3983         if (e->Id)
3984         {
3985           dbug(1,dprintf("cancel RC in REMOVE state"));
3986           return;
3987         }
3988         plci->sig_remove_id = 0;
3989       }
3990       plci->sig_req = 0;
3991       if (plci->sig_global_req)
3992       {
3993         global_req = plci->sig_global_req;
3994         plci->sig_global_req = 0;
3995         if (rc != ASSIGN_OK)
3996           e->Id = 0;
3997         channel_xmit_xon (plci);
3998         control_rc (plci, 0, rc, ch, global_req, false);
3999       }
4000       else
4001       {
4002         channel_xmit_xon (plci);
4003         control_rc (plci, req, rc, ch, 0, false);
4004       }
4005     }
4006     /*
4007       Again: in accordance with IDI spec Rc and Ind can't be delivered in the
4008       same callback. Also if new XDI and protocol code used then jump
4009       direct to finish.
4010       */
4011     if (no_cancel_rc) {
4012       channel_xmit_xon(plci);
4013       goto capi_callback_suffix;
4014     }
4015   }
4016
4017   channel_xmit_xon(plci);
4018
4019   if (e->Ind) {
4020     if (e->user[0] &0x8000) {
4021       byte Ind = e->Ind & 0x0f;
4022       byte Ch = e->IndCh;
4023       if (((Ind==N_DISC) || (Ind==N_DISC_ACK)) &&
4024           (a->ch_flow_plci[Ch] == plci->Id)) {
4025         if (a->ch_flow_control[Ch] & N_RX_FLOW_CONTROL_MASK) {
4026           dbug(3,dprintf ("XDI CAPI: I: pending N-XON Ch:%02x", Ch));
4027         }
4028         a->ch_flow_control[Ch] &= ~N_RX_FLOW_CONTROL_MASK;
4029       }
4030       nl_ind(plci);
4031       if ((e->RNR != 1) &&
4032           (a->ch_flow_plci[Ch] == plci->Id) &&
4033           (a->ch_flow_control[Ch] & N_RX_FLOW_CONTROL_MASK)) {
4034         a->ch_flow_control[Ch] &= ~N_RX_FLOW_CONTROL_MASK;
4035         dbug(3,dprintf ("XDI CAPI: I: remove faked N-XON Ch:%02x", Ch));
4036       }
4037     } else {
4038       sig_ind(plci);
4039     }
4040     e->Ind = 0;
4041   }
4042
4043 capi_callback_suffix:
4044
4045   while (!plci->req_in
4046    && !plci->internal_command
4047    && (plci->msg_in_write_pos != plci->msg_in_read_pos))
4048   {
4049     j = (plci->msg_in_read_pos == plci->msg_in_wrap_pos) ? 0 : plci->msg_in_read_pos;
4050
4051     i = (((CAPI_MSG   *)(&((byte   *)(plci->msg_in_queue))[j]))->header.length + 3) & 0xfffc;
4052
4053     m = (CAPI_MSG   *)(&((byte   *)(plci->msg_in_queue))[j]);
4054     appl = *((APPL   *   *)(&((byte   *)(plci->msg_in_queue))[j+i]));
4055     dbug(1,dprintf("dequeue msg(0x%04x) - write=%d read=%d wrap=%d",
4056       m->header.command, plci->msg_in_write_pos, plci->msg_in_read_pos, plci->msg_in_wrap_pos));
4057     if (plci->msg_in_read_pos == plci->msg_in_wrap_pos)
4058     {
4059       plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
4060       plci->msg_in_read_pos = i + MSG_IN_OVERHEAD;
4061     }
4062     else
4063     {
4064       plci->msg_in_read_pos = j + i + MSG_IN_OVERHEAD;
4065     }
4066     if (plci->msg_in_read_pos == plci->msg_in_write_pos)
4067     {
4068       plci->msg_in_write_pos = MSG_IN_QUEUE_SIZE;
4069       plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
4070     }
4071     else if (plci->msg_in_read_pos == plci->msg_in_wrap_pos)
4072     {
4073       plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
4074       plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
4075     }
4076     i = api_put (appl, m);
4077     if (i != 0)
4078     {
4079       if (m->header.command == _DATA_B3_R)
4080
4081         TransmitBufferFree (appl, (byte *)(long)(m->info.data_b3_req.Data));
4082
4083       dbug(1,dprintf("Error 0x%04x from msg(0x%04x)", i, m->header.command));
4084       break;
4085     }
4086
4087     if (plci->li_notify_update)
4088     {
4089       plci->li_notify_update = false;
4090       mixer_notify_update (plci, false);
4091     }
4092
4093   }
4094   send_data(plci);
4095   send_req(plci);
4096 }
4097
4098
4099 static void control_rc(PLCI *plci, byte req, byte rc, byte ch, byte global_req,
4100                        byte nl_rc)
4101 {
4102   dword Id;
4103   dword rId;
4104   word Number;
4105   word Info=0;
4106   word i;
4107   word ncci;
4108   DIVA_CAPI_ADAPTER   * a;
4109   APPL   * appl;
4110   PLCI   * rplci;
4111     byte SSparms[]  = "\x05\x00\x00\x02\x00\x00";
4112     byte SSstruct[] = "\x09\x00\x00\x06\x00\x00\x00\x00\x00\x00";
4113
4114   if (!plci) {
4115     dbug(0,dprintf("A: control_rc, no plci %02x:%02x:%02x:%02x:%02x", req, rc, ch, global_req, nl_rc));
4116     return;
4117   }
4118   dbug(1,dprintf("req0_in/out=%d/%d",plci->req_in,plci->req_out));
4119   if(plci->req_in!=plci->req_out)
4120   {
4121     if (nl_rc || (global_req != ASSIGN) || (rc == ASSIGN_OK))
4122     {
4123       dbug(1,dprintf("req_1return"));
4124       return;
4125     }
4126     /* cancel outstanding request on the PLCI after SIG ASSIGN failure */
4127   }
4128   plci->req_in = plci->req_in_start = plci->req_out = 0;
4129   dbug(1,dprintf("control_rc"));
4130
4131   appl = plci->appl;
4132   a = plci->adapter;
4133   ncci = a->ch_ncci[ch];
4134   if(appl)
4135   {
4136     Id = (((dword)(ncci ? ncci : ch)) << 16) | ((word)plci->Id << 8) | a->Id;
4137     if(plci->tel && plci->SuppState!=CALL_HELD) Id|=EXT_CONTROLLER;
4138     Number = plci->number;
4139     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));
4140     dbug(1,dprintf("channels=0x%x",plci->channels));
4141     if (plci_remove_check(plci))
4142       return;
4143     if(req==REMOVE && rc==ASSIGN_OK)
4144     {
4145       sig_req(plci,HANGUP,0);
4146       sig_req(plci,REMOVE,0);
4147       send_req(plci);
4148     }
4149     if(plci->command)
4150     {
4151       switch(plci->command)
4152       {
4153       case C_HOLD_REQ:
4154         dbug(1,dprintf("HoldRC=0x%x",rc));
4155         SSparms[1] = (byte)S_HOLD;
4156         if(rc!=OK)
4157         {
4158           plci->SuppState = IDLE;
4159           Info = 0x2001;
4160         }
4161         sendf(appl,_FACILITY_R|CONFIRM,Id,Number,"wws",Info,3,SSparms);
4162         break;
4163
4164       case C_RETRIEVE_REQ:
4165         dbug(1,dprintf("RetrieveRC=0x%x",rc));
4166         SSparms[1] = (byte)S_RETRIEVE;
4167         if(rc!=OK)
4168         {
4169           plci->SuppState = CALL_HELD;
4170           Info = 0x2001;
4171         }
4172         sendf(appl,_FACILITY_R|CONFIRM,Id,Number,"wws",Info,3,SSparms);
4173         break;
4174
4175       case _INFO_R:
4176         dbug(1,dprintf("InfoRC=0x%x",rc));
4177         if(rc!=OK) Info=_WRONG_STATE;
4178         sendf(appl,_INFO_R|CONFIRM,Id,Number,"w",Info);
4179         break;
4180
4181       case _CONNECT_R:
4182         dbug(1,dprintf("Connect_R=0x%x/0x%x/0x%x/0x%x",req,rc,global_req,nl_rc));
4183         if (plci->State == INC_DIS_PENDING)
4184           break;
4185         if(plci->Sig.Id!=0xff)
4186         {
4187           if (((global_req == ASSIGN) && (rc != ASSIGN_OK))
4188            || (!nl_rc && (req == CALL_REQ) && (rc != OK)))
4189           {
4190             dbug(1,dprintf("No more IDs/Call_Req failed"));
4191             sendf(appl,_CONNECT_R|CONFIRM,Id&0xffL,Number,"w",_OUT_OF_PLCI);
4192             plci_remove(plci);
4193             plci->State = IDLE;
4194             break;
4195           }
4196           if(plci->State!=LOCAL_CONNECT)plci->State = OUTG_CON_PENDING;
4197           sendf(appl,_CONNECT_R|CONFIRM,Id,Number,"w",0);
4198         }
4199         else /* D-ch activation */
4200         {
4201           if (rc != ASSIGN_OK)
4202           {
4203             dbug(1,dprintf("No more IDs/X.25 Call_Req failed"));
4204             sendf(appl,_CONNECT_R|CONFIRM,Id&0xffL,Number,"w",_OUT_OF_PLCI);
4205             plci_remove(plci);
4206             plci->State = IDLE;
4207             break;
4208           }
4209           sendf(appl,_CONNECT_R|CONFIRM,Id,Number,"w",0);
4210           sendf(plci->appl,_CONNECT_ACTIVE_I,Id,0,"sss","","","");
4211           plci->State = INC_ACT_PENDING;
4212         }
4213         break;
4214
4215       case _CONNECT_I|RESPONSE:
4216         if (plci->State != INC_DIS_PENDING)
4217           plci->State = INC_CON_ACCEPT;
4218         break;
4219
4220       case _DISCONNECT_R:
4221         if (plci->State == INC_DIS_PENDING)
4222           break;
4223         if(plci->Sig.Id!=0xff)
4224         {
4225           plci->State = OUTG_DIS_PENDING;
4226           sendf(appl,_DISCONNECT_R|CONFIRM,Id,Number,"w",0);
4227         }
4228         break;
4229
4230       case SUSPEND_REQ:
4231         break;
4232
4233       case RESUME_REQ:
4234         break;
4235
4236       case _CONNECT_B3_R:
4237         if(rc!=OK)
4238         {
4239           sendf(appl,_CONNECT_B3_R|CONFIRM,Id,Number,"w",_WRONG_IDENTIFIER);
4240           break;
4241         }
4242         ncci = get_ncci (plci, ch, 0);
4243         Id = (Id & 0xffff) | (((dword) ncci) << 16);
4244         plci->channels++;
4245         if(req==N_RESET)
4246         {
4247           a->ncci_state[ncci] = INC_ACT_PENDING;
4248           sendf(appl,_CONNECT_B3_R|CONFIRM,Id,Number,"w",0);
4249           sendf(appl,_CONNECT_B3_ACTIVE_I,Id,0,"s","");
4250         }
4251         else
4252         {
4253           a->ncci_state[ncci] = OUTG_CON_PENDING;
4254           sendf(appl,_CONNECT_B3_R|CONFIRM,Id,Number,"w",0);
4255         }
4256         break;
4257
4258       case _CONNECT_B3_I|RESPONSE:
4259         break;
4260
4261       case _RESET_B3_R:
4262 /*        sendf(appl,_RESET_B3_R|CONFIRM,Id,Number,"w",0);*/
4263         break;
4264
4265       case _DISCONNECT_B3_R:
4266         sendf(appl,_DISCONNECT_B3_R|CONFIRM,Id,Number,"w",0);
4267         break;
4268
4269       case _MANUFACTURER_R:
4270         break;
4271
4272       case PERM_LIST_REQ:
4273         if(rc!=OK)
4274         {
4275           Info = _WRONG_IDENTIFIER;
4276           sendf(plci->appl,_CONNECT_R|CONFIRM,Id,Number,"w",Info);
4277           plci_remove(plci);
4278         }
4279         else
4280           sendf(plci->appl,_CONNECT_R|CONFIRM,Id,Number,"w",Info);
4281         break;
4282
4283       default:
4284         break;
4285       }
4286       plci->command = 0;
4287     }
4288     else if (plci->internal_command)
4289     {
4290       switch(plci->internal_command)
4291       {
4292       case BLOCK_PLCI:
4293         return;
4294
4295       case GET_MWI_STATE:
4296         if(rc==OK) /* command supported, wait for indication */
4297         {
4298           return;
4299         }
4300         plci_remove(plci);
4301         break;
4302
4303         /* Get Supported Services */
4304       case GETSERV_REQ_PEND:
4305         if(rc==OK) /* command supported, wait for indication */
4306         {
4307           break;
4308         }
4309         PUT_DWORD(&SSstruct[6], MASK_TERMINAL_PORTABILITY);
4310         sendf(appl, _FACILITY_R|CONFIRM, Id, Number, "wws",0,3,SSstruct);
4311         plci_remove(plci);
4312         break;
4313
4314       case INTERR_DIVERSION_REQ_PEND:      /* Interrogate Parameters        */
4315       case INTERR_NUMBERS_REQ_PEND:
4316       case CF_START_PEND:                  /* Call Forwarding Start pending */
4317       case CF_STOP_PEND:                   /* Call Forwarding Stop pending  */
4318       case CCBS_REQUEST_REQ_PEND:
4319       case CCBS_DEACTIVATE_REQ_PEND:
4320       case CCBS_INTERROGATE_REQ_PEND:
4321         switch(plci->internal_command)
4322         {
4323           case INTERR_DIVERSION_REQ_PEND:
4324             SSparms[1] = S_INTERROGATE_DIVERSION;
4325             break;
4326           case INTERR_NUMBERS_REQ_PEND:
4327             SSparms[1] = S_INTERROGATE_NUMBERS;
4328             break;
4329           case CF_START_PEND:
4330             SSparms[1] = S_CALL_FORWARDING_START;
4331             break;
4332           case CF_STOP_PEND:
4333             SSparms[1] = S_CALL_FORWARDING_STOP;
4334             break;
4335           case CCBS_REQUEST_REQ_PEND:
4336             SSparms[1] = S_CCBS_REQUEST;
4337             break;
4338           case CCBS_DEACTIVATE_REQ_PEND:
4339             SSparms[1] = S_CCBS_DEACTIVATE;
4340             break;
4341           case CCBS_INTERROGATE_REQ_PEND:
4342             SSparms[1] = S_CCBS_INTERROGATE;
4343             break;
4344         }
4345         if(global_req==ASSIGN)
4346         {
4347           dbug(1,dprintf("AssignDiversion_RC=0x%x/0x%x",req,rc));
4348           return;
4349         }
4350         if(!plci->appl) break;
4351         if(rc==ISDN_GUARD_REJ)
4352         {
4353           Info = _CAPI_GUARD_ERROR;
4354         }
4355         else if(rc!=OK)
4356         {
4357           Info = _SUPPLEMENTARY_SERVICE_NOT_SUPPORTED;
4358         }
4359         sendf(plci->appl,_FACILITY_R|CONFIRM,Id&0x7,
4360               plci->number,"wws",Info,(word)3,SSparms);
4361         if(Info) plci_remove(plci);
4362         break;
4363
4364         /* 3pty conference pending */
4365       case PTY_REQ_PEND:
4366         if(!plci->relatedPTYPLCI) break;
4367         rplci = plci->relatedPTYPLCI;
4368         SSparms[1] = plci->ptyState;
4369         rId = ((word)rplci->Id<<8)|rplci->adapter->Id;
4370         if(rplci->tel) rId|=EXT_CONTROLLER;
4371         if(rc!=OK)
4372         {
4373           Info = 0x300E; /* not supported */
4374           plci->relatedPTYPLCI = NULL;
4375           plci->ptyState = 0;
4376         }
4377         sendf(rplci->appl,
4378               _FACILITY_R|CONFIRM,
4379               rId,
4380               plci->number,
4381               "wws",Info,(word)3,SSparms);
4382         break;
4383
4384         /* Explicit Call Transfer pending */
4385       case ECT_REQ_PEND:
4386         dbug(1,dprintf("ECT_RC=0x%x/0x%x",req,rc));
4387         if(!plci->relatedPTYPLCI) break;
4388         rplci = plci->relatedPTYPLCI;
4389         SSparms[1] = S_ECT;
4390         rId = ((word)rplci->Id<<8)|rplci->adapter->Id;
4391         if(rplci->tel) rId|=EXT_CONTROLLER;
4392         if(rc!=OK)
4393         {
4394           Info = 0x300E; /* not supported */
4395           plci->relatedPTYPLCI = NULL;
4396           plci->ptyState = 0;
4397         }
4398         sendf(rplci->appl,
4399               _FACILITY_R|CONFIRM,
4400               rId,
4401               plci->number,
4402               "wws",Info,(word)3,SSparms);
4403         break;
4404
4405       case _MANUFACTURER_R:
4406         dbug(1,dprintf("_Manufacturer_R=0x%x/0x%x",req,rc));
4407         if ((global_req == ASSIGN) && (rc != ASSIGN_OK))
4408         {
4409           dbug(1,dprintf("No more IDs"));
4410           sendf(appl,_MANUFACTURER_R|CONFIRM,Id,Number,"dww",_DI_MANU_ID,_MANUFACTURER_R,_OUT_OF_PLCI);
4411           plci_remove(plci);  /* after codec init, internal codec commands pending */
4412         }
4413         break;
4414
4415       case _CONNECT_R:
4416         dbug(1,dprintf("_Connect_R=0x%x/0x%x",req,rc));
4417         if ((global_req == ASSIGN) && (rc != ASSIGN_OK))
4418         {
4419           dbug(1,dprintf("No more IDs"));
4420           sendf(appl,_CONNECT_R|CONFIRM,Id&0xffL,Number,"w",_OUT_OF_PLCI);
4421           plci_remove(plci);  /* after codec init, internal codec commands pending */
4422         }
4423         break;
4424
4425       case PERM_COD_HOOK:                     /* finished with Hook_Ind */
4426         return;
4427
4428       case PERM_COD_CALL:
4429         dbug(1,dprintf("***Codec Connect_Pending A, Rc = 0x%x",rc));
4430         plci->internal_command = PERM_COD_CONN_PEND;
4431         return;
4432
4433       case PERM_COD_ASSIGN:
4434         dbug(1,dprintf("***Codec Assign A, Rc = 0x%x",rc));
4435         if(rc!=ASSIGN_OK) break;
4436         sig_req(plci,CALL_REQ,0);
4437         send_req(plci);
4438         plci->internal_command = PERM_COD_CALL;
4439         return;
4440
4441         /* Null Call Reference Request pending */
4442       case C_NCR_FAC_REQ:
4443         dbug(1,dprintf("NCR_FAC=0x%x/0x%x",req,rc));
4444         if(global_req==ASSIGN)
4445         {
4446           if(rc==ASSIGN_OK)
4447           {
4448             return;
4449           }
4450           else
4451           {
4452             sendf(appl,_INFO_R|CONFIRM,Id&0xf,Number,"w",_WRONG_STATE);
4453             appl->NullCREnable = false;
4454             plci_remove(plci);
4455           }
4456         }
4457         else if(req==NCR_FACILITY)
4458         {
4459           if(rc==OK)
4460           {
4461             sendf(appl,_INFO_R|CONFIRM,Id&0xf,Number,"w",0);
4462           }
4463           else
4464           {
4465             sendf(appl,_INFO_R|CONFIRM,Id&0xf,Number,"w",_WRONG_STATE);
4466             appl->NullCREnable = false;
4467           }
4468           plci_remove(plci);
4469         }
4470         break;
4471
4472       case HOOK_ON_REQ:
4473         if(plci->channels)
4474         {
4475           if(a->ncci_state[ncci]==CONNECTED)
4476           {
4477             a->ncci_state[ncci] = OUTG_DIS_PENDING;
4478             cleanup_ncci_data (plci, ncci);
4479             nl_req_ncci(plci,N_DISC,(byte)ncci);
4480           }
4481           break;
4482         }
4483         break;
4484
4485       case HOOK_OFF_REQ:
4486         if (plci->State == INC_DIS_PENDING)
4487           break;
4488         sig_req(plci,CALL_REQ,0);
4489         send_req(plci);
4490         plci->State=OUTG_CON_PENDING;
4491         break;
4492
4493
4494       case MWI_ACTIVATE_REQ_PEND:
4495       case MWI_DEACTIVATE_REQ_PEND:
4496         if(global_req == ASSIGN && rc==ASSIGN_OK)
4497         {
4498           dbug(1,dprintf("MWI_REQ assigned"));
4499           return;
4500         }
4501         else if(rc!=OK)
4502         {
4503           if(rc==WRONG_IE)
4504           {
4505             Info = 0x2007; /* Illegal message parameter coding */
4506             dbug(1,dprintf("MWI_REQ invalid parameter"));
4507           }
4508           else
4509           {
4510             Info = 0x300B; /* not supported */
4511             dbug(1,dprintf("MWI_REQ not supported"));
4512           }
4513           /* 0x3010: Request not allowed in this state */
4514           PUT_WORD(&SSparms[4],0x300E); /* SS not supported */
4515
4516         }
4517         if(plci->internal_command==MWI_ACTIVATE_REQ_PEND)
4518         {
4519           PUT_WORD(&SSparms[1],S_MWI_ACTIVATE);
4520         }
4521         else PUT_WORD(&SSparms[1],S_MWI_DEACTIVATE);
4522
4523         if(plci->cr_enquiry)
4524         {
4525           sendf(plci->appl,
4526                 _FACILITY_R|CONFIRM,
4527                 Id&0xf,
4528                 plci->number,
4529                 "wws",Info,(word)3,SSparms);
4530           if(rc!=OK) plci_remove(plci);
4531         }
4532         else
4533         {
4534           sendf(plci->appl,
4535                 _FACILITY_R|CONFIRM,
4536                 Id,
4537                 plci->number,
4538                 "wws",Info,(word)3,SSparms);
4539         }
4540         break;
4541
4542       case CONF_BEGIN_REQ_PEND:
4543       case CONF_ADD_REQ_PEND:
4544       case CONF_SPLIT_REQ_PEND:
4545       case CONF_DROP_REQ_PEND:
4546       case CONF_ISOLATE_REQ_PEND:
4547       case CONF_REATTACH_REQ_PEND:
4548         dbug(1,dprintf("CONF_RC=0x%x/0x%x",req,rc));
4549         if((plci->internal_command==CONF_ADD_REQ_PEND)&&(!plci->relatedPTYPLCI)) break;
4550         rplci = plci;
4551         rId = Id;
4552         switch(plci->internal_command)
4553         {
4554           case CONF_BEGIN_REQ_PEND:
4555             SSparms[1] = S_CONF_BEGIN;
4556             break;
4557           case CONF_ADD_REQ_PEND:
4558             SSparms[1] = S_CONF_ADD;
4559             rplci = plci->relatedPTYPLCI;
4560             rId = ((word)rplci->Id<<8)|rplci->adapter->Id;
4561             break;
4562           case CONF_SPLIT_REQ_PEND:
4563             SSparms[1] = S_CONF_SPLIT;
4564             break;
4565           case CONF_DROP_REQ_PEND:
4566             SSparms[1] = S_CONF_DROP;
4567             break;
4568           case CONF_ISOLATE_REQ_PEND:
4569             SSparms[1] = S_CONF_ISOLATE;
4570             break;
4571           case CONF_REATTACH_REQ_PEND:
4572             SSparms[1] = S_CONF_REATTACH;
4573             break;
4574         }
4575
4576         if(rc!=OK)
4577         {
4578           Info = 0x300E; /* not supported */
4579           plci->relatedPTYPLCI = NULL;
4580           plci->ptyState = 0;
4581         }
4582         sendf(rplci->appl,
4583               _FACILITY_R|CONFIRM,
4584               rId,
4585               plci->number,
4586               "wws",Info,(word)3,SSparms);
4587         break;
4588
4589       case VSWITCH_REQ_PEND:
4590         if(rc!=OK)
4591         {
4592           if(plci->relatedPTYPLCI)
4593           {
4594             plci->relatedPTYPLCI->vswitchstate=0;
4595             plci->relatedPTYPLCI->vsprot=0;
4596             plci->relatedPTYPLCI->vsprotdialect=0;
4597           }
4598           plci->vswitchstate=0;
4599           plci->vsprot=0;
4600           plci->vsprotdialect=0;
4601         }
4602         else
4603         {
4604           if(plci->relatedPTYPLCI &&
4605              plci->vswitchstate==1 &&
4606              plci->relatedPTYPLCI->vswitchstate==3) /* join complete */
4607             plci->vswitchstate=3;
4608         }
4609         break;
4610
4611   /* Call Deflection Request pending (SSCT) */
4612       case CD_REQ_PEND:
4613         SSparms[1] = S_CALL_DEFLECTION;
4614         if(rc!=OK)
4615         {
4616           Info = 0x300E; /* not supported */
4617           plci->appl->CDEnable = 0;
4618         }
4619         sendf(plci->appl,_FACILITY_R|CONFIRM,Id,
4620           plci->number,"wws",Info,(word)3,SSparms);
4621         break;
4622
4623       case RTP_CONNECT_B3_REQ_COMMAND_2:
4624         if (rc == OK)
4625         {
4626           ncci = get_ncci (plci, ch, 0);
4627           Id = (Id & 0xffff) | (((dword) ncci) << 16);
4628           plci->channels++;
4629           a->ncci_state[ncci] = OUTG_CON_PENDING;
4630         }
4631
4632       default:
4633         if (plci->internal_command_queue[0])
4634         {
4635           (*(plci->internal_command_queue[0]))(Id, plci, rc);
4636           if (plci->internal_command)
4637             return;
4638         }
4639         break;
4640       }
4641       next_internal_command (Id, plci);
4642     }
4643   }
4644   else /* appl==0 */
4645   {
4646     Id = ((word)plci->Id<<8)|plci->adapter->Id;
4647     if(plci->tel) Id|=EXT_CONTROLLER;
4648
4649     switch(plci->internal_command)
4650     {
4651     case BLOCK_PLCI:
4652       return;
4653
4654     case START_L1_SIG_ASSIGN_PEND:
4655     case REM_L1_SIG_ASSIGN_PEND:
4656       if(global_req == ASSIGN)
4657       {
4658         break;
4659       }
4660       else
4661       {
4662         dbug(1,dprintf("***L1 Req rem PLCI"));
4663         plci->internal_command = 0;
4664         sig_req(plci,REMOVE,0);
4665         send_req(plci);
4666       }
4667       break;
4668
4669       /* Call Deflection Request pending, just no appl ptr assigned */
4670     case CD_REQ_PEND:
4671       SSparms[1] = S_CALL_DEFLECTION;
4672       if(rc!=OK)
4673       {
4674         Info = 0x300E; /* not supported */
4675       }
4676       for(i=0; i<max_appl; i++)
4677       {
4678         if(application[i].CDEnable)
4679         {
4680           if(!application[i].Id) application[i].CDEnable = 0;
4681           else
4682           {
4683             sendf(&application[i],_FACILITY_R|CONFIRM,Id,
4684                   plci->number,"wws",Info,(word)3,SSparms);
4685             if(Info) application[i].CDEnable = 0;
4686           }
4687         }
4688       }
4689       plci->internal_command = 0;
4690       break;
4691
4692     case PERM_COD_HOOK:                   /* finished with Hook_Ind */
4693       return;
4694
4695     case PERM_COD_CALL:
4696       plci->internal_command = PERM_COD_CONN_PEND;
4697       dbug(1,dprintf("***Codec Connect_Pending, Rc = 0x%x",rc));
4698       return;
4699
4700     case PERM_COD_ASSIGN:
4701       dbug(1,dprintf("***Codec Assign, Rc = 0x%x",rc));
4702       plci->internal_command = 0;
4703       if(rc!=ASSIGN_OK) break;
4704       plci->internal_command = PERM_COD_CALL;
4705       sig_req(plci,CALL_REQ,0);
4706       send_req(plci);
4707       return;
4708
4709     case LISTEN_SIG_ASSIGN_PEND:
4710       if(rc == ASSIGN_OK)
4711       {
4712         plci->internal_command = 0;
4713         dbug(1,dprintf("ListenCheck, new SIG_ID = 0x%x",plci->Sig.Id));
4714         add_p(plci,ESC,"\x02\x18\x00");             /* support call waiting */
4715         sig_req(plci,INDICATE_REQ,0);
4716         send_req(plci);
4717       }
4718       else
4719       {
4720         dbug(1,dprintf("ListenCheck failed (assignRc=0x%x)",rc));
4721         a->listen_active--;
4722         plci_remove(plci);
4723         plci->State = IDLE;
4724       }
4725       break;
4726
4727     case USELAW_REQ:
4728       if(global_req == ASSIGN)
4729       {
4730         if (rc==ASSIGN_OK)
4731       {
4732         sig_req(plci,LAW_REQ,0);
4733         send_req(plci);
4734         dbug(1,dprintf("Auto-Law assigned"));
4735         }
4736         else
4737         {
4738           dbug(1,dprintf("Auto-Law assign failed"));
4739           a->automatic_law = 3;
4740           plci->internal_command = 0;
4741           a->automatic_lawPLCI = NULL;
4742         }
4743         break;
4744       }
4745       else if(req == LAW_REQ && rc==OK)
4746       {
4747         dbug(1,dprintf("Auto-Law initiated"));
4748         a->automatic_law = 2;
4749         plci->internal_command = 0;
4750       }
4751       else
4752       {
4753         dbug(1,dprintf("Auto-Law not supported"));
4754         a->automatic_law = 3;
4755         plci->internal_command = 0;
4756         sig_req(plci,REMOVE,0);
4757         send_req(plci);
4758         a->automatic_lawPLCI = NULL;
4759       }
4760       break;
4761     }
4762     plci_remove_check(plci);
4763   }
4764 }
4765
4766 static void data_rc(PLCI *plci, byte ch)
4767 {
4768   dword Id;
4769   DIVA_CAPI_ADAPTER   * a;
4770   NCCI   *ncci_ptr;
4771   DATA_B3_DESC   *data;
4772   word ncci;
4773
4774   if (plci->appl)
4775   {
4776     TransmitBufferFree (plci->appl, plci->data_sent_ptr);
4777     a = plci->adapter;
4778     ncci = a->ch_ncci[ch];
4779     if (ncci && (a->ncci_plci[ncci] == plci->Id))
4780     {
4781       ncci_ptr = &(a->ncci[ncci]);
4782       dbug(1,dprintf("data_out=%d, data_pending=%d",ncci_ptr->data_out,ncci_ptr->data_pending));
4783       if (ncci_ptr->data_pending)
4784       {
4785         data = &(ncci_ptr->DBuffer[ncci_ptr->data_out]);
4786         if (!(data->Flags &4) && a->ncci_state[ncci])
4787         {
4788           Id = (((dword)ncci)<<16)|((word)plci->Id<<8)|a->Id;
4789           if(plci->tel) Id|=EXT_CONTROLLER;
4790           sendf(plci->appl,_DATA_B3_R|CONFIRM,Id,data->Number,
4791                 "ww",data->Handle,0);
4792         }
4793         (ncci_ptr->data_out)++;
4794         if (ncci_ptr->data_out == MAX_DATA_B3)
4795           ncci_ptr->data_out = 0;
4796         (ncci_ptr->data_pending)--;
4797       }
4798     }
4799   }
4800 }
4801
4802 static void data_ack(PLCI *plci, byte ch)
4803 {
4804   dword Id;
4805   DIVA_CAPI_ADAPTER   * a;
4806   NCCI   *ncci_ptr;
4807   word ncci;
4808
4809   a = plci->adapter;
4810   ncci = a->ch_ncci[ch];
4811   ncci_ptr = &(a->ncci[ncci]);
4812   if (ncci_ptr->data_ack_pending)
4813   {
4814     if (a->ncci_state[ncci] && (a->ncci_plci[ncci] == plci->Id))
4815     {
4816       Id = (((dword)ncci)<<16)|((word)plci->Id<<8)|a->Id;
4817       if(plci->tel) Id|=EXT_CONTROLLER;
4818       sendf(plci->appl,_DATA_B3_R|CONFIRM,Id,ncci_ptr->DataAck[ncci_ptr->data_ack_out].Number,
4819             "ww",ncci_ptr->DataAck[ncci_ptr->data_ack_out].Handle,0);
4820     }
4821     (ncci_ptr->data_ack_out)++;
4822     if (ncci_ptr->data_ack_out == MAX_DATA_ACK)
4823       ncci_ptr->data_ack_out = 0;
4824     (ncci_ptr->data_ack_pending)--;
4825   }
4826 }
4827
4828 static void sig_ind(PLCI *plci)
4829 {
4830   dword x_Id;
4831   dword Id;
4832   dword rId;
4833   word Number = 0;
4834   word i;
4835   word cip;
4836   dword cip_mask;
4837   byte   *ie;
4838   DIVA_CAPI_ADAPTER   * a;
4839     API_PARSE saved_parms[MAX_MSG_PARMS+1];
4840 #define MAXPARMSIDS 31
4841     byte   * parms[MAXPARMSIDS];
4842     byte   * add_i[4];
4843     byte   * multi_fac_parms[MAX_MULTI_IE];
4844     byte   * multi_pi_parms [MAX_MULTI_IE];
4845     byte   * multi_ssext_parms [MAX_MULTI_IE];
4846     byte   * multi_CiPN_parms [MAX_MULTI_IE];
4847
4848     byte   * multi_vswitch_parms [MAX_MULTI_IE];
4849
4850   byte ai_len;
4851     byte   *esc_chi = "";
4852     byte   *esc_law = "";
4853     byte   *pty_cai = "";
4854     byte   *esc_cr  = "";
4855     byte   *esc_profile = "";
4856
4857     byte facility[256];
4858   PLCI   * tplci = NULL;
4859   byte chi[] = "\x02\x18\x01";
4860   byte voice_cai[]  = "\x06\x14\x00\x00\x00\x00\x08";
4861     byte resume_cau[] = "\x05\x05\x00\x02\x00\x00";
4862   /* ESC_MSGTYPE must be the last but one message, a new IE has to be */
4863   /* included before the ESC_MSGTYPE and MAXPARMSIDS has to be incremented */
4864   /* SMSG is situated at the end because its 0 (for compatibility reasons */
4865   /* (see Info_Mask Bit 4, first IE. then the message type)           */
4866     word parms_id[] =
4867          {MAXPARMSIDS, CPN, 0xff, DSA, OSA, BC, LLC, HLC, ESC_CAUSE, DSP, DT, CHA,
4868           UUI, CONG_RR, CONG_RNR, ESC_CHI, KEY, CHI, CAU, ESC_LAW,
4869           RDN, RDX, CONN_NR, RIN, NI, CAI, ESC_CR,
4870           CST, ESC_PROFILE, 0xff, ESC_MSGTYPE, SMSG};
4871           /* 14 FTY repl by ESC_CHI */
4872           /* 18 PI  repl by ESC_LAW */
4873          /* removed OAD changed to 0xff for future use, OAD is multiIE now */
4874      word multi_fac_id[] = {1, FTY};
4875      word multi_pi_id[]  = {1, PI};
4876      word multi_CiPN_id[]  = {1, OAD};
4877      word multi_ssext_id[]  = {1, ESC_SSEXT};
4878
4879      word multi_vswitch_id[]  = {1, ESC_VSWITCH};
4880
4881   byte   * cau;
4882   word ncci;
4883     byte SS_Ind[] = "\x05\x02\x00\x02\x00\x00"; /* Hold_Ind struct*/
4884     byte CF_Ind[] = "\x09\x02\x00\x06\x00\x00\x00\x00\x00\x00";
4885     byte Interr_Err_Ind[] = "\x0a\x02\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
4886     byte CONF_Ind[] = "\x09\x16\x00\x06\x00\x00\0x00\0x00\0x00\0x00";
4887   byte force_mt_info = false;
4888   byte dir;
4889   dword d;
4890   word w;
4891
4892   a = plci->adapter;
4893   Id = ((word)plci->Id<<8)|a->Id;
4894   PUT_WORD(&SS_Ind[4],0x0000);
4895
4896   if (plci->sig_remove_id)
4897   {
4898     plci->Sig.RNR = 2; /* discard */
4899     dbug(1,dprintf("SIG discard while remove pending"));
4900     return;
4901   }
4902   if(plci->tel && plci->SuppState!=CALL_HELD) Id|=EXT_CONTROLLER;
4903   dbug(1,dprintf("SigInd-Id=%08lx,plci=%x,tel=%x,state=0x%x,channels=%d,Discflowcl=%d",
4904     Id,plci->Id,plci->tel,plci->State,plci->channels,plci->hangup_flow_ctrl_timer));
4905   if(plci->Sig.Ind==CALL_HOLD_ACK && plci->channels)
4906   {
4907     plci->Sig.RNR = 1;
4908     return;
4909   }
4910   if(plci->Sig.Ind==HANGUP && plci->channels)
4911   {
4912     plci->Sig.RNR = 1;
4913     plci->hangup_flow_ctrl_timer++;
4914     /* recover the network layer after timeout */
4915     if(plci->hangup_flow_ctrl_timer==100)
4916     {
4917       dbug(1,dprintf("Exceptional disc"));
4918       plci->Sig.RNR = 0;
4919       plci->hangup_flow_ctrl_timer = 0;
4920       for (ncci = 1; ncci < MAX_NCCI+1; ncci++)
4921       {
4922         if (a->ncci_plci[ncci] == plci->Id)
4923         {
4924           cleanup_ncci_data (plci, ncci);
4925           if(plci->channels)plci->channels--;
4926           if (plci->appl)
4927             sendf(plci->appl,_DISCONNECT_B3_I, (((dword) ncci) << 16) | Id,0,"ws",0,"");
4928         }
4929       }
4930       if (plci->appl)
4931         sendf(plci->appl, _DISCONNECT_I, Id, 0, "w", 0);
4932       plci_remove(plci);
4933       plci->State=IDLE;
4934     }
4935     return;
4936   }
4937
4938   /* do first parse the info with no OAD in, because OAD will be converted */
4939   /* first the multiple facility IE, then mult. progress ind.              */
4940   /* then the parameters for the info_ind + conn_ind                       */
4941   IndParse(plci,multi_fac_id,multi_fac_parms,MAX_MULTI_IE);
4942   IndParse(plci,multi_pi_id,multi_pi_parms,MAX_MULTI_IE);
4943   IndParse(plci,multi_ssext_id,multi_ssext_parms,MAX_MULTI_IE);
4944
4945   IndParse(plci,multi_vswitch_id,multi_vswitch_parms,MAX_MULTI_IE);
4946
4947   IndParse(plci,parms_id,parms,0);
4948   IndParse(plci,multi_CiPN_id,multi_CiPN_parms,MAX_MULTI_IE);
4949   esc_chi  = parms[14];
4950   esc_law  = parms[18];
4951   pty_cai  = parms[24];
4952   esc_cr   = parms[25];
4953   esc_profile = parms[27];
4954   if(esc_cr[0] && plci)
4955   {
4956     if(plci->cr_enquiry && plci->appl)
4957     {
4958       plci->cr_enquiry = false;
4959       /* d = MANU_ID            */
4960       /* w = m_command          */
4961       /* b = total length       */
4962       /* b = indication type    */
4963       /* b = length of all IEs  */
4964       /* b = IE1                */
4965       /* S = IE1 length + cont. */
4966       /* b = IE2                */
4967       /* S = IE2 length + cont. */
4968       sendf(plci->appl,
4969         _MANUFACTURER_I,
4970         Id,
4971         0,
4972         "dwbbbbSbS",_DI_MANU_ID,plci->m_command,
4973         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);
4974     }
4975   }
4976   /* create the additional info structure                                  */
4977   add_i[1] = parms[15]; /* KEY of additional info */
4978   add_i[2] = parms[11]; /* UUI of additional info */
4979   ai_len = AddInfo(add_i,multi_fac_parms, esc_chi, facility);
4980
4981   /* the ESC_LAW indicates if u-Law or a-Law is actually used by the card  */
4982   /* indication returns by the card if requested by the function           */
4983   /* AutomaticLaw() after driver init                                      */
4984   if (a->automatic_law<4)
4985   {
4986     if(esc_law[0]){
4987       if(esc_law[2]){
4988         dbug(0,dprintf("u-Law selected"));
4989         a->u_law = 1;
4990       }
4991       else {
4992         dbug(0,dprintf("a-Law selected"));
4993         a->u_law = 0;
4994       }
4995       a->automatic_law = 4;
4996       if(plci==a->automatic_lawPLCI) {
4997         plci->internal_command = 0;
4998         sig_req(plci,REMOVE,0);
4999         send_req(plci);
5000         a->automatic_lawPLCI = NULL;
5001       }
5002     }
5003     if (esc_profile[0])
5004     {
5005       dbug (1, dprintf ("[%06x] CardProfile: %lx %lx %lx %lx %lx",
5006         UnMapController (a->Id), GET_DWORD (&esc_profile[6]),
5007         GET_DWORD (&esc_profile[10]), GET_DWORD (&esc_profile[14]),
5008         GET_DWORD (&esc_profile[18]), GET_DWORD (&esc_profile[46])));
5009
5010       a->profile.Global_Options &= 0x000000ffL;
5011       a->profile.B1_Protocols &= 0x000003ffL;
5012       a->profile.B2_Protocols &= 0x00001fdfL;
5013       a->profile.B3_Protocols &= 0x000000b7L;
5014
5015       a->profile.Global_Options &= GET_DWORD (&esc_profile[6]) |
5016         GL_BCHANNEL_OPERATION_SUPPORTED;
5017       a->profile.B1_Protocols &= GET_DWORD (&esc_profile[10]);
5018       a->profile.B2_Protocols &= GET_DWORD (&esc_profile[14]);
5019       a->profile.B3_Protocols &= GET_DWORD (&esc_profile[18]);
5020       a->manufacturer_features = GET_DWORD (&esc_profile[46]);
5021       a->man_profile.private_options = 0;
5022
5023       if (a->manufacturer_features & MANUFACTURER_FEATURE_ECHO_CANCELLER)
5024       {
5025         a->man_profile.private_options |= 1L << PRIVATE_ECHO_CANCELLER;
5026         a->profile.Global_Options |= GL_ECHO_CANCELLER_SUPPORTED;
5027       }
5028
5029
5030       if (a->manufacturer_features & MANUFACTURER_FEATURE_RTP)
5031         a->man_profile.private_options |= 1L << PRIVATE_RTP;
5032       a->man_profile.rtp_primary_payloads = GET_DWORD (&esc_profile[50]);
5033       a->man_profile.rtp_additional_payloads = GET_DWORD (&esc_profile[54]);
5034
5035
5036       if (a->manufacturer_features & MANUFACTURER_FEATURE_T38)
5037         a->man_profile.private_options |= 1L << PRIVATE_T38;
5038
5039
5040       if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_SUB_SEP_PWD)
5041         a->man_profile.private_options |= 1L << PRIVATE_FAX_SUB_SEP_PWD;
5042
5043
5044       if (a->manufacturer_features & MANUFACTURER_FEATURE_V18)
5045         a->man_profile.private_options |= 1L << PRIVATE_V18;
5046
5047
5048       if (a->manufacturer_features & MANUFACTURER_FEATURE_DTMF_TONE)
5049         a->man_profile.private_options |= 1L << PRIVATE_DTMF_TONE;
5050
5051
5052       if (a->manufacturer_features & MANUFACTURER_FEATURE_PIAFS)
5053         a->man_profile.private_options |= 1L << PRIVATE_PIAFS;
5054
5055
5056       if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
5057         a->man_profile.private_options |= 1L << PRIVATE_FAX_PAPER_FORMATS;
5058
5059
5060       if (a->manufacturer_features & MANUFACTURER_FEATURE_VOWN)
5061         a->man_profile.private_options |= 1L << PRIVATE_VOWN;
5062
5063
5064       if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_NONSTANDARD)
5065         a->man_profile.private_options |= 1L << PRIVATE_FAX_NONSTANDARD;
5066
5067     }
5068     else
5069     {
5070       a->profile.Global_Options &= 0x0000007fL;
5071       a->profile.B1_Protocols &= 0x000003dfL;
5072       a->profile.B2_Protocols &= 0x00001adfL;
5073       a->profile.B3_Protocols &= 0x000000b7L;
5074       a->manufacturer_features &= MANUFACTURER_FEATURE_HARDDTMF;
5075     }
5076     if (a->manufacturer_features & (MANUFACTURER_FEATURE_HARDDTMF |
5077       MANUFACTURER_FEATURE_SOFTDTMF_SEND | MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE))
5078     {
5079       a->profile.Global_Options |= GL_DTMF_SUPPORTED;
5080     }
5081     a->manufacturer_features &= ~MANUFACTURER_FEATURE_OOB_CHANNEL;
5082     dbug (1, dprintf ("[%06x] Profile: %lx %lx %lx %lx %lx",
5083       UnMapController (a->Id), a->profile.Global_Options,
5084       a->profile.B1_Protocols, a->profile.B2_Protocols,
5085       a->profile.B3_Protocols, a->manufacturer_features));
5086   }
5087   /* codec plci for the handset/hook state support is just an internal id  */
5088   if(plci!=a->AdvCodecPLCI)
5089   {
5090     force_mt_info =  SendMultiIE(plci,Id,multi_fac_parms, FTY, 0x20, 0);
5091     force_mt_info |= SendMultiIE(plci,Id,multi_pi_parms, PI, 0x210, 0);
5092     SendSSExtInd(NULL,plci,Id,multi_ssext_parms);
5093     SendInfo(plci,Id, parms, force_mt_info);
5094
5095     VSwitchReqInd(plci,Id,multi_vswitch_parms);
5096
5097   }
5098
5099   /* switch the codec to the b-channel                                     */
5100   if(esc_chi[0] && plci && !plci->SuppState){
5101     plci->b_channel = esc_chi[esc_chi[0]]&0x1f;
5102     mixer_set_bchannel_id_esc (plci, plci->b_channel);
5103     dbug(1,dprintf("storeChannel=0x%x",plci->b_channel));
5104     if(plci->tel==ADV_VOICE && plci->appl) {
5105       SetVoiceChannel(a->AdvCodecPLCI, esc_chi, a);
5106     }
5107   }
5108
5109   if(plci->appl) Number = plci->appl->Number++;
5110
5111   switch(plci->Sig.Ind) {
5112   /* Response to Get_Supported_Services request */
5113   case S_SUPPORTED:
5114     dbug(1,dprintf("S_Supported"));
5115     if(!plci->appl) break;
5116     if(pty_cai[0]==4)
5117     {
5118       PUT_DWORD(&CF_Ind[6],GET_DWORD(&pty_cai[1]) );
5119     }
5120     else
5121     {
5122       PUT_DWORD(&CF_Ind[6],MASK_TERMINAL_PORTABILITY | MASK_HOLD_RETRIEVE);
5123     }
5124     PUT_WORD (&CF_Ind[1], 0);
5125     PUT_WORD (&CF_Ind[4], 0);
5126     sendf(plci->appl,_FACILITY_R|CONFIRM,Id&0x7,plci->number, "wws",0,3,CF_Ind);
5127     plci_remove(plci);
5128     break;
5129
5130   /* Supplementary Service rejected */
5131   case S_SERVICE_REJ:
5132     dbug(1,dprintf("S_Reject=0x%x",pty_cai[5]));
5133     if(!pty_cai[0]) break;
5134     switch (pty_cai[5])
5135     {
5136     case ECT_EXECUTE:
5137     case THREE_PTY_END:
5138     case THREE_PTY_BEGIN:
5139       if(!plci->relatedPTYPLCI) break;
5140       tplci = plci->relatedPTYPLCI;
5141       rId = ( (word)tplci->Id<<8)|tplci->adapter->Id;
5142       if(tplci->tel) rId|=EXT_CONTROLLER;
5143       if(pty_cai[5]==ECT_EXECUTE)
5144       {
5145         PUT_WORD(&SS_Ind[1],S_ECT);
5146
5147         plci->vswitchstate=0;
5148         plci->relatedPTYPLCI->vswitchstate=0;
5149
5150       }
5151       else
5152       {
5153         PUT_WORD(&SS_Ind[1],pty_cai[5]+3);
5154       }
5155       if(pty_cai[2]!=0xff)
5156       {
5157         PUT_WORD(&SS_Ind[4],0x3600|(word)pty_cai[2]);
5158       }
5159       else
5160       {
5161         PUT_WORD(&SS_Ind[4],0x300E);
5162       }
5163       plci->relatedPTYPLCI = NULL;
5164       plci->ptyState = 0;
5165       sendf(tplci->appl,_FACILITY_I,rId,0,"ws",3, SS_Ind);
5166       break;
5167
5168     case CALL_DEFLECTION:
5169       if(pty_cai[2]!=0xff)
5170       {
5171         PUT_WORD(&SS_Ind[4],0x3600|(word)pty_cai[2]);
5172       }
5173       else
5174       {
5175         PUT_WORD(&SS_Ind[4],0x300E);
5176       }
5177       PUT_WORD(&SS_Ind[1],pty_cai[5]);
5178       for(i=0; i<max_appl; i++)
5179       {
5180         if(application[i].CDEnable)
5181         {
5182           if(application[i].Id) sendf(&application[i],_FACILITY_I,Id,0,"ws",3, SS_Ind);
5183           application[i].CDEnable = false;
5184         }
5185       }
5186       break;
5187
5188     case DEACTIVATION_DIVERSION:
5189     case ACTIVATION_DIVERSION:
5190     case DIVERSION_INTERROGATE_CFU:
5191     case DIVERSION_INTERROGATE_CFB:
5192     case DIVERSION_INTERROGATE_CFNR:
5193     case DIVERSION_INTERROGATE_NUM:
5194     case CCBS_REQUEST:
5195     case CCBS_DEACTIVATE:
5196     case CCBS_INTERROGATE:
5197       if(!plci->appl) break;
5198       if(pty_cai[2]!=0xff)
5199       {
5200         PUT_WORD(&Interr_Err_Ind[4],0x3600|(word)pty_cai[2]);
5201       }
5202       else
5203       {
5204         PUT_WORD(&Interr_Err_Ind[4],0x300E);
5205       }
5206       switch (pty_cai[5])
5207       {
5208         case DEACTIVATION_DIVERSION:
5209           dbug(1,dprintf("Deact_Div"));
5210           Interr_Err_Ind[0]=0x9;
5211           Interr_Err_Ind[3]=0x6;
5212           PUT_WORD(&Interr_Err_Ind[1],S_CALL_FORWARDING_STOP);
5213           break;
5214         case ACTIVATION_DIVERSION:
5215           dbug(1,dprintf("Act_Div"));
5216           Interr_Err_Ind[0]=0x9;
5217           Interr_Err_Ind[3]=0x6;
5218           PUT_WORD(&Interr_Err_Ind[1],S_CALL_FORWARDING_START);
5219           break;
5220         case DIVERSION_INTERROGATE_CFU:
5221         case DIVERSION_INTERROGATE_CFB:
5222         case DIVERSION_INTERROGATE_CFNR:
5223           dbug(1,dprintf("Interr_Div"));
5224           Interr_Err_Ind[0]=0xa;
5225           Interr_Err_Ind[3]=0x7;
5226           PUT_WORD(&Interr_Err_Ind[1],S_INTERROGATE_DIVERSION);
5227           break;
5228         case DIVERSION_INTERROGATE_NUM:
5229           dbug(1,dprintf("Interr_Num"));
5230           Interr_Err_Ind[0]=0xa;
5231           Interr_Err_Ind[3]=0x7;
5232           PUT_WORD(&Interr_Err_Ind[1],S_INTERROGATE_NUMBERS);
5233           break;
5234         case CCBS_REQUEST:
5235           dbug(1,dprintf("CCBS Request"));
5236           Interr_Err_Ind[0]=0xd;
5237           Interr_Err_Ind[3]=0xa;
5238           PUT_WORD(&Interr_Err_Ind[1],S_CCBS_REQUEST);
5239           break;
5240         case CCBS_DEACTIVATE:
5241           dbug(1,dprintf("CCBS Deactivate"));
5242           Interr_Err_Ind[0]=0x9;
5243           Interr_Err_Ind[3]=0x6;
5244           PUT_WORD(&Interr_Err_Ind[1],S_CCBS_DEACTIVATE);
5245           break;
5246         case CCBS_INTERROGATE:
5247           dbug(1,dprintf("CCBS Interrogate"));
5248           Interr_Err_Ind[0]=0xb;
5249           Interr_Err_Ind[3]=0x8;
5250           PUT_WORD(&Interr_Err_Ind[1],S_CCBS_INTERROGATE);
5251           break;
5252       }
5253       PUT_DWORD(&Interr_Err_Ind[6],plci->appl->S_Handle);
5254       sendf(plci->appl,_FACILITY_I,Id&0x7,0,"ws",3, Interr_Err_Ind);
5255       plci_remove(plci);
5256       break;
5257     case ACTIVATION_MWI:
5258     case DEACTIVATION_MWI:
5259       if(pty_cai[5]==ACTIVATION_MWI)
5260       {
5261         PUT_WORD(&SS_Ind[1],S_MWI_ACTIVATE);
5262       }
5263       else PUT_WORD(&SS_Ind[1],S_MWI_DEACTIVATE);
5264
5265       if(pty_cai[2]!=0xff)
5266       {
5267         PUT_WORD(&SS_Ind[4],0x3600|(word)pty_cai[2]);
5268       }
5269       else
5270       {
5271         PUT_WORD(&SS_Ind[4],0x300E);
5272       }
5273
5274       if(plci->cr_enquiry)
5275       {
5276         sendf(plci->appl,_FACILITY_I,Id&0xf,0,"ws",3, SS_Ind);
5277         plci_remove(plci);
5278       }
5279       else
5280       {
5281         sendf(plci->appl,_FACILITY_I,Id,0,"ws",3, SS_Ind);
5282       }
5283       break;
5284     case CONF_ADD: /* ERROR */
5285     case CONF_BEGIN:
5286     case CONF_DROP:
5287     case CONF_ISOLATE:
5288     case CONF_REATTACH:
5289       CONF_Ind[0]=9;
5290       CONF_Ind[3]=6;
5291       switch(pty_cai[5])
5292       {
5293       case CONF_BEGIN:
5294           PUT_WORD(&CONF_Ind[1],S_CONF_BEGIN);
5295           plci->ptyState = 0;
5296           break;
5297       case CONF_DROP:
5298           CONF_Ind[0]=5;
5299           CONF_Ind[3]=2;
5300           PUT_WORD(&CONF_Ind[1],S_CONF_DROP);
5301           plci->ptyState = CONNECTED;
5302           break;
5303       case CONF_ISOLATE:
5304           CONF_Ind[0]=5;
5305           CONF_Ind[3]=2;
5306           PUT_WORD(&CONF_Ind[1],S_CONF_ISOLATE);
5307           plci->ptyState = CONNECTED;
5308           break;
5309       case CONF_REATTACH:
5310           CONF_Ind[0]=5;
5311           CONF_Ind[3]=2;
5312           PUT_WORD(&CONF_Ind[1],S_CONF_REATTACH);
5313           plci->ptyState = CONNECTED;
5314           break;
5315       case CONF_ADD:
5316           PUT_WORD(&CONF_Ind[1],S_CONF_ADD);
5317           plci->relatedPTYPLCI = NULL;
5318           tplci=plci->relatedPTYPLCI;
5319           if(tplci) tplci->ptyState = CONNECTED;
5320           plci->ptyState = CONNECTED;
5321           break;
5322       }
5323
5324       if(pty_cai[2]!=0xff)
5325       {
5326         PUT_WORD(&CONF_Ind[4],0x3600|(word)pty_cai[2]);
5327       }
5328       else
5329       {
5330         PUT_WORD(&CONF_Ind[4],0x3303); /* Time-out: network did not respond
5331                                             within the required time */
5332       }
5333
5334       PUT_DWORD(&CONF_Ind[6],0x0);
5335       sendf(plci->appl,_FACILITY_I,Id,0,"ws",3, CONF_Ind);
5336       break;
5337     }
5338     break;
5339
5340   /* Supplementary Service indicates success */
5341   case S_SERVICE:
5342     dbug(1,dprintf("Service_Ind"));
5343     PUT_WORD (&CF_Ind[4], 0);
5344     switch (pty_cai[5])
5345     {
5346     case THREE_PTY_END:
5347     case THREE_PTY_BEGIN:
5348     case ECT_EXECUTE:
5349       if(!plci->relatedPTYPLCI) break;
5350       tplci = plci->relatedPTYPLCI;
5351       rId = ( (word)tplci->Id<<8)|tplci->adapter->Id;
5352       if(tplci->tel) rId|=EXT_CONTROLLER;
5353       if(pty_cai[5]==ECT_EXECUTE)
5354       {
5355         PUT_WORD(&SS_Ind[1],S_ECT);
5356
5357         if(plci->vswitchstate!=3)
5358         {
5359
5360         plci->ptyState = IDLE;
5361         plci->relatedPTYPLCI = NULL;
5362         plci->ptyState = 0;
5363
5364         }
5365
5366         dbug(1,dprintf("ECT OK"));
5367         sendf(tplci->appl,_FACILITY_I,rId,0,"ws",3, SS_Ind);
5368
5369
5370
5371       }
5372       else
5373       {
5374         switch (plci->ptyState)
5375         {
5376         case S_3PTY_BEGIN:
5377           plci->ptyState = CONNECTED;
5378           dbug(1,dprintf("3PTY ON"));
5379           break;
5380
5381         case S_3PTY_END:
5382           plci->ptyState = IDLE;
5383           plci->relatedPTYPLCI = NULL;
5384           plci->ptyState = 0;
5385           dbug(1,dprintf("3PTY OFF"));
5386           break;
5387         }
5388         PUT_WORD(&SS_Ind[1],pty_cai[5]+3);
5389         sendf(tplci->appl,_FACILITY_I,rId,0,"ws",3, SS_Ind);
5390       }
5391       break;
5392
5393     case CALL_DEFLECTION:
5394       PUT_WORD(&SS_Ind[1],pty_cai[5]);
5395       for(i=0; i<max_appl; i++)
5396       {
5397         if(application[i].CDEnable)
5398         {
5399           if(application[i].Id) sendf(&application[i],_FACILITY_I,Id,0,"ws",3, SS_Ind);
5400           application[i].CDEnable = false;
5401         }
5402       }
5403       break;
5404
5405     case DEACTIVATION_DIVERSION:
5406     case ACTIVATION_DIVERSION:
5407       if(!plci->appl) break;
5408       PUT_WORD(&CF_Ind[1],pty_cai[5]+2);
5409       PUT_DWORD(&CF_Ind[6],plci->appl->S_Handle);
5410       sendf(plci->appl,_FACILITY_I,Id&0x7,0,"ws",3, CF_Ind);
5411       plci_remove(plci);
5412       break;
5413
5414     case DIVERSION_INTERROGATE_CFU:
5415     case DIVERSION_INTERROGATE_CFB:
5416     case DIVERSION_INTERROGATE_CFNR:
5417     case DIVERSION_INTERROGATE_NUM:
5418     case CCBS_REQUEST:
5419     case CCBS_DEACTIVATE:
5420     case CCBS_INTERROGATE:
5421       if(!plci->appl) break;
5422       switch (pty_cai[5])
5423       {
5424         case DIVERSION_INTERROGATE_CFU:
5425         case DIVERSION_INTERROGATE_CFB:
5426         case DIVERSION_INTERROGATE_CFNR:
5427           dbug(1,dprintf("Interr_Div"));
5428           PUT_WORD(&pty_cai[1],S_INTERROGATE_DIVERSION);
5429           pty_cai[3]=pty_cai[0]-3; /* Supplementary Service-specific parameter len */
5430           break;
5431         case DIVERSION_INTERROGATE_NUM:
5432           dbug(1,dprintf("Interr_Num"));
5433           PUT_WORD(&pty_cai[1],S_INTERROGATE_NUMBERS);
5434           pty_cai[3]=pty_cai[0]-3; /* Supplementary Service-specific parameter len */
5435           break;
5436         case CCBS_REQUEST:
5437           dbug(1,dprintf("CCBS Request"));
5438           PUT_WORD(&pty_cai[1],S_CCBS_REQUEST);
5439           pty_cai[3]=pty_cai[0]-3; /* Supplementary Service-specific parameter len */
5440           break;
5441         case CCBS_DEACTIVATE:
5442           dbug(1,dprintf("CCBS Deactivate"));
5443           PUT_WORD(&pty_cai[1],S_CCBS_DEACTIVATE);
5444           pty_cai[3]=pty_cai[0]-3; /* Supplementary Service-specific parameter len */
5445           break;
5446         case CCBS_INTERROGATE:
5447           dbug(1,dprintf("CCBS Interrogate"));
5448           PUT_WORD(&pty_cai[1],S_CCBS_INTERROGATE);
5449           pty_cai[3]=pty_cai[0]-3; /* Supplementary Service-specific parameter len */
5450           break;
5451       }
5452       PUT_WORD(&pty_cai[4],0); /* Supplementary Service Reason */
5453       PUT_DWORD(&pty_cai[6],plci->appl->S_Handle);
5454       sendf(plci->appl,_FACILITY_I,Id&0x7,0,"wS",3, pty_cai);
5455       plci_remove(plci);
5456       break;
5457
5458     case ACTIVATION_MWI:
5459     case DEACTIVATION_MWI:
5460       if(pty_cai[5]==ACTIVATION_MWI)
5461       {
5462         PUT_WORD(&SS_Ind[1],S_MWI_ACTIVATE);
5463       }
5464       else PUT_WORD(&SS_Ind[1],S_MWI_DEACTIVATE);
5465       if(plci->cr_enquiry)
5466       {
5467         sendf(plci->appl,_FACILITY_I,Id&0xf,0,"ws",3, SS_Ind);
5468         plci_remove(plci);
5469       }
5470       else
5471       {
5472         sendf(plci->appl,_FACILITY_I,Id,0,"ws",3, SS_Ind);
5473       }
5474       break;
5475     case MWI_INDICATION:
5476       if(pty_cai[0]>=0x12)
5477       {
5478         PUT_WORD(&pty_cai[3],S_MWI_INDICATE);
5479         pty_cai[2]=pty_cai[0]-2; /* len Parameter */
5480         pty_cai[5]=pty_cai[0]-5; /* Supplementary Service-specific parameter len */
5481         if(plci->appl && (a->Notification_Mask[plci->appl->Id-1]&SMASK_MWI))
5482         {
5483           if(plci->internal_command==GET_MWI_STATE) /* result on Message Waiting Listen */
5484           {
5485             sendf(plci->appl,_FACILITY_I,Id&0xf,0,"wS",3, &pty_cai[2]);
5486             plci_remove(plci);
5487             return;
5488           }
5489           else  sendf(plci->appl,_FACILITY_I,Id,0,"wS",3, &pty_cai[2]);
5490           pty_cai[0]=0;
5491         }
5492         else
5493         {
5494           for(i=0; i<max_appl; i++)
5495           {
5496             if(a->Notification_Mask[i]&SMASK_MWI)
5497             {
5498               sendf(&application[i],_FACILITY_I,Id&0x7,0,"wS",3, &pty_cai[2]);
5499               pty_cai[0]=0;
5500             }
5501           }
5502         }
5503
5504         if(!pty_cai[0])
5505         { /* acknowledge */
5506           facility[2]= 0; /* returncode */
5507         }
5508         else facility[2]= 0xff;
5509       }
5510       else
5511       {
5512         /* reject */
5513         facility[2]= 0xff; /* returncode */
5514       }
5515       facility[0]= 2;
5516       facility[1]= MWI_RESPONSE; /* Function */
5517       add_p(plci,CAI,facility);
5518       add_p(plci,ESC,multi_ssext_parms[0]); /* remembered parameter -> only one possible */
5519       sig_req(plci,S_SERVICE,0);
5520       send_req(plci);
5521       plci->command = 0;
5522       next_internal_command (Id, plci);
5523       break;
5524     case CONF_ADD: /* OK */
5525     case CONF_BEGIN:
5526     case CONF_DROP:
5527     case CONF_ISOLATE:
5528     case CONF_REATTACH:
5529     case CONF_PARTYDISC:
5530       CONF_Ind[0]=9;
5531       CONF_Ind[3]=6;
5532       switch(pty_cai[5])
5533       {
5534       case CONF_BEGIN:
5535           PUT_WORD(&CONF_Ind[1],S_CONF_BEGIN);
5536           if(pty_cai[0]==6)
5537           {
5538               d=pty_cai[6];
5539               PUT_DWORD(&CONF_Ind[6],d); /* PartyID */
5540           }
5541           else
5542           {
5543               PUT_DWORD(&CONF_Ind[6],0x0);
5544           }
5545           break;
5546       case CONF_ISOLATE:
5547           PUT_WORD(&CONF_Ind[1],S_CONF_ISOLATE);
5548           CONF_Ind[0]=5;
5549           CONF_Ind[3]=2;
5550           break;
5551       case CONF_REATTACH:
5552           PUT_WORD(&CONF_Ind[1],S_CONF_REATTACH);
5553           CONF_Ind[0]=5;
5554           CONF_Ind[3]=2;
5555           break;
5556       case CONF_DROP:
5557           PUT_WORD(&CONF_Ind[1],S_CONF_DROP);
5558           CONF_Ind[0]=5;
5559           CONF_Ind[3]=2;
5560           break;
5561       case CONF_ADD:
5562           PUT_WORD(&CONF_Ind[1],S_CONF_ADD);
5563           d=pty_cai[6];
5564           PUT_DWORD(&CONF_Ind[6],d); /* PartyID */
5565           tplci=plci->relatedPTYPLCI;
5566           if(tplci) tplci->ptyState = CONNECTED;
5567           break;
5568       case CONF_PARTYDISC:
5569           CONF_Ind[0]=7;
5570           CONF_Ind[3]=4;
5571           PUT_WORD(&CONF_Ind[1],S_CONF_PARTYDISC);
5572           d=pty_cai[6];
5573           PUT_DWORD(&CONF_Ind[4],d); /* PartyID */
5574           break;
5575       }
5576       plci->ptyState = CONNECTED;
5577       sendf(plci->appl,_FACILITY_I,Id,0,"ws",3, CONF_Ind);
5578       break;
5579     case CCBS_INFO_RETAIN:
5580     case CCBS_ERASECALLLINKAGEID:
5581     case CCBS_STOP_ALERTING:
5582       CONF_Ind[0]=5;
5583       CONF_Ind[3]=2;
5584       switch(pty_cai[5])
5585       {
5586       case CCBS_INFO_RETAIN:
5587         PUT_WORD(&CONF_Ind[1],S_CCBS_INFO_RETAIN);
5588         break;
5589       case CCBS_STOP_ALERTING:
5590         PUT_WORD(&CONF_Ind[1],S_CCBS_STOP_ALERTING);
5591     break;
5592       case CCBS_ERASECALLLINKAGEID:
5593         PUT_WORD(&CONF_Ind[1],S_CCBS_ERASECALLLINKAGEID);
5594         CONF_Ind[0]=7;
5595         CONF_Ind[3]=4;
5596         CONF_Ind[6]=0;
5597         CONF_Ind[7]=0;
5598         break;
5599       }
5600       w=pty_cai[6];
5601       PUT_WORD(&CONF_Ind[4],w); /* PartyID */
5602
5603       if(plci->appl && (a->Notification_Mask[plci->appl->Id-1]&SMASK_CCBS))
5604       {
5605         sendf(plci->appl,_FACILITY_I,Id,0,"ws",3, CONF_Ind);
5606       }
5607       else
5608       {
5609         for(i=0; i<max_appl; i++)
5610             if(a->Notification_Mask[i]&SMASK_CCBS)
5611                 sendf(&application[i],_FACILITY_I,Id&0x7,0,"ws",3, CONF_Ind);
5612       }
5613       break;
5614     }
5615     break;
5616   case CALL_HOLD_REJ:
5617     cau = parms[7];
5618     if(cau)
5619     {
5620       i = _L3_CAUSE | cau[2];
5621       if(cau[2]==0) i = 0x3603;
5622     }
5623     else
5624     {
5625       i = 0x3603;
5626     }
5627     PUT_WORD(&SS_Ind[1],S_HOLD);
5628     PUT_WORD(&SS_Ind[4],i);
5629     if(plci->SuppState == HOLD_REQUEST)
5630     {
5631       plci->SuppState = IDLE;
5632       sendf(plci->appl,_FACILITY_I,Id,0,"ws",3, SS_Ind);
5633     }
5634     break;
5635
5636   case CALL_HOLD_ACK:
5637     if(plci->SuppState == HOLD_REQUEST)
5638     {
5639       plci->SuppState = CALL_HELD;
5640       CodecIdCheck(a, plci);
5641       start_internal_command (Id, plci, hold_save_command);
5642     }
5643     break;
5644
5645   case CALL_RETRIEVE_REJ:
5646     cau = parms[7];
5647     if(cau)
5648     {
5649       i = _L3_CAUSE | cau[2];
5650       if(cau[2]==0) i = 0x3603;
5651     }
5652     else
5653     {
5654       i = 0x3603;
5655     }
5656     PUT_WORD(&SS_Ind[1],S_RETRIEVE);
5657     PUT_WORD(&SS_Ind[4],i);
5658     if(plci->SuppState == RETRIEVE_REQUEST)
5659     {
5660       plci->SuppState = CALL_HELD;
5661       CodecIdCheck(a, plci);
5662       sendf(plci->appl,_FACILITY_I,Id,0,"ws",3, SS_Ind);
5663     }
5664     break;
5665
5666   case CALL_RETRIEVE_ACK:
5667     PUT_WORD(&SS_Ind[1],S_RETRIEVE);
5668     if(plci->SuppState == RETRIEVE_REQUEST)
5669     {
5670       plci->SuppState = IDLE;
5671       plci->call_dir |= CALL_DIR_FORCE_OUTG_NL;
5672       plci->b_channel = esc_chi[esc_chi[0]]&0x1f;
5673       if(plci->tel)
5674       {
5675         mixer_set_bchannel_id_esc (plci, plci->b_channel);
5676         dbug(1,dprintf("RetrChannel=0x%x",plci->b_channel));
5677         SetVoiceChannel(a->AdvCodecPLCI, esc_chi, a);
5678         if(plci->B2_prot==B2_TRANSPARENT && plci->B3_prot==B3_TRANSPARENT)
5679         {
5680           dbug(1,dprintf("Get B-ch"));
5681           start_internal_command (Id, plci, retrieve_restore_command);
5682         }
5683         else
5684           sendf(plci->appl,_FACILITY_I,Id,0,"ws",3, SS_Ind);
5685       }
5686       else
5687         start_internal_command (Id, plci, retrieve_restore_command);
5688     }
5689     break;
5690
5691   case INDICATE_IND:
5692     if(plci->State != LISTENING) {
5693       sig_req(plci,HANGUP,0);
5694       send_req(plci);
5695       break;
5696     }
5697     cip = find_cip(a,parms[4],parms[6]);
5698     cip_mask = 1L<<cip;
5699     dbug(1,dprintf("cip=%d,cip_mask=%lx",cip,cip_mask));
5700     clear_c_ind_mask (plci);
5701     if (!remove_started && !a->adapter_disabled)
5702     {
5703       set_c_ind_mask_bit (plci, MAX_APPL);
5704       group_optimization(a, plci);
5705       for(i=0; i<max_appl; i++) {
5706         if(application[i].Id
5707         && (a->CIP_Mask[i]&1 || a->CIP_Mask[i]&cip_mask)
5708         && CPN_filter_ok(parms[0],a,i)
5709         && test_group_ind_mask_bit (plci, i) ) {
5710           dbug(1,dprintf("storedcip_mask[%d]=0x%lx",i,a->CIP_Mask[i] ));
5711           set_c_ind_mask_bit (plci, i);
5712           dump_c_ind_mask (plci);
5713           plci->State = INC_CON_PENDING;
5714           plci->call_dir = (plci->call_dir & ~(CALL_DIR_OUT | CALL_DIR_ORIGINATE)) |
5715             CALL_DIR_IN | CALL_DIR_ANSWER;
5716           if(esc_chi[0]) {
5717             plci->b_channel = esc_chi[esc_chi[0]]&0x1f;
5718             mixer_set_bchannel_id_esc (plci, plci->b_channel);
5719           }
5720           /* if a listen on the ext controller is done, check if hook states */
5721           /* are supported or if just a on board codec must be activated     */
5722           if(a->codec_listen[i] && !a->AdvSignalPLCI) {
5723             if(a->profile.Global_Options & HANDSET)
5724               plci->tel = ADV_VOICE;
5725             else if(a->profile.Global_Options & ON_BOARD_CODEC)
5726               plci->tel = CODEC;
5727             if(plci->tel) Id|=EXT_CONTROLLER;
5728             a->codec_listen[i] = plci;
5729           }
5730
5731           sendf(&application[i],_CONNECT_I,Id,0,
5732                 "wSSSSSSSbSSSSS", cip,    /* CIP                 */
5733                              parms[0],    /* CalledPartyNumber   */
5734                              multi_CiPN_parms[0],    /* CallingPartyNumber  */
5735                              parms[2],    /* CalledPartySubad    */
5736                              parms[3],    /* CallingPartySubad   */
5737                              parms[4],    /* BearerCapability    */
5738                              parms[5],    /* LowLC               */
5739                              parms[6],    /* HighLC              */
5740                              ai_len,      /* nested struct add_i */
5741                              add_i[0],    /* B channel info    */
5742                              add_i[1],    /* keypad facility   */
5743                              add_i[2],    /* user user data    */
5744                              add_i[3],    /* nested facility   */
5745                              multi_CiPN_parms[1]    /* second CiPN(SCR)   */
5746                              );
5747           SendSSExtInd(&application[i],
5748                         plci,
5749                         Id,
5750                         multi_ssext_parms);
5751           SendSetupInfo(&application[i],
5752                         plci,
5753                         Id,
5754                         parms,
5755                         SendMultiIE(plci,Id,multi_pi_parms, PI, 0x210, true));
5756         }
5757       }
5758       clear_c_ind_mask_bit (plci, MAX_APPL);
5759       dump_c_ind_mask (plci);
5760     }
5761     if(c_ind_mask_empty (plci)) {
5762       sig_req(plci,HANGUP,0);
5763       send_req(plci);
5764       plci->State = IDLE;
5765     }
5766     plci->notifiedcall = 0;
5767     a->listen_active--;
5768     listen_check(a);
5769     break;
5770
5771   case CALL_PEND_NOTIFY:
5772     plci->notifiedcall = 1;
5773     listen_check(a);
5774     break;
5775
5776   case CALL_IND:
5777   case CALL_CON:
5778     if(plci->State==ADVANCED_VOICE_SIG || plci->State==ADVANCED_VOICE_NOSIG)
5779     {
5780       if(plci->internal_command==PERM_COD_CONN_PEND)
5781       {
5782         if(plci->State==ADVANCED_VOICE_NOSIG)
5783         {
5784           dbug(1,dprintf("***Codec OK"));
5785           if(a->AdvSignalPLCI)
5786           {
5787             tplci = a->AdvSignalPLCI;
5788             if(tplci->spoofed_msg)
5789             {
5790               dbug(1,dprintf("***Spoofed Msg(0x%x)",tplci->spoofed_msg));
5791               tplci->command = 0;
5792               tplci->internal_command = 0;
5793               x_Id = ((word)tplci->Id<<8)|tplci->adapter->Id | 0x80;
5794               switch (tplci->spoofed_msg)
5795               {
5796               case CALL_RES:
5797                 tplci->command = _CONNECT_I|RESPONSE;
5798                 api_load_msg (&tplci->saved_msg, saved_parms);
5799                 add_b1(tplci,&saved_parms[1],0,tplci->B1_facilities);
5800                 if (tplci->adapter->Info_Mask[tplci->appl->Id-1] & 0x200)
5801                 {
5802                   /* early B3 connect (CIP mask bit 9) no release after a disc */
5803                   add_p(tplci,LLI,"\x01\x01");
5804                 }
5805                 add_s(tplci, CONN_NR, &saved_parms[2]);
5806                 add_s(tplci, LLC, &saved_parms[4]);
5807                 add_ai(tplci, &saved_parms[5]);
5808                 tplci->State = INC_CON_ACCEPT;
5809                 sig_req(tplci, CALL_RES,0);
5810                 send_req(tplci);
5811                 break;
5812
5813               case AWAITING_SELECT_B:
5814                 dbug(1,dprintf("Select_B continue"));
5815                 start_internal_command (x_Id, tplci, select_b_command);
5816                 break;
5817
5818               case AWAITING_MANUF_CON: /* Get_Plci per Manufacturer_Req to ext controller */
5819                 if(!tplci->Sig.Id)
5820                 {
5821                   dbug(1,dprintf("No SigID!"));
5822                   sendf(tplci->appl, _MANUFACTURER_R|CONFIRM,x_Id,tplci->number, "dww",_DI_MANU_ID,_MANUFACTURER_R,_OUT_OF_PLCI);
5823                   plci_remove(tplci);
5824                   break;
5825                 }
5826                 tplci->command = _MANUFACTURER_R;
5827                 api_load_msg (&tplci->saved_msg, saved_parms);
5828                 dir = saved_parms[2].info[0];
5829                 if(dir==1) {
5830                   sig_req(tplci,CALL_REQ,0);
5831                 }
5832                 else if(!dir){
5833                   sig_req(tplci,LISTEN_REQ,0);
5834                 }
5835                 send_req(tplci);
5836                 sendf(tplci->appl, _MANUFACTURER_R|CONFIRM,x_Id,tplci->number, "dww",_DI_MANU_ID,_MANUFACTURER_R,0);
5837                 break;
5838
5839               case (CALL_REQ|AWAITING_MANUF_CON):
5840                 sig_req(tplci,CALL_REQ,0);
5841                 send_req(tplci);
5842                 break;
5843
5844               case CALL_REQ:
5845                 if(!tplci->Sig.Id)
5846                 {
5847                   dbug(1,dprintf("No SigID!"));
5848                   sendf(tplci->appl,_CONNECT_R|CONFIRM,tplci->adapter->Id,0,"w",_OUT_OF_PLCI);
5849                   plci_remove(tplci);
5850                   break;
5851                 }
5852                 tplci->command = _CONNECT_R;
5853                 api_load_msg (&tplci->saved_msg, saved_parms);
5854                 add_s(tplci,CPN,&saved_parms[1]);
5855                 add_s(tplci,DSA,&saved_parms[3]);
5856                 add_ai(tplci,&saved_parms[9]);
5857                 sig_req(tplci,CALL_REQ,0);
5858                 send_req(tplci);
5859                 break;
5860
5861               case CALL_RETRIEVE:
5862                 tplci->command = C_RETRIEVE_REQ;
5863                 sig_req(tplci,CALL_RETRIEVE,0);
5864                 send_req(tplci);
5865                 break;
5866               }
5867               tplci->spoofed_msg = 0;
5868               if (tplci->internal_command == 0)
5869                 next_internal_command (x_Id, tplci);
5870             }
5871           }
5872           next_internal_command (Id, plci);
5873           break;
5874         }
5875         dbug(1,dprintf("***Codec Hook Init Req"));
5876         plci->internal_command = PERM_COD_HOOK;
5877         add_p(plci,FTY,"\x01\x09");             /* Get Hook State*/
5878         sig_req(plci,TEL_CTRL,0);
5879         send_req(plci);
5880       }
5881     }
5882     else if(plci->command != _MANUFACTURER_R  /* old style permanent connect */
5883     && plci->State!=INC_ACT_PENDING)
5884     {
5885       mixer_set_bchannel_id_esc (plci, plci->b_channel);
5886       if(plci->tel == ADV_VOICE && plci->SuppState == IDLE) /* with permanent codec switch on immediately */
5887       {
5888         chi[2] = plci->b_channel;
5889         SetVoiceChannel(a->AdvCodecPLCI, chi, a);
5890       }
5891       sendf(plci->appl,_CONNECT_ACTIVE_I,Id,0,"Sss",parms[21],"","");
5892       plci->State = INC_ACT_PENDING;
5893     }
5894     break;
5895
5896   case TEL_CTRL:
5897     Number = 0;
5898     ie = multi_fac_parms[0]; /* inspect the facility hook indications */
5899     if(plci->State==ADVANCED_VOICE_SIG && ie[0]){
5900       switch (ie[1]&0x91) {
5901         case 0x80:   /* hook off */
5902         case 0x81:
5903           if(plci->internal_command==PERM_COD_HOOK)
5904           {
5905             dbug(1,dprintf("init:hook_off"));
5906             plci->hook_state = ie[1];
5907             next_internal_command (Id, plci);
5908             break;
5909           }
5910           else /* ignore doubled hook indications */
5911           {
5912             if( ((plci->hook_state)&0xf0)==0x80)
5913             {
5914               dbug(1,dprintf("ignore hook"));
5915               break;
5916             }
5917             plci->hook_state = ie[1]&0x91;
5918           }
5919           /* check for incoming call pending */
5920           /* and signal '+'.Appl must decide */
5921           /* with connect_res if call must   */
5922           /* accepted or not                 */
5923           for(i=0, tplci=NULL;i<max_appl;i++){
5924             if(a->codec_listen[i]
5925             && (a->codec_listen[i]->State==INC_CON_PENDING
5926               ||a->codec_listen[i]->State==INC_CON_ALERT) ){
5927               tplci = a->codec_listen[i];
5928               tplci->appl = &application[i];
5929             }
5930           }
5931           /* no incoming call, do outgoing call */
5932           /* and signal '+' if outg. setup   */
5933           if(!a->AdvSignalPLCI && !tplci){
5934             if((i=get_plci(a))) {
5935               a->AdvSignalPLCI = &a->plci[i-1];
5936               tplci = a->AdvSignalPLCI;
5937               tplci->tel  = ADV_VOICE;
5938               PUT_WORD(&voice_cai[5],a->AdvSignalAppl->MaxDataLength);
5939               if (a->Info_Mask[a->AdvSignalAppl->Id-1] & 0x200){
5940                 /* early B3 connect (CIP mask bit 9) no release after a disc */
5941                 add_p(tplci,LLI,"\x01\x01");
5942               }
5943               add_p(tplci, CAI, voice_cai);
5944               add_p(tplci, OAD, a->TelOAD);
5945               add_p(tplci, OSA, a->TelOSA);
5946               add_p(tplci,SHIFT|6,NULL);
5947               add_p(tplci,SIN,"\x02\x01\x00");
5948               add_p(tplci,UID,"\x06\x43\x61\x70\x69\x32\x30");
5949               sig_req(tplci,ASSIGN,DSIG_ID);
5950               a->AdvSignalPLCI->internal_command = HOOK_OFF_REQ;
5951               a->AdvSignalPLCI->command = 0;
5952               tplci->appl = a->AdvSignalAppl;
5953               tplci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
5954               send_req(tplci);
5955             }
5956
5957           }
5958
5959           if(!tplci) break;
5960           Id = ((word)tplci->Id<<8)|a->Id;
5961           Id|=EXT_CONTROLLER;
5962           sendf(tplci->appl,
5963                 _FACILITY_I,
5964                 Id,
5965                 0,
5966                 "ws", (word)0, "\x01+");
5967           break;
5968
5969         case 0x90:   /* hook on  */
5970         case 0x91:
5971           if(plci->internal_command==PERM_COD_HOOK)
5972           {
5973             dbug(1,dprintf("init:hook_on"));
5974             plci->hook_state = ie[1]&0x91;
5975             next_internal_command (Id, plci);
5976             break;
5977           }
5978           else /* ignore doubled hook indications */
5979           {
5980             if( ((plci->hook_state)&0xf0)==0x90) break;
5981             plci->hook_state = ie[1]&0x91;
5982           }
5983           /* hangup the adv. voice call and signal '-' to the appl */
5984           if(a->AdvSignalPLCI) {
5985             Id = ((word)a->AdvSignalPLCI->Id<<8)|a->Id;
5986             if(plci->tel) Id|=EXT_CONTROLLER;
5987             sendf(a->AdvSignalAppl,
5988                   _FACILITY_I,
5989                   Id,
5990                   0,
5991                   "ws", (word)0, "\x01-");
5992             a->AdvSignalPLCI->internal_command = HOOK_ON_REQ;
5993             a->AdvSignalPLCI->command = 0;
5994             sig_req(a->AdvSignalPLCI,HANGUP,0);
5995             send_req(a->AdvSignalPLCI);
5996           }
5997           break;
5998       }
5999     }
6000     break;
6001
6002   case RESUME:
6003     clear_c_ind_mask_bit (plci, (word)(plci->appl->Id-1));
6004     PUT_WORD(&resume_cau[4],GOOD);
6005     sendf(plci->appl,_FACILITY_I,Id,0,"ws", (word)3, resume_cau);
6006     break;
6007
6008   case SUSPEND:
6009     clear_c_ind_mask (plci);
6010
6011     if (plci->NL.Id && !plci->nl_remove_id) {
6012       mixer_remove (plci);
6013       nl_req_ncci(plci,REMOVE,0);
6014     }
6015     if (!plci->sig_remove_id) {
6016       plci->internal_command = 0;
6017       sig_req(plci,REMOVE,0);
6018     }
6019     send_req(plci);
6020     if(!plci->channels) {
6021       sendf(plci->appl,_FACILITY_I,Id,0,"ws", (word)3, "\x05\x04\x00\x02\x00\x00");
6022       sendf(plci->appl, _DISCONNECT_I, Id, 0, "w", 0);
6023     }
6024     break;
6025
6026   case SUSPEND_REJ:
6027     break;
6028
6029   case HANGUP:
6030     plci->hangup_flow_ctrl_timer=0;
6031     if(plci->manufacturer && plci->State==LOCAL_CONNECT) break;
6032     cau = parms[7];
6033     if(cau) {
6034       i = _L3_CAUSE | cau[2];
6035       if(cau[2]==0) i = 0;
6036       else if(cau[2]==8) i = _L1_ERROR;
6037       else if(cau[2]==9 || cau[2]==10) i = _L2_ERROR;
6038       else if(cau[2]==5) i = _CAPI_GUARD_ERROR;
6039     }
6040     else {
6041       i = _L3_ERROR;
6042     }
6043
6044     if(plci->State==INC_CON_PENDING || plci->State==INC_CON_ALERT)
6045     {
6046       for(i=0; i<max_appl; i++)
6047       {
6048         if(test_c_ind_mask_bit (plci, i))
6049           sendf(&application[i], _DISCONNECT_I, Id, 0, "w", 0);
6050       }
6051     }
6052     else
6053     {
6054       clear_c_ind_mask (plci);
6055     }
6056     if(!plci->appl)
6057     {
6058       if (plci->State == LISTENING)
6059       {
6060         plci->notifiedcall=0;
6061         a->listen_active--;
6062       }
6063       plci->State = INC_DIS_PENDING;
6064       if(c_ind_mask_empty (plci))
6065       {
6066         plci->State = IDLE;
6067         if (plci->NL.Id && !plci->nl_remove_id)
6068         {
6069           mixer_remove (plci);
6070           nl_req_ncci(plci,REMOVE,0);
6071         }
6072         if (!plci->sig_remove_id)
6073         {
6074           plci->internal_command = 0;
6075           sig_req(plci,REMOVE,0);
6076         }
6077         send_req(plci);
6078       }
6079     }
6080     else
6081     {
6082         /* collision of DISCONNECT or CONNECT_RES with HANGUP can   */
6083         /* result in a second HANGUP! Don't generate another        */
6084         /* DISCONNECT                                               */
6085       if(plci->State!=IDLE && plci->State!=INC_DIS_PENDING)
6086       {
6087         if(plci->State==RESUMING)
6088         {
6089           PUT_WORD(&resume_cau[4],i);
6090           sendf(plci->appl,_FACILITY_I,Id,0,"ws", (word)3, resume_cau);
6091         }
6092         plci->State = INC_DIS_PENDING;
6093         sendf(plci->appl,_DISCONNECT_I,Id,0,"w",i);
6094       }
6095     }
6096     break;
6097
6098   case SSEXT_IND:
6099     SendSSExtInd(NULL,plci,Id,multi_ssext_parms);
6100     break;
6101
6102   case VSWITCH_REQ:
6103     VSwitchReqInd(plci,Id,multi_vswitch_parms);
6104     break;
6105   case VSWITCH_IND:
6106  if(plci->relatedPTYPLCI &&
6107   plci->vswitchstate==3 &&
6108   plci->relatedPTYPLCI->vswitchstate==3 &&
6109   parms[MAXPARMSIDS-1][0])
6110  {
6111   add_p(plci->relatedPTYPLCI,SMSG,parms[MAXPARMSIDS-1]);
6112   sig_req(plci->relatedPTYPLCI,VSWITCH_REQ,0);
6113   send_req(plci->relatedPTYPLCI);
6114  }
6115     else VSwitchReqInd(plci,Id,multi_vswitch_parms);
6116     break;
6117
6118   }
6119 }
6120
6121
6122 static void SendSetupInfo(APPL   * appl, PLCI   * plci, dword Id, byte   * * parms, byte Info_Sent_Flag)
6123 {
6124   word i;
6125   byte   * ie;
6126   word Info_Number;
6127   byte   * Info_Element;
6128   word Info_Mask = 0;
6129
6130   dbug(1,dprintf("SetupInfo"));
6131
6132   for(i=0; i<MAXPARMSIDS; i++) {
6133     ie = parms[i];
6134     Info_Number = 0;
6135     Info_Element = ie;
6136     if(ie[0]) {
6137       switch(i) {
6138       case 0:
6139         dbug(1,dprintf("CPN "));
6140         Info_Number = 0x0070;
6141         Info_Mask   = 0x80;
6142         Info_Sent_Flag = true;
6143         break;
6144       case 8:  /* display      */
6145         dbug(1,dprintf("display(%d)",i));
6146         Info_Number = 0x0028;
6147         Info_Mask = 0x04;
6148         Info_Sent_Flag = true;
6149         break;
6150       case 16: /* Channel Id */
6151         dbug(1,dprintf("CHI"));
6152         Info_Number = 0x0018;
6153         Info_Mask = 0x100;
6154         Info_Sent_Flag = true;
6155         mixer_set_bchannel_id (plci, Info_Element);
6156         break;
6157       case 19: /* Redirected Number */
6158         dbug(1,dprintf("RDN"));
6159         Info_Number = 0x0074;
6160         Info_Mask = 0x400;
6161         Info_Sent_Flag = true;
6162         break;
6163       case 20: /* Redirected Number extended */
6164         dbug(1,dprintf("RDX"));
6165         Info_Number = 0x0073;
6166         Info_Mask = 0x400;
6167         Info_Sent_Flag = true;
6168         break;
6169       case 22: /* Redirecing Number  */
6170         dbug(1,dprintf("RIN"));
6171         Info_Number = 0x0076;
6172         Info_Mask = 0x400;
6173         Info_Sent_Flag = true;
6174         break;
6175       default:
6176         Info_Number = 0;
6177         break;
6178       }
6179     }
6180
6181     if(i==MAXPARMSIDS-2){ /* to indicate the message type "Setup" */
6182       Info_Number = 0x8000 |5;
6183       Info_Mask = 0x10;
6184       Info_Element = "";
6185     }
6186
6187     if(Info_Sent_Flag && Info_Number){
6188       if(plci->adapter->Info_Mask[appl->Id-1] & Info_Mask) {
6189         sendf(appl,_INFO_I,Id,0,"wS",Info_Number,Info_Element);
6190       }
6191     }
6192   }
6193 }
6194
6195
6196 static void SendInfo(PLCI *plci, dword Id, byte **parms, byte iesent)
6197 {
6198   word i;
6199   word j;
6200   word k;
6201   byte   * ie;
6202   word Info_Number;
6203   byte   * Info_Element;
6204   word Info_Mask = 0;
6205   static byte charges[5] = {4,0,0,0,0};
6206   static byte cause[] = {0x02,0x80,0x00};
6207   APPL   *appl;
6208
6209   dbug(1,dprintf("InfoParse "));
6210
6211   if(
6212         !plci->appl
6213         && !plci->State
6214         && plci->Sig.Ind!=NCR_FACILITY
6215       )
6216   {
6217     dbug(1,dprintf("NoParse "));
6218     return;
6219   }
6220   cause[2] = 0;
6221   for(i=0; i<MAXPARMSIDS; i++) {
6222     ie = parms[i];
6223     Info_Number = 0;
6224     Info_Element = ie;
6225     if(ie[0]) {
6226       switch(i) {
6227       case 0:
6228         dbug(1,dprintf("CPN "));
6229         Info_Number = 0x0070;
6230         Info_Mask   = 0x80;
6231         break;
6232       case 7: /* ESC_CAU */
6233         dbug(1,dprintf("cau(0x%x)",ie[2]));
6234         Info_Number = 0x0008;
6235         Info_Mask = 0x00;
6236         cause[2] = ie[2];
6237         Info_Element = NULL;
6238         break;
6239       case 8:  /* display      */
6240         dbug(1,dprintf("display(%d)",i));
6241         Info_Number = 0x0028;
6242         Info_Mask = 0x04;
6243         break;
6244       case 9:  /* Date display */
6245         dbug(1,dprintf("date(%d)",i));
6246         Info_Number = 0x0029;
6247         Info_Mask = 0x02;
6248         break;
6249       case 10: /* charges */
6250         for(j=0;j<4;j++) charges[1+j] = 0;
6251         for(j=0; j<ie[0] && !(ie[1+j]&0x80); j++);
6252         for(k=1,j++; j<ie[0] && k<=4; j++,k++) charges[k] = ie[1+j];
6253         Info_Number = 0x4000;
6254         Info_Mask = 0x40;
6255         Info_Element = charges;
6256         break;
6257       case 11: /* user user info */
6258         dbug(1,dprintf("uui"));
6259         Info_Number = 0x007E;
6260         Info_Mask = 0x08;
6261         break;
6262       case 12: /* congestion receiver ready */
6263         dbug(1,dprintf("clRDY"));
6264         Info_Number = 0x00B0;
6265         Info_Mask = 0x08;
6266         Info_Element = "";
6267         break;
6268       case 13: /* congestion receiver not ready */
6269         dbug(1,dprintf("clNRDY"));
6270         Info_Number = 0x00BF;
6271         Info_Mask = 0x08;
6272         Info_Element = "";
6273         break;
6274       case 15: /* Keypad Facility */
6275         dbug(1,dprintf("KEY"));
6276         Info_Number = 0x002C;
6277         Info_Mask = 0x20;
6278         break;
6279       case 16: /* Channel Id */
6280         dbug(1,dprintf("CHI"));
6281         Info_Number = 0x0018;
6282         Info_Mask = 0x100;
6283         mixer_set_bchannel_id (plci, Info_Element);
6284         break;
6285       case 17: /* if no 1tr6 cause, send full cause, else esc_cause */
6286         dbug(1,dprintf("q9cau(0x%x)",ie[2]));
6287         if(!cause[2] || cause[2]<0x80) break;  /* eg. layer 1 error */
6288         Info_Number = 0x0008;
6289         Info_Mask = 0x01;
6290         if(cause[2] != ie[2]) Info_Element = cause;
6291         break;
6292       case 19: /* Redirected Number */
6293         dbug(1,dprintf("RDN"));
6294         Info_Number = 0x0074;
6295         Info_Mask = 0x400;
6296         break;
6297       case 22: /* Redirecing Number  */
6298         dbug(1,dprintf("RIN"));
6299         Info_Number = 0x0076;
6300         Info_Mask = 0x400;
6301         break;
6302       case 23: /* Notification Indicator  */
6303         dbug(1,dprintf("NI"));
6304         Info_Number = (word)NI;
6305         Info_Mask = 0x210;
6306         break;
6307       case 26: /* Call State  */
6308         dbug(1,dprintf("CST"));
6309         Info_Number = (word)CST;
6310         Info_Mask = 0x01; /* do with cause i.e. for now */
6311         break;
6312       case MAXPARMSIDS-2:  /* Escape Message Type, must be the last indication */
6313         dbug(1,dprintf("ESC/MT[0x%x]",ie[3]));
6314         Info_Number = 0x8000 |ie[3];
6315         if(iesent) Info_Mask = 0xffff;
6316         else  Info_Mask = 0x10;
6317         Info_Element = "";
6318         break;
6319       default:
6320         Info_Number  = 0;
6321         Info_Mask    = 0;
6322         Info_Element = "";
6323         break;
6324       }
6325     }
6326
6327     if(plci->Sig.Ind==NCR_FACILITY)           /* check controller broadcast */
6328     {
6329       for(j=0; j<max_appl; j++)
6330       {
6331         appl = &application[j];
6332         if(Info_Number
6333         && appl->Id
6334         && plci->adapter->Info_Mask[appl->Id-1] &Info_Mask)
6335         {
6336           dbug(1,dprintf("NCR_Ind"));
6337           iesent=true;
6338           sendf(&application[j],_INFO_I,Id&0x0f,0,"wS",Info_Number,Info_Element);
6339         }
6340       }
6341     }
6342     else if(!plci->appl)
6343     { /* overlap receiving broadcast */
6344       if(Info_Number==CPN
6345       || Info_Number==KEY
6346       || Info_Number==NI
6347       || Info_Number==DSP
6348       || Info_Number==UUI )
6349       {
6350         for(j=0; j<max_appl; j++)
6351         {
6352           if(test_c_ind_mask_bit (plci, j))
6353           {
6354             dbug(1,dprintf("Ovl_Ind"));
6355             iesent=true;
6356             sendf(&application[j],_INFO_I,Id,0,"wS",Info_Number,Info_Element);
6357           }
6358         }
6359       }
6360     }               /* all other signalling states */
6361     else if(Info_Number
6362     && plci->adapter->Info_Mask[plci->appl->Id-1] &Info_Mask)
6363     {
6364       dbug(1,dprintf("Std_Ind"));
6365       iesent=true;
6366       sendf(plci->appl,_INFO_I,Id,0,"wS",Info_Number,Info_Element);
6367     }
6368   }
6369 }
6370
6371
6372 static byte SendMultiIE(PLCI *plci, dword Id, byte **parms, byte ie_type,
6373                         dword info_mask, byte setupParse)
6374 {
6375   word i;
6376   word j;
6377   byte   * ie;
6378   word Info_Number;
6379   byte   * Info_Element;
6380   APPL   *appl;
6381   word Info_Mask = 0;
6382   byte iesent=0;
6383
6384   if(
6385       !plci->appl
6386       && !plci->State
6387       && plci->Sig.Ind!=NCR_FACILITY
6388       && !setupParse
6389       )
6390   {
6391     dbug(1,dprintf("NoM-IEParse "));
6392     return 0;
6393   }
6394   dbug(1,dprintf("M-IEParse "));
6395
6396   for(i=0; i<MAX_MULTI_IE; i++)
6397   {
6398     ie = parms[i];
6399     Info_Number = 0;
6400     Info_Element = ie;
6401     if(ie[0])
6402     {
6403       dbug(1,dprintf("[Ind0x%x]:IE=0x%x",plci->Sig.Ind,ie_type));
6404       Info_Number = (word)ie_type;
6405       Info_Mask = (word)info_mask;
6406     }
6407
6408     if(plci->Sig.Ind==NCR_FACILITY)           /* check controller broadcast */
6409     {
6410       for(j=0; j<max_appl; j++)
6411       {
6412         appl = &application[j];
6413         if(Info_Number
6414         && appl->Id
6415         && plci->adapter->Info_Mask[appl->Id-1] &Info_Mask)
6416         {
6417           iesent = true;
6418           dbug(1,dprintf("Mlt_NCR_Ind"));
6419           sendf(&application[j],_INFO_I,Id&0x0f,0,"wS",Info_Number,Info_Element);
6420         }
6421       }
6422     }
6423     else if(!plci->appl && Info_Number)
6424     {                                        /* overlap receiving broadcast */
6425       for(j=0; j<max_appl; j++)
6426       {
6427         if(test_c_ind_mask_bit (plci, j))
6428         {
6429           iesent = true;
6430           dbug(1,dprintf("Mlt_Ovl_Ind"));
6431           sendf(&application[j],_INFO_I,Id,0,"wS",Info_Number,Info_Element);
6432         }
6433       }
6434     }                                        /* all other signalling states */
6435     else if(Info_Number
6436     && plci->adapter->Info_Mask[plci->appl->Id-1] &Info_Mask)
6437     {
6438       iesent = true;
6439       dbug(1,dprintf("Mlt_Std_Ind"));
6440       sendf(plci->appl,_INFO_I,Id,0,"wS",Info_Number,Info_Element);
6441     }
6442   }
6443   return iesent;
6444 }
6445
6446 static void SendSSExtInd(APPL   * appl, PLCI   * plci, dword Id, byte   * * parms)
6447 {
6448   word i;
6449    /* Format of multi_ssext_parms[i][]:
6450    0 byte length
6451    1 byte SSEXTIE
6452    2 byte SSEXT_REQ/SSEXT_IND
6453    3 byte length
6454    4 word SSExtCommand
6455    6... Params
6456    */
6457   if(
6458    plci
6459    && plci->State
6460    && plci->Sig.Ind!=NCR_FACILITY
6461     )
6462  for(i=0;i<MAX_MULTI_IE;i++)
6463     {
6464       if(parms[i][0]<6) continue;
6465    if(parms[i][2]==SSEXT_REQ) continue;
6466
6467    if(appl)
6468    {
6469     parms[i][0]=0; /* kill it */
6470     sendf(appl,_MANUFACTURER_I,
6471     Id,
6472     0,
6473     "dwS",
6474     _DI_MANU_ID,
6475     _DI_SSEXT_CTRL,
6476     &parms[i][3]);
6477    }
6478    else if(plci->appl)
6479    {
6480     parms[i][0]=0; /* kill it */
6481     sendf(plci->appl,_MANUFACTURER_I,
6482     Id,
6483     0,
6484     "dwS",
6485     _DI_MANU_ID,
6486     _DI_SSEXT_CTRL,
6487     &parms[i][3]);
6488    }
6489     }
6490 };
6491
6492 static void nl_ind(PLCI *plci)
6493 {
6494   byte ch;
6495   word ncci;
6496   dword Id;
6497   DIVA_CAPI_ADAPTER   * a;
6498   word NCCIcode;
6499   APPL   * APPLptr;
6500   word count;
6501   word Num;
6502   word i, ncpi_state;
6503   byte len, ncci_state;
6504   word msg;
6505   word info = 0;
6506   word fax_feature_bits;
6507   byte fax_send_edata_ack;
6508   static byte v120_header_buffer[2 + 3];
6509   static word fax_info[] = {
6510     0,                     /* T30_SUCCESS                        */
6511     _FAX_NO_CONNECTION,    /* T30_ERR_NO_DIS_RECEIVED            */
6512     _FAX_PROTOCOL_ERROR,   /* T30_ERR_TIMEOUT_NO_RESPONSE        */
6513     _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_RESPONSE          */
6514     _FAX_PROTOCOL_ERROR,   /* T30_ERR_TOO_MANY_REPEATS           */
6515     _FAX_PROTOCOL_ERROR,   /* T30_ERR_UNEXPECTED_MESSAGE         */
6516     _FAX_REMOTE_ABORT,     /* T30_ERR_UNEXPECTED_DCN             */
6517     _FAX_LOCAL_ABORT,      /* T30_ERR_DTC_UNSUPPORTED            */
6518     _FAX_TRAINING_ERROR,   /* T30_ERR_ALL_RATES_FAILED           */
6519     _FAX_TRAINING_ERROR,   /* T30_ERR_TOO_MANY_TRAINS            */
6520     _FAX_PARAMETER_ERROR,  /* T30_ERR_RECEIVE_CORRUPTED          */
6521     _FAX_REMOTE_ABORT,     /* T30_ERR_UNEXPECTED_DISC            */
6522     _FAX_LOCAL_ABORT,      /* T30_ERR_APPLICATION_DISC           */
6523     _FAX_REMOTE_REJECT,    /* T30_ERR_INCOMPATIBLE_DIS           */
6524     _FAX_LOCAL_ABORT,      /* T30_ERR_INCOMPATIBLE_DCS           */
6525     _FAX_PROTOCOL_ERROR,   /* T30_ERR_TIMEOUT_NO_COMMAND         */
6526     _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_COMMAND           */
6527     _FAX_PROTOCOL_ERROR,   /* T30_ERR_TIMEOUT_COMMAND_TOO_LONG   */
6528     _FAX_PROTOCOL_ERROR,   /* T30_ERR_TIMEOUT_RESPONSE_TOO_LONG  */
6529     _FAX_NO_CONNECTION,    /* T30_ERR_NOT_IDENTIFIED             */
6530     _FAX_PROTOCOL_ERROR,   /* T30_ERR_SUPERVISORY_TIMEOUT        */
6531     _FAX_PARAMETER_ERROR,  /* T30_ERR_TOO_LONG_SCAN_LINE         */
6532     _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_PAGE_AFTER_MPS    */
6533     _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_PAGE_AFTER_CFR    */
6534     _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_DCS_AFTER_FTT     */
6535     _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_DCS_AFTER_EOM     */
6536     _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_DCS_AFTER_MPS     */
6537     _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_DCN_AFTER_MCF     */
6538     _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_DCN_AFTER_RTN     */
6539     _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_CFR               */
6540     _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_MCF_AFTER_EOP     */
6541     _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_MCF_AFTER_EOM     */
6542     _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_MCF_AFTER_MPS     */
6543     0x331d,                /* T30_ERR_SUB_SEP_UNSUPPORTED        */
6544     0x331e,                /* T30_ERR_PWD_UNSUPPORTED            */
6545     0x331f,                /* T30_ERR_SUB_SEP_PWD_UNSUPPORTED    */
6546     _FAX_PROTOCOL_ERROR,   /* T30_ERR_INVALID_COMMAND_FRAME      */
6547     _FAX_PARAMETER_ERROR,  /* T30_ERR_UNSUPPORTED_PAGE_CODING    */
6548     _FAX_PARAMETER_ERROR,  /* T30_ERR_INVALID_PAGE_CODING        */
6549     _FAX_REMOTE_REJECT,    /* T30_ERR_INCOMPATIBLE_PAGE_CONFIG   */
6550     _FAX_LOCAL_ABORT,      /* T30_ERR_TIMEOUT_FROM_APPLICATION   */
6551     _FAX_PROTOCOL_ERROR,   /* T30_ERR_V34FAX_NO_REACTION_ON_MARK */
6552     _FAX_PROTOCOL_ERROR,   /* T30_ERR_V34FAX_TRAINING_TIMEOUT    */
6553     _FAX_PROTOCOL_ERROR,   /* T30_ERR_V34FAX_UNEXPECTED_V21      */
6554     _FAX_PROTOCOL_ERROR,   /* T30_ERR_V34FAX_PRIMARY_CTS_ON      */
6555     _FAX_LOCAL_ABORT,      /* T30_ERR_V34FAX_TURNAROUND_POLLING  */
6556     _FAX_LOCAL_ABORT       /* T30_ERR_V34FAX_V8_INCOMPATIBILITY  */
6557   };
6558
6559     byte dtmf_code_buffer[CAPIDTMF_RECV_DIGIT_BUFFER_SIZE + 1];
6560
6561
6562   static word rtp_info[] = {
6563     GOOD,                  /* RTP_SUCCESS                       */
6564     0x3600                 /* RTP_ERR_SSRC_OR_PAYLOAD_CHANGE    */
6565   };
6566
6567   static dword udata_forwarding_table[0x100 / sizeof(dword)] =
6568   {
6569     0x0020301e, 0x00000000, 0x00000000, 0x00000000,
6570     0x00000000, 0x00000000, 0x00000000, 0x00000000
6571   };
6572
6573   ch = plci->NL.IndCh;
6574   a = plci->adapter;
6575   ncci = a->ch_ncci[ch];
6576   Id = (((dword)(ncci ? ncci : ch)) << 16) | (((word) plci->Id) << 8) | a->Id;
6577   if(plci->tel) Id|=EXT_CONTROLLER;
6578   APPLptr = plci->appl;
6579   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",
6580     plci->NL.Id,Id,plci->Id,plci->tel,plci->State,ch,plci->channels,plci->NL.Ind &0x0f));
6581
6582   /* in the case if no connect_active_Ind was sent to the appl we wait for */
6583
6584   if (plci->nl_remove_id)
6585   {
6586     plci->NL.RNR = 2; /* discard */
6587     dbug(1,dprintf("NL discard while remove pending"));
6588     return;
6589   }
6590   if((plci->NL.Ind &0x0f)==N_CONNECT)
6591   {
6592     if(plci->State==INC_DIS_PENDING
6593     || plci->State==OUTG_DIS_PENDING
6594     || plci->State==IDLE)
6595     {
6596       plci->NL.RNR = 2; /* discard */
6597       dbug(1,dprintf("discard n_connect"));
6598       return;
6599     }
6600     if(plci->State < INC_ACT_PENDING)
6601     {
6602       plci->NL.RNR = 1; /* flow control */
6603       channel_x_off (plci, ch, N_XON_CONNECT_IND);
6604       return;
6605     }
6606   }
6607
6608   if(!APPLptr)                         /* no application or invalid data */
6609   {                                    /* while reloading the DSP        */
6610     dbug(1,dprintf("discard1"));
6611     plci->NL.RNR = 2;
6612     return;
6613   }
6614
6615   if (((plci->NL.Ind &0x0f) == N_UDATA)
6616      && (((plci->B2_prot != B2_SDLC) && ((plci->B1_resource == 17) || (plci->B1_resource == 18)))
6617         || (plci->B2_prot == 7)
6618         || (plci->B3_prot == 7)) )
6619   {
6620     plci->ncpi_buffer[0] = 0;
6621
6622     ncpi_state = plci->ncpi_state;
6623     if (plci->NL.complete == 1)
6624     {
6625       byte  * data = &plci->NL.RBuffer->P[0];
6626
6627       if ((plci->NL.RBuffer->length >= 12)
6628         &&( (*data == DSP_UDATA_INDICATION_DCD_ON)
6629           ||(*data == DSP_UDATA_INDICATION_CTS_ON)) )
6630       {
6631         word conn_opt, ncpi_opt = 0x00;
6632 /*      HexDump ("MDM N_UDATA:", plci->NL.RBuffer->length, data); */
6633
6634         if (*data == DSP_UDATA_INDICATION_DCD_ON)
6635           plci->ncpi_state |= NCPI_MDM_DCD_ON_RECEIVED;
6636         if (*data == DSP_UDATA_INDICATION_CTS_ON)
6637           plci->ncpi_state |= NCPI_MDM_CTS_ON_RECEIVED;
6638
6639         data++;    /* indication code */
6640         data += 2; /* timestamp */
6641         if ((*data == DSP_CONNECTED_NORM_V18) || (*data == DSP_CONNECTED_NORM_VOWN))
6642           ncpi_state &= ~(NCPI_MDM_DCD_ON_RECEIVED | NCPI_MDM_CTS_ON_RECEIVED);
6643         data++;    /* connected norm */
6644         conn_opt = GET_WORD(data);
6645         data += 2; /* connected options */
6646
6647         PUT_WORD (&(plci->ncpi_buffer[1]), (word)(GET_DWORD(data) & 0x0000FFFF));
6648
6649         if (conn_opt & DSP_CONNECTED_OPTION_MASK_V42)
6650         {
6651           ncpi_opt |= MDM_NCPI_ECM_V42;
6652         }
6653         else if (conn_opt & DSP_CONNECTED_OPTION_MASK_MNP)
6654         {
6655           ncpi_opt |= MDM_NCPI_ECM_MNP;
6656         }
6657         else
6658         {
6659           ncpi_opt |= MDM_NCPI_TRANSPARENT;
6660         }
6661         if (conn_opt & DSP_CONNECTED_OPTION_MASK_COMPRESSION)
6662         {
6663           ncpi_opt |= MDM_NCPI_COMPRESSED;
6664         }
6665         PUT_WORD (&(plci->ncpi_buffer[3]), ncpi_opt);
6666         plci->ncpi_buffer[0] = 4;
6667
6668         plci->ncpi_state |= NCPI_VALID_CONNECT_B3_IND | NCPI_VALID_CONNECT_B3_ACT | NCPI_VALID_DISC_B3_IND;
6669       }
6670     }
6671     if (plci->B3_prot == 7)
6672     {
6673       if (((a->ncci_state[ncci] == INC_ACT_PENDING) || (a->ncci_state[ncci] == OUTG_CON_PENDING))
6674        && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6675        && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6676       {
6677         a->ncci_state[ncci] = INC_ACT_PENDING;
6678         sendf(plci->appl,_CONNECT_B3_ACTIVE_I,Id,0,"S",plci->ncpi_buffer);
6679         plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6680       }
6681     }
6682
6683     if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id-1])
6684         & ((1L << PRIVATE_V18) | (1L << PRIVATE_VOWN)))
6685      || !(ncpi_state & NCPI_MDM_DCD_ON_RECEIVED)
6686      || !(ncpi_state & NCPI_MDM_CTS_ON_RECEIVED))
6687
6688     {
6689       plci->NL.RNR = 2;
6690       return;
6691     }
6692   }
6693
6694   if(plci->NL.complete == 2)
6695     {
6696     if (((plci->NL.Ind &0x0f) == N_UDATA)
6697      && !(udata_forwarding_table[plci->RData[0].P[0] >> 5] & (1L << (plci->RData[0].P[0] & 0x1f))))
6698     {
6699       switch(plci->RData[0].P[0])
6700       {
6701
6702       case DTMF_UDATA_INDICATION_FAX_CALLING_TONE:
6703         if (plci->dtmf_rec_active & DTMF_LISTEN_ACTIVE_FLAG)
6704           sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0,"ws", SELECTOR_DTMF, "\x01X");
6705         break;
6706       case DTMF_UDATA_INDICATION_ANSWER_TONE:
6707         if (plci->dtmf_rec_active & DTMF_LISTEN_ACTIVE_FLAG)
6708           sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0,"ws", SELECTOR_DTMF, "\x01Y");
6709         break;
6710       case DTMF_UDATA_INDICATION_DIGITS_RECEIVED:
6711         dtmf_indication (Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6712         break;
6713       case DTMF_UDATA_INDICATION_DIGITS_SENT:
6714         dtmf_confirmation (Id, plci);
6715         break;
6716
6717
6718       case UDATA_INDICATION_MIXER_TAP_DATA:
6719         capidtmf_recv_process_block (&(plci->capidtmf_state), plci->RData[0].P + 1, (word)(plci->RData[0].PLength - 1));
6720  i = capidtmf_indication (&(plci->capidtmf_state), dtmf_code_buffer + 1);
6721  if (i != 0)
6722  {
6723    dtmf_code_buffer[0] = DTMF_UDATA_INDICATION_DIGITS_RECEIVED;
6724           dtmf_indication (Id, plci, dtmf_code_buffer, (word)(i + 1));
6725  }
6726         break;
6727
6728
6729       case UDATA_INDICATION_MIXER_COEFS_SET:
6730         mixer_indication_coefs_set (Id, plci);
6731         break;
6732       case UDATA_INDICATION_XCONNECT_FROM:
6733         mixer_indication_xconnect_from (Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6734         break;
6735       case UDATA_INDICATION_XCONNECT_TO:
6736         mixer_indication_xconnect_to (Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6737         break;
6738
6739
6740       case LEC_UDATA_INDICATION_DISABLE_DETECT:
6741         ec_indication (Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6742         break;
6743
6744
6745
6746       default:
6747         break;
6748       }
6749     }
6750     else
6751   {
6752       if ((plci->RData[0].PLength != 0)
6753      && ((plci->B2_prot == B2_V120_ASYNC)
6754       || (plci->B2_prot == B2_V120_ASYNC_V42BIS)
6755       || (plci->B2_prot == B2_V120_BIT_TRANSPARENT)))
6756     {
6757
6758       sendf(plci->appl,_DATA_B3_I,Id,0,
6759             "dwww",
6760             plci->RData[1].P,
6761               (plci->NL.RNum < 2) ? 0 : plci->RData[1].PLength,
6762             plci->RNum,
6763             plci->RFlags);
6764
6765     }
6766     else
6767     {
6768
6769       sendf(plci->appl,_DATA_B3_I,Id,0,
6770             "dwww",
6771             plci->RData[0].P,
6772             plci->RData[0].PLength,
6773             plci->RNum,
6774             plci->RFlags);
6775
6776     }
6777     }
6778     return;
6779   }
6780
6781   fax_feature_bits = 0;
6782   if((plci->NL.Ind &0x0f)==N_CONNECT ||
6783      (plci->NL.Ind &0x0f)==N_CONNECT_ACK ||
6784      (plci->NL.Ind &0x0f)==N_DISC ||
6785      (plci->NL.Ind &0x0f)==N_EDATA ||
6786      (plci->NL.Ind &0x0f)==N_DISC_ACK)
6787   {
6788     info = 0;
6789     plci->ncpi_buffer[0] = 0;
6790     switch (plci->B3_prot) {
6791     case  0: /*XPARENT*/
6792     case  1: /*T.90 NL*/
6793       break;    /* no network control protocol info - jfr */
6794     case  2: /*ISO8202*/
6795     case  3: /*X25 DCE*/
6796       for(i=0; i<plci->NL.RLength; i++) plci->ncpi_buffer[4+i] = plci->NL.RBuffer->P[i];
6797       plci->ncpi_buffer[0] = (byte)(i+3);
6798       plci->ncpi_buffer[1] = (byte)(plci->NL.Ind &N_D_BIT? 1:0);
6799       plci->ncpi_buffer[2] = 0;
6800       plci->ncpi_buffer[3] = 0;
6801       break;
6802     case  4: /*T.30 - FAX*/
6803     case  5: /*T.30 - FAX*/
6804       if(plci->NL.RLength>=sizeof(T30_INFO))
6805       {
6806         dbug(1,dprintf("FaxStatus %04x", ((T30_INFO   *)plci->NL.RBuffer->P)->code));
6807         len = 9;
6808         PUT_WORD(&(plci->ncpi_buffer[1]),((T30_INFO   *)plci->NL.RBuffer->P)->rate_div_2400 * 2400);
6809         fax_feature_bits = GET_WORD(&((T30_INFO   *)plci->NL.RBuffer->P)->feature_bits_low);
6810         i = (((T30_INFO   *)plci->NL.RBuffer->P)->resolution & T30_RESOLUTION_R8_0770_OR_200) ? 0x0001 : 0x0000;
6811         if (plci->B3_prot == 5)
6812         {
6813           if (!(fax_feature_bits & T30_FEATURE_BIT_ECM))
6814             i |= 0x8000; /* This is not an ECM connection */
6815           if (fax_feature_bits & T30_FEATURE_BIT_T6_CODING)
6816             i |= 0x4000; /* This is a connection with MMR compression */
6817           if (fax_feature_bits & T30_FEATURE_BIT_2D_CODING)
6818             i |= 0x2000; /* This is a connection with MR compression */
6819           if (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS)
6820             i |= 0x0004; /* More documents */
6821           if (fax_feature_bits & T30_FEATURE_BIT_POLLING)
6822             i |= 0x0002; /* Fax-polling indication */
6823         }
6824         dbug(1,dprintf("FAX Options %04x %04x",fax_feature_bits,i));
6825         PUT_WORD(&(plci->ncpi_buffer[3]),i);
6826         PUT_WORD(&(plci->ncpi_buffer[5]),((T30_INFO   *)plci->NL.RBuffer->P)->data_format);
6827         plci->ncpi_buffer[7] = ((T30_INFO   *)plci->NL.RBuffer->P)->pages_low;
6828         plci->ncpi_buffer[8] = ((T30_INFO   *)plci->NL.RBuffer->P)->pages_high;
6829         plci->ncpi_buffer[len] = 0;
6830         if(((T30_INFO   *)plci->NL.RBuffer->P)->station_id_len)
6831         {
6832           plci->ncpi_buffer[len] = 20;
6833           for (i = 0; i < T30_MAX_STATION_ID_LENGTH; i++)
6834             plci->ncpi_buffer[++len] = ((T30_INFO   *)plci->NL.RBuffer->P)->station_id[i];
6835         }
6836         if (((plci->NL.Ind & 0x0f) == N_DISC) || ((plci->NL.Ind & 0x0f) == N_DISC_ACK))
6837         {
6838           if (((T30_INFO   *)plci->NL.RBuffer->P)->code < ARRAY_SIZE(fax_info))
6839             info = fax_info[((T30_INFO   *)plci->NL.RBuffer->P)->code];
6840           else
6841             info = _FAX_PROTOCOL_ERROR;
6842         }
6843
6844         if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id-1])
6845           & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
6846         {
6847           i = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + ((T30_INFO   *)plci->NL.RBuffer->P)->head_line_len;
6848           while (i < plci->NL.RBuffer->length)
6849             plci->ncpi_buffer[++len] = plci->NL.RBuffer->P[i++];
6850         }
6851
6852         plci->ncpi_buffer[0] = len;
6853         fax_feature_bits = GET_WORD(&((T30_INFO   *)plci->NL.RBuffer->P)->feature_bits_low);
6854         PUT_WORD(&((T30_INFO   *)plci->fax_connect_info_buffer)->feature_bits_low, fax_feature_bits);
6855
6856         plci->ncpi_state |= NCPI_VALID_CONNECT_B3_IND;
6857  if (((plci->NL.Ind &0x0f) == N_CONNECT_ACK)
6858          || (((plci->NL.Ind &0x0f) == N_CONNECT)
6859           && (fax_feature_bits & T30_FEATURE_BIT_POLLING))
6860          || (((plci->NL.Ind &0x0f) == N_EDATA)
6861           && ((((T30_INFO   *)plci->NL.RBuffer->P)->code == EDATA_T30_TRAIN_OK)
6862            || (((T30_INFO   *)plci->NL.RBuffer->P)->code == EDATA_T30_DIS)
6863            || (((T30_INFO   *)plci->NL.RBuffer->P)->code == EDATA_T30_DTC))))
6864  {
6865           plci->ncpi_state |= NCPI_VALID_CONNECT_B3_ACT;
6866  }
6867  if (((plci->NL.Ind &0x0f) == N_DISC)
6868   || ((plci->NL.Ind &0x0f) == N_DISC_ACK)
6869   || (((plci->NL.Ind &0x0f) == N_EDATA)
6870    && (((T30_INFO   *)plci->NL.RBuffer->P)->code == EDATA_T30_EOP_CAPI)))
6871  {
6872           plci->ncpi_state |= NCPI_VALID_CONNECT_B3_ACT | NCPI_VALID_DISC_B3_IND;
6873  }
6874       }
6875       break;
6876
6877     case B3_RTP:
6878       if (((plci->NL.Ind & 0x0f) == N_DISC) || ((plci->NL.Ind & 0x0f) == N_DISC_ACK))
6879       {
6880         if (plci->NL.RLength != 0)
6881         {
6882           info = rtp_info[plci->NL.RBuffer->P[0]];
6883           plci->ncpi_buffer[0] = plci->NL.RLength - 1;
6884           for (i = 1; i < plci->NL.RLength; i++)
6885             plci->ncpi_buffer[i] = plci->NL.RBuffer->P[i];
6886         }
6887       }
6888       break;
6889
6890     }
6891     plci->NL.RNR = 2;
6892   }
6893   switch(plci->NL.Ind &0x0f) {
6894   case N_EDATA:
6895     if ((plci->B3_prot == 4) || (plci->B3_prot == 5))
6896     {
6897       dbug(1,dprintf("EDATA ncci=0x%x state=%d code=%02x", ncci, a->ncci_state[ncci],
6898         ((T30_INFO   *)plci->NL.RBuffer->P)->code));
6899       fax_send_edata_ack = (((T30_INFO   *)(plci->fax_connect_info_buffer))->operating_mode == T30_OPERATING_MODE_CAPI_NEG);
6900
6901       if ((plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF)
6902        && (plci->nsf_control_bits & (T30_NSF_CONTROL_BIT_NEGOTIATE_IND | T30_NSF_CONTROL_BIT_NEGOTIATE_RESP))
6903        && (((T30_INFO   *)plci->NL.RBuffer->P)->code == EDATA_T30_DIS)
6904        && (a->ncci_state[ncci] == OUTG_CON_PENDING)
6905        && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6906        && !(plci->ncpi_state & NCPI_NEGOTIATE_B3_SENT))
6907       {
6908         ((T30_INFO   *)(plci->fax_connect_info_buffer))->code = ((T30_INFO   *)plci->NL.RBuffer->P)->code;
6909         sendf(plci->appl,_MANUFACTURER_I,Id,0,"dwbS",_DI_MANU_ID,_DI_NEGOTIATE_B3,
6910           (byte)(plci->ncpi_buffer[0] + 1), plci->ncpi_buffer);
6911         plci->ncpi_state |= NCPI_NEGOTIATE_B3_SENT;
6912  if (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP)
6913    fax_send_edata_ack = false;
6914       }
6915
6916       if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
6917       {
6918         switch (((T30_INFO   *)plci->NL.RBuffer->P)->code)
6919         {
6920         case EDATA_T30_DIS:
6921           if ((a->ncci_state[ncci] == OUTG_CON_PENDING)
6922            && !(GET_WORD(&((T30_INFO   *)plci->fax_connect_info_buffer)->control_bits_low) & T30_CONTROL_BIT_REQUEST_POLLING)
6923            && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6924            && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6925           {
6926             a->ncci_state[ncci] = INC_ACT_PENDING;
6927             if (plci->B3_prot == 4)
6928               sendf(plci->appl,_CONNECT_B3_ACTIVE_I,Id,0,"s","");
6929             else
6930               sendf(plci->appl,_CONNECT_B3_ACTIVE_I,Id,0,"S",plci->ncpi_buffer);
6931             plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6932           }
6933           break;
6934
6935         case EDATA_T30_TRAIN_OK:
6936           if ((a->ncci_state[ncci] == INC_ACT_PENDING)
6937            && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6938            && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6939           {
6940             if (plci->B3_prot == 4)
6941               sendf(plci->appl,_CONNECT_B3_ACTIVE_I,Id,0,"s","");
6942             else
6943               sendf(plci->appl,_CONNECT_B3_ACTIVE_I,Id,0,"S",plci->ncpi_buffer);
6944             plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6945           }
6946           break;
6947
6948         case EDATA_T30_EOP_CAPI:
6949           if (a->ncci_state[ncci] == CONNECTED)
6950           {
6951             sendf(plci->appl,_DISCONNECT_B3_I,Id,0,"wS",GOOD,plci->ncpi_buffer);
6952             a->ncci_state[ncci] = INC_DIS_PENDING;
6953             plci->ncpi_state = 0;
6954      fax_send_edata_ack = false;
6955           }
6956           break;
6957         }
6958       }
6959       else
6960       {
6961         switch (((T30_INFO   *)plci->NL.RBuffer->P)->code)
6962         {
6963         case EDATA_T30_TRAIN_OK:
6964           if ((a->ncci_state[ncci] == INC_ACT_PENDING)
6965            && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6966            && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6967           {
6968             if (plci->B3_prot == 4)
6969               sendf(plci->appl,_CONNECT_B3_ACTIVE_I,Id,0,"s","");
6970             else
6971               sendf(plci->appl,_CONNECT_B3_ACTIVE_I,Id,0,"S",plci->ncpi_buffer);
6972             plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6973           }
6974           break;
6975         }
6976       }
6977       if (fax_send_edata_ack)
6978       {
6979         ((T30_INFO   *)(plci->fax_connect_info_buffer))->code = ((T30_INFO   *)plci->NL.RBuffer->P)->code;
6980  plci->fax_edata_ack_length = 1;
6981         start_internal_command (Id, plci, fax_edata_ack_command);
6982       }
6983     }
6984     else
6985     {
6986       dbug(1,dprintf("EDATA ncci=0x%x state=%d", ncci, a->ncci_state[ncci]));
6987     }
6988     break;
6989   case N_CONNECT:
6990     if (!a->ch_ncci[ch])
6991     {
6992       ncci = get_ncci (plci, ch, 0);
6993       Id = (Id & 0xffff) | (((dword) ncci) << 16);
6994     }
6995     dbug(1,dprintf("N_CONNECT: ch=%d state=%d plci=%lx plci_Id=%lx plci_State=%d",
6996       ch, a->ncci_state[ncci], a->ncci_plci[ncci], plci->Id, plci->State));
6997
6998     msg = _CONNECT_B3_I;
6999     if (a->ncci_state[ncci] == IDLE)
7000       plci->channels++;
7001     else if (plci->B3_prot == 1)
7002       msg = _CONNECT_B3_T90_ACTIVE_I;
7003
7004     a->ncci_state[ncci] = INC_CON_PENDING;
7005     if(plci->B3_prot == 4)
7006       sendf(plci->appl,msg,Id,0,"s","");
7007     else
7008       sendf(plci->appl,msg,Id,0,"S",plci->ncpi_buffer);
7009     break;
7010   case N_CONNECT_ACK:
7011     dbug(1,dprintf("N_connect_Ack"));
7012     if (plci->internal_command_queue[0]
7013      && ((plci->adjust_b_state == ADJUST_B_CONNECT_2)
7014       || (plci->adjust_b_state == ADJUST_B_CONNECT_3)
7015       || (plci->adjust_b_state == ADJUST_B_CONNECT_4)))
7016     {
7017       (*(plci->internal_command_queue[0]))(Id, plci, 0);
7018       if (!plci->internal_command)
7019         next_internal_command (Id, plci);
7020       break;
7021     }
7022     msg = _CONNECT_B3_ACTIVE_I;
7023     if (plci->B3_prot == 1)
7024     {
7025       if (a->ncci_state[ncci] != OUTG_CON_PENDING)
7026         msg = _CONNECT_B3_T90_ACTIVE_I;
7027       a->ncci_state[ncci] = INC_ACT_PENDING;
7028       sendf(plci->appl,msg,Id,0,"S",plci->ncpi_buffer);
7029     }
7030     else if ((plci->B3_prot == 4) || (plci->B3_prot == 5) || (plci->B3_prot == 7))
7031     {
7032       if ((a->ncci_state[ncci] == OUTG_CON_PENDING)
7033        && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
7034        && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
7035       {
7036         a->ncci_state[ncci] = INC_ACT_PENDING;
7037         if (plci->B3_prot == 4)
7038           sendf(plci->appl,msg,Id,0,"s","");
7039         else
7040           sendf(plci->appl,msg,Id,0,"S",plci->ncpi_buffer);
7041         plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
7042       }
7043     }
7044     else
7045     {
7046       a->ncci_state[ncci] = INC_ACT_PENDING;
7047       sendf(plci->appl,msg,Id,0,"S",plci->ncpi_buffer);
7048     }
7049     if (plci->adjust_b_restore)
7050     {
7051       plci->adjust_b_restore = false;
7052       start_internal_command (Id, plci, adjust_b_restore);
7053     }
7054     break;
7055   case N_DISC:
7056   case N_DISC_ACK:
7057     if (plci->internal_command_queue[0]
7058      && ((plci->internal_command == FAX_DISCONNECT_COMMAND_1)
7059       || (plci->internal_command == FAX_DISCONNECT_COMMAND_2)
7060       || (plci->internal_command == FAX_DISCONNECT_COMMAND_3)))
7061     {
7062       (*(plci->internal_command_queue[0]))(Id, plci, 0);
7063       if (!plci->internal_command)
7064         next_internal_command (Id, plci);
7065     }
7066     ncci_state = a->ncci_state[ncci];
7067     ncci_remove (plci, ncci, false);
7068
7069         /* with N_DISC or N_DISC_ACK the IDI frees the respective   */
7070         /* channel, so we cannot store the state in ncci_state! The */
7071         /* information which channel we received a N_DISC is thus   */
7072         /* stored in the inc_dis_ncci_table buffer.                 */
7073     for(i=0; plci->inc_dis_ncci_table[i]; i++);
7074     plci->inc_dis_ncci_table[i] = (byte) ncci;
7075
7076       /* need a connect_b3_ind before a disconnect_b3_ind with FAX */
7077     if (!plci->channels
7078      && (plci->B1_resource == 16)
7079      && (plci->State <= CONNECTED))
7080     {
7081       len = 9;
7082       i = ((T30_INFO   *)plci->fax_connect_info_buffer)->rate_div_2400 * 2400;
7083       PUT_WORD (&plci->ncpi_buffer[1], i);
7084       PUT_WORD (&plci->ncpi_buffer[3], 0);
7085       i = ((T30_INFO   *)plci->fax_connect_info_buffer)->data_format;
7086       PUT_WORD (&plci->ncpi_buffer[5], i);
7087       PUT_WORD (&plci->ncpi_buffer[7], 0);
7088       plci->ncpi_buffer[len] = 0;
7089       plci->ncpi_buffer[0] = len;
7090       if(plci->B3_prot == 4)
7091         sendf(plci->appl,_CONNECT_B3_I,Id,0,"s","");
7092       else
7093       {
7094
7095         if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id-1])
7096           & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
7097         {
7098           plci->ncpi_buffer[++len] = 0;
7099           plci->ncpi_buffer[++len] = 0;
7100           plci->ncpi_buffer[++len] = 0;
7101           plci->ncpi_buffer[0] = len;
7102         }
7103
7104         sendf(plci->appl,_CONNECT_B3_I,Id,0,"S",plci->ncpi_buffer);
7105       }
7106       sendf(plci->appl,_DISCONNECT_B3_I,Id,0,"wS",info,plci->ncpi_buffer);
7107       plci->ncpi_state = 0;
7108       sig_req(plci,HANGUP,0);
7109       send_req(plci);
7110       plci->State = OUTG_DIS_PENDING;
7111       /* disc here */
7112     }
7113     else if ((a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
7114      && ((plci->B3_prot == 4) || (plci->B3_prot == 5))
7115      && ((ncci_state == INC_DIS_PENDING) || (ncci_state == IDLE)))
7116     {
7117       if (ncci_state == IDLE)
7118       {
7119         if (plci->channels)
7120           plci->channels--;
7121         if((plci->State==IDLE || plci->State==SUSPENDING) && !plci->channels){
7122           if(plci->State == SUSPENDING){
7123             sendf(plci->appl,
7124                   _FACILITY_I,
7125                   Id & 0xffffL,
7126                   0,
7127                   "ws", (word)3, "\x03\x04\x00\x00");
7128             sendf(plci->appl, _DISCONNECT_I, Id & 0xffffL, 0, "w", 0);
7129           }
7130           plci_remove(plci);
7131           plci->State=IDLE;
7132         }
7133       }
7134     }
7135     else if (plci->channels)
7136     {
7137       sendf(plci->appl,_DISCONNECT_B3_I,Id,0,"wS",info,plci->ncpi_buffer);
7138       plci->ncpi_state = 0;
7139       if ((ncci_state == OUTG_REJ_PENDING)
7140        && ((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE)))
7141       {
7142         sig_req(plci,HANGUP,0);
7143         send_req(plci);
7144         plci->State = OUTG_DIS_PENDING;
7145       }
7146     }
7147     break;
7148   case N_RESET:
7149     a->ncci_state[ncci] = INC_RES_PENDING;
7150     sendf(plci->appl,_RESET_B3_I,Id,0,"S",plci->ncpi_buffer);
7151     break;
7152   case N_RESET_ACK:
7153     a->ncci_state[ncci] = CONNECTED;
7154     sendf(plci->appl,_RESET_B3_I,Id,0,"S",plci->ncpi_buffer);
7155     break;
7156
7157   case N_UDATA:
7158     if (!(udata_forwarding_table[plci->NL.RBuffer->P[0] >> 5] & (1L << (plci->NL.RBuffer->P[0] & 0x1f))))
7159     {
7160       plci->RData[0].P = plci->internal_ind_buffer + (-((int)(long)(plci->internal_ind_buffer)) & 3);
7161       plci->RData[0].PLength = INTERNAL_IND_BUFFER_SIZE;
7162       plci->NL.R = plci->RData;
7163       plci->NL.RNum = 1;
7164       return;
7165     }
7166   case N_BDATA:
7167   case N_DATA:
7168     if (((a->ncci_state[ncci] != CONNECTED) && (plci->B2_prot == 1)) /* transparent */
7169      || (a->ncci_state[ncci] == IDLE)
7170      || (a->ncci_state[ncci] == INC_DIS_PENDING))
7171     {
7172       plci->NL.RNR = 2;
7173       break;
7174     }
7175     if ((a->ncci_state[ncci] != CONNECTED)
7176      && (a->ncci_state[ncci] != OUTG_DIS_PENDING)
7177      && (a->ncci_state[ncci] != OUTG_REJ_PENDING))
7178     {
7179       dbug(1,dprintf("flow control"));
7180       plci->NL.RNR = 1; /* flow control  */
7181       channel_x_off (plci, ch, 0);
7182       break;
7183     }
7184
7185     NCCIcode = ncci | (((word)a->Id) << 8);
7186
7187                 /* count all buffers within the Application pool    */
7188                 /* belonging to the same NCCI. If this is below the */
7189                 /* number of buffers available per NCCI we accept   */
7190                 /* this packet, otherwise we reject it              */
7191     count = 0;
7192     Num = 0xffff;
7193     for(i=0; i<APPLptr->MaxBuffer; i++) {
7194       if(NCCIcode==APPLptr->DataNCCI[i]) count++;
7195       if(!APPLptr->DataNCCI[i] && Num==0xffff) Num = i;
7196     }
7197
7198     if(count>=APPLptr->MaxNCCIData || Num==0xffff)
7199     {
7200       dbug(3,dprintf("Flow-Control"));
7201       plci->NL.RNR = 1;
7202       if( ++(APPLptr->NCCIDataFlowCtrlTimer)>=
7203        (word)((a->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL) ? 40 : 2000))
7204       {
7205         plci->NL.RNR = 2;
7206         dbug(3,dprintf("DiscardData"));
7207       } else {
7208         channel_x_off (plci, ch, 0);
7209       }
7210       break;
7211     }
7212     else
7213     {
7214       APPLptr->NCCIDataFlowCtrlTimer = 0;
7215     }
7216
7217     plci->RData[0].P = ReceiveBufferGet(APPLptr,Num);
7218     if(!plci->RData[0].P) {
7219       plci->NL.RNR = 1;
7220       channel_x_off (plci, ch, 0);
7221       break;
7222     }
7223
7224     APPLptr->DataNCCI[Num] = NCCIcode;
7225     APPLptr->DataFlags[Num] = (plci->Id<<8) | (plci->NL.Ind>>4);
7226     dbug(3,dprintf("Buffer(%d), Max = %d",Num,APPLptr->MaxBuffer));
7227
7228     plci->RNum = Num;
7229     plci->RFlags = plci->NL.Ind>>4;
7230     plci->RData[0].PLength = APPLptr->MaxDataLength;
7231     plci->NL.R = plci->RData;
7232     if ((plci->NL.RLength != 0)
7233      && ((plci->B2_prot == B2_V120_ASYNC)
7234       || (plci->B2_prot == B2_V120_ASYNC_V42BIS)
7235       || (plci->B2_prot == B2_V120_BIT_TRANSPARENT)))
7236     {
7237       plci->RData[1].P = plci->RData[0].P;
7238       plci->RData[1].PLength = plci->RData[0].PLength;
7239       plci->RData[0].P = v120_header_buffer + (-((unsigned long)v120_header_buffer) & 3);
7240       if ((plci->NL.RBuffer->P[0] & V120_HEADER_EXTEND_BIT) || (plci->NL.RLength == 1))
7241         plci->RData[0].PLength = 1;
7242       else
7243         plci->RData[0].PLength = 2;
7244       if (plci->NL.RBuffer->P[0] & V120_HEADER_BREAK_BIT)
7245         plci->RFlags |= 0x0010;
7246       if (plci->NL.RBuffer->P[0] & (V120_HEADER_C1_BIT | V120_HEADER_C2_BIT))
7247         plci->RFlags |= 0x8000;
7248       plci->NL.RNum = 2;
7249     }
7250     else
7251     {
7252       if((plci->NL.Ind &0x0f)==N_UDATA)
7253         plci->RFlags |= 0x0010;
7254
7255       else if ((plci->B3_prot == B3_RTP) && ((plci->NL.Ind & 0x0f) == N_BDATA))
7256         plci->RFlags |= 0x0001;
7257
7258       plci->NL.RNum = 1;
7259     }
7260     break;
7261   case N_DATA_ACK:
7262     data_ack (plci, ch);
7263     break;
7264   default:
7265     plci->NL.RNR = 2;
7266     break;
7267   }
7268 }
7269
7270 /*------------------------------------------------------------------*/
7271 /* find a free PLCI                                                 */
7272 /*------------------------------------------------------------------*/
7273
7274 static word get_plci(DIVA_CAPI_ADAPTER *a)
7275 {
7276   word i,j;
7277   PLCI   * plci;
7278
7279   dump_plcis (a);
7280   for(i=0;i<a->max_plci && a->plci[i].Id;i++);
7281   if(i==a->max_plci) {
7282     dbug(1,dprintf("get_plci: out of PLCIs"));
7283     return 0;
7284   }
7285   plci = &a->plci[i];
7286   plci->Id = (byte)(i+1);
7287
7288   plci->Sig.Id = 0;
7289   plci->NL.Id = 0;
7290   plci->sig_req = 0;
7291   plci->nl_req = 0;
7292
7293   plci->appl = NULL;
7294   plci->relatedPTYPLCI = NULL;
7295   plci->State = IDLE;
7296   plci->SuppState = IDLE;
7297   plci->channels = 0;
7298   plci->tel = 0;
7299   plci->B1_resource = 0;
7300   plci->B2_prot = 0;
7301   plci->B3_prot = 0;
7302
7303   plci->command = 0;
7304   plci->m_command = 0;
7305   init_internal_command_queue (plci);
7306   plci->number = 0;
7307   plci->req_in_start = 0;
7308   plci->req_in = 0;
7309   plci->req_out = 0;
7310   plci->msg_in_write_pos = MSG_IN_QUEUE_SIZE;
7311   plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
7312   plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
7313
7314   plci->data_sent = false;
7315   plci->send_disc = 0;
7316   plci->sig_global_req = 0;
7317   plci->sig_remove_id = 0;
7318   plci->nl_global_req = 0;
7319   plci->nl_remove_id = 0;
7320   plci->adv_nl = 0;
7321   plci->manufacturer = false;
7322   plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
7323   plci->spoofed_msg = 0;
7324   plci->ptyState = 0;
7325   plci->cr_enquiry = false;
7326   plci->hangup_flow_ctrl_timer = 0;
7327
7328   plci->ncci_ring_list = 0;
7329   for(j=0;j<MAX_CHANNELS_PER_PLCI;j++) plci->inc_dis_ncci_table[j] = 0;
7330   clear_c_ind_mask (plci);
7331   set_group_ind_mask (plci);
7332   plci->fax_connect_info_length = 0;
7333   plci->nsf_control_bits = 0;
7334   plci->ncpi_state = 0x00;
7335   plci->ncpi_buffer[0] = 0;
7336
7337   plci->requested_options_conn = 0;
7338   plci->requested_options = 0;
7339   plci->notifiedcall = 0;
7340   plci->vswitchstate = 0;
7341   plci->vsprot = 0;
7342   plci->vsprotdialect = 0;
7343   init_b1_config (plci);
7344   dbug(1,dprintf("get_plci(%x)",plci->Id));
7345   return i+1;
7346 }
7347
7348 /*------------------------------------------------------------------*/
7349 /* put a parameter in the parameter buffer                          */
7350 /*------------------------------------------------------------------*/
7351
7352 static void add_p(PLCI   * plci, byte code, byte   * p)
7353 {
7354   word p_length;
7355
7356   p_length = 0;
7357   if(p) p_length = p[0];
7358   add_ie(plci, code, p, p_length);
7359 }
7360
7361 /*------------------------------------------------------------------*/
7362 /* put a structure in the parameter buffer                          */
7363 /*------------------------------------------------------------------*/
7364 static void add_s(PLCI   * plci, byte code, API_PARSE * p)
7365 {
7366   if(p) add_ie(plci, code, p->info, (word)p->length);
7367 }
7368
7369 /*------------------------------------------------------------------*/
7370 /* put multiple structures in the parameter buffer                  */
7371 /*------------------------------------------------------------------*/
7372 static void add_ss(PLCI   * plci, byte code, API_PARSE * p)
7373 {
7374   byte i;
7375
7376   if(p){
7377     dbug(1,dprintf("add_ss(%x,len=%d)",code,p->length));
7378     for(i=2;i<(byte)p->length;i+=p->info[i]+2){
7379       dbug(1,dprintf("add_ss_ie(%x,len=%d)",p->info[i-1],p->info[i]));
7380       add_ie(plci, p->info[i-1], (byte   *)&(p->info[i]), (word)p->info[i]);
7381     }
7382   }
7383 }
7384
7385 /*------------------------------------------------------------------*/
7386 /* return the channel number sent by the application in a esc_chi   */
7387 /*------------------------------------------------------------------*/
7388 static byte getChannel(API_PARSE * p)
7389 {
7390   byte i;
7391
7392   if(p){
7393     for(i=2;i<(byte)p->length;i+=p->info[i]+2){
7394       if(p->info[i]==2){
7395         if(p->info[i-1]==ESC && p->info[i+1]==CHI) return (p->info[i+2]);
7396       }
7397     }
7398   }
7399   return 0;
7400 }
7401
7402
7403 /*------------------------------------------------------------------*/
7404 /* put an information element in the parameter buffer               */
7405 /*------------------------------------------------------------------*/
7406
7407 static void add_ie(PLCI   * plci, byte code, byte   * p, word p_length)
7408 {
7409   word i;
7410
7411   if(!(code &0x80) && !p_length) return;
7412
7413   if(plci->req_in==plci->req_in_start) {
7414     plci->req_in +=2;
7415   }
7416   else {
7417     plci->req_in--;
7418   }
7419   plci->RBuffer[plci->req_in++] = code;
7420
7421   if(p) {
7422     plci->RBuffer[plci->req_in++] = (byte)p_length;
7423     for(i=0;i<p_length;i++) plci->RBuffer[plci->req_in++] = p[1+i];
7424   }
7425
7426   plci->RBuffer[plci->req_in++] = 0;
7427 }
7428
7429 /*------------------------------------------------------------------*/
7430 /* put a unstructured data into the buffer                          */
7431 /*------------------------------------------------------------------*/
7432
7433 static void add_d(PLCI *plci, word length, byte *p)
7434 {
7435   word i;
7436
7437   if(plci->req_in==plci->req_in_start) {
7438     plci->req_in +=2;
7439   }
7440   else {
7441     plci->req_in--;
7442   }
7443   for(i=0;i<length;i++) plci->RBuffer[plci->req_in++] = p[i];
7444 }
7445
7446 /*------------------------------------------------------------------*/
7447 /* put parameters from the Additional Info parameter in the         */
7448 /* parameter buffer                                                 */
7449 /*------------------------------------------------------------------*/
7450
7451 static void add_ai(PLCI *plci, API_PARSE *ai)
7452 {
7453   word i;
7454     API_PARSE ai_parms[5];
7455
7456   for(i=0;i<5;i++) ai_parms[i].length = 0;
7457
7458   if(!ai->length)
7459     return;
7460   if(api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms))
7461     return;
7462
7463   add_s (plci,KEY,&ai_parms[1]);
7464   add_s (plci,UUI,&ai_parms[2]);
7465   add_ss(plci,FTY,&ai_parms[3]);
7466 }
7467
7468 /*------------------------------------------------------------------*/
7469 /* put parameter for b1 protocol in the parameter buffer            */
7470 /*------------------------------------------------------------------*/
7471
7472 static word add_b1(PLCI *plci, API_PARSE *bp, word b_channel_info,
7473                    word b1_facilities)
7474 {
7475     API_PARSE bp_parms[8];
7476     API_PARSE mdm_cfg[9];
7477     API_PARSE global_config[2];
7478     byte cai[256];
7479   byte resource[] = {5,9,13,12,16,39,9,17,17,18};
7480   byte voice_cai[] = "\x06\x14\x00\x00\x00\x00\x08";
7481   word i;
7482
7483     API_PARSE mdm_cfg_v18[4];
7484   word j, n, w;
7485   dword d;
7486
7487
7488   for(i=0;i<8;i++) bp_parms[i].length = 0;
7489   for(i=0;i<2;i++) global_config[i].length = 0;
7490
7491   dbug(1,dprintf("add_b1"));
7492   api_save_msg(bp, "s", &plci->B_protocol);
7493
7494   if(b_channel_info==2){
7495     plci->B1_resource = 0;
7496     adjust_b1_facilities (plci, plci->B1_resource, b1_facilities);
7497     add_p(plci, CAI, "\x01\x00");
7498     dbug(1,dprintf("Cai=1,0 (no resource)"));
7499     return 0;
7500   }
7501
7502   if(plci->tel == CODEC_PERMANENT) return 0;
7503   else if(plci->tel == CODEC){
7504     plci->B1_resource = 1;
7505     adjust_b1_facilities (plci, plci->B1_resource, b1_facilities);
7506     add_p(plci, CAI, "\x01\x01");
7507     dbug(1,dprintf("Cai=1,1 (Codec)"));
7508     return 0;
7509   }
7510   else if(plci->tel == ADV_VOICE){
7511     plci->B1_resource = add_b1_facilities (plci, 9, (word)(b1_facilities | B1_FACILITY_VOICE));
7512     adjust_b1_facilities (plci, plci->B1_resource, (word)(b1_facilities | B1_FACILITY_VOICE));
7513     voice_cai[1] = plci->B1_resource;
7514     PUT_WORD (&voice_cai[5], plci->appl->MaxDataLength);
7515     add_p(plci, CAI, voice_cai);
7516     dbug(1,dprintf("Cai=1,0x%x (AdvVoice)",voice_cai[1]));
7517     return 0;
7518   }
7519   plci->call_dir &= ~(CALL_DIR_ORIGINATE | CALL_DIR_ANSWER);
7520   if (plci->call_dir & CALL_DIR_OUT)
7521     plci->call_dir |= CALL_DIR_ORIGINATE;
7522   else if (plci->call_dir & CALL_DIR_IN)
7523     plci->call_dir |= CALL_DIR_ANSWER;
7524
7525   if(!bp->length){
7526     plci->B1_resource = 0x5;
7527     adjust_b1_facilities (plci, plci->B1_resource, b1_facilities);
7528     add_p(plci, CAI, "\x01\x05");
7529     return 0;
7530   }
7531
7532   dbug(1,dprintf("b_prot_len=%d",(word)bp->length));
7533   if(bp->length>256) return _WRONG_MESSAGE_FORMAT;
7534   if(api_parse(&bp->info[1], (word)bp->length, "wwwsssb", bp_parms))
7535   {
7536     bp_parms[6].length = 0;
7537     if(api_parse(&bp->info[1], (word)bp->length, "wwwsss", bp_parms))
7538     {
7539       dbug(1,dprintf("b-form.!"));
7540       return _WRONG_MESSAGE_FORMAT;
7541     }
7542   }
7543   else if (api_parse(&bp->info[1], (word)bp->length, "wwwssss", bp_parms))
7544   {
7545     dbug(1,dprintf("b-form.!"));
7546     return _WRONG_MESSAGE_FORMAT;
7547   }
7548
7549   if(bp_parms[6].length)
7550   {
7551     if(api_parse(&bp_parms[6].info[1], (word)bp_parms[6].length, "w", global_config))
7552     {
7553       return _WRONG_MESSAGE_FORMAT;
7554     }
7555     switch(GET_WORD(global_config[0].info))
7556     {
7557     case 1:
7558       plci->call_dir = (plci->call_dir & ~CALL_DIR_ANSWER) | CALL_DIR_ORIGINATE;
7559       break;
7560     case 2:
7561       plci->call_dir = (plci->call_dir & ~CALL_DIR_ORIGINATE) | CALL_DIR_ANSWER;
7562       break;
7563     }
7564   }
7565   dbug(1,dprintf("call_dir=%04x", plci->call_dir));
7566
7567
7568   if ((GET_WORD(bp_parms[0].info) == B1_RTP)
7569    && (plci->adapter->man_profile.private_options & (1L << PRIVATE_RTP)))
7570   {
7571     plci->B1_resource = add_b1_facilities (plci, 31, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7572     adjust_b1_facilities (plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7573     cai[1] = plci->B1_resource;
7574     cai[2] = 0;
7575     cai[3] = 0;
7576     cai[4] = 0;
7577     PUT_WORD(&cai[5],plci->appl->MaxDataLength);
7578     for (i = 0; i < bp_parms[3].length; i++)
7579       cai[7+i] = bp_parms[3].info[1+i];
7580     cai[0] = 6 + bp_parms[3].length;
7581     add_p(plci, CAI, cai);
7582     return 0;
7583   }
7584
7585
7586   if ((GET_WORD(bp_parms[0].info) == B1_PIAFS)
7587    && (plci->adapter->man_profile.private_options & (1L << PRIVATE_PIAFS)))
7588   {
7589     plci->B1_resource = add_b1_facilities (plci, 35/* PIAFS HARDWARE FACILITY */, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7590     adjust_b1_facilities (plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7591     cai[1] = plci->B1_resource;
7592     cai[2] = 0;
7593     cai[3] = 0;
7594     cai[4] = 0;
7595     PUT_WORD(&cai[5],plci->appl->MaxDataLength);
7596     cai[0] = 6;
7597     add_p(plci, CAI, cai);
7598     return 0;
7599   }
7600
7601
7602   if ((GET_WORD(bp_parms[0].info) >= 32)
7603    || (!((1L << GET_WORD(bp_parms[0].info)) & plci->adapter->profile.B1_Protocols)
7604     && ((GET_WORD(bp_parms[0].info) != 3)
7605      || !((1L << B1_HDLC) & plci->adapter->profile.B1_Protocols)
7606      || ((bp_parms[3].length != 0) && (GET_WORD(&bp_parms[3].info[1]) != 0) && (GET_WORD(&bp_parms[3].info[1]) != 56000)))))
7607   {
7608     return _B1_NOT_SUPPORTED;
7609   }
7610   plci->B1_resource = add_b1_facilities (plci, resource[GET_WORD(bp_parms[0].info)],
7611     (word)(b1_facilities & ~B1_FACILITY_VOICE));
7612   adjust_b1_facilities (plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7613   cai[0] = 6;
7614   cai[1] = plci->B1_resource;
7615   for (i=2;i<sizeof(cai);i++) cai[i] = 0;
7616
7617   if ((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE)
7618    || (GET_WORD(bp_parms[0].info) == B1_MODEM_ASYNC)
7619    || (GET_WORD(bp_parms[0].info) == B1_MODEM_SYNC_HDLC))
7620   { /* B1 - modem */
7621     for (i=0;i<7;i++) mdm_cfg[i].length = 0;
7622
7623     if (bp_parms[3].length)
7624     {
7625       if(api_parse(&bp_parms[3].info[1],(word)bp_parms[3].length,"wwwwww", mdm_cfg))
7626       {
7627         return (_WRONG_MESSAGE_FORMAT);
7628       }
7629
7630       cai[2] = 0; /* Bit rate for adaptation */
7631
7632       dbug(1,dprintf("MDM Max Bit Rate:<%d>", GET_WORD(mdm_cfg[0].info)));
7633
7634       PUT_WORD (&cai[13], 0);                          /* Min Tx speed */
7635       PUT_WORD (&cai[15], GET_WORD(mdm_cfg[0].info)); /* Max Tx speed */
7636       PUT_WORD (&cai[17], 0);                          /* Min Rx speed */
7637       PUT_WORD (&cai[19], GET_WORD(mdm_cfg[0].info)); /* Max Rx speed */
7638
7639       cai[3] = 0; /* Async framing parameters */
7640       switch (GET_WORD (mdm_cfg[2].info))
7641       {       /* Parity     */
7642       case 1: /* odd parity */
7643         cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_ODD);
7644         dbug(1,dprintf("MDM: odd parity"));
7645         break;
7646
7647       case 2: /* even parity */
7648         cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_EVEN);
7649         dbug(1,dprintf("MDM: even parity"));
7650         break;
7651
7652       default:
7653         dbug(1,dprintf("MDM: no parity"));
7654         break;
7655       }
7656
7657       switch (GET_WORD (mdm_cfg[3].info))
7658       {       /* stop bits   */
7659       case 1: /* 2 stop bits */
7660         cai[3] |= DSP_CAI_ASYNC_TWO_STOP_BITS;
7661         dbug(1,dprintf("MDM: 2 stop bits"));
7662         break;
7663
7664       default:
7665         dbug(1,dprintf("MDM: 1 stop bit"));
7666         break;
7667       }
7668
7669       switch (GET_WORD (mdm_cfg[1].info))
7670       {     /* char length */
7671       case 5:
7672         cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_5;
7673         dbug(1,dprintf("MDM: 5 bits"));
7674         break;
7675
7676       case 6:
7677         cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_6;
7678         dbug(1,dprintf("MDM: 6 bits"));
7679         break;
7680
7681       case 7:
7682         cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_7;
7683         dbug(1,dprintf("MDM: 7 bits"));
7684         break;
7685
7686       default:
7687         dbug(1,dprintf("MDM: 8 bits"));
7688         break;
7689       }
7690
7691       cai[7] = 0; /* Line taking options */
7692       cai[8] = 0; /* Modulation negotiation options */
7693       cai[9] = 0; /* Modulation options */
7694
7695       if (((plci->call_dir & CALL_DIR_ORIGINATE) != 0) ^ ((plci->call_dir & CALL_DIR_OUT) != 0))
7696       {
7697         cai[9] |= DSP_CAI_MODEM_REVERSE_DIRECTION;
7698         dbug(1, dprintf("MDM: Reverse direction"));
7699       }
7700
7701       if (GET_WORD (mdm_cfg[4].info) & MDM_CAPI_DISABLE_RETRAIN)
7702       {
7703         cai[9] |= DSP_CAI_MODEM_DISABLE_RETRAIN;
7704         dbug(1, dprintf("MDM: Disable retrain"));
7705       }
7706
7707       if (GET_WORD (mdm_cfg[4].info) & MDM_CAPI_DISABLE_RING_TONE)
7708       {
7709         cai[7] |= DSP_CAI_MODEM_DISABLE_CALLING_TONE | DSP_CAI_MODEM_DISABLE_ANSWER_TONE;
7710         dbug(1, dprintf("MDM: Disable ring tone"));
7711       }
7712
7713       if (GET_WORD (mdm_cfg[4].info) & MDM_CAPI_GUARD_1800)
7714       {
7715         cai[8] |= DSP_CAI_MODEM_GUARD_TONE_1800HZ;
7716         dbug(1, dprintf("MDM: 1800 guard tone"));
7717       }
7718       else if (GET_WORD (mdm_cfg[4].info) & MDM_CAPI_GUARD_550 )
7719       {
7720         cai[8] |= DSP_CAI_MODEM_GUARD_TONE_550HZ;
7721         dbug(1, dprintf("MDM: 550 guard tone"));
7722       }
7723
7724       if ((GET_WORD (mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_V100)
7725       {
7726         cai[8] |= DSP_CAI_MODEM_NEGOTIATE_V100;
7727         dbug(1, dprintf("MDM: V100"));
7728       }
7729       else if ((GET_WORD (mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_MOD_CLASS)
7730       {
7731         cai[8] |= DSP_CAI_MODEM_NEGOTIATE_IN_CLASS;
7732         dbug(1, dprintf("MDM: IN CLASS"));
7733       }
7734       else if ((GET_WORD (mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_DISABLED)
7735       {
7736         cai[8] |= DSP_CAI_MODEM_NEGOTIATE_DISABLED;
7737         dbug(1, dprintf("MDM: DISABLED"));
7738       }
7739       cai[0] = 20;
7740
7741       if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_V18))
7742        && (GET_WORD(mdm_cfg[5].info) & 0x8000)) /* Private V.18 enable */
7743       {
7744         plci->requested_options |= 1L << PRIVATE_V18;
7745       }
7746       if (GET_WORD(mdm_cfg[5].info) & 0x4000) /* Private VOWN enable */
7747         plci->requested_options |= 1L << PRIVATE_VOWN;
7748
7749       if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id-1])
7750         & ((1L << PRIVATE_V18) | (1L << PRIVATE_VOWN)))
7751       {
7752         if (!api_parse(&bp_parms[3].info[1],(word)bp_parms[3].length,"wwwwwws", mdm_cfg))
7753         {
7754           i = 27;
7755           if (mdm_cfg[6].length >= 4)
7756           {
7757             d = GET_DWORD(&mdm_cfg[6].info[1]);
7758             cai[7] |= (byte) d;          /* line taking options */
7759             cai[9] |= (byte)(d >> 8);    /* modulation options */
7760             cai[++i] = (byte)(d >> 16);  /* vown modulation options */
7761             cai[++i] = (byte)(d >> 24);
7762             if (mdm_cfg[6].length >= 8)
7763             {
7764               d = GET_DWORD(&mdm_cfg[6].info[5]);
7765               cai[10] |= (byte) d;        /* disabled modulations mask */
7766               cai[11] |= (byte)(d >> 8);
7767               if (mdm_cfg[6].length >= 12)
7768               {
7769                 d = GET_DWORD(&mdm_cfg[6].info[9]);
7770                 cai[12] = (byte) d;          /* enabled modulations mask */
7771                 cai[++i] = (byte)(d >> 8);   /* vown enabled modulations */
7772                 cai[++i] = (byte)(d >> 16);
7773                 cai[++i] = (byte)(d >> 24);
7774                 cai[++i] = 0;
7775                 if (mdm_cfg[6].length >= 14)
7776                 {
7777                   w = GET_WORD(&mdm_cfg[6].info[13]);
7778                   if (w != 0)
7779                     PUT_WORD(&cai[13], w);  /* min tx speed */
7780                   if (mdm_cfg[6].length >= 16)
7781                   {
7782                     w = GET_WORD(&mdm_cfg[6].info[15]);
7783                     if (w != 0)
7784                       PUT_WORD(&cai[15], w);  /* max tx speed */
7785                     if (mdm_cfg[6].length >= 18)
7786                     {
7787                       w = GET_WORD(&mdm_cfg[6].info[17]);
7788                       if (w != 0)
7789                         PUT_WORD(&cai[17], w);  /* min rx speed */
7790                       if (mdm_cfg[6].length >= 20)
7791                       {
7792                         w = GET_WORD(&mdm_cfg[6].info[19]);
7793                         if (w != 0)
7794                           PUT_WORD(&cai[19], w);  /* max rx speed */
7795                         if (mdm_cfg[6].length >= 22)
7796                         {
7797                           w = GET_WORD(&mdm_cfg[6].info[21]);
7798                           cai[23] = (byte)(-((short) w));  /* transmit level */
7799                           if (mdm_cfg[6].length >= 24)
7800                           {
7801                             w = GET_WORD(&mdm_cfg[6].info[23]);
7802                             cai[22] |= (byte) w;        /* info options mask */
7803                             cai[21] |= (byte)(w >> 8);  /* disabled symbol rates */
7804                           }
7805                         }
7806                       }
7807                     }
7808                   }
7809                 }
7810               }
7811             }
7812           }
7813           cai[27] = i - 27;
7814           i++;
7815           if (!api_parse(&bp_parms[3].info[1],(word)bp_parms[3].length,"wwwwwwss", mdm_cfg))
7816           {
7817             if (!api_parse(&mdm_cfg[7].info[1],(word)mdm_cfg[7].length,"sss", mdm_cfg_v18))
7818             {
7819               for (n = 0; n < 3; n++)
7820               {
7821                 cai[i] = (byte)(mdm_cfg_v18[n].length);
7822                 for (j = 1; j < ((word)(cai[i] + 1)); j++)
7823                   cai[i+j] = mdm_cfg_v18[n].info[j];
7824                 i += cai[i] + 1;
7825               }
7826             }
7827           }
7828           cai[0] = (byte)(i - 1);
7829         }
7830       }
7831
7832     }
7833   }
7834   if(GET_WORD(bp_parms[0].info)==2 ||                         /* V.110 async */
7835      GET_WORD(bp_parms[0].info)==3 )                          /* V.110 sync */
7836   {
7837     if(bp_parms[3].length){
7838       dbug(1,dprintf("V.110,%d",GET_WORD(&bp_parms[3].info[1])));
7839       switch(GET_WORD(&bp_parms[3].info[1])){                 /* Rate */
7840         case 0:
7841         case 56000:
7842           if(GET_WORD(bp_parms[0].info)==3){                  /* V.110 sync 56k */
7843             dbug(1,dprintf("56k sync HSCX"));
7844             cai[1] = 8;
7845             cai[2] = 0;
7846             cai[3] = 0;
7847           }
7848           else if(GET_WORD(bp_parms[0].info)==2){
7849             dbug(1,dprintf("56k async DSP"));
7850             cai[2] = 9;
7851           }
7852           break;
7853         case 50:     cai[2] = 1;  break;
7854         case 75:     cai[2] = 1;  break;
7855         case 110:    cai[2] = 1;  break;
7856         case 150:    cai[2] = 1;  break;
7857         case 200:    cai[2] = 1;  break;
7858         case 300:    cai[2] = 1;  break;
7859         case 600:    cai[2] = 1;  break;
7860         case 1200:   cai[2] = 2;  break;
7861         case 2400:   cai[2] = 3;  break;
7862         case 4800:   cai[2] = 4;  break;
7863         case 7200:   cai[2] = 10; break;
7864         case 9600:   cai[2] = 5;  break;
7865         case 12000:  cai[2] = 13; break;
7866         case 24000:  cai[2] = 0;  break;
7867         case 14400:  cai[2] = 11; break;
7868         case 19200:  cai[2] = 6;  break;
7869         case 28800:  cai[2] = 12; break;
7870         case 38400:  cai[2] = 7;  break;
7871         case 48000:  cai[2] = 8;  break;
7872         case 76:     cai[2] = 15; break;  /* 75/1200     */
7873         case 1201:   cai[2] = 14; break;  /* 1200/75     */
7874         case 56001:  cai[2] = 9;  break;  /* V.110 56000 */
7875
7876         default:
7877           return _B1_PARM_NOT_SUPPORTED;
7878       }
7879       cai[3] = 0;
7880       if (cai[1] == 13)                                        /* v.110 async */
7881       {
7882         if (bp_parms[3].length >= 8)
7883         {
7884           switch (GET_WORD (&bp_parms[3].info[3]))
7885           {       /* char length */
7886           case 5:
7887             cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_5;
7888             break;
7889           case 6:
7890             cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_6;
7891             break;
7892           case 7:
7893             cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_7;
7894             break;
7895           }
7896           switch (GET_WORD (&bp_parms[3].info[5]))
7897           {       /* Parity     */
7898           case 1: /* odd parity */
7899             cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_ODD);
7900             break;
7901           case 2: /* even parity */
7902             cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_EVEN);
7903             break;
7904           }
7905           switch (GET_WORD (&bp_parms[3].info[7]))
7906           {       /* stop bits   */
7907           case 1: /* 2 stop bits */
7908             cai[3] |= DSP_CAI_ASYNC_TWO_STOP_BITS;
7909             break;
7910           }
7911         }
7912       }
7913     }
7914     else if(cai[1]==8 || GET_WORD(bp_parms[0].info)==3 ){
7915       dbug(1,dprintf("V.110 default 56k sync"));
7916       cai[1] = 8;
7917       cai[2] = 0;
7918       cai[3] = 0;
7919     }
7920     else {
7921       dbug(1,dprintf("V.110 default 9600 async"));
7922       cai[2] = 5;
7923     }
7924   }
7925   PUT_WORD(&cai[5],plci->appl->MaxDataLength);
7926   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]));
7927 /* HexDump ("CAI", sizeof(cai), &cai[0]); */
7928
7929   add_p(plci, CAI, cai);
7930   return 0;
7931 }
7932
7933 /*------------------------------------------------------------------*/
7934 /* put parameter for b2 and B3  protocol in the parameter buffer    */
7935 /*------------------------------------------------------------------*/
7936
7937 static word add_b23(PLCI *plci, API_PARSE *bp)
7938 {
7939   word i, fax_control_bits;
7940   byte pos, len;
7941   byte SAPI = 0x40;  /* default SAPI 16 for x.31 */
7942     API_PARSE bp_parms[8];
7943   API_PARSE * b1_config;
7944   API_PARSE * b2_config;
7945     API_PARSE b2_config_parms[8];
7946   API_PARSE * b3_config;
7947     API_PARSE b3_config_parms[6];
7948     API_PARSE global_config[2];
7949
7950   static byte llc[3] = {2,0,0};
7951   static byte dlc[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
7952   static byte nlc[256];
7953   static byte lli[12] = {1,1};
7954
7955   const byte llc2_out[] = {1,2,4,6,2,0,0,0, X75_V42BIS,V120_L2,V120_V42BIS,V120_L2,6};
7956   const byte llc2_in[]  = {1,3,4,6,3,0,0,0, X75_V42BIS,V120_L2,V120_V42BIS,V120_L2,6};
7957
7958   const byte llc3[] = {4,3,2,2,6,6,0};
7959   const byte header[] = {0,2,3,3,0,0,0};
7960
7961   for(i=0;i<8;i++) bp_parms[i].length = 0;
7962   for(i=0;i<6;i++) b2_config_parms[i].length = 0;
7963   for(i=0;i<5;i++) b3_config_parms[i].length = 0;
7964
7965   lli[0] = 1;
7966   lli[1] = 1;
7967   if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL)
7968     lli[1] |= 2;
7969   if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL)
7970     lli[1] |= 4;
7971
7972   if ((lli[1] & 0x02) && (diva_xdi_extended_features & DIVA_CAPI_USE_CMA)) {
7973     lli[1] |= 0x10;
7974     if (plci->rx_dma_descriptor <= 0) {
7975       plci->rx_dma_descriptor=diva_get_dma_descriptor(plci,&plci->rx_dma_magic);
7976       if (plci->rx_dma_descriptor >= 0)
7977         plci->rx_dma_descriptor++;
7978     }
7979     if (plci->rx_dma_descriptor > 0) {
7980       lli[0] = 6;
7981       lli[1] |= 0x40;
7982       lli[2] = (byte)(plci->rx_dma_descriptor - 1);
7983       lli[3] = (byte)plci->rx_dma_magic;
7984       lli[4] = (byte)(plci->rx_dma_magic >>  8);
7985       lli[5] = (byte)(plci->rx_dma_magic >> 16);
7986       lli[6] = (byte)(plci->rx_dma_magic >> 24);
7987     }
7988   }
7989
7990   if (DIVA_CAPI_SUPPORTS_NO_CANCEL(plci->adapter)) {
7991     lli[1] |= 0x20;
7992   }
7993
7994   dbug(1,dprintf("add_b23"));
7995   api_save_msg(bp, "s", &plci->B_protocol);
7996
7997   if(!bp->length && plci->tel)
7998   {
7999     plci->adv_nl = true;
8000     dbug(1,dprintf("Default adv.Nl"));
8001     add_p(plci,LLI,lli);
8002     plci->B2_prot = 1 /*XPARENT*/;
8003     plci->B3_prot = 0 /*XPARENT*/;
8004     llc[1] = 2;
8005     llc[2] = 4;
8006     add_p(plci, LLC, llc);
8007     dlc[0] = 2;
8008     PUT_WORD(&dlc[1],plci->appl->MaxDataLength);
8009     add_p(plci, DLC, dlc);
8010     return 0;
8011   }
8012
8013   if(!bp->length) /*default*/
8014   {
8015     dbug(1,dprintf("ret default"));
8016     add_p(plci,LLI,lli);
8017     plci->B2_prot = 0 /*X.75   */;
8018     plci->B3_prot = 0 /*XPARENT*/;
8019     llc[1] = 1;
8020     llc[2] = 4;
8021     add_p(plci, LLC, llc);
8022     dlc[0] = 2;
8023     PUT_WORD(&dlc[1],plci->appl->MaxDataLength);
8024     add_p(plci, DLC, dlc);
8025     return 0;
8026   }
8027   dbug(1,dprintf("b_prot_len=%d",(word)bp->length));
8028   if((word)bp->length > 256)    return _WRONG_MESSAGE_FORMAT;
8029
8030   if(api_parse(&bp->info[1], (word)bp->length, "wwwsssb", bp_parms))
8031   {
8032     bp_parms[6].length = 0;
8033     if(api_parse(&bp->info[1], (word)bp->length, "wwwsss", bp_parms))
8034     {
8035       dbug(1,dprintf("b-form.!"));
8036       return _WRONG_MESSAGE_FORMAT;
8037     }
8038   }
8039   else if (api_parse(&bp->info[1], (word)bp->length, "wwwssss", bp_parms))
8040   {
8041     dbug(1,dprintf("b-form.!"));
8042     return _WRONG_MESSAGE_FORMAT;
8043   }
8044
8045   if(plci->tel==ADV_VOICE) /* transparent B on advanced voice */
8046   {
8047     if(GET_WORD(bp_parms[1].info)!=1
8048     || GET_WORD(bp_parms[2].info)!=0) return _B2_NOT_SUPPORTED;
8049     plci->adv_nl = true;
8050   }
8051   else if(plci->tel) return _B2_NOT_SUPPORTED;
8052
8053
8054   if ((GET_WORD(bp_parms[1].info) == B2_RTP)
8055    && (GET_WORD(bp_parms[2].info) == B3_RTP)
8056    && (plci->adapter->man_profile.private_options & (1L << PRIVATE_RTP)))
8057   {
8058     add_p(plci,LLI,lli);
8059     plci->B2_prot = (byte) GET_WORD(bp_parms[1].info);
8060     plci->B3_prot = (byte) GET_WORD(bp_parms[2].info);
8061     llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ? 14 : 13;
8062     llc[2] = 4;
8063     add_p(plci, LLC, llc);
8064     dlc[0] = 2;
8065     PUT_WORD(&dlc[1],plci->appl->MaxDataLength);
8066     dlc[3] = 3; /* Addr A */
8067     dlc[4] = 1; /* Addr B */
8068     dlc[5] = 7; /* modulo mode */
8069     dlc[6] = 7; /* window size */
8070     dlc[7] = 0; /* XID len Lo  */
8071     dlc[8] = 0; /* XID len Hi  */
8072     for (i = 0; i < bp_parms[4].length; i++)
8073       dlc[9+i] = bp_parms[4].info[1+i];
8074     dlc[0] = (byte)(8 + bp_parms[4].length);
8075     add_p(plci, DLC, dlc);
8076     for (i = 0; i < bp_parms[5].length; i++)
8077       nlc[1+i] = bp_parms[5].info[1+i];
8078     nlc[0] = (byte)(bp_parms[5].length);
8079     add_p(plci, NLC, nlc);
8080     return 0;
8081   }
8082
8083
8084
8085   if ((GET_WORD(bp_parms[1].info) >= 32)
8086    || (!((1L << GET_WORD(bp_parms[1].info)) & plci->adapter->profile.B2_Protocols)
8087     && ((GET_WORD(bp_parms[1].info) != B2_PIAFS)
8088      || !(plci->adapter->man_profile.private_options & (1L << PRIVATE_PIAFS)))))
8089
8090   {
8091     return _B2_NOT_SUPPORTED;
8092   }
8093   if ((GET_WORD(bp_parms[2].info) >= 32)
8094    || !((1L << GET_WORD(bp_parms[2].info)) & plci->adapter->profile.B3_Protocols))
8095   {
8096     return _B3_NOT_SUPPORTED;
8097   }
8098   if ((GET_WORD(bp_parms[1].info) != B2_SDLC)
8099    && ((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE)
8100     || (GET_WORD(bp_parms[0].info) == B1_MODEM_ASYNC)
8101     || (GET_WORD(bp_parms[0].info) == B1_MODEM_SYNC_HDLC)))
8102   {
8103     return (add_modem_b23 (plci, bp_parms));
8104   }
8105
8106   add_p(plci,LLI,lli);
8107
8108   plci->B2_prot = (byte) GET_WORD(bp_parms[1].info);
8109   plci->B3_prot = (byte) GET_WORD(bp_parms[2].info);
8110   if(plci->B2_prot==12) SAPI = 0; /* default SAPI D-channel */
8111
8112   if(bp_parms[6].length)
8113   {
8114     if(api_parse(&bp_parms[6].info[1], (word)bp_parms[6].length, "w", global_config))
8115     {
8116       return _WRONG_MESSAGE_FORMAT;
8117     }
8118     switch(GET_WORD(global_config[0].info))
8119     {
8120     case 1:
8121       plci->call_dir = (plci->call_dir & ~CALL_DIR_ANSWER) | CALL_DIR_ORIGINATE;
8122       break;
8123     case 2:
8124       plci->call_dir = (plci->call_dir & ~CALL_DIR_ORIGINATE) | CALL_DIR_ANSWER;
8125       break;
8126     }
8127   }
8128   dbug(1,dprintf("call_dir=%04x", plci->call_dir));
8129
8130
8131   if (plci->B2_prot == B2_PIAFS)
8132     llc[1] = PIAFS_CRC;
8133   else
8134 /* IMPLEMENT_PIAFS */
8135   {
8136     llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ?
8137              llc2_out[GET_WORD(bp_parms[1].info)] : llc2_in[GET_WORD(bp_parms[1].info)];
8138   }
8139   llc[2] = llc3[GET_WORD(bp_parms[2].info)];
8140
8141   add_p(plci, LLC, llc);
8142
8143   dlc[0] = 2;
8144   PUT_WORD(&dlc[1], plci->appl->MaxDataLength +
8145                       header[GET_WORD(bp_parms[2].info)]);
8146
8147   b1_config = &bp_parms[3];
8148   nlc[0] = 0;
8149   if(plci->B3_prot == 4
8150   || plci->B3_prot == 5)
8151   {
8152     for (i=0;i<sizeof(T30_INFO);i++) nlc[i] = 0;
8153     nlc[0] = sizeof(T30_INFO);
8154     if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
8155       ((T30_INFO *)&nlc[1])->operating_mode = T30_OPERATING_MODE_CAPI;
8156     ((T30_INFO *)&nlc[1])->rate_div_2400 = 0xff;
8157     if(b1_config->length>=2)
8158     {
8159       ((T30_INFO *)&nlc[1])->rate_div_2400 = (byte)(GET_WORD(&b1_config->info[1])/2400);
8160     }
8161   }
8162   b2_config = &bp_parms[4];
8163
8164
8165   if (llc[1] == PIAFS_CRC)
8166   {
8167     if (plci->B3_prot != B3_TRANSPARENT)
8168     {
8169       return _B_STACK_NOT_SUPPORTED;
8170     }
8171     if(b2_config->length && api_parse(&b2_config->info[1], (word)b2_config->length, "bwww", b2_config_parms)) {
8172       return _WRONG_MESSAGE_FORMAT;
8173     }
8174     PUT_WORD(&dlc[1],plci->appl->MaxDataLength);
8175     dlc[3] = 0; /* Addr A */
8176     dlc[4] = 0; /* Addr B */
8177     dlc[5] = 0; /* modulo mode */
8178     dlc[6] = 0; /* window size */
8179     if (b2_config->length >= 7){
8180       dlc[ 7] = 7;
8181       dlc[ 8] = 0;
8182       dlc[ 9] = b2_config_parms[0].info[0]; /* PIAFS protocol Speed configuration */
8183       dlc[10] = b2_config_parms[1].info[0]; /* V.42bis P0 */
8184       dlc[11] = b2_config_parms[1].info[1]; /* V.42bis P0 */
8185       dlc[12] = b2_config_parms[2].info[0]; /* V.42bis P1 */
8186       dlc[13] = b2_config_parms[2].info[1]; /* V.42bis P1 */
8187       dlc[14] = b2_config_parms[3].info[0]; /* V.42bis P2 */
8188       dlc[15] = b2_config_parms[3].info[1]; /* V.42bis P2 */
8189       dlc[ 0] = 15;
8190       if(b2_config->length >= 8) { /* PIAFS control abilities */
8191         dlc[ 7] = 10;
8192         dlc[16] = 2; /* Length of PIAFS extension */
8193         dlc[17] = PIAFS_UDATA_ABILITIES; /* control (UDATA) ability */
8194         dlc[18] = b2_config_parms[4].info[0]; /* value */
8195         dlc[ 0] = 18;
8196       }
8197     }
8198     else /* default values, 64K, variable, no compression */
8199     {
8200       dlc[ 7] = 7;
8201       dlc[ 8] = 0;
8202       dlc[ 9] = 0x03; /* PIAFS protocol Speed configuration */
8203       dlc[10] = 0x03; /* V.42bis P0 */
8204       dlc[11] = 0;    /* V.42bis P0 */
8205       dlc[12] = 0;    /* V.42bis P1 */
8206       dlc[13] = 0;    /* V.42bis P1 */
8207       dlc[14] = 0;    /* V.42bis P2 */
8208       dlc[15] = 0;    /* V.42bis P2 */
8209     dlc[ 0] = 15;
8210     }
8211     add_p(plci, DLC, dlc);
8212   }
8213   else
8214
8215   if ((llc[1] == V120_L2) || (llc[1] == V120_V42BIS))
8216   {
8217     if (plci->B3_prot != B3_TRANSPARENT)
8218       return _B_STACK_NOT_SUPPORTED;
8219
8220     dlc[0] = 6;
8221     PUT_WORD (&dlc[1], GET_WORD (&dlc[1]) + 2);
8222     dlc[3] = 0x08;
8223     dlc[4] = 0x01;
8224     dlc[5] = 127;
8225     dlc[6] = 7;
8226     if (b2_config->length != 0)
8227     {
8228       if((llc[1]==V120_V42BIS) && api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbwww", b2_config_parms)) {
8229         return _WRONG_MESSAGE_FORMAT;
8230       }
8231       dlc[3] = (byte)((b2_config->info[2] << 3) | ((b2_config->info[1] >> 5) & 0x04));
8232       dlc[4] = (byte)((b2_config->info[1] << 1) | 0x01);
8233       if (b2_config->info[3] != 128)
8234       {
8235         dbug(1,dprintf("1D-dlc= %x %x %x %x %x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4]));
8236         return _B2_PARM_NOT_SUPPORTED;
8237       }
8238       dlc[5] = (byte)(b2_config->info[3] - 1);
8239       dlc[6] = b2_config->info[4];
8240       if(llc[1]==V120_V42BIS){
8241         if (b2_config->length >= 10){
8242           dlc[ 7] = 6;
8243           dlc[ 8] = 0;
8244           dlc[ 9] = b2_config_parms[4].info[0];
8245           dlc[10] = b2_config_parms[4].info[1];
8246           dlc[11] = b2_config_parms[5].info[0];
8247           dlc[12] = b2_config_parms[5].info[1];
8248           dlc[13] = b2_config_parms[6].info[0];
8249           dlc[14] = b2_config_parms[6].info[1];
8250           dlc[ 0] = 14;
8251           dbug(1,dprintf("b2_config_parms[4].info[0] [1]:  %x %x", b2_config_parms[4].info[0], b2_config_parms[4].info[1]));
8252           dbug(1,dprintf("b2_config_parms[5].info[0] [1]:  %x %x", b2_config_parms[5].info[0], b2_config_parms[5].info[1]));
8253           dbug(1,dprintf("b2_config_parms[6].info[0] [1]:  %x %x", b2_config_parms[6].info[0], b2_config_parms[6].info[1]));
8254         }
8255         else {
8256           dlc[ 6] = 14;
8257         }
8258       }
8259     }
8260   }
8261   else
8262   {
8263     if(b2_config->length)
8264     {
8265       dbug(1,dprintf("B2-Config"));
8266       if(llc[1]==X75_V42BIS){
8267         if(api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbwww", b2_config_parms))
8268         {
8269           return _WRONG_MESSAGE_FORMAT;
8270         }
8271       }
8272       else {
8273         if(api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbs", b2_config_parms))
8274         {
8275           return _WRONG_MESSAGE_FORMAT;
8276         }
8277       }
8278           /* if B2 Protocol is LAPD, b2_config structure is different */
8279       if(llc[1]==6)
8280       {
8281         dlc[0] = 4;
8282         if(b2_config->length>=1) dlc[2] = b2_config->info[1];      /* TEI */
8283         else dlc[2] = 0x01;
8284         if( (b2_config->length>=2) && (plci->B2_prot==12) )
8285         {
8286           SAPI = b2_config->info[2];    /* SAPI */
8287         }
8288         dlc[1] = SAPI;
8289         if( (b2_config->length>=3) && (b2_config->info[3]==128) )
8290         {
8291           dlc[3] = 127;      /* Mode */
8292         }
8293         else
8294         {
8295           dlc[3] = 7;        /* Mode */
8296         }
8297
8298         if(b2_config->length>=4) dlc[4] = b2_config->info[4];      /* Window */
8299         else dlc[4] = 1;
8300         dbug(1,dprintf("D-dlc[%d]=%x,%x,%x,%x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4]));
8301         if(b2_config->length>5) return _B2_PARM_NOT_SUPPORTED;
8302       }
8303       else
8304       {
8305         dlc[0] = (byte)(b2_config_parms[4].length+6);
8306         dlc[3] = b2_config->info[1];
8307         dlc[4] = b2_config->info[2];
8308         if(b2_config->info[3]!=8 && b2_config->info[3]!=128){
8309           dbug(1,dprintf("1D-dlc= %x %x %x %x %x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4]));
8310           return _B2_PARM_NOT_SUPPORTED;
8311         }
8312
8313         dlc[5] = (byte)(b2_config->info[3]-1);
8314         dlc[6] = b2_config->info[4];
8315         if(dlc[6]>dlc[5]){
8316           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]));
8317           return _B2_PARM_NOT_SUPPORTED;
8318         }
8319
8320         if(llc[1]==X75_V42BIS) {
8321           if (b2_config->length >= 10){
8322             dlc[ 7] = 6;
8323             dlc[ 8] = 0;
8324             dlc[ 9] = b2_config_parms[4].info[0];
8325             dlc[10] = b2_config_parms[4].info[1];
8326             dlc[11] = b2_config_parms[5].info[0];
8327             dlc[12] = b2_config_parms[5].info[1];
8328             dlc[13] = b2_config_parms[6].info[0];
8329             dlc[14] = b2_config_parms[6].info[1];
8330             dlc[ 0] = 14;
8331             dbug(1,dprintf("b2_config_parms[4].info[0] [1]:  %x %x", b2_config_parms[4].info[0], b2_config_parms[4].info[1]));
8332             dbug(1,dprintf("b2_config_parms[5].info[0] [1]:  %x %x", b2_config_parms[5].info[0], b2_config_parms[5].info[1]));
8333             dbug(1,dprintf("b2_config_parms[6].info[0] [1]:  %x %x", b2_config_parms[6].info[0], b2_config_parms[6].info[1]));
8334           }
8335           else {
8336             dlc[ 6] = 14;
8337           }
8338
8339         }
8340         else {
8341           PUT_WORD(&dlc[7], (word)b2_config_parms[4].length);
8342           for(i=0; i<b2_config_parms[4].length; i++)
8343             dlc[11+i] = b2_config_parms[4].info[1+i];
8344         }
8345       }
8346     }
8347   }
8348   add_p(plci, DLC, dlc);
8349
8350   b3_config = &bp_parms[5];
8351   if(b3_config->length)
8352   {
8353     if(plci->B3_prot == 4
8354     || plci->B3_prot == 5)
8355     {
8356       if(api_parse(&b3_config->info[1], (word)b3_config->length, "wwss", b3_config_parms))
8357       {
8358         return _WRONG_MESSAGE_FORMAT;
8359       }
8360       i = GET_WORD((byte   *)(b3_config_parms[0].info));
8361       ((T30_INFO *)&nlc[1])->resolution = (byte)(((i & 0x0001) ||
8362         ((plci->B3_prot == 4) && (((byte)(GET_WORD((byte   *)b3_config_parms[1].info))) != 5))) ? T30_RESOLUTION_R8_0770_OR_200 : 0);
8363       ((T30_INFO *)&nlc[1])->data_format = (byte)(GET_WORD((byte   *)b3_config_parms[1].info));
8364       fax_control_bits = T30_CONTROL_BIT_ALL_FEATURES;
8365       if ((((T30_INFO *)&nlc[1])->rate_div_2400 != 0) && (((T30_INFO *)&nlc[1])->rate_div_2400 <= 6))
8366         fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_V34FAX;
8367       if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
8368       {
8369
8370         if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id-1])
8371           & (1L << PRIVATE_FAX_PAPER_FORMATS))
8372         {
8373           ((T30_INFO *)&nlc[1])->resolution |= T30_RESOLUTION_R8_1540 |
8374             T30_RESOLUTION_R16_1540_OR_400 | T30_RESOLUTION_300_300 |
8375             T30_RESOLUTION_INCH_BASED | T30_RESOLUTION_METRIC_BASED;
8376         }
8377
8378  ((T30_INFO *)&nlc[1])->recording_properties =
8379    T30_RECORDING_WIDTH_ISO_A3 |
8380    (T30_RECORDING_LENGTH_UNLIMITED << 2) |
8381    (T30_MIN_SCANLINE_TIME_00_00_00 << 4);
8382       }
8383       if(plci->B3_prot == 5)
8384       {
8385         if (i & 0x0002) /* Accept incoming fax-polling requests */
8386           fax_control_bits |= T30_CONTROL_BIT_ACCEPT_POLLING;
8387         if (i & 0x2000) /* Do not use MR compression */
8388           fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_2D_CODING;
8389         if (i & 0x4000) /* Do not use MMR compression */
8390           fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_T6_CODING;
8391         if (i & 0x8000) /* Do not use ECM */
8392           fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_ECM;
8393         if (plci->fax_connect_info_length != 0)
8394         {
8395           ((T30_INFO *)&nlc[1])->resolution = ((T30_INFO   *)plci->fax_connect_info_buffer)->resolution;
8396           ((T30_INFO *)&nlc[1])->data_format = ((T30_INFO   *)plci->fax_connect_info_buffer)->data_format;
8397           ((T30_INFO *)&nlc[1])->recording_properties = ((T30_INFO   *)plci->fax_connect_info_buffer)->recording_properties;
8398           fax_control_bits |= GET_WORD(&((T30_INFO   *)plci->fax_connect_info_buffer)->control_bits_low) &
8399             (T30_CONTROL_BIT_REQUEST_POLLING | T30_CONTROL_BIT_MORE_DOCUMENTS);
8400         }
8401       }
8402       /* copy station id to NLC */
8403       for(i=0; i < T30_MAX_STATION_ID_LENGTH; i++)
8404       {
8405         if(i<b3_config_parms[2].length)
8406         {
8407           ((T30_INFO *)&nlc[1])->station_id[i] = ((byte   *)b3_config_parms[2].info)[1+i];
8408         }
8409         else
8410         {
8411           ((T30_INFO *)&nlc[1])->station_id[i] = ' ';
8412         }
8413       }
8414       ((T30_INFO *)&nlc[1])->station_id_len = T30_MAX_STATION_ID_LENGTH;
8415       /* copy head line to NLC */
8416       if(b3_config_parms[3].length)
8417       {
8418
8419         pos = (byte)(fax_head_line_time (&(((T30_INFO *)&nlc[1])->station_id[T30_MAX_STATION_ID_LENGTH])));
8420         if (pos != 0)
8421         {
8422           if (CAPI_MAX_DATE_TIME_LENGTH + 2 + b3_config_parms[3].length > CAPI_MAX_HEAD_LINE_SPACE)
8423             pos = 0;
8424           else
8425           {
8426             nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
8427             nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
8428             len = (byte)b3_config_parms[2].length;
8429             if (len > 20)
8430               len = 20;
8431             if (CAPI_MAX_DATE_TIME_LENGTH + 2 + len + 2 + b3_config_parms[3].length <= CAPI_MAX_HEAD_LINE_SPACE)
8432             {
8433               for (i = 0; i < len; i++)
8434                 nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ((byte   *)b3_config_parms[2].info)[1+i];
8435               nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
8436               nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
8437             }
8438           }
8439         }
8440
8441         len = (byte)b3_config_parms[3].length;
8442         if (len > CAPI_MAX_HEAD_LINE_SPACE - pos)
8443           len = (byte)(CAPI_MAX_HEAD_LINE_SPACE - pos);
8444         ((T30_INFO *)&nlc[1])->head_line_len = (byte)(pos + len);
8445         nlc[0] += (byte)(pos + len);
8446         for (i = 0; i < len; i++)
8447           nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] =  ((byte   *)b3_config_parms[3].info)[1+i];
8448       } else
8449         ((T30_INFO *)&nlc[1])->head_line_len = 0;
8450
8451       plci->nsf_control_bits = 0;
8452       if(plci->B3_prot == 5)
8453       {
8454         if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_FAX_SUB_SEP_PWD))
8455          && (GET_WORD((byte   *)b3_config_parms[1].info) & 0x8000)) /* Private SUB/SEP/PWD enable */
8456         {
8457           plci->requested_options |= 1L << PRIVATE_FAX_SUB_SEP_PWD;
8458         }
8459         if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_FAX_NONSTANDARD))
8460          && (GET_WORD((byte   *)b3_config_parms[1].info) & 0x4000)) /* Private non-standard facilities enable */
8461         {
8462           plci->requested_options |= 1L << PRIVATE_FAX_NONSTANDARD;
8463         }
8464         if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id-1])
8465           & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
8466         {
8467         if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id-1])
8468           & (1L << PRIVATE_FAX_SUB_SEP_PWD))
8469         {
8470           fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_PASSWORD;
8471           if (fax_control_bits & T30_CONTROL_BIT_ACCEPT_POLLING)
8472             fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SEL_POLLING;
8473           }
8474             len = nlc[0];
8475           pos = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
8476    if (pos < plci->fax_connect_info_length)
8477    {
8478      for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--)
8479               nlc[++len] = plci->fax_connect_info_buffer[pos++];
8480           }
8481    else
8482      nlc[++len] = 0;
8483    if (pos < plci->fax_connect_info_length)
8484    {
8485      for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--)
8486               nlc[++len] = plci->fax_connect_info_buffer[pos++];
8487           }
8488    else
8489      nlc[++len] = 0;
8490           if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id-1])
8491             & (1L << PRIVATE_FAX_NONSTANDARD))
8492           {
8493      if ((pos < plci->fax_connect_info_length) && (plci->fax_connect_info_buffer[pos] != 0))
8494      {
8495               if ((plci->fax_connect_info_buffer[pos] >= 3) && (plci->fax_connect_info_buffer[pos+1] >= 2))
8496                 plci->nsf_control_bits = GET_WORD(&plci->fax_connect_info_buffer[pos+2]);
8497        for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--)
8498                 nlc[++len] = plci->fax_connect_info_buffer[pos++];
8499             }
8500      else
8501      {
8502               if(api_parse(&b3_config->info[1], (word)b3_config->length, "wwsss", b3_config_parms))
8503               {
8504                 dbug(1,dprintf("non-standard facilities info missing or wrong format"));
8505                 nlc[++len] = 0;
8506               }
8507        else
8508        {
8509                 if ((b3_config_parms[4].length >= 3) && (b3_config_parms[4].info[1] >= 2))
8510                   plci->nsf_control_bits = GET_WORD(&b3_config_parms[4].info[2]);
8511          nlc[++len] = (byte)(b3_config_parms[4].length);
8512          for (i = 0; i < b3_config_parms[4].length; i++)
8513     nlc[++len] = b3_config_parms[4].info[1+i];
8514        }
8515             }
8516           }
8517             nlc[0] = len;
8518    if ((plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF)
8519     && (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP))
8520    {
8521             ((T30_INFO *)&nlc[1])->operating_mode = T30_OPERATING_MODE_CAPI_NEG;
8522           }
8523         }
8524       }
8525
8526       PUT_WORD(&(((T30_INFO *)&nlc[1])->control_bits_low), fax_control_bits);
8527       len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
8528       for (i = 0; i < len; i++)
8529         plci->fax_connect_info_buffer[i] = nlc[1+i];
8530       ((T30_INFO   *) plci->fax_connect_info_buffer)->head_line_len = 0;
8531       i += ((T30_INFO *)&nlc[1])->head_line_len;
8532       while (i < nlc[0])
8533         plci->fax_connect_info_buffer[len++] = nlc[++i];
8534       plci->fax_connect_info_length = len;
8535     }
8536     else
8537     {
8538       nlc[0] = 14;
8539       if(b3_config->length!=16)
8540         return _B3_PARM_NOT_SUPPORTED;
8541       for(i=0; i<12; i++) nlc[1+i] = b3_config->info[1+i];
8542       if(GET_WORD(&b3_config->info[13])!=8 && GET_WORD(&b3_config->info[13])!=128)
8543         return _B3_PARM_NOT_SUPPORTED;
8544       nlc[13] = b3_config->info[13];
8545       if(GET_WORD(&b3_config->info[15])>=nlc[13])
8546         return _B3_PARM_NOT_SUPPORTED;
8547       nlc[14] = b3_config->info[15];
8548     }
8549   }
8550   else
8551   {
8552     if (plci->B3_prot == 4
8553      || plci->B3_prot == 5 /*T.30 - FAX*/ ) return _B3_PARM_NOT_SUPPORTED;
8554   }
8555   add_p(plci, NLC, nlc);
8556   return 0;
8557 }
8558
8559 /*----------------------------------------------------------------*/
8560 /*      make the same as add_b23, but only for the modem related  */
8561 /*      L2 and L3 B-Chan protocol.                                */
8562 /*                                                                */
8563 /*      Enabled L2 and L3 Configurations:                         */
8564 /*        If L1 == Modem all negotiation                          */
8565 /*          only L2 == Modem with full negotiation is allowed     */
8566 /*        If L1 == Modem async or sync                            */
8567 /*          only L2 == Transparent is allowed                     */
8568 /*        L3 == Modem or L3 == Transparent are allowed            */
8569 /*      B2 Configuration for modem:                               */
8570 /*          word : enable/disable compression, bitoptions         */
8571 /*      B3 Configuration for modem:                               */
8572 /*          empty                                                 */
8573 /*----------------------------------------------------------------*/
8574 static word add_modem_b23 (PLCI  * plci, API_PARSE* bp_parms)
8575 {
8576   static byte lli[12] = {1,1};
8577   static byte llc[3] = {2,0,0};
8578   static byte dlc[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
8579     API_PARSE mdm_config[2];
8580   word i;
8581   word b2_config = 0;
8582
8583   for(i=0;i<2;i++) mdm_config[i].length = 0;
8584   for(i=0;i<sizeof(dlc);i++) dlc[i] = 0;
8585
8586   if (((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE)
8587     && (GET_WORD(bp_parms[1].info) != B2_MODEM_EC_COMPRESSION))
8588    || ((GET_WORD(bp_parms[0].info) != B1_MODEM_ALL_NEGOTIATE)
8589     && (GET_WORD(bp_parms[1].info) != B2_TRANSPARENT)))
8590   {
8591     return (_B_STACK_NOT_SUPPORTED);
8592   }
8593   if ((GET_WORD(bp_parms[2].info) != B3_MODEM)
8594    && (GET_WORD(bp_parms[2].info) != B3_TRANSPARENT))
8595   {
8596     return (_B_STACK_NOT_SUPPORTED);
8597   }
8598
8599   plci->B2_prot = (byte) GET_WORD(bp_parms[1].info);
8600   plci->B3_prot = (byte) GET_WORD(bp_parms[2].info);
8601
8602   if ((GET_WORD(bp_parms[1].info) == B2_MODEM_EC_COMPRESSION) && bp_parms[4].length)
8603   {
8604     if (api_parse (&bp_parms[4].info[1],
8605                   (word)bp_parms[4].length, "w",
8606                   mdm_config))
8607     {
8608       return (_WRONG_MESSAGE_FORMAT);
8609     }
8610     b2_config = GET_WORD(mdm_config[0].info);
8611   }
8612
8613   /* OK, L2 is modem */
8614
8615   lli[0] = 1;
8616   lli[1] = 1;
8617   if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL)
8618     lli[1] |= 2;
8619   if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL)
8620     lli[1] |= 4;
8621
8622   if ((lli[1] & 0x02) && (diva_xdi_extended_features & DIVA_CAPI_USE_CMA)) {
8623     lli[1] |= 0x10;
8624     if (plci->rx_dma_descriptor <= 0) {
8625       plci->rx_dma_descriptor=diva_get_dma_descriptor(plci,&plci->rx_dma_magic);
8626       if (plci->rx_dma_descriptor >= 0)
8627         plci->rx_dma_descriptor++;
8628     }
8629     if (plci->rx_dma_descriptor > 0) {
8630       lli[1] |= 0x40;
8631       lli[0] = 6;
8632       lli[2] = (byte)(plci->rx_dma_descriptor - 1);
8633       lli[3] = (byte)plci->rx_dma_magic;
8634       lli[4] = (byte)(plci->rx_dma_magic >>  8);
8635       lli[5] = (byte)(plci->rx_dma_magic >> 16);
8636       lli[6] = (byte)(plci->rx_dma_magic >> 24);
8637     }
8638   }
8639
8640   if (DIVA_CAPI_SUPPORTS_NO_CANCEL(plci->adapter)) {
8641     lli[1] |= 0x20;
8642   }
8643
8644   llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ?
8645     /*V42*/ 10 : /*V42_IN*/ 9;
8646   llc[2] = 4;                      /* pass L3 always transparent */
8647   add_p(plci, LLI, lli);
8648   add_p(plci, LLC, llc);
8649   i =  1;
8650   PUT_WORD (&dlc[i], plci->appl->MaxDataLength);
8651   i += 2;
8652   if (GET_WORD(bp_parms[1].info) == B2_MODEM_EC_COMPRESSION)
8653   {
8654     if (bp_parms[4].length)
8655   {
8656     dbug(1, dprintf("MDM b2_config=%02x", b2_config));
8657     dlc[i++] = 3; /* Addr A */
8658     dlc[i++] = 1; /* Addr B */
8659     dlc[i++] = 7; /* modulo mode */
8660     dlc[i++] = 7; /* window size */
8661     dlc[i++] = 0; /* XID len Lo  */
8662     dlc[i++] = 0; /* XID len Hi  */
8663
8664     if (b2_config & MDM_B2_DISABLE_V42bis)
8665     {
8666       dlc[i] |= DLC_MODEMPROT_DISABLE_V42_V42BIS;
8667     }
8668     if (b2_config & MDM_B2_DISABLE_MNP)
8669     {
8670       dlc[i] |= DLC_MODEMPROT_DISABLE_MNP_MNP5;
8671     }
8672     if (b2_config & MDM_B2_DISABLE_TRANS)
8673     {
8674       dlc[i] |= DLC_MODEMPROT_REQUIRE_PROTOCOL;
8675     }
8676     if (b2_config & MDM_B2_DISABLE_V42)
8677     {
8678       dlc[i] |= DLC_MODEMPROT_DISABLE_V42_DETECT;
8679     }
8680     if (b2_config & MDM_B2_DISABLE_COMP)
8681     {
8682       dlc[i] |= DLC_MODEMPROT_DISABLE_COMPRESSION;
8683     }
8684     i++;
8685   }
8686   }
8687   else
8688   {
8689     dlc[i++] = 3; /* Addr A */
8690     dlc[i++] = 1; /* Addr B */
8691     dlc[i++] = 7; /* modulo mode */
8692     dlc[i++] = 7; /* window size */
8693     dlc[i++] = 0; /* XID len Lo  */
8694     dlc[i++] = 0; /* XID len Hi  */
8695     dlc[i++] = DLC_MODEMPROT_DISABLE_V42_V42BIS |
8696                DLC_MODEMPROT_DISABLE_MNP_MNP5 |
8697                DLC_MODEMPROT_DISABLE_V42_DETECT |
8698                DLC_MODEMPROT_DISABLE_COMPRESSION;
8699   }
8700   dlc[0] = (byte)(i - 1);
8701 /* HexDump ("DLC", sizeof(dlc), &dlc[0]); */
8702   add_p(plci, DLC, dlc);
8703   return (0);
8704 }
8705
8706
8707 /*------------------------------------------------------------------*/
8708 /* send a request for the signaling entity                          */
8709 /*------------------------------------------------------------------*/
8710
8711 static void sig_req(PLCI *plci, byte req, byte Id)
8712 {
8713   if(!plci) return;
8714   if(plci->adapter->adapter_disabled) return;
8715   dbug(1,dprintf("sig_req(%x)",req));
8716   if (req == REMOVE)
8717     plci->sig_remove_id = plci->Sig.Id;
8718   if(plci->req_in==plci->req_in_start) {
8719     plci->req_in +=2;
8720     plci->RBuffer[plci->req_in++] = 0;
8721   }
8722   PUT_WORD(&plci->RBuffer[plci->req_in_start], plci->req_in-plci->req_in_start-2);
8723   plci->RBuffer[plci->req_in++] = Id;   /* sig/nl flag */
8724   plci->RBuffer[plci->req_in++] = req;  /* request */
8725   plci->RBuffer[plci->req_in++] = 0;    /* channel */
8726   plci->req_in_start = plci->req_in;
8727 }
8728
8729 /*------------------------------------------------------------------*/
8730 /* send a request for the network layer entity                      */
8731 /*------------------------------------------------------------------*/
8732
8733 static void nl_req_ncci(PLCI *plci, byte req, byte ncci)
8734 {
8735   if(!plci) return;
8736   if(plci->adapter->adapter_disabled) return;
8737   dbug(1,dprintf("nl_req %02x %02x %02x", plci->Id, req, ncci));
8738   if (req == REMOVE)
8739   {
8740     plci->nl_remove_id = plci->NL.Id;
8741     ncci_remove (plci, 0, (byte)(ncci != 0));
8742     ncci = 0;
8743   }
8744   if(plci->req_in==plci->req_in_start) {
8745     plci->req_in +=2;
8746     plci->RBuffer[plci->req_in++] = 0;
8747   }
8748   PUT_WORD(&plci->RBuffer[plci->req_in_start], plci->req_in-plci->req_in_start-2);
8749   plci->RBuffer[plci->req_in++] = 1;    /* sig/nl flag */
8750   plci->RBuffer[plci->req_in++] = req;  /* request */
8751   plci->RBuffer[plci->req_in++] = plci->adapter->ncci_ch[ncci];   /* channel */
8752   plci->req_in_start = plci->req_in;
8753 }
8754
8755 static void send_req(PLCI *plci)
8756 {
8757   ENTITY   * e;
8758   word l;
8759 /*  word i; */
8760
8761   if(!plci) return;
8762   if(plci->adapter->adapter_disabled) return;
8763   channel_xmit_xon (plci);
8764
8765         /* if nothing to do, return */
8766   if(plci->req_in==plci->req_out) return;
8767   dbug(1,dprintf("send_req(in=%d,out=%d)",plci->req_in,plci->req_out));
8768
8769   if(plci->nl_req || plci->sig_req) return;
8770
8771   l = GET_WORD(&plci->RBuffer[plci->req_out]);
8772   plci->req_out += 2;
8773   plci->XData[0].P = &plci->RBuffer[plci->req_out];
8774   plci->req_out += l;
8775   if(plci->RBuffer[plci->req_out]==1)
8776   {
8777     e = &plci->NL;
8778     plci->req_out++;
8779     e->Req = plci->nl_req = plci->RBuffer[plci->req_out++];
8780     e->ReqCh = plci->RBuffer[plci->req_out++];
8781     if(!(e->Id & 0x1f))
8782     {
8783       e->Id = NL_ID;
8784       plci->RBuffer[plci->req_out-4] = CAI;
8785       plci->RBuffer[plci->req_out-3] = 1;
8786       plci->RBuffer[plci->req_out-2] = (plci->Sig.Id==0xff) ? 0 : plci->Sig.Id;
8787       plci->RBuffer[plci->req_out-1] = 0;
8788       l+=3;
8789       plci->nl_global_req = plci->nl_req;
8790     }
8791     dbug(1,dprintf("%x:NLREQ(%x:%x:%x)",plci->adapter->Id,e->Id,e->Req,e->ReqCh));
8792   }
8793   else
8794   {
8795     e = &plci->Sig;
8796     if(plci->RBuffer[plci->req_out])
8797       e->Id = plci->RBuffer[plci->req_out];
8798     plci->req_out++;
8799     e->Req = plci->sig_req = plci->RBuffer[plci->req_out++];
8800     e->ReqCh = plci->RBuffer[plci->req_out++];
8801     if(!(e->Id & 0x1f))
8802       plci->sig_global_req = plci->sig_req;
8803     dbug(1,dprintf("%x:SIGREQ(%x:%x:%x)",plci->adapter->Id,e->Id,e->Req,e->ReqCh));
8804   }
8805   plci->XData[0].PLength = l;
8806   e->X = plci->XData;
8807   plci->adapter->request(e);
8808   dbug(1,dprintf("send_ok"));
8809 }
8810
8811 static void send_data(PLCI *plci)
8812 {
8813   DIVA_CAPI_ADAPTER   * a;
8814   DATA_B3_DESC   * data;
8815   NCCI   *ncci_ptr;
8816   word ncci;
8817
8818   if (!plci->nl_req && plci->ncci_ring_list)
8819   {
8820     a = plci->adapter;
8821     ncci = plci->ncci_ring_list;
8822     do
8823     {
8824       ncci = a->ncci_next[ncci];
8825       ncci_ptr = &(a->ncci[ncci]);
8826       if (!(a->ncci_ch[ncci]
8827          && (a->ch_flow_control[a->ncci_ch[ncci]] & N_OK_FC_PENDING)))
8828       {
8829         if (ncci_ptr->data_pending)
8830         {
8831           if ((a->ncci_state[ncci] == CONNECTED)
8832            || (a->ncci_state[ncci] == INC_ACT_PENDING)
8833            || (plci->send_disc == ncci))
8834           {
8835             data = &(ncci_ptr->DBuffer[ncci_ptr->data_out]);
8836             if ((plci->B2_prot == B2_V120_ASYNC)
8837              || (plci->B2_prot == B2_V120_ASYNC_V42BIS)
8838              || (plci->B2_prot == B2_V120_BIT_TRANSPARENT))
8839             {
8840               plci->NData[1].P = TransmitBufferGet (plci->appl, data->P);
8841               plci->NData[1].PLength = data->Length;
8842               if (data->Flags & 0x10)
8843                 plci->NData[0].P = v120_break_header;
8844               else
8845                 plci->NData[0].P = v120_default_header;
8846               plci->NData[0].PLength = 1 ;
8847               plci->NL.XNum = 2;
8848               plci->NL.Req = plci->nl_req = (byte)((data->Flags&0x07)<<4 |N_DATA);
8849             }
8850             else
8851             {
8852               plci->NData[0].P = TransmitBufferGet (plci->appl, data->P);
8853               plci->NData[0].PLength = data->Length;
8854               if (data->Flags & 0x10)
8855                 plci->NL.Req = plci->nl_req = (byte)N_UDATA;
8856
8857               else if ((plci->B3_prot == B3_RTP) && (data->Flags & 0x01))
8858                 plci->NL.Req = plci->nl_req = (byte)N_BDATA;
8859
8860               else
8861                 plci->NL.Req = plci->nl_req = (byte)((data->Flags&0x07)<<4 |N_DATA);
8862             }
8863             plci->NL.X = plci->NData;
8864             plci->NL.ReqCh = a->ncci_ch[ncci];
8865             dbug(1,dprintf("%x:DREQ(%x:%x)",a->Id,plci->NL.Id,plci->NL.Req));
8866             plci->data_sent = true;
8867             plci->data_sent_ptr = data->P;
8868             a->request(&plci->NL);
8869           }
8870           else {
8871             cleanup_ncci_data (plci, ncci);
8872           }
8873         }
8874         else if (plci->send_disc == ncci)
8875         {
8876           /* dprintf("N_DISC"); */
8877           plci->NData[0].PLength = 0;
8878           plci->NL.ReqCh = a->ncci_ch[ncci];
8879           plci->NL.Req = plci->nl_req = N_DISC;
8880           a->request(&plci->NL);
8881           plci->command = _DISCONNECT_B3_R;
8882           plci->send_disc = 0;
8883         }
8884       }
8885     } while (!plci->nl_req && (ncci != plci->ncci_ring_list));
8886     plci->ncci_ring_list = ncci;
8887   }
8888 }
8889
8890 static void listen_check(DIVA_CAPI_ADAPTER *a)
8891 {
8892   word i,j;
8893   PLCI   * plci;
8894   byte activnotifiedcalls = 0;
8895
8896   dbug(1,dprintf("listen_check(%d,%d)",a->listen_active,a->max_listen));
8897   if (!remove_started && !a->adapter_disabled)
8898   {
8899     for(i=0;i<a->max_plci;i++)
8900     {
8901       plci = &(a->plci[i]);
8902       if(plci->notifiedcall) activnotifiedcalls++;
8903     }
8904     dbug(1,dprintf("listen_check(%d)",activnotifiedcalls));
8905
8906     for(i=a->listen_active; i < ((word)(a->max_listen+activnotifiedcalls)); i++) {
8907       if((j=get_plci(a))) {
8908         a->listen_active++;
8909         plci = &a->plci[j-1];
8910         plci->State = LISTENING;
8911
8912         add_p(plci,OAD,"\x01\xfd");
8913
8914         add_p(plci,KEY,"\x04\x43\x41\x32\x30");
8915
8916         add_p(plci,CAI,"\x01\xc0");
8917         add_p(plci,UID,"\x06\x43\x61\x70\x69\x32\x30");
8918         add_p(plci,LLI,"\x01\xc4");                  /* support Dummy CR FAC + MWI + SpoofNotify */
8919         add_p(plci,SHIFT|6,NULL);
8920         add_p(plci,SIN,"\x02\x00\x00");
8921         plci->internal_command = LISTEN_SIG_ASSIGN_PEND;     /* do indicate_req if OK  */
8922         sig_req(plci,ASSIGN,DSIG_ID);
8923         send_req(plci);
8924       }
8925     }
8926   }
8927 }
8928
8929 /*------------------------------------------------------------------*/
8930 /* functions for all parameters sent in INDs                        */
8931 /*------------------------------------------------------------------*/
8932
8933 static void IndParse(PLCI *plci, word *parms_id, byte **parms, byte multiIEsize)
8934 {
8935   word ploc;            /* points to current location within packet */
8936   byte w;
8937   byte wlen;
8938   byte codeset,lock;
8939   byte   * in;
8940   word i;
8941   word code;
8942   word mIEindex = 0;
8943   ploc = 0;
8944   codeset = 0;
8945   lock = 0;
8946
8947   in = plci->Sig.RBuffer->P;
8948   for(i=0; i<parms_id[0]; i++)   /* multiIE parms_id contains just the 1st */
8949   {                            /* element but parms array is larger      */
8950     parms[i] = (byte   *)"";
8951   }
8952   for(i=0; i<multiIEsize; i++)
8953   {
8954     parms[i] = (byte   *)"";
8955   }
8956
8957   while(ploc<plci->Sig.RBuffer->length-1) {
8958
8959         /* read information element id and length                   */
8960     w = in[ploc];
8961
8962     if(w & 0x80) {
8963 /*    w &=0xf0; removed, cannot detect congestion levels */
8964 /*    upper 4 bit masked with w==SHIFT now               */
8965       wlen = 0;
8966     }
8967     else {
8968       wlen = (byte)(in[ploc+1]+1);
8969     }
8970         /* check if length valid (not exceeding end of packet)      */
8971     if((ploc+wlen) > 270) return ;
8972     if(lock & 0x80) lock &=0x7f;
8973     else codeset = lock;
8974
8975     if((w&0xf0)==SHIFT) {
8976       codeset = in[ploc];
8977       if(!(codeset & 0x08)) lock = (byte)(codeset & 7);
8978       codeset &=7;
8979       lock |=0x80;
8980     }
8981     else {
8982       if(w==ESC && wlen>=3) code = in[ploc+2] |0x800;
8983       else code = w;
8984       code |= (codeset<<8);
8985
8986       for(i=1; i<parms_id[0]+1 && parms_id[i]!=code; i++);
8987
8988       if(i<parms_id[0]+1) {
8989         if(!multiIEsize) { /* with multiIEs use next field index,          */
8990           mIEindex = i-1;    /* with normal IEs use same index like parms_id */
8991         }
8992
8993         parms[mIEindex] = &in[ploc+1];
8994         dbug(1,dprintf("mIE[%d]=0x%x",*parms[mIEindex],in[ploc]));
8995         if(parms_id[i]==OAD
8996         || parms_id[i]==CONN_NR
8997         || parms_id[i]==CAD) {
8998           if(in[ploc+2] &0x80) {
8999             in[ploc+0] = (byte)(in[ploc+1]+1);
9000             in[ploc+1] = (byte)(in[ploc+2] &0x7f);
9001             in[ploc+2] = 0x80;
9002             parms[mIEindex] = &in[ploc];
9003           }
9004         }
9005         mIEindex++;       /* effects multiIEs only */
9006       }
9007     }
9008
9009     ploc +=(wlen+1);
9010   }
9011   return ;
9012 }
9013
9014 /*------------------------------------------------------------------*/
9015 /* try to match a cip from received BC and HLC                      */
9016 /*------------------------------------------------------------------*/
9017
9018 static byte ie_compare(byte *ie1, byte *ie2)
9019 {
9020   word i;
9021   if(!ie1 || ! ie2) return false;
9022   if(!ie1[0]) return false;
9023   for(i=0;i<(word)(ie1[0]+1);i++) if(ie1[i]!=ie2[i]) return false;
9024   return true;
9025 }
9026
9027 static word find_cip(DIVA_CAPI_ADAPTER *a, byte *bc, byte *hlc)
9028 {
9029   word i;
9030   word j;
9031
9032   for(i=9;i && !ie_compare(bc,cip_bc[i][a->u_law]);i--);
9033
9034   for(j=16;j<29 &&
9035            (!ie_compare(bc,cip_bc[j][a->u_law]) || !ie_compare(hlc,cip_hlc[j])); j++);
9036   if(j==29) return i;
9037   return j;
9038 }
9039
9040
9041 static byte AddInfo(byte   **add_i,
9042                     byte   **fty_i,
9043                     byte   *esc_chi,
9044                     byte *facility)
9045 {
9046   byte i;
9047   byte j;
9048   byte k;
9049   byte flen;
9050   byte len=0;
9051    /* facility is a nested structure */
9052    /* FTY can be more than once      */
9053
9054         if (esc_chi[0] && !(esc_chi[esc_chi[0]] & 0x7f))
9055   {
9056     add_i[0] = (byte   *)"\x02\x02\x00"; /* use neither b nor d channel */
9057   }
9058
9059   else
9060   {
9061     add_i[0] = (byte   *)"";
9062   }
9063   if(!fty_i[0][0])
9064   {
9065     add_i[3] = (byte   *)"";
9066   }
9067   else
9068   {    /* facility array found  */
9069     for(i=0,j=1;i<MAX_MULTI_IE && fty_i[i][0];i++)
9070     {
9071       dbug(1,dprintf("AddIFac[%d]",fty_i[i][0]));
9072       len += fty_i[i][0];
9073       len += 2;
9074       flen=fty_i[i][0];
9075       facility[j++]=0x1c; /* copy fac IE */
9076       for(k=0;k<=flen;k++,j++)
9077       {
9078         facility[j]=fty_i[i][k];
9079 /*      dbug(1,dprintf("%x ",facility[j])); */
9080       }
9081     }
9082     facility[0] = len;
9083     add_i[3] = facility;
9084   }
9085 /*  dbug(1,dprintf("FacArrLen=%d ",len)); */
9086   len = add_i[0][0]+add_i[1][0]+add_i[2][0]+add_i[3][0];
9087   len += 4;                          /* calculate length of all */
9088   return(len);
9089 }
9090
9091 /*------------------------------------------------------------------*/
9092 /* voice and codec features                                         */
9093 /*------------------------------------------------------------------*/
9094
9095 static void SetVoiceChannel(PLCI *plci, byte *chi, DIVA_CAPI_ADAPTER *a)
9096 {
9097   byte voice_chi[] = "\x02\x18\x01";
9098   byte channel;
9099
9100   channel = chi[chi[0]]&0x3;
9101   dbug(1,dprintf("ExtDevON(Ch=0x%x)",channel));
9102   voice_chi[2] = (channel) ? channel : 1;
9103   add_p(plci,FTY,"\x02\x01\x07");             /* B On, default on 1 */
9104   add_p(plci,ESC,voice_chi);                  /* Channel */
9105   sig_req(plci,TEL_CTRL,0);
9106   send_req(plci);
9107   if(a->AdvSignalPLCI)
9108   {
9109     adv_voice_write_coefs (a->AdvSignalPLCI, ADV_VOICE_WRITE_ACTIVATION);
9110   }
9111 }
9112
9113 static void VoiceChannelOff(PLCI *plci)
9114 {
9115   dbug(1,dprintf("ExtDevOFF"));
9116   add_p(plci,FTY,"\x02\x01\x08");             /* B Off */
9117   sig_req(plci,TEL_CTRL,0);
9118   send_req(plci);
9119   if(plci->adapter->AdvSignalPLCI)
9120   {
9121     adv_voice_clear_config (plci->adapter->AdvSignalPLCI);
9122   }
9123 }
9124
9125
9126 static word AdvCodecSupport(DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl,
9127                             byte hook_listen)
9128 {
9129   word j;
9130   PLCI   *splci;
9131
9132   /* check if hardware supports handset with hook states (adv.codec) */
9133   /* or if just a on board codec is supported                        */
9134   /* the advanced codec plci is just for internal use                */
9135
9136   /* diva Pro with on-board codec:                                   */
9137   if(a->profile.Global_Options & HANDSET)
9138   {
9139     /* new call, but hook states are already signalled */
9140     if(a->AdvCodecFLAG)
9141     {
9142       if(a->AdvSignalAppl!=appl || a->AdvSignalPLCI)
9143       {
9144         dbug(1,dprintf("AdvSigPlci=0x%x",a->AdvSignalPLCI));
9145         return 0x2001; /* codec in use by another application */
9146       }
9147       if(plci!=NULL)
9148       {
9149         a->AdvSignalPLCI = plci;
9150         plci->tel=ADV_VOICE;
9151       }
9152       return 0;                      /* adv codec still used */
9153     }
9154     if((j=get_plci(a)))
9155     {
9156       splci = &a->plci[j-1];
9157       splci->tel = CODEC_PERMANENT;
9158       /* hook_listen indicates if a facility_req with handset/hook support */
9159       /* was sent. Otherwise if just a call on an external device was made */
9160       /* the codec will be used but the hook info will be discarded (just  */
9161       /* the external controller is in use                                 */
9162       if(hook_listen) splci->State = ADVANCED_VOICE_SIG;
9163       else
9164       {
9165         splci->State = ADVANCED_VOICE_NOSIG;
9166         if(plci)
9167         {
9168           plci->spoofed_msg = SPOOFING_REQUIRED;
9169         }
9170                                                /* indicate D-ch connect if  */
9171       }                                        /* codec is connected OK     */
9172       if(plci!=NULL)
9173       {
9174         a->AdvSignalPLCI = plci;
9175         plci->tel=ADV_VOICE;
9176       }
9177       a->AdvSignalAppl = appl;
9178       a->AdvCodecFLAG = true;
9179       a->AdvCodecPLCI = splci;
9180       add_p(splci,CAI,"\x01\x15");
9181       add_p(splci,LLI,"\x01\x00");
9182       add_p(splci,ESC,"\x02\x18\x00");
9183       add_p(splci,UID,"\x06\x43\x61\x70\x69\x32\x30");
9184       splci->internal_command = PERM_COD_ASSIGN;
9185       dbug(1,dprintf("Codec Assign"));
9186       sig_req(splci,ASSIGN,DSIG_ID);
9187       send_req(splci);
9188     }
9189     else
9190     {
9191       return 0x2001; /* wrong state, no more plcis */
9192     }
9193   }
9194   else if(a->profile.Global_Options & ON_BOARD_CODEC)
9195   {
9196     if(hook_listen) return 0x300B;               /* Facility not supported */
9197                                                  /* no hook with SCOM      */
9198     if(plci!=NULL) plci->tel = CODEC;
9199     dbug(1,dprintf("S/SCOM codec"));
9200     /* first time we use the scom-s codec we must shut down the internal   */
9201     /* handset application of the card. This can be done by an assign with */
9202     /* a cai with the 0x80 bit set. Assign return code is 'out of resource'*/
9203     if(!a->scom_appl_disable){
9204       if((j=get_plci(a))) {
9205         splci = &a->plci[j-1];
9206         add_p(splci,CAI,"\x01\x80");
9207         add_p(splci,UID,"\x06\x43\x61\x70\x69\x32\x30");
9208         sig_req(splci,ASSIGN,0xC0);  /* 0xc0 is the TEL_ID */
9209         send_req(splci);
9210         a->scom_appl_disable = true;
9211       }
9212       else{
9213         return 0x2001; /* wrong state, no more plcis */
9214       }
9215     }
9216   }
9217   else return 0x300B;               /* Facility not supported */
9218
9219   return 0;
9220 }
9221
9222
9223 static void CodecIdCheck(DIVA_CAPI_ADAPTER *a, PLCI *plci)
9224 {
9225
9226   dbug(1,dprintf("CodecIdCheck"));
9227
9228   if(a->AdvSignalPLCI == plci)
9229   {
9230     dbug(1,dprintf("PLCI owns codec"));
9231     VoiceChannelOff(a->AdvCodecPLCI);
9232     if(a->AdvCodecPLCI->State == ADVANCED_VOICE_NOSIG)
9233     {
9234       dbug(1,dprintf("remove temp codec PLCI"));
9235       plci_remove(a->AdvCodecPLCI);
9236       a->AdvCodecFLAG  = 0;
9237       a->AdvCodecPLCI  = NULL;
9238       a->AdvSignalAppl = NULL;
9239     }
9240     a->AdvSignalPLCI = NULL;
9241   }
9242 }
9243
9244 /* -------------------------------------------------------------------
9245     Ask for physical address of card on PCI bus
9246    ------------------------------------------------------------------- */
9247 static void diva_ask_for_xdi_sdram_bar (DIVA_CAPI_ADAPTER  * a,
9248                                         IDI_SYNC_REQ  * preq) {
9249   a->sdram_bar = 0;
9250   if (diva_xdi_extended_features & DIVA_CAPI_XDI_PROVIDES_SDRAM_BAR) {
9251     ENTITY   * e = (ENTITY   *)preq;
9252
9253     e->user[0] = a->Id - 1;
9254     preq->xdi_sdram_bar.info.bar    = 0;
9255     preq->xdi_sdram_bar.Req         = 0;
9256     preq->xdi_sdram_bar.Rc           = IDI_SYNC_REQ_XDI_GET_ADAPTER_SDRAM_BAR;
9257
9258     (*(a->request))(e);
9259
9260     a->sdram_bar = preq->xdi_sdram_bar.info.bar;
9261     dbug(3,dprintf("A(%d) SDRAM BAR = %08x", a->Id, a->sdram_bar));
9262   }
9263 }
9264
9265 /* -------------------------------------------------------------------
9266      Ask XDI about extended features
9267    ------------------------------------------------------------------- */
9268 static void diva_get_extended_adapter_features (DIVA_CAPI_ADAPTER  * a) {
9269   IDI_SYNC_REQ   * preq;
9270     char buffer[              ((sizeof(preq->xdi_extended_features)+4) > sizeof(ENTITY)) ?                     (sizeof(preq->xdi_extended_features)+4) : sizeof(ENTITY)];
9271
9272     char features[4];
9273   preq = (IDI_SYNC_REQ   *)&buffer[0];
9274
9275   if (!diva_xdi_extended_features) {
9276     ENTITY   * e = (ENTITY   *)preq;
9277     diva_xdi_extended_features |= 0x80000000;
9278
9279     e->user[0] = a->Id - 1;
9280     preq->xdi_extended_features.Req = 0;
9281     preq->xdi_extended_features.Rc  = IDI_SYNC_REQ_XDI_GET_EXTENDED_FEATURES;
9282     preq->xdi_extended_features.info.buffer_length_in_bytes = sizeof(features);
9283     preq->xdi_extended_features.info.features = &features[0];
9284
9285     (*(a->request))(e);
9286
9287     if (features[0] & DIVA_XDI_EXTENDED_FEATURES_VALID) {
9288       /*
9289          Check features located in the byte '0'
9290          */
9291       if (features[0] & DIVA_XDI_EXTENDED_FEATURE_CMA) {
9292         diva_xdi_extended_features |= DIVA_CAPI_USE_CMA;
9293       }
9294       if (features[0] & DIVA_XDI_EXTENDED_FEATURE_RX_DMA) {
9295         diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_RX_DMA;
9296         dbug(1,dprintf("XDI provides RxDMA"));
9297       }
9298       if (features[0] & DIVA_XDI_EXTENDED_FEATURE_SDRAM_BAR) {
9299         diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_SDRAM_BAR;
9300       }
9301       if (features[0] & DIVA_XDI_EXTENDED_FEATURE_NO_CANCEL_RC) {
9302         diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_NO_CANCEL;
9303         dbug(3,dprintf("XDI provides NO_CANCEL_RC feature"));
9304       }
9305
9306     }
9307   }
9308
9309   diva_ask_for_xdi_sdram_bar (a, preq);
9310 }
9311
9312 /*------------------------------------------------------------------*/
9313 /* automatic law                                                    */
9314 /*------------------------------------------------------------------*/
9315 /* called from OS specific part after init time to get the Law              */
9316 /* a-law (Euro) and u-law (us,japan) use different BCs in the Setup message */
9317 void AutomaticLaw(DIVA_CAPI_ADAPTER   *a)
9318 {
9319   word j;
9320   PLCI   *splci;
9321
9322   if(a->automatic_law) {
9323     return;
9324   }
9325   if((j=get_plci(a))) {
9326     diva_get_extended_adapter_features (a);
9327     splci = &a->plci[j-1];
9328     a->automatic_lawPLCI = splci;
9329     a->automatic_law = 1;
9330     add_p(splci,CAI,"\x01\x80");
9331     add_p(splci,UID,"\x06\x43\x61\x70\x69\x32\x30");
9332     splci->internal_command = USELAW_REQ;
9333     splci->command = 0;
9334     splci->number = 0;
9335     sig_req(splci,ASSIGN,DSIG_ID);
9336     send_req(splci);
9337   }
9338 }
9339
9340 /* called from OS specific part if an application sends an Capi20Release */
9341 word CapiRelease(word Id)
9342 {
9343   word i, j, appls_found;
9344   PLCI   *plci;
9345   APPL   *this;
9346   DIVA_CAPI_ADAPTER   *a;
9347
9348   if (!Id)
9349   {
9350     dbug(0,dprintf("A: CapiRelease(Id==0)"));
9351     return (_WRONG_APPL_ID);
9352   }
9353
9354   this = &application[Id-1];               /* get application pointer */
9355
9356   for(i=0,appls_found=0; i<max_appl; i++)
9357   {
9358     if(application[i].Id)       /* an application has been found        */
9359     {
9360       appls_found++;
9361     }
9362   }
9363
9364   for(i=0; i<max_adapter; i++)             /* scan all adapters...    */
9365   {
9366     a = &adapter[i];
9367     if (a->request)
9368     {
9369       a->Info_Mask[Id-1] = 0;
9370       a->CIP_Mask[Id-1] = 0;
9371       a->Notification_Mask[Id-1] = 0;
9372       a->codec_listen[Id-1] = NULL;
9373       a->requested_options_table[Id-1] = 0;
9374       for(j=0; j<a->max_plci; j++)           /* and all PLCIs connected */
9375       {                                      /* with this application   */
9376         plci = &a->plci[j];
9377         if(plci->Id)                         /* if plci owns no application */
9378         {                                    /* it may be not jet connected */
9379           if(plci->State==INC_CON_PENDING
9380           || plci->State==INC_CON_ALERT)
9381           {
9382             if(test_c_ind_mask_bit (plci, (word)(Id-1)))
9383             {
9384               clear_c_ind_mask_bit (plci, (word)(Id-1));
9385               if(c_ind_mask_empty (plci))
9386               {
9387                 sig_req(plci,HANGUP,0);
9388                 send_req(plci);
9389                 plci->State = OUTG_DIS_PENDING;
9390               }
9391             }
9392           }
9393           if(test_c_ind_mask_bit (plci, (word)(Id-1)))
9394           {
9395             clear_c_ind_mask_bit (plci, (word)(Id-1));
9396             if(c_ind_mask_empty (plci))
9397             {
9398               if(!plci->appl)
9399               {
9400                 plci_remove(plci);
9401                 plci->State = IDLE;
9402               }
9403             }
9404           }
9405           if(plci->appl==this)
9406           {
9407             plci->appl = NULL;
9408             plci_remove(plci);
9409             plci->State = IDLE;
9410           }
9411         }
9412       }
9413       listen_check(a);
9414
9415       if(a->flag_dynamic_l1_down)
9416       {
9417         if(appls_found==1)            /* last application does a capi release */
9418         {
9419           if((j=get_plci(a)))
9420           {
9421             plci = &a->plci[j-1];
9422             plci->command = 0;
9423             add_p(plci,OAD,"\x01\xfd");
9424             add_p(plci,CAI,"\x01\x80");
9425             add_p(plci,UID,"\x06\x43\x61\x70\x69\x32\x30");
9426             add_p(plci,SHIFT|6,NULL);
9427             add_p(plci,SIN,"\x02\x00\x00");
9428             plci->internal_command = REM_L1_SIG_ASSIGN_PEND;
9429             sig_req(plci,ASSIGN,DSIG_ID);
9430             add_p(plci,FTY,"\x02\xff\x06"); /* l1 down */
9431             sig_req(plci,SIG_CTRL,0);
9432             send_req(plci);
9433           }
9434         }
9435       }
9436       if(a->AdvSignalAppl==this)
9437       {
9438         this->NullCREnable = false;
9439         if (a->AdvCodecPLCI)
9440         {
9441           plci_remove(a->AdvCodecPLCI);
9442           a->AdvCodecPLCI->tel = 0;
9443           a->AdvCodecPLCI->adv_nl = 0;
9444         }
9445         a->AdvSignalAppl = NULL;
9446         a->AdvSignalPLCI = NULL;
9447         a->AdvCodecFLAG = 0;
9448         a->AdvCodecPLCI = NULL;
9449       }
9450     }
9451   }
9452
9453   this->Id = 0;
9454
9455   return GOOD;
9456 }
9457
9458 static word plci_remove_check(PLCI   *plci)
9459 {
9460   if(!plci) return true;
9461   if(!plci->NL.Id && c_ind_mask_empty (plci))
9462   {
9463     if(plci->Sig.Id == 0xff)
9464       plci->Sig.Id = 0;
9465     if(!plci->Sig.Id)
9466     {
9467       dbug(1,dprintf("plci_remove_complete(%x)",plci->Id));
9468       dbug(1,dprintf("tel=0x%x,Sig=0x%x",plci->tel,plci->Sig.Id));
9469       if (plci->Id)
9470       {
9471         CodecIdCheck(plci->adapter, plci);
9472         clear_b1_config (plci);
9473         ncci_remove (plci, 0, false);
9474         plci_free_msg_in_queue (plci);
9475         channel_flow_control_remove (plci);
9476         plci->Id = 0;
9477         plci->State = IDLE;
9478         plci->channels = 0;
9479         plci->appl = NULL;
9480         plci->notifiedcall = 0;
9481       }
9482       listen_check(plci->adapter);
9483       return true;
9484     }
9485   }
9486   return false;
9487 }
9488
9489
9490 /*------------------------------------------------------------------*/
9491
9492 static byte plci_nl_busy (PLCI   *plci)
9493 {
9494   /* only applicable for non-multiplexed protocols */
9495   return (plci->nl_req
9496     || (plci->ncci_ring_list
9497      && plci->adapter->ncci_ch[plci->ncci_ring_list]
9498      && (plci->adapter->ch_flow_control[plci->adapter->ncci_ch[plci->ncci_ring_list]] & N_OK_FC_PENDING)));
9499 }
9500
9501
9502 /*------------------------------------------------------------------*/
9503 /* DTMF facilities                                                  */
9504 /*------------------------------------------------------------------*/
9505
9506
9507 static struct
9508 {
9509   byte send_mask;
9510   byte listen_mask;
9511   byte character;
9512   byte code;
9513 } dtmf_digit_map[] =
9514 {
9515   { 0x01, 0x01, 0x23, DTMF_DIGIT_TONE_CODE_HASHMARK },
9516   { 0x01, 0x01, 0x2a, DTMF_DIGIT_TONE_CODE_STAR },
9517   { 0x01, 0x01, 0x30, DTMF_DIGIT_TONE_CODE_0 },
9518   { 0x01, 0x01, 0x31, DTMF_DIGIT_TONE_CODE_1 },
9519   { 0x01, 0x01, 0x32, DTMF_DIGIT_TONE_CODE_2 },
9520   { 0x01, 0x01, 0x33, DTMF_DIGIT_TONE_CODE_3 },
9521   { 0x01, 0x01, 0x34, DTMF_DIGIT_TONE_CODE_4 },
9522   { 0x01, 0x01, 0x35, DTMF_DIGIT_TONE_CODE_5 },
9523   { 0x01, 0x01, 0x36, DTMF_DIGIT_TONE_CODE_6 },
9524   { 0x01, 0x01, 0x37, DTMF_DIGIT_TONE_CODE_7 },
9525   { 0x01, 0x01, 0x38, DTMF_DIGIT_TONE_CODE_8 },
9526   { 0x01, 0x01, 0x39, DTMF_DIGIT_TONE_CODE_9 },
9527   { 0x01, 0x01, 0x41, DTMF_DIGIT_TONE_CODE_A },
9528   { 0x01, 0x01, 0x42, DTMF_DIGIT_TONE_CODE_B },
9529   { 0x01, 0x01, 0x43, DTMF_DIGIT_TONE_CODE_C },
9530   { 0x01, 0x01, 0x44, DTMF_DIGIT_TONE_CODE_D },
9531   { 0x01, 0x00, 0x61, DTMF_DIGIT_TONE_CODE_A },
9532   { 0x01, 0x00, 0x62, DTMF_DIGIT_TONE_CODE_B },
9533   { 0x01, 0x00, 0x63, DTMF_DIGIT_TONE_CODE_C },
9534   { 0x01, 0x00, 0x64, DTMF_DIGIT_TONE_CODE_D },
9535
9536   { 0x04, 0x04, 0x80, DTMF_SIGNAL_NO_TONE },
9537   { 0x00, 0x04, 0x81, DTMF_SIGNAL_UNIDENTIFIED_TONE },
9538   { 0x04, 0x04, 0x82, DTMF_SIGNAL_DIAL_TONE },
9539   { 0x04, 0x04, 0x83, DTMF_SIGNAL_PABX_INTERNAL_DIAL_TONE },
9540   { 0x04, 0x04, 0x84, DTMF_SIGNAL_SPECIAL_DIAL_TONE },
9541   { 0x04, 0x04, 0x85, DTMF_SIGNAL_SECOND_DIAL_TONE },
9542   { 0x04, 0x04, 0x86, DTMF_SIGNAL_RINGING_TONE },
9543   { 0x04, 0x04, 0x87, DTMF_SIGNAL_SPECIAL_RINGING_TONE },
9544   { 0x04, 0x04, 0x88, DTMF_SIGNAL_BUSY_TONE },
9545   { 0x04, 0x04, 0x89, DTMF_SIGNAL_CONGESTION_TONE },
9546   { 0x04, 0x04, 0x8a, DTMF_SIGNAL_SPECIAL_INFORMATION_TONE },
9547   { 0x04, 0x04, 0x8b, DTMF_SIGNAL_COMFORT_TONE },
9548   { 0x04, 0x04, 0x8c, DTMF_SIGNAL_HOLD_TONE },
9549   { 0x04, 0x04, 0x8d, DTMF_SIGNAL_RECORD_TONE },
9550   { 0x04, 0x04, 0x8e, DTMF_SIGNAL_CALLER_WAITING_TONE },
9551   { 0x04, 0x04, 0x8f, DTMF_SIGNAL_CALL_WAITING_TONE },
9552   { 0x04, 0x04, 0x90, DTMF_SIGNAL_PAY_TONE },
9553   { 0x04, 0x04, 0x91, DTMF_SIGNAL_POSITIVE_INDICATION_TONE },
9554   { 0x04, 0x04, 0x92, DTMF_SIGNAL_NEGATIVE_INDICATION_TONE },
9555   { 0x04, 0x04, 0x93, DTMF_SIGNAL_WARNING_TONE },
9556   { 0x04, 0x04, 0x94, DTMF_SIGNAL_INTRUSION_TONE },
9557   { 0x04, 0x04, 0x95, DTMF_SIGNAL_CALLING_CARD_SERVICE_TONE },
9558   { 0x04, 0x04, 0x96, DTMF_SIGNAL_PAYPHONE_RECOGNITION_TONE },
9559   { 0x04, 0x04, 0x97, DTMF_SIGNAL_CPE_ALERTING_SIGNAL },
9560   { 0x04, 0x04, 0x98, DTMF_SIGNAL_OFF_HOOK_WARNING_TONE },
9561   { 0x04, 0x04, 0xbf, DTMF_SIGNAL_INTERCEPT_TONE },
9562   { 0x04, 0x04, 0xc0, DTMF_SIGNAL_MODEM_CALLING_TONE },
9563   { 0x04, 0x04, 0xc1, DTMF_SIGNAL_FAX_CALLING_TONE },
9564   { 0x04, 0x04, 0xc2, DTMF_SIGNAL_ANSWER_TONE },
9565   { 0x04, 0x04, 0xc3, DTMF_SIGNAL_REVERSED_ANSWER_TONE },
9566   { 0x04, 0x04, 0xc4, DTMF_SIGNAL_ANSAM_TONE },
9567   { 0x04, 0x04, 0xc5, DTMF_SIGNAL_REVERSED_ANSAM_TONE },
9568   { 0x04, 0x04, 0xc6, DTMF_SIGNAL_BELL103_ANSWER_TONE },
9569   { 0x04, 0x04, 0xc7, DTMF_SIGNAL_FAX_FLAGS },
9570   { 0x04, 0x04, 0xc8, DTMF_SIGNAL_G2_FAX_GROUP_ID },
9571   { 0x00, 0x04, 0xc9, DTMF_SIGNAL_HUMAN_SPEECH },
9572   { 0x04, 0x04, 0xca, DTMF_SIGNAL_ANSWERING_MACHINE_390 },
9573   { 0x02, 0x02, 0xf1, DTMF_MF_DIGIT_TONE_CODE_1 },
9574   { 0x02, 0x02, 0xf2, DTMF_MF_DIGIT_TONE_CODE_2 },
9575   { 0x02, 0x02, 0xf3, DTMF_MF_DIGIT_TONE_CODE_3 },
9576   { 0x02, 0x02, 0xf4, DTMF_MF_DIGIT_TONE_CODE_4 },
9577   { 0x02, 0x02, 0xf5, DTMF_MF_DIGIT_TONE_CODE_5 },
9578   { 0x02, 0x02, 0xf6, DTMF_MF_DIGIT_TONE_CODE_6 },
9579   { 0x02, 0x02, 0xf7, DTMF_MF_DIGIT_TONE_CODE_7 },
9580   { 0x02, 0x02, 0xf8, DTMF_MF_DIGIT_TONE_CODE_8 },
9581   { 0x02, 0x02, 0xf9, DTMF_MF_DIGIT_TONE_CODE_9 },
9582   { 0x02, 0x02, 0xfa, DTMF_MF_DIGIT_TONE_CODE_0 },
9583   { 0x02, 0x02, 0xfb, DTMF_MF_DIGIT_TONE_CODE_K1 },
9584   { 0x02, 0x02, 0xfc, DTMF_MF_DIGIT_TONE_CODE_K2 },
9585   { 0x02, 0x02, 0xfd, DTMF_MF_DIGIT_TONE_CODE_KP },
9586   { 0x02, 0x02, 0xfe, DTMF_MF_DIGIT_TONE_CODE_S1 },
9587   { 0x02, 0x02, 0xff, DTMF_MF_DIGIT_TONE_CODE_ST },
9588
9589 };
9590
9591 #define DTMF_DIGIT_MAP_ENTRIES ARRAY_SIZE(dtmf_digit_map)
9592
9593
9594 static void dtmf_enable_receiver (PLCI   *plci, byte enable_mask)
9595 {
9596   word min_digit_duration, min_gap_duration;
9597
9598   dbug (1, dprintf ("[%06lx] %s,%d: dtmf_enable_receiver %02x",
9599     (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
9600     (char   *)(FILE_), __LINE__, enable_mask));
9601
9602   if (enable_mask != 0)
9603   {
9604     min_digit_duration = (plci->dtmf_rec_pulse_ms == 0) ? 40 : plci->dtmf_rec_pulse_ms;
9605     min_gap_duration = (plci->dtmf_rec_pause_ms == 0) ? 40 : plci->dtmf_rec_pause_ms;
9606     plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_ENABLE_RECEIVER;
9607     PUT_WORD (&plci->internal_req_buffer[1], min_digit_duration);
9608     PUT_WORD (&plci->internal_req_buffer[3], min_gap_duration);
9609     plci->NData[0].PLength = 5;
9610
9611     PUT_WORD (&plci->internal_req_buffer[5], INTERNAL_IND_BUFFER_SIZE);
9612     plci->NData[0].PLength += 2;
9613     capidtmf_recv_enable (&(plci->capidtmf_state), min_digit_duration, min_gap_duration);
9614
9615   }
9616   else
9617   {
9618     plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_DISABLE_RECEIVER;
9619     plci->NData[0].PLength = 1;
9620
9621     capidtmf_recv_disable (&(plci->capidtmf_state));
9622
9623   }
9624   plci->NData[0].P = plci->internal_req_buffer;
9625   plci->NL.X = plci->NData;
9626   plci->NL.ReqCh = 0;
9627   plci->NL.Req = plci->nl_req = (byte) N_UDATA;
9628   plci->adapter->request (&plci->NL);
9629 }
9630
9631
9632 static void dtmf_send_digits (PLCI   *plci, byte   *digit_buffer, word digit_count)
9633 {
9634   word w, i;
9635
9636   dbug (1, dprintf ("[%06lx] %s,%d: dtmf_send_digits %d",
9637     (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
9638     (char   *)(FILE_), __LINE__, digit_count));
9639
9640   plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_SEND_DIGITS;
9641   w = (plci->dtmf_send_pulse_ms == 0) ? 40 : plci->dtmf_send_pulse_ms;
9642   PUT_WORD (&plci->internal_req_buffer[1], w);
9643   w = (plci->dtmf_send_pause_ms == 0) ? 40 : plci->dtmf_send_pause_ms;
9644   PUT_WORD (&plci->internal_req_buffer[3], w);
9645   for (i = 0; i < digit_count; i++)
9646   {
9647     w = 0;
9648     while ((w < DTMF_DIGIT_MAP_ENTRIES)
9649       && (digit_buffer[i] != dtmf_digit_map[w].character))
9650     {
9651       w++;
9652     }
9653     plci->internal_req_buffer[5+i] = (w < DTMF_DIGIT_MAP_ENTRIES) ?
9654       dtmf_digit_map[w].code : DTMF_DIGIT_TONE_CODE_STAR;
9655   }
9656   plci->NData[0].PLength = 5 + digit_count;
9657   plci->NData[0].P = plci->internal_req_buffer;
9658   plci->NL.X = plci->NData;
9659   plci->NL.ReqCh = 0;
9660   plci->NL.Req = plci->nl_req = (byte) N_UDATA;
9661   plci->adapter->request (&plci->NL);
9662 }
9663
9664
9665 static void dtmf_rec_clear_config (PLCI   *plci)
9666 {
9667
9668   dbug (1, dprintf ("[%06lx] %s,%d: dtmf_rec_clear_config",
9669     (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
9670     (char   *)(FILE_), __LINE__));
9671
9672   plci->dtmf_rec_active = 0;
9673   plci->dtmf_rec_pulse_ms = 0;
9674   plci->dtmf_rec_pause_ms = 0;
9675
9676   capidtmf_init (&(plci->capidtmf_state), plci->adapter->u_law);
9677
9678 }
9679
9680
9681 static void dtmf_send_clear_config (PLCI   *plci)
9682 {
9683
9684   dbug (1, dprintf ("[%06lx] %s,%d: dtmf_send_clear_config",
9685     (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
9686     (char   *)(FILE_), __LINE__));
9687
9688   plci->dtmf_send_requests = 0;
9689   plci->dtmf_send_pulse_ms = 0;
9690   plci->dtmf_send_pause_ms = 0;
9691 }
9692
9693
9694 static void dtmf_prepare_switch (dword Id, PLCI   *plci)
9695 {
9696
9697   dbug (1, dprintf ("[%06lx] %s,%d: dtmf_prepare_switch",
9698     UnMapId (Id), (char   *)(FILE_), __LINE__));
9699
9700   while (plci->dtmf_send_requests != 0)
9701     dtmf_confirmation (Id, plci);
9702 }
9703
9704
9705 static word dtmf_save_config (dword Id, PLCI   *plci, byte Rc)
9706 {
9707
9708   dbug (1, dprintf ("[%06lx] %s,%d: dtmf_save_config %02x %d",
9709     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
9710
9711   return (GOOD);
9712 }
9713
9714
9715 static word dtmf_restore_config (dword Id, PLCI   *plci, byte Rc)
9716 {
9717   word Info;
9718
9719   dbug (1, dprintf ("[%06lx] %s,%d: dtmf_restore_config %02x %d",
9720     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
9721
9722   Info = GOOD;
9723   if (plci->B1_facilities & B1_FACILITY_DTMFR)
9724   {
9725     switch (plci->adjust_b_state)
9726     {
9727     case ADJUST_B_RESTORE_DTMF_1:
9728       plci->internal_command = plci->adjust_b_command;
9729       if (plci_nl_busy (plci))
9730       {
9731         plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
9732         break;
9733       }
9734       dtmf_enable_receiver (plci, plci->dtmf_rec_active);
9735       plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_2;
9736       break;
9737     case ADJUST_B_RESTORE_DTMF_2:
9738       if ((Rc != OK) && (Rc != OK_FC))
9739       {
9740         dbug (1, dprintf ("[%06lx] %s,%d: Reenable DTMF receiver failed %02x",
9741           UnMapId (Id), (char   *)(FILE_), __LINE__, Rc));
9742         Info = _WRONG_STATE;
9743         break;
9744       }
9745       break;
9746     }
9747   }
9748   return (Info);
9749 }
9750
9751
9752 static void dtmf_command (dword Id, PLCI   *plci, byte Rc)
9753 {
9754   word internal_command, Info;
9755   byte mask;
9756     byte result[4];
9757
9758   dbug (1, dprintf ("[%06lx] %s,%d: dtmf_command %02x %04x %04x %d %d %d %d",
9759     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->internal_command,
9760     plci->dtmf_cmd, plci->dtmf_rec_pulse_ms, plci->dtmf_rec_pause_ms,
9761     plci->dtmf_send_pulse_ms, plci->dtmf_send_pause_ms));
9762
9763   Info = GOOD;
9764   result[0] = 2;
9765   PUT_WORD (&result[1], DTMF_SUCCESS);
9766   internal_command = plci->internal_command;
9767   plci->internal_command = 0;
9768   mask = 0x01;
9769   switch (plci->dtmf_cmd)
9770   {
9771
9772   case DTMF_LISTEN_TONE_START:
9773     mask <<= 1;
9774   case DTMF_LISTEN_MF_START:
9775     mask <<= 1;
9776
9777   case DTMF_LISTEN_START:
9778     switch (internal_command)
9779     {
9780     default:
9781       adjust_b1_resource (Id, plci, NULL, (word)(plci->B1_facilities |
9782         B1_FACILITY_DTMFR), DTMF_COMMAND_1);
9783     case DTMF_COMMAND_1:
9784       if (adjust_b_process (Id, plci, Rc) != GOOD)
9785       {
9786         dbug (1, dprintf ("[%06lx] %s,%d: Load DTMF failed",
9787           UnMapId (Id), (char   *)(FILE_), __LINE__));
9788         Info = _FACILITY_NOT_SUPPORTED;
9789         break;
9790       }
9791       if (plci->internal_command)
9792         return;
9793     case DTMF_COMMAND_2:
9794       if (plci_nl_busy (plci))
9795       {
9796         plci->internal_command = DTMF_COMMAND_2;
9797         return;
9798       }
9799       plci->internal_command = DTMF_COMMAND_3;
9800       dtmf_enable_receiver (plci, (byte)(plci->dtmf_rec_active | mask));
9801       return;
9802     case DTMF_COMMAND_3:
9803       if ((Rc != OK) && (Rc != OK_FC))
9804       {
9805         dbug (1, dprintf ("[%06lx] %s,%d: Enable DTMF receiver failed %02x",
9806           UnMapId (Id), (char   *)(FILE_), __LINE__, Rc));
9807         Info = _FACILITY_NOT_SUPPORTED;
9808         break;
9809       }
9810
9811       plci->tone_last_indication_code = DTMF_SIGNAL_NO_TONE;
9812
9813       plci->dtmf_rec_active |= mask;
9814       break;
9815     }
9816     break;
9817
9818
9819   case DTMF_LISTEN_TONE_STOP:
9820     mask <<= 1;
9821   case DTMF_LISTEN_MF_STOP:
9822     mask <<= 1;
9823
9824   case DTMF_LISTEN_STOP:
9825     switch (internal_command)
9826     {
9827     default:
9828       plci->dtmf_rec_active &= ~mask;
9829       if (plci->dtmf_rec_active)
9830         break;
9831 /*
9832     case DTMF_COMMAND_1:
9833       if (plci->dtmf_rec_active)
9834       {
9835         if (plci_nl_busy (plci))
9836         {
9837           plci->internal_command = DTMF_COMMAND_1;
9838           return;
9839         }
9840         plci->dtmf_rec_active &= ~mask;
9841         plci->internal_command = DTMF_COMMAND_2;
9842         dtmf_enable_receiver (plci, false);
9843         return;
9844       }
9845       Rc = OK;
9846     case DTMF_COMMAND_2:
9847       if ((Rc != OK) && (Rc != OK_FC))
9848       {
9849         dbug (1, dprintf ("[%06lx] %s,%d: Disable DTMF receiver failed %02x",
9850           UnMapId (Id), (char far *)(FILE_), __LINE__, Rc));
9851         Info = _FACILITY_NOT_SUPPORTED;
9852         break;
9853       }
9854 */
9855       adjust_b1_resource (Id, plci, NULL, (word)(plci->B1_facilities &
9856         ~(B1_FACILITY_DTMFX | B1_FACILITY_DTMFR)), DTMF_COMMAND_3);
9857     case DTMF_COMMAND_3:
9858       if (adjust_b_process (Id, plci, Rc) != GOOD)
9859       {
9860         dbug (1, dprintf ("[%06lx] %s,%d: Unload DTMF failed",
9861           UnMapId (Id), (char   *)(FILE_), __LINE__));
9862         Info = _FACILITY_NOT_SUPPORTED;
9863         break;
9864       }
9865       if (plci->internal_command)
9866         return;
9867       break;
9868     }
9869     break;
9870
9871
9872   case DTMF_SEND_TONE:
9873     mask <<= 1;
9874   case DTMF_SEND_MF:
9875     mask <<= 1;
9876
9877   case DTMF_DIGITS_SEND:
9878     switch (internal_command)
9879     {
9880     default:
9881       adjust_b1_resource (Id, plci, NULL, (word)(plci->B1_facilities |
9882         ((plci->dtmf_parameter_length != 0) ? B1_FACILITY_DTMFX | B1_FACILITY_DTMFR : B1_FACILITY_DTMFX)),
9883         DTMF_COMMAND_1);
9884     case DTMF_COMMAND_1:
9885       if (adjust_b_process (Id, plci, Rc) != GOOD)
9886       {
9887         dbug (1, dprintf ("[%06lx] %s,%d: Load DTMF failed",
9888           UnMapId (Id), (char   *)(FILE_), __LINE__));
9889         Info = _FACILITY_NOT_SUPPORTED;
9890         break;
9891       }
9892       if (plci->internal_command)
9893         return;
9894     case DTMF_COMMAND_2:
9895       if (plci_nl_busy (plci))
9896       {
9897         plci->internal_command = DTMF_COMMAND_2;
9898         return;
9899       }
9900       plci->dtmf_msg_number_queue[(plci->dtmf_send_requests)++] = plci->number;
9901       plci->internal_command = DTMF_COMMAND_3;
9902       dtmf_send_digits (plci, &plci->saved_msg.parms[3].info[1], plci->saved_msg.parms[3].length);
9903       return;
9904     case DTMF_COMMAND_3:
9905       if ((Rc != OK) && (Rc != OK_FC))
9906       {
9907         dbug (1, dprintf ("[%06lx] %s,%d: Send DTMF digits failed %02x",
9908           UnMapId (Id), (char   *)(FILE_), __LINE__, Rc));
9909         if (plci->dtmf_send_requests != 0)
9910           (plci->dtmf_send_requests)--;
9911         Info = _FACILITY_NOT_SUPPORTED;
9912         break;
9913       }
9914       return;
9915     }
9916     break;
9917   }
9918   sendf (plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->number,
9919     "wws", Info, SELECTOR_DTMF, result);
9920 }
9921
9922
9923 static byte dtmf_request (dword Id, word Number, DIVA_CAPI_ADAPTER   *a, PLCI   *plci, APPL   *appl, API_PARSE *msg)
9924 {
9925   word Info;
9926   word i, j;
9927   byte mask;
9928     API_PARSE dtmf_parms[5];
9929     byte result[40];
9930
9931   dbug (1, dprintf ("[%06lx] %s,%d: dtmf_request",
9932     UnMapId (Id), (char   *)(FILE_), __LINE__));
9933
9934   Info = GOOD;
9935   result[0] = 2;
9936   PUT_WORD (&result[1], DTMF_SUCCESS);
9937   if (!(a->profile.Global_Options & GL_DTMF_SUPPORTED))
9938   {
9939     dbug (1, dprintf ("[%06lx] %s,%d: Facility not supported",
9940       UnMapId (Id), (char   *)(FILE_), __LINE__));
9941     Info = _FACILITY_NOT_SUPPORTED;
9942   }
9943   else if (api_parse (&msg[1].info[1], msg[1].length, "w", dtmf_parms))
9944   {
9945     dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
9946       UnMapId (Id), (char   *)(FILE_), __LINE__));
9947     Info = _WRONG_MESSAGE_FORMAT;
9948   }
9949
9950   else if ((GET_WORD (dtmf_parms[0].info) == DTMF_GET_SUPPORTED_DETECT_CODES)
9951     || (GET_WORD (dtmf_parms[0].info) == DTMF_GET_SUPPORTED_SEND_CODES))
9952   {
9953     if (!((a->requested_options_table[appl->Id-1])
9954         & (1L << PRIVATE_DTMF_TONE)))
9955     {
9956       dbug (1, dprintf ("[%06lx] %s,%d: DTMF unknown request %04x",
9957         UnMapId (Id), (char   *)(FILE_), __LINE__, GET_WORD (dtmf_parms[0].info)));
9958       PUT_WORD (&result[1], DTMF_UNKNOWN_REQUEST);
9959     }
9960     else
9961     {
9962       for (i = 0; i < 32; i++)
9963         result[4 + i] = 0;
9964       if (GET_WORD (dtmf_parms[0].info) == DTMF_GET_SUPPORTED_DETECT_CODES)
9965       {
9966         for (i = 0; i < DTMF_DIGIT_MAP_ENTRIES; i++)
9967         {
9968           if (dtmf_digit_map[i].listen_mask != 0)
9969             result[4 + (dtmf_digit_map[i].character >> 3)] |= (1 << (dtmf_digit_map[i].character & 0x7));
9970         }
9971       }
9972       else
9973       {
9974         for (i = 0; i < DTMF_DIGIT_MAP_ENTRIES; i++)
9975         {
9976           if (dtmf_digit_map[i].send_mask != 0)
9977             result[4 + (dtmf_digit_map[i].character >> 3)] |= (1 << (dtmf_digit_map[i].character & 0x7));
9978         }
9979       }
9980       result[0] = 3 + 32;
9981       result[3] = 32;
9982     }
9983   }
9984
9985   else if (plci == NULL)
9986   {
9987     dbug (1, dprintf ("[%06lx] %s,%d: Wrong PLCI",
9988       UnMapId (Id), (char   *)(FILE_), __LINE__));
9989     Info = _WRONG_IDENTIFIER;
9990   }
9991   else
9992   {
9993     if (!plci->State
9994      || !plci->NL.Id || plci->nl_remove_id)
9995     {
9996       dbug (1, dprintf ("[%06lx] %s,%d: Wrong state",
9997         UnMapId (Id), (char   *)(FILE_), __LINE__));
9998       Info = _WRONG_STATE;
9999     }
10000     else
10001     {
10002       plci->command = 0;
10003       plci->dtmf_cmd = GET_WORD (dtmf_parms[0].info);
10004       mask = 0x01;
10005       switch (plci->dtmf_cmd)
10006       {
10007
10008       case DTMF_LISTEN_TONE_START:
10009       case DTMF_LISTEN_TONE_STOP:
10010         mask <<= 1;
10011       case DTMF_LISTEN_MF_START:
10012       case DTMF_LISTEN_MF_STOP:
10013         mask <<= 1;
10014         if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[appl->Id-1])
10015           & (1L << PRIVATE_DTMF_TONE)))
10016         {
10017           dbug (1, dprintf ("[%06lx] %s,%d: DTMF unknown request %04x",
10018             UnMapId (Id), (char   *)(FILE_), __LINE__, GET_WORD (dtmf_parms[0].info)));
10019           PUT_WORD (&result[1], DTMF_UNKNOWN_REQUEST);
10020           break;
10021         }
10022
10023       case DTMF_LISTEN_START:
10024       case DTMF_LISTEN_STOP:
10025         if (!(a->manufacturer_features & MANUFACTURER_FEATURE_HARDDTMF)
10026          && !(a->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE))
10027         {
10028           dbug (1, dprintf ("[%06lx] %s,%d: Facility not supported",
10029             UnMapId (Id), (char   *)(FILE_), __LINE__));
10030           Info = _FACILITY_NOT_SUPPORTED;
10031           break;
10032         }
10033         if (mask & DTMF_LISTEN_ACTIVE_FLAG)
10034         {
10035           if (api_parse (&msg[1].info[1], msg[1].length, "wwws", dtmf_parms))
10036           {
10037             plci->dtmf_rec_pulse_ms = 0;
10038             plci->dtmf_rec_pause_ms = 0;
10039           }
10040           else
10041           {
10042             plci->dtmf_rec_pulse_ms = GET_WORD (dtmf_parms[1].info);
10043             plci->dtmf_rec_pause_ms = GET_WORD (dtmf_parms[2].info);
10044           }
10045         }
10046         start_internal_command (Id, plci, dtmf_command);
10047         return (false);
10048
10049
10050       case DTMF_SEND_TONE:
10051         mask <<= 1;
10052       case DTMF_SEND_MF:
10053         mask <<= 1;
10054         if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[appl->Id-1])
10055           & (1L << PRIVATE_DTMF_TONE)))
10056         {
10057           dbug (1, dprintf ("[%06lx] %s,%d: DTMF unknown request %04x",
10058             UnMapId (Id), (char   *)(FILE_), __LINE__, GET_WORD (dtmf_parms[0].info)));
10059           PUT_WORD (&result[1], DTMF_UNKNOWN_REQUEST);
10060           break;
10061         }
10062
10063       case DTMF_DIGITS_SEND:
10064         if (api_parse (&msg[1].info[1], msg[1].length, "wwws", dtmf_parms))
10065         {
10066           dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
10067             UnMapId (Id), (char   *)(FILE_), __LINE__));
10068           Info = _WRONG_MESSAGE_FORMAT;
10069           break;
10070         }
10071         if (mask & DTMF_LISTEN_ACTIVE_FLAG)
10072         {
10073           plci->dtmf_send_pulse_ms = GET_WORD (dtmf_parms[1].info);
10074           plci->dtmf_send_pause_ms = GET_WORD (dtmf_parms[2].info);
10075         }
10076         i = 0;
10077         j = 0;
10078         while ((i < dtmf_parms[3].length) && (j < DTMF_DIGIT_MAP_ENTRIES))
10079         {
10080           j = 0;
10081           while ((j < DTMF_DIGIT_MAP_ENTRIES)
10082             && ((dtmf_parms[3].info[i+1] != dtmf_digit_map[j].character)
10083              || ((dtmf_digit_map[j].send_mask & mask) == 0)))
10084           {
10085             j++;
10086           }
10087           i++;
10088         }
10089         if (j == DTMF_DIGIT_MAP_ENTRIES)
10090         {
10091           dbug (1, dprintf ("[%06lx] %s,%d: Incorrect DTMF digit %02x",
10092             UnMapId (Id), (char   *)(FILE_), __LINE__, dtmf_parms[3].info[i]));
10093           PUT_WORD (&result[1], DTMF_INCORRECT_DIGIT);
10094           break;
10095         }
10096         if (plci->dtmf_send_requests >= ARRAY_SIZE(plci->dtmf_msg_number_queue))
10097         {
10098           dbug (1, dprintf ("[%06lx] %s,%d: DTMF request overrun",
10099             UnMapId (Id), (char   *)(FILE_), __LINE__));
10100           Info = _WRONG_STATE;
10101           break;
10102         }
10103         api_save_msg (dtmf_parms, "wwws", &plci->saved_msg);
10104         start_internal_command (Id, plci, dtmf_command);
10105         return (false);
10106
10107       default:
10108         dbug (1, dprintf ("[%06lx] %s,%d: DTMF unknown request %04x",
10109           UnMapId (Id), (char   *)(FILE_), __LINE__, plci->dtmf_cmd));
10110         PUT_WORD (&result[1], DTMF_UNKNOWN_REQUEST);
10111       }
10112     }
10113   }
10114   sendf (appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
10115     "wws", Info, SELECTOR_DTMF, result);
10116   return (false);
10117 }
10118
10119
10120 static void dtmf_confirmation (dword Id, PLCI   *plci)
10121 {
10122   word Info;
10123   word i;
10124     byte result[4];
10125
10126   dbug (1, dprintf ("[%06lx] %s,%d: dtmf_confirmation",
10127     UnMapId (Id), (char   *)(FILE_), __LINE__));
10128
10129   Info = GOOD;
10130   result[0] = 2;
10131   PUT_WORD (&result[1], DTMF_SUCCESS);
10132   if (plci->dtmf_send_requests != 0)
10133   {
10134     sendf (plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->dtmf_msg_number_queue[0],
10135       "wws", GOOD, SELECTOR_DTMF, result);
10136     (plci->dtmf_send_requests)--;
10137     for (i = 0; i < plci->dtmf_send_requests; i++)
10138       plci->dtmf_msg_number_queue[i] = plci->dtmf_msg_number_queue[i+1];
10139   }
10140 }
10141
10142
10143 static void dtmf_indication (dword Id, PLCI   *plci, byte   *msg, word length)
10144 {
10145   word i, j, n;
10146
10147   dbug (1, dprintf ("[%06lx] %s,%d: dtmf_indication",
10148     UnMapId (Id), (char   *)(FILE_), __LINE__));
10149
10150   n = 0;
10151   for (i = 1; i < length; i++)
10152   {
10153     j = 0;
10154     while ((j < DTMF_DIGIT_MAP_ENTRIES)
10155       && ((msg[i] != dtmf_digit_map[j].code)
10156        || ((dtmf_digit_map[j].listen_mask & plci->dtmf_rec_active) == 0)))
10157     {
10158       j++;
10159     }
10160     if (j < DTMF_DIGIT_MAP_ENTRIES)
10161     {
10162
10163       if ((dtmf_digit_map[j].listen_mask & DTMF_TONE_LISTEN_ACTIVE_FLAG)
10164        && (plci->tone_last_indication_code == DTMF_SIGNAL_NO_TONE)
10165        && (dtmf_digit_map[j].character != DTMF_SIGNAL_UNIDENTIFIED_TONE))
10166       {
10167         if (n + 1 == i)
10168         {
10169           for (i = length; i > n + 1; i--)
10170             msg[i] = msg[i - 1];
10171           length++;
10172           i++;
10173         }
10174         msg[++n] = DTMF_SIGNAL_UNIDENTIFIED_TONE;
10175       }
10176       plci->tone_last_indication_code = dtmf_digit_map[j].character;
10177
10178       msg[++n] = dtmf_digit_map[j].character;
10179     }
10180   }
10181   if (n != 0)
10182   {
10183     msg[0] = (byte) n;
10184     sendf (plci->appl, _FACILITY_I, Id & 0xffffL, 0, "wS", SELECTOR_DTMF, msg);
10185   }
10186 }
10187
10188
10189 /*------------------------------------------------------------------*/
10190 /* DTMF parameters                                                  */
10191 /*------------------------------------------------------------------*/
10192
10193 static void dtmf_parameter_write (PLCI   *plci)
10194 {
10195   word i;
10196     byte parameter_buffer[DTMF_PARAMETER_BUFFER_SIZE + 2];
10197
10198   dbug (1, dprintf ("[%06lx] %s,%d: dtmf_parameter_write",
10199     (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
10200     (char   *)(FILE_), __LINE__));
10201
10202   parameter_buffer[0] = plci->dtmf_parameter_length + 1;
10203   parameter_buffer[1] = DSP_CTRL_SET_DTMF_PARAMETERS;
10204   for (i = 0; i < plci->dtmf_parameter_length; i++)
10205     parameter_buffer[2+i] = plci->dtmf_parameter_buffer[i];
10206   add_p (plci, FTY, parameter_buffer);
10207   sig_req (plci, TEL_CTRL, 0);
10208   send_req (plci);
10209 }
10210
10211
10212 static void dtmf_parameter_clear_config (PLCI   *plci)
10213 {
10214
10215   dbug (1, dprintf ("[%06lx] %s,%d: dtmf_parameter_clear_config",
10216     (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
10217     (char   *)(FILE_), __LINE__));
10218
10219   plci->dtmf_parameter_length = 0;
10220 }
10221
10222
10223 static void dtmf_parameter_prepare_switch (dword Id, PLCI   *plci)
10224 {
10225
10226   dbug (1, dprintf ("[%06lx] %s,%d: dtmf_parameter_prepare_switch",
10227     UnMapId (Id), (char   *)(FILE_), __LINE__));
10228
10229 }
10230
10231
10232 static word dtmf_parameter_save_config (dword Id, PLCI   *plci, byte Rc)
10233 {
10234
10235   dbug (1, dprintf ("[%06lx] %s,%d: dtmf_parameter_save_config %02x %d",
10236     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
10237
10238   return (GOOD);
10239 }
10240
10241
10242 static word dtmf_parameter_restore_config (dword Id, PLCI   *plci, byte Rc)
10243 {
10244   word Info;
10245
10246   dbug (1, dprintf ("[%06lx] %s,%d: dtmf_parameter_restore_config %02x %d",
10247     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
10248
10249   Info = GOOD;
10250   if ((plci->B1_facilities & B1_FACILITY_DTMFR)
10251    && (plci->dtmf_parameter_length != 0))
10252   {
10253     switch (plci->adjust_b_state)
10254     {
10255     case ADJUST_B_RESTORE_DTMF_PARAMETER_1:
10256       plci->internal_command = plci->adjust_b_command;
10257       if (plci->sig_req)
10258       {
10259         plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_1;
10260         break;
10261       }
10262       dtmf_parameter_write (plci);
10263       plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_2;
10264       break;
10265     case ADJUST_B_RESTORE_DTMF_PARAMETER_2:
10266       if ((Rc != OK) && (Rc != OK_FC))
10267       {
10268         dbug (1, dprintf ("[%06lx] %s,%d: Restore DTMF parameters failed %02x",
10269           UnMapId (Id), (char   *)(FILE_), __LINE__, Rc));
10270         Info = _WRONG_STATE;
10271         break;
10272       }
10273       break;
10274     }
10275   }
10276   return (Info);
10277 }
10278
10279
10280 /*------------------------------------------------------------------*/
10281 /* Line interconnect facilities                                     */
10282 /*------------------------------------------------------------------*/
10283
10284
10285 LI_CONFIG   *li_config_table;
10286 word li_total_channels;
10287
10288
10289 /*------------------------------------------------------------------*/
10290 /* translate a CHI information element to a channel number          */
10291 /* returns 0xff - any channel                                       */
10292 /*         0xfe - chi wrong coding                                  */
10293 /*         0xfd - D-channel                                         */
10294 /*         0x00 - no channel                                        */
10295 /*         else channel number / PRI: timeslot                      */
10296 /* if channels is provided we accept more than one channel.         */
10297 /*------------------------------------------------------------------*/
10298
10299 static byte chi_to_channel (byte   *chi, dword *pchannelmap)
10300 {
10301   int p;
10302   int i;
10303   dword map;
10304   byte excl;
10305   byte ofs;
10306   byte ch;
10307
10308   if (pchannelmap) *pchannelmap = 0;
10309   if(!chi[0]) return 0xff;
10310   excl = 0;
10311
10312   if(chi[1] & 0x20) {
10313     if(chi[0]==1 && chi[1]==0xac) return 0xfd; /* exclusive d-channel */
10314     for(i=1; i<chi[0] && !(chi[i] &0x80); i++);
10315     if(i==chi[0] || !(chi[i] &0x80)) return 0xfe;
10316     if((chi[1] |0xc8)!=0xe9) return 0xfe;
10317     if(chi[1] &0x08) excl = 0x40;
10318
10319         /* int. id present */
10320     if(chi[1] &0x40) {
10321       p=i+1;
10322       for(i=p; i<chi[0] && !(chi[i] &0x80); i++);
10323       if(i==chi[0] || !(chi[i] &0x80)) return 0xfe;
10324     }
10325
10326         /* coding standard, Number/Map, Channel Type */
10327     p=i+1;
10328     for(i=p; i<chi[0] && !(chi[i] &0x80); i++);
10329     if(i==chi[0] || !(chi[i] &0x80)) return 0xfe;
10330     if((chi[p]|0xd0)!=0xd3) return 0xfe;
10331
10332         /* Number/Map */
10333     if(chi[p] &0x10) {
10334
10335         /* map */
10336       if((chi[0]-p)==4) ofs = 0;
10337       else if((chi[0]-p)==3) ofs = 1;
10338       else return 0xfe;
10339       ch = 0;
10340       map = 0;
10341       for(i=0; i<4 && p<chi[0]; i++) {
10342         p++;
10343         ch += 8;
10344         map <<= 8;
10345         if(chi[p]) {
10346           for (ch=0; !(chi[p] & (1 << ch)); ch++);
10347           map |= chi[p];
10348         }
10349       }
10350       ch += ofs;
10351       map <<= ofs;
10352     }
10353     else {
10354
10355         /* number */
10356       p=i+1;
10357       ch = chi[p] &0x3f;
10358       if(pchannelmap) {
10359         if((byte)(chi[0]-p)>30) return 0xfe;
10360         map = 0;
10361         for(i=p; i<=chi[0]; i++) {
10362           if ((chi[i] &0x7f) > 31) return 0xfe;
10363           map |= (1L << (chi[i] &0x7f));
10364         }
10365       }
10366       else {
10367         if(p!=chi[0]) return 0xfe;
10368         if (ch > 31) return 0xfe;
10369         map = (1L << ch);
10370       }
10371       if(chi[p] &0x40) return 0xfe;
10372     }
10373     if (pchannelmap) *pchannelmap = map;
10374     else if (map != ((dword)(1L << ch))) return 0xfe;
10375     return (byte)(excl | ch);
10376   }
10377   else {  /* not PRI */
10378     for(i=1; i<chi[0] && !(chi[i] &0x80); i++);
10379     if(i!=chi[0] || !(chi[i] &0x80)) return 0xfe;
10380     if(chi[1] &0x08) excl = 0x40;
10381
10382     switch(chi[1] |0x98) {
10383     case 0x98: return 0;
10384     case 0x99:
10385       if (pchannelmap) *pchannelmap = 2;
10386       return excl |1;
10387     case 0x9a:
10388       if (pchannelmap) *pchannelmap = 4;
10389       return excl |2;
10390     case 0x9b: return 0xff;
10391     case 0x9c: return 0xfd; /* d-ch */
10392     default: return 0xfe;
10393     }
10394   }
10395 }
10396
10397
10398 static void mixer_set_bchannel_id_esc (PLCI   *plci, byte bchannel_id)
10399 {
10400   DIVA_CAPI_ADAPTER   *a;
10401   PLCI   *splci;
10402   byte old_id;
10403
10404   a = plci->adapter;
10405   old_id = plci->li_bchannel_id;
10406   if (a->li_pri)
10407   {
10408     if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10409       li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10410     plci->li_bchannel_id = (bchannel_id & 0x1f) + 1;
10411     if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10412       li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10413   }
10414   else
10415   {
10416     if (((bchannel_id & 0x03) == 1) || ((bchannel_id & 0x03) == 2))
10417     {
10418       if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10419         li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10420       plci->li_bchannel_id = bchannel_id & 0x03;
10421       if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI != plci) && (a->AdvSignalPLCI->tel == ADV_VOICE))
10422       {
10423         splci = a->AdvSignalPLCI;
10424         if (li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci == NULL)
10425         {
10426           if ((splci->li_bchannel_id != 0)
10427            && (li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci == splci))
10428           {
10429             li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci = NULL;
10430           }
10431           splci->li_bchannel_id = 3 - plci->li_bchannel_id;
10432           li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci = splci;
10433           dbug (1, dprintf ("[%06lx] %s,%d: adv_voice_set_bchannel_id_esc %d",
10434             (dword)((splci->Id << 8) | UnMapController (splci->adapter->Id)),
10435             (char   *)(FILE_), __LINE__, splci->li_bchannel_id));
10436         }
10437       }
10438       if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10439         li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10440     }
10441   }
10442   if ((old_id == 0) && (plci->li_bchannel_id != 0)
10443    && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
10444   {
10445     mixer_clear_config (plci);
10446   }
10447   dbug (1, dprintf ("[%06lx] %s,%d: mixer_set_bchannel_id_esc %d %d",
10448     (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
10449     (char   *)(FILE_), __LINE__, bchannel_id, plci->li_bchannel_id));
10450 }
10451
10452
10453 static void mixer_set_bchannel_id (PLCI   *plci, byte   *chi)
10454 {
10455   DIVA_CAPI_ADAPTER   *a;
10456   PLCI   *splci;
10457   byte ch, old_id;
10458
10459   a = plci->adapter;
10460   old_id = plci->li_bchannel_id;
10461   ch = chi_to_channel (chi, NULL);
10462   if (!(ch & 0x80))
10463   {
10464     if (a->li_pri)
10465     {
10466       if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10467         li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10468       plci->li_bchannel_id = (ch & 0x1f) + 1;
10469       if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10470         li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10471     }
10472     else
10473     {
10474       if (((ch & 0x1f) == 1) || ((ch & 0x1f) == 2))
10475       {
10476         if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10477           li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10478         plci->li_bchannel_id = ch & 0x1f;
10479         if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI != plci) && (a->AdvSignalPLCI->tel == ADV_VOICE))
10480         {
10481           splci = a->AdvSignalPLCI;
10482           if (li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci == NULL)
10483           {
10484             if ((splci->li_bchannel_id != 0)
10485              && (li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci == splci))
10486             {
10487               li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci = NULL;
10488             }
10489             splci->li_bchannel_id = 3 - plci->li_bchannel_id;
10490             li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci = splci;
10491             dbug (1, dprintf ("[%06lx] %s,%d: adv_voice_set_bchannel_id %d",
10492               (dword)((splci->Id << 8) | UnMapController (splci->adapter->Id)),
10493               (char   *)(FILE_), __LINE__, splci->li_bchannel_id));
10494           }
10495         }
10496         if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10497           li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10498       }
10499     }
10500   }
10501   if ((old_id == 0) && (plci->li_bchannel_id != 0)
10502    && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
10503   {
10504     mixer_clear_config (plci);
10505   }
10506   dbug (1, dprintf ("[%06lx] %s,%d: mixer_set_bchannel_id %02x %d",
10507     (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
10508     (char   *)(FILE_), __LINE__, ch, plci->li_bchannel_id));
10509 }
10510
10511
10512 #define MIXER_MAX_DUMP_CHANNELS 34
10513
10514 static void mixer_calculate_coefs (DIVA_CAPI_ADAPTER   *a)
10515 {
10516 static char hex_digit_table[0x10] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
10517   word n, i, j;
10518   char *p;
10519     char hex_line[2 * MIXER_MAX_DUMP_CHANNELS + MIXER_MAX_DUMP_CHANNELS / 8 + 4];
10520
10521   dbug (1, dprintf ("[%06lx] %s,%d: mixer_calculate_coefs",
10522     (dword)(UnMapController (a->Id)), (char   *)(FILE_), __LINE__));
10523
10524   for (i = 0; i < li_total_channels; i++)
10525   {
10526     li_config_table[i].channel &= LI_CHANNEL_ADDRESSES_SET;
10527     if (li_config_table[i].chflags != 0)
10528       li_config_table[i].channel |= LI_CHANNEL_INVOLVED;
10529     else
10530     {
10531       for (j = 0; j < li_total_channels; j++)
10532       {
10533         if (((li_config_table[i].flag_table[j]) != 0)
10534          || ((li_config_table[j].flag_table[i]) != 0))
10535         {
10536           li_config_table[i].channel |= LI_CHANNEL_INVOLVED;
10537         }
10538         if (((li_config_table[i].flag_table[j] & LI_FLAG_CONFERENCE) != 0)
10539          || ((li_config_table[j].flag_table[i] & LI_FLAG_CONFERENCE) != 0))
10540         {
10541           li_config_table[i].channel |= LI_CHANNEL_CONFERENCE;
10542         }
10543       }
10544     }
10545   }
10546   for (i = 0; i < li_total_channels; i++)
10547   {
10548     for (j = 0; j < li_total_channels; j++)
10549     {
10550       li_config_table[i].coef_table[j] &= ~(LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC);
10551       if (li_config_table[i].flag_table[j] & LI_FLAG_CONFERENCE)
10552         li_config_table[i].coef_table[j] |= LI_COEF_CH_CH;
10553     }
10554   }
10555   for (n = 0; n < li_total_channels; n++)
10556   {
10557     if (li_config_table[n].channel & LI_CHANNEL_CONFERENCE)
10558     {
10559       for (i = 0; i < li_total_channels; i++)
10560       {
10561         if (li_config_table[i].channel & LI_CHANNEL_CONFERENCE)
10562         {
10563           for (j = 0; j < li_total_channels; j++)
10564           {
10565             li_config_table[i].coef_table[j] |=
10566               li_config_table[i].coef_table[n] & li_config_table[n].coef_table[j];
10567           }
10568         }
10569       }
10570     }
10571   }
10572   for (i = 0; i < li_total_channels; i++)
10573   {
10574     if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10575     {
10576       li_config_table[i].coef_table[i] &= ~LI_COEF_CH_CH;
10577       for (j = 0; j < li_total_channels; j++)
10578       {
10579         if (li_config_table[i].coef_table[j] & LI_COEF_CH_CH)
10580           li_config_table[i].flag_table[j] |= LI_FLAG_CONFERENCE;
10581       }
10582       if (li_config_table[i].flag_table[i] & LI_FLAG_CONFERENCE)
10583         li_config_table[i].coef_table[i] |= LI_COEF_CH_CH;
10584     }
10585   }
10586   for (i = 0; i < li_total_channels; i++)
10587   {
10588     if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10589     {
10590       for (j = 0; j < li_total_channels; j++)
10591       {
10592         if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
10593           li_config_table[i].coef_table[j] |= LI_COEF_CH_CH;
10594         if (li_config_table[i].flag_table[j] & LI_FLAG_MONITOR)
10595           li_config_table[i].coef_table[j] |= LI_COEF_CH_PC;
10596         if (li_config_table[i].flag_table[j] & LI_FLAG_MIX)
10597           li_config_table[i].coef_table[j] |= LI_COEF_PC_CH;
10598         if (li_config_table[i].flag_table[j] & LI_FLAG_PCCONNECT)
10599           li_config_table[i].coef_table[j] |= LI_COEF_PC_PC;
10600       }
10601       if (li_config_table[i].chflags & LI_CHFLAG_MONITOR)
10602       {
10603         for (j = 0; j < li_total_channels; j++)
10604         {
10605           if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
10606           {
10607             li_config_table[i].coef_table[j] |= LI_COEF_CH_PC;
10608             if (li_config_table[j].chflags & LI_CHFLAG_MIX)
10609               li_config_table[i].coef_table[j] |= LI_COEF_PC_CH | LI_COEF_PC_PC;
10610           }
10611         }
10612       }
10613       if (li_config_table[i].chflags & LI_CHFLAG_MIX)
10614       {
10615         for (j = 0; j < li_total_channels; j++)
10616         {
10617           if (li_config_table[j].flag_table[i] & LI_FLAG_INTERCONNECT)
10618             li_config_table[j].coef_table[i] |= LI_COEF_PC_CH;
10619         }
10620       }
10621       if (li_config_table[i].chflags & LI_CHFLAG_LOOP)
10622       {
10623         for (j = 0; j < li_total_channels; j++)
10624         {
10625           if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
10626           {
10627             for (n = 0; n < li_total_channels; n++)
10628             {
10629               if (li_config_table[n].flag_table[i] & LI_FLAG_INTERCONNECT)
10630               {
10631                 li_config_table[n].coef_table[j] |= LI_COEF_CH_CH;
10632                 if (li_config_table[j].chflags & LI_CHFLAG_MIX)
10633                 {
10634                   li_config_table[n].coef_table[j] |= LI_COEF_PC_CH;
10635                   if (li_config_table[n].chflags & LI_CHFLAG_MONITOR)
10636                     li_config_table[n].coef_table[j] |= LI_COEF_CH_PC | LI_COEF_PC_PC;
10637                 }
10638                 else if (li_config_table[n].chflags & LI_CHFLAG_MONITOR)
10639                   li_config_table[n].coef_table[j] |= LI_COEF_CH_PC;
10640               }
10641             }
10642           }
10643         }
10644       }
10645     }
10646   }
10647   for (i = 0; i < li_total_channels; i++)
10648   {
10649     if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10650     {
10651       if (li_config_table[i].chflags & (LI_CHFLAG_MONITOR | LI_CHFLAG_MIX | LI_CHFLAG_LOOP))
10652         li_config_table[i].channel |= LI_CHANNEL_ACTIVE;
10653       if (li_config_table[i].chflags & LI_CHFLAG_MONITOR)
10654         li_config_table[i].channel |= LI_CHANNEL_RX_DATA;
10655       if (li_config_table[i].chflags & LI_CHFLAG_MIX)
10656         li_config_table[i].channel |= LI_CHANNEL_TX_DATA;
10657       for (j = 0; j < li_total_channels; j++)
10658       {
10659         if ((li_config_table[i].flag_table[j] &
10660           (LI_FLAG_INTERCONNECT | LI_FLAG_PCCONNECT | LI_FLAG_CONFERENCE | LI_FLAG_MONITOR))
10661          || (li_config_table[j].flag_table[i] &
10662           (LI_FLAG_INTERCONNECT | LI_FLAG_PCCONNECT | LI_FLAG_CONFERENCE | LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX)))
10663         {
10664           li_config_table[i].channel |= LI_CHANNEL_ACTIVE;
10665         }
10666         if (li_config_table[i].flag_table[j] & (LI_FLAG_PCCONNECT | LI_FLAG_MONITOR))
10667           li_config_table[i].channel |= LI_CHANNEL_RX_DATA;
10668         if (li_config_table[j].flag_table[i] & (LI_FLAG_PCCONNECT | LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX))
10669           li_config_table[i].channel |= LI_CHANNEL_TX_DATA;
10670       }
10671       if (!(li_config_table[i].channel & LI_CHANNEL_ACTIVE))
10672       {
10673         li_config_table[i].coef_table[i] |= LI_COEF_PC_CH | LI_COEF_CH_PC;
10674         li_config_table[i].channel |= LI_CHANNEL_TX_DATA | LI_CHANNEL_RX_DATA;
10675       }
10676     }
10677   }
10678   for (i = 0; i < li_total_channels; i++)
10679   {
10680     if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10681     {
10682       j = 0;
10683       while ((j < li_total_channels) && !(li_config_table[i].flag_table[j] & LI_FLAG_ANNOUNCEMENT))
10684         j++;
10685       if (j < li_total_channels)
10686       {
10687         for (j = 0; j < li_total_channels; j++)
10688         {
10689           li_config_table[i].coef_table[j] &= ~(LI_COEF_CH_CH | LI_COEF_PC_CH);
10690           if (li_config_table[i].flag_table[j] & LI_FLAG_ANNOUNCEMENT)
10691             li_config_table[i].coef_table[j] |= LI_COEF_PC_CH;
10692         }
10693       }
10694     }
10695   }
10696   n = li_total_channels;
10697   if (n > MIXER_MAX_DUMP_CHANNELS)
10698     n = MIXER_MAX_DUMP_CHANNELS;
10699   p = hex_line;
10700   for (j = 0; j < n; j++)
10701   {
10702     if ((j & 0x7) == 0)
10703       *(p++) = ' ';
10704     *(p++) = hex_digit_table[li_config_table[j].curchnl >> 4];
10705     *(p++) = hex_digit_table[li_config_table[j].curchnl & 0xf];
10706   }
10707   *p = '\0';
10708   dbug (1, dprintf ("[%06lx] CURRENT %s",
10709     (dword)(UnMapController (a->Id)), (char   *) hex_line));
10710   p = hex_line;
10711   for (j = 0; j < n; j++)
10712   {
10713     if ((j & 0x7) == 0)
10714       *(p++) = ' ';
10715     *(p++) = hex_digit_table[li_config_table[j].channel >> 4];
10716     *(p++) = hex_digit_table[li_config_table[j].channel & 0xf];
10717   }
10718   *p = '\0';
10719   dbug (1, dprintf ("[%06lx] CHANNEL %s",
10720     (dword)(UnMapController (a->Id)), (char   *) hex_line));
10721   p = hex_line;
10722   for (j = 0; j < n; j++)
10723   {
10724     if ((j & 0x7) == 0)
10725       *(p++) = ' ';
10726     *(p++) = hex_digit_table[li_config_table[j].chflags >> 4];
10727     *(p++) = hex_digit_table[li_config_table[j].chflags & 0xf];
10728   }
10729   *p = '\0';
10730   dbug (1, dprintf ("[%06lx] CHFLAG  %s",
10731     (dword)(UnMapController (a->Id)), (char   *) hex_line));
10732   for (i = 0; i < n; i++)
10733   {
10734     p = hex_line;
10735     for (j = 0; j < n; j++)
10736     {
10737       if ((j & 0x7) == 0)
10738         *(p++) = ' ';
10739       *(p++) = hex_digit_table[li_config_table[i].flag_table[j] >> 4];
10740       *(p++) = hex_digit_table[li_config_table[i].flag_table[j] & 0xf];
10741     }
10742     *p = '\0';
10743     dbug (1, dprintf ("[%06lx] FLAG[%02x]%s",
10744       (dword)(UnMapController (a->Id)), i, (char   *) hex_line));
10745   }
10746   for (i = 0; i < n; i++)
10747   {
10748     p = hex_line;
10749     for (j = 0; j < n; j++)
10750     {
10751       if ((j & 0x7) == 0)
10752         *(p++) = ' ';
10753       *(p++) = hex_digit_table[li_config_table[i].coef_table[j] >> 4];
10754       *(p++) = hex_digit_table[li_config_table[i].coef_table[j] & 0xf];
10755     }
10756     *p = '\0';
10757     dbug (1, dprintf ("[%06lx] COEF[%02x]%s",
10758       (dword)(UnMapController (a->Id)), i, (char   *) hex_line));
10759   }
10760 }
10761
10762
10763 static struct
10764 {
10765   byte mask;
10766   byte line_flags;
10767 } mixer_write_prog_pri[] =
10768 {
10769   { LI_COEF_CH_CH, 0 },
10770   { LI_COEF_CH_PC, MIXER_COEF_LINE_TO_PC_FLAG },
10771   { LI_COEF_PC_CH, MIXER_COEF_LINE_FROM_PC_FLAG },
10772   { LI_COEF_PC_PC, MIXER_COEF_LINE_TO_PC_FLAG | MIXER_COEF_LINE_FROM_PC_FLAG }
10773 };
10774
10775 static struct
10776 {
10777   byte from_ch;
10778   byte to_ch;
10779   byte mask;
10780   byte xconnect_override;
10781 } mixer_write_prog_bri[] =
10782 {
10783   { 0, 0, LI_COEF_CH_CH, 0x01 },  /* B      to B      */
10784   { 1, 0, LI_COEF_CH_CH, 0x01 },  /* Alt B  to B      */
10785   { 0, 0, LI_COEF_PC_CH, 0x80 },  /* PC     to B      */
10786   { 1, 0, LI_COEF_PC_CH, 0x01 },  /* Alt PC to B      */
10787   { 2, 0, LI_COEF_CH_CH, 0x00 },  /* IC     to B      */
10788   { 3, 0, LI_COEF_CH_CH, 0x00 },  /* Alt IC to B      */
10789   { 0, 0, LI_COEF_CH_PC, 0x80 },  /* B      to PC     */
10790   { 1, 0, LI_COEF_CH_PC, 0x01 },  /* Alt B  to PC     */
10791   { 0, 0, LI_COEF_PC_PC, 0x01 },  /* PC     to PC     */
10792   { 1, 0, LI_COEF_PC_PC, 0x01 },  /* Alt PC to PC     */
10793   { 2, 0, LI_COEF_CH_PC, 0x00 },  /* IC     to PC     */
10794   { 3, 0, LI_COEF_CH_PC, 0x00 },  /* Alt IC to PC     */
10795   { 0, 2, LI_COEF_CH_CH, 0x00 },  /* B      to IC     */
10796   { 1, 2, LI_COEF_CH_CH, 0x00 },  /* Alt B  to IC     */
10797   { 0, 2, LI_COEF_PC_CH, 0x00 },  /* PC     to IC     */
10798   { 1, 2, LI_COEF_PC_CH, 0x00 },  /* Alt PC to IC     */
10799   { 2, 2, LI_COEF_CH_CH, 0x00 },  /* IC     to IC     */
10800   { 3, 2, LI_COEF_CH_CH, 0x00 },  /* Alt IC to IC     */
10801   { 1, 1, LI_COEF_CH_CH, 0x01 },  /* Alt B  to Alt B  */
10802   { 0, 1, LI_COEF_CH_CH, 0x01 },  /* B      to Alt B  */
10803   { 1, 1, LI_COEF_PC_CH, 0x80 },  /* Alt PC to Alt B  */
10804   { 0, 1, LI_COEF_PC_CH, 0x01 },  /* PC     to Alt B  */
10805   { 3, 1, LI_COEF_CH_CH, 0x00 },  /* Alt IC to Alt B  */
10806   { 2, 1, LI_COEF_CH_CH, 0x00 },  /* IC     to Alt B  */
10807   { 1, 1, LI_COEF_CH_PC, 0x80 },  /* Alt B  to Alt PC */
10808   { 0, 1, LI_COEF_CH_PC, 0x01 },  /* B      to Alt PC */
10809   { 1, 1, LI_COEF_PC_PC, 0x01 },  /* Alt PC to Alt PC */
10810   { 0, 1, LI_COEF_PC_PC, 0x01 },  /* PC     to Alt PC */
10811   { 3, 1, LI_COEF_CH_PC, 0x00 },  /* Alt IC to Alt PC */
10812   { 2, 1, LI_COEF_CH_PC, 0x00 },  /* IC     to Alt PC */
10813   { 1, 3, LI_COEF_CH_CH, 0x00 },  /* Alt B  to Alt IC */
10814   { 0, 3, LI_COEF_CH_CH, 0x00 },  /* B      to Alt IC */
10815   { 1, 3, LI_COEF_PC_CH, 0x00 },  /* Alt PC to Alt IC */
10816   { 0, 3, LI_COEF_PC_CH, 0x00 },  /* PC     to Alt IC */
10817   { 3, 3, LI_COEF_CH_CH, 0x00 },  /* Alt IC to Alt IC */
10818   { 2, 3, LI_COEF_CH_CH, 0x00 }   /* IC     to Alt IC */
10819 };
10820
10821 static byte mixer_swapped_index_bri[] =
10822 {
10823   18,  /* B      to B      */
10824   19,  /* Alt B  to B      */
10825   20,  /* PC     to B      */
10826   21,  /* Alt PC to B      */
10827   22,  /* IC     to B      */
10828   23,  /* Alt IC to B      */
10829   24,  /* B      to PC     */
10830   25,  /* Alt B  to PC     */
10831   26,  /* PC     to PC     */
10832   27,  /* Alt PC to PC     */
10833   28,  /* IC     to PC     */
10834   29,  /* Alt IC to PC     */
10835   30,  /* B      to IC     */
10836   31,  /* Alt B  to IC     */
10837   32,  /* PC     to IC     */
10838   33,  /* Alt PC to IC     */
10839   34,  /* IC     to IC     */
10840   35,  /* Alt IC to IC     */
10841   0,   /* Alt B  to Alt B  */
10842   1,   /* B      to Alt B  */
10843   2,   /* Alt PC to Alt B  */
10844   3,   /* PC     to Alt B  */
10845   4,   /* Alt IC to Alt B  */
10846   5,   /* IC     to Alt B  */
10847   6,   /* Alt B  to Alt PC */
10848   7,   /* B      to Alt PC */
10849   8,   /* Alt PC to Alt PC */
10850   9,   /* PC     to Alt PC */
10851   10,  /* Alt IC to Alt PC */
10852   11,  /* IC     to Alt PC */
10853   12,  /* Alt B  to Alt IC */
10854   13,  /* B      to Alt IC */
10855   14,  /* Alt PC to Alt IC */
10856   15,  /* PC     to Alt IC */
10857   16,  /* Alt IC to Alt IC */
10858   17   /* IC     to Alt IC */
10859 };
10860
10861 static struct
10862 {
10863   byte mask;
10864   byte from_pc;
10865   byte to_pc;
10866 } xconnect_write_prog[] =
10867 {
10868   { LI_COEF_CH_CH, false, false },
10869   { LI_COEF_CH_PC, false, true },
10870   { LI_COEF_PC_CH, true, false },
10871   { LI_COEF_PC_PC, true, true }
10872 };
10873
10874
10875 static void xconnect_query_addresses (PLCI   *plci)
10876 {
10877   DIVA_CAPI_ADAPTER   *a;
10878   word w, ch;
10879   byte   *p;
10880
10881   dbug (1, dprintf ("[%06lx] %s,%d: xconnect_query_addresses",
10882     (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
10883     (char   *)(FILE_), __LINE__));
10884
10885   a = plci->adapter;
10886   if (a->li_pri && ((plci->li_bchannel_id == 0)
10887    || (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci)))
10888   {
10889     dbug (1, dprintf ("[%06x] %s,%d: Channel id wiped out",
10890       (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
10891       (char   *)(FILE_), __LINE__));
10892     return;
10893   }
10894   p = plci->internal_req_buffer;
10895   ch = (a->li_pri) ? plci->li_bchannel_id - 1 : 0;
10896   *(p++) = UDATA_REQUEST_XCONNECT_FROM;
10897   w = ch;
10898   *(p++) = (byte) w;
10899   *(p++) = (byte)(w >> 8);
10900   w = ch | XCONNECT_CHANNEL_PORT_PC;
10901   *(p++) = (byte) w;
10902   *(p++) = (byte)(w >> 8);
10903   plci->NData[0].P = plci->internal_req_buffer;
10904   plci->NData[0].PLength = p - plci->internal_req_buffer;
10905   plci->NL.X = plci->NData;
10906   plci->NL.ReqCh = 0;
10907   plci->NL.Req = plci->nl_req = (byte) N_UDATA;
10908   plci->adapter->request (&plci->NL);
10909 }
10910
10911
10912 static void xconnect_write_coefs (PLCI   *plci, word internal_command)
10913 {
10914
10915   dbug (1, dprintf ("[%06lx] %s,%d: xconnect_write_coefs %04x",
10916     (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
10917     (char   *)(FILE_), __LINE__, internal_command));
10918
10919   plci->li_write_command = internal_command;
10920   plci->li_write_channel = 0;
10921 }
10922
10923
10924 static byte xconnect_write_coefs_process (dword Id, PLCI   *plci, byte Rc)
10925 {
10926   DIVA_CAPI_ADAPTER   *a;
10927   word w, n, i, j, r, s, to_ch;
10928   dword d;
10929   byte   *p;
10930   struct xconnect_transfer_address_s   *transfer_address;
10931   byte ch_map[MIXER_CHANNELS_BRI];
10932
10933   dbug (1, dprintf ("[%06x] %s,%d: xconnect_write_coefs_process %02x %d",
10934     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->li_write_channel));
10935
10936   a = plci->adapter;
10937   if ((plci->li_bchannel_id == 0)
10938    || (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci))
10939   {
10940     dbug (1, dprintf ("[%06x] %s,%d: Channel id wiped out",
10941       UnMapId (Id), (char   *)(FILE_), __LINE__));
10942     return (true);
10943   }
10944   i = a->li_base + (plci->li_bchannel_id - 1);
10945   j = plci->li_write_channel;
10946   p = plci->internal_req_buffer;
10947   if (j != 0)
10948   {
10949     if ((Rc != OK) && (Rc != OK_FC))
10950     {
10951       dbug (1, dprintf ("[%06lx] %s,%d: LI write coefs failed %02x",
10952         UnMapId (Id), (char   *)(FILE_), __LINE__, Rc));
10953       return (false);
10954     }
10955   }
10956   if (li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
10957   {
10958     r = 0;
10959     s = 0;
10960     if (j < li_total_channels)
10961     {
10962       if (li_config_table[i].channel & LI_CHANNEL_ADDRESSES_SET)
10963       {
10964         s = ((li_config_table[i].send_b.card_address.low | li_config_table[i].send_b.card_address.high) ?
10965             (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_PC | LI_COEF_PC_PC)) &
10966           ((li_config_table[i].send_pc.card_address.low | li_config_table[i].send_pc.card_address.high) ?
10967             (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_PC_CH));
10968       }
10969       r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
10970       while ((j < li_total_channels)
10971         && ((r == 0)
10972          || (!(li_config_table[j].channel & LI_CHANNEL_ADDRESSES_SET))
10973          || (!li_config_table[j].adapter->li_pri
10974           && (j >= li_config_table[j].adapter->li_base + MIXER_BCHANNELS_BRI))
10975          || (((li_config_table[j].send_b.card_address.low != li_config_table[i].send_b.card_address.low)
10976            || (li_config_table[j].send_b.card_address.high != li_config_table[i].send_b.card_address.high))
10977           && (!(a->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)
10978            || !(li_config_table[j].adapter->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)))
10979          || ((li_config_table[j].adapter->li_base != a->li_base)
10980           && !(r & s &
10981             ((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ?
10982               (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) &
10983             ((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ?
10984               (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC))))))
10985       {
10986         j++;
10987         if (j < li_total_channels)
10988           r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
10989       }
10990     }
10991     if (j < li_total_channels)
10992     {
10993       plci->internal_command = plci->li_write_command;
10994       if (plci_nl_busy (plci))
10995         return (true);
10996       to_ch = (a->li_pri) ? plci->li_bchannel_id - 1 : 0;
10997       *(p++) = UDATA_REQUEST_XCONNECT_TO;
10998       do
10999       {
11000         if (li_config_table[j].adapter->li_base != a->li_base)
11001         {
11002           r &= s &
11003             ((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ?
11004               (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) &
11005             ((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ?
11006               (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC));
11007         }
11008         n = 0;
11009         do
11010         {
11011           if (r & xconnect_write_prog[n].mask)
11012           {
11013             if (xconnect_write_prog[n].from_pc)
11014               transfer_address = &(li_config_table[j].send_pc);
11015             else
11016               transfer_address = &(li_config_table[j].send_b);
11017             d = transfer_address->card_address.low;
11018             *(p++) = (byte) d;
11019             *(p++) = (byte)(d >> 8);
11020             *(p++) = (byte)(d >> 16);
11021             *(p++) = (byte)(d >> 24);
11022             d = transfer_address->card_address.high;
11023             *(p++) = (byte) d;
11024             *(p++) = (byte)(d >> 8);
11025             *(p++) = (byte)(d >> 16);
11026             *(p++) = (byte)(d >> 24);
11027             d = transfer_address->offset;
11028             *(p++) = (byte) d;
11029             *(p++) = (byte)(d >> 8);
11030             *(p++) = (byte)(d >> 16);
11031             *(p++) = (byte)(d >> 24);
11032             w = xconnect_write_prog[n].to_pc ? to_ch | XCONNECT_CHANNEL_PORT_PC : to_ch;
11033             *(p++) = (byte) w;
11034             *(p++) = (byte)(w >> 8);
11035             w = ((li_config_table[i].coef_table[j] & xconnect_write_prog[n].mask) == 0) ? 0x01 :
11036               (li_config_table[i].adapter->u_law ?
11037                  (li_config_table[j].adapter->u_law ? 0x80 : 0x86) :
11038                  (li_config_table[j].adapter->u_law ? 0x7a : 0x80));
11039             *(p++) = (byte) w;
11040             *(p++) = (byte) 0;
11041             li_config_table[i].coef_table[j] ^= xconnect_write_prog[n].mask << 4;
11042           }
11043           n++;
11044         } while ((n < ARRAY_SIZE(xconnect_write_prog))
11045           && ((p - plci->internal_req_buffer) + 16 < INTERNAL_REQ_BUFFER_SIZE));
11046         if (n == ARRAY_SIZE(xconnect_write_prog))
11047         {
11048           do
11049           {
11050             j++;
11051             if (j < li_total_channels)
11052               r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
11053           } while ((j < li_total_channels)
11054             && ((r == 0)
11055              || (!(li_config_table[j].channel & LI_CHANNEL_ADDRESSES_SET))
11056              || (!li_config_table[j].adapter->li_pri
11057               && (j >= li_config_table[j].adapter->li_base + MIXER_BCHANNELS_BRI))
11058              || (((li_config_table[j].send_b.card_address.low != li_config_table[i].send_b.card_address.low)
11059                || (li_config_table[j].send_b.card_address.high != li_config_table[i].send_b.card_address.high))
11060               && (!(a->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)
11061                || !(li_config_table[j].adapter->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)))
11062              || ((li_config_table[j].adapter->li_base != a->li_base)
11063               && !(r & s &
11064                 ((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ?
11065                   (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) &
11066                 ((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ?
11067                   (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC))))));
11068         }
11069       } while ((j < li_total_channels)
11070         && ((p - plci->internal_req_buffer) + 16 < INTERNAL_REQ_BUFFER_SIZE));
11071     }
11072     else if (j == li_total_channels)
11073     {
11074       plci->internal_command = plci->li_write_command;
11075       if (plci_nl_busy (plci))
11076         return (true);
11077       if (a->li_pri)
11078       {
11079         *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_PRI_SYNC;
11080         w = 0;
11081         if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
11082           w |= MIXER_FEATURE_ENABLE_TX_DATA;
11083         if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
11084           w |= MIXER_FEATURE_ENABLE_RX_DATA;
11085         *(p++) = (byte) w;
11086         *(p++) = (byte)(w >> 8);
11087       }
11088       else
11089       {
11090         *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_BRI;
11091         w = 0;
11092         if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI)
11093          && (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length))
11094         {
11095           w = GET_WORD (a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE);
11096         }
11097         if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
11098           w |= MIXER_FEATURE_ENABLE_TX_DATA;
11099         if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
11100           w |= MIXER_FEATURE_ENABLE_RX_DATA;
11101         *(p++) = (byte) w;
11102         *(p++) = (byte)(w >> 8);
11103         for (j = 0; j < sizeof(ch_map); j += 2)
11104         {
11105           if (plci->li_bchannel_id == 2)
11106           {
11107             ch_map[j] = (byte)(j+1);
11108             ch_map[j+1] = (byte) j;
11109           }
11110           else
11111           {
11112             ch_map[j] = (byte) j;
11113             ch_map[j+1] = (byte)(j+1);
11114           }
11115         }
11116         for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++)
11117         {
11118           i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch];
11119           j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch];
11120           if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED)
11121           {
11122             *p = (mixer_write_prog_bri[n].xconnect_override != 0) ?
11123               mixer_write_prog_bri[n].xconnect_override :
11124               ((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01);
11125             if ((i >= a->li_base + MIXER_BCHANNELS_BRI) || (j >= a->li_base + MIXER_BCHANNELS_BRI))
11126             {
11127               w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
11128               li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4;
11129             }
11130           }
11131           else
11132           {
11133             *p = 0x00;
11134             if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI->tel == ADV_VOICE))
11135             {
11136               w = (plci == a->AdvSignalPLCI) ? n : mixer_swapped_index_bri[n];
11137               if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w < a->adv_voice_coef_length)
11138                 *p = a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w];
11139             }
11140           }
11141           p++;
11142         }
11143       }
11144       j = li_total_channels + 1;
11145     }
11146   }
11147   else
11148   {
11149     if (j <= li_total_channels)
11150     {
11151       plci->internal_command = plci->li_write_command;
11152       if (plci_nl_busy (plci))
11153         return (true);
11154       if (j < a->li_base)
11155         j = a->li_base;
11156       if (a->li_pri)
11157       {
11158         *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_PRI_SYNC;
11159         w = 0;
11160         if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
11161           w |= MIXER_FEATURE_ENABLE_TX_DATA;
11162         if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
11163           w |= MIXER_FEATURE_ENABLE_RX_DATA;
11164         *(p++) = (byte) w;
11165         *(p++) = (byte)(w >> 8);
11166         for (n = 0; n < ARRAY_SIZE(mixer_write_prog_pri); n++)
11167         {
11168           *(p++) = (byte)((plci->li_bchannel_id - 1) | mixer_write_prog_pri[n].line_flags);
11169           for (j = a->li_base; j < a->li_base + MIXER_CHANNELS_PRI; j++)
11170           {
11171             w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
11172             if (w & mixer_write_prog_pri[n].mask)
11173             {
11174               *(p++) = (li_config_table[i].coef_table[j] & mixer_write_prog_pri[n].mask) ? 0x80 : 0x01;
11175               li_config_table[i].coef_table[j] ^= mixer_write_prog_pri[n].mask << 4;
11176             }
11177             else
11178               *(p++) = 0x00;
11179           }
11180           *(p++) = (byte)((plci->li_bchannel_id - 1) | MIXER_COEF_LINE_ROW_FLAG | mixer_write_prog_pri[n].line_flags);
11181           for (j = a->li_base; j < a->li_base + MIXER_CHANNELS_PRI; j++)
11182           {
11183             w = ((li_config_table[j].coef_table[i] & 0xf) ^ (li_config_table[j].coef_table[i] >> 4));
11184             if (w & mixer_write_prog_pri[n].mask)
11185             {
11186               *(p++) = (li_config_table[j].coef_table[i] & mixer_write_prog_pri[n].mask) ? 0x80 : 0x01;
11187               li_config_table[j].coef_table[i] ^= mixer_write_prog_pri[n].mask << 4;
11188             }
11189             else
11190               *(p++) = 0x00;
11191           }
11192         }
11193       }
11194       else
11195       {
11196         *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_BRI;
11197         w = 0;
11198         if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI)
11199          && (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length))
11200         {
11201           w = GET_WORD (a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE);
11202         }
11203         if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
11204           w |= MIXER_FEATURE_ENABLE_TX_DATA;
11205         if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
11206           w |= MIXER_FEATURE_ENABLE_RX_DATA;
11207         *(p++) = (byte) w;
11208         *(p++) = (byte)(w >> 8);
11209         for (j = 0; j < sizeof(ch_map); j += 2)
11210         {
11211           if (plci->li_bchannel_id == 2)
11212           {
11213             ch_map[j] = (byte)(j+1);
11214             ch_map[j+1] = (byte) j;
11215           }
11216           else
11217           {
11218             ch_map[j] = (byte) j;
11219             ch_map[j+1] = (byte)(j+1);
11220           }
11221         }
11222         for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++)
11223         {
11224           i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch];
11225           j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch];
11226           if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED)
11227           {
11228             *p = ((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01);
11229             w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
11230             li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4;
11231           }
11232           else
11233           {
11234             *p = 0x00;
11235             if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI->tel == ADV_VOICE))
11236             {
11237               w = (plci == a->AdvSignalPLCI) ? n : mixer_swapped_index_bri[n];
11238               if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w < a->adv_voice_coef_length)
11239                 *p = a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w];
11240             }
11241           }
11242           p++;
11243         }
11244       }
11245       j = li_total_channels + 1;
11246     }
11247   }
11248   plci->li_write_channel = j;
11249   if (p != plci->internal_req_buffer)
11250   {
11251     plci->NData[0].P = plci->internal_req_buffer;
11252     plci->NData[0].PLength = p - plci->internal_req_buffer;
11253     plci->NL.X = plci->NData;
11254     plci->NL.ReqCh = 0;
11255     plci->NL.Req = plci->nl_req = (byte) N_UDATA;
11256     plci->adapter->request (&plci->NL);
11257   }
11258   return (true);
11259 }
11260
11261
11262 static void mixer_notify_update (PLCI   *plci, byte others)
11263 {
11264   DIVA_CAPI_ADAPTER   *a;
11265   word i, w;
11266   PLCI   *notify_plci;
11267     byte msg[sizeof(CAPI_MSG_HEADER) + 6];
11268
11269   dbug (1, dprintf ("[%06lx] %s,%d: mixer_notify_update %d",
11270     (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
11271     (char   *)(FILE_), __LINE__, others));
11272
11273   a = plci->adapter;
11274   if (a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED)
11275   {
11276     if (others)
11277       plci->li_notify_update = true;
11278     i = 0;
11279     do
11280     {
11281       notify_plci = NULL;
11282       if (others)
11283       {
11284         while ((i < li_total_channels) && (li_config_table[i].plci == NULL))
11285           i++;
11286         if (i < li_total_channels)
11287           notify_plci = li_config_table[i++].plci;
11288       }
11289       else
11290       {
11291         if ((plci->li_bchannel_id != 0)
11292          && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11293         {
11294           notify_plci = plci;
11295         }
11296       }
11297       if ((notify_plci != NULL)
11298        && !notify_plci->li_notify_update
11299        && (notify_plci->appl != NULL)
11300        && (notify_plci->State)
11301        && notify_plci->NL.Id && !notify_plci->nl_remove_id)
11302       {
11303         notify_plci->li_notify_update = true;
11304         ((CAPI_MSG *) msg)->header.length = 18;
11305         ((CAPI_MSG *) msg)->header.appl_id = notify_plci->appl->Id;
11306         ((CAPI_MSG *) msg)->header.command = _FACILITY_R;
11307         ((CAPI_MSG *) msg)->header.number = 0;
11308         ((CAPI_MSG *) msg)->header.controller = notify_plci->adapter->Id;
11309         ((CAPI_MSG *) msg)->header.plci = notify_plci->Id;
11310         ((CAPI_MSG *) msg)->header.ncci = 0;
11311         ((CAPI_MSG *) msg)->info.facility_req.Selector = SELECTOR_LINE_INTERCONNECT;
11312         ((CAPI_MSG *) msg)->info.facility_req.structs[0] = 3;
11313         PUT_WORD (&(((CAPI_MSG *) msg)->info.facility_req.structs[1]), LI_REQ_SILENT_UPDATE);
11314         ((CAPI_MSG *) msg)->info.facility_req.structs[3] = 0;
11315         w = api_put (notify_plci->appl, (CAPI_MSG *) msg);
11316         if (w != _QUEUE_FULL)
11317         {
11318           if (w != 0)
11319           {
11320             dbug (1, dprintf ("[%06lx] %s,%d: Interconnect notify failed %06x %d",
11321               (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
11322               (char   *)(FILE_), __LINE__,
11323               (dword)((notify_plci->Id << 8) | UnMapController (notify_plci->adapter->Id)), w));
11324           }
11325           notify_plci->li_notify_update = false;
11326         }
11327       }
11328     } while (others && (notify_plci != NULL));
11329     if (others)
11330       plci->li_notify_update = false;
11331   }
11332 }
11333
11334
11335 static void mixer_clear_config (PLCI   *plci)
11336 {
11337   DIVA_CAPI_ADAPTER   *a;
11338   word i, j;
11339
11340   dbug (1, dprintf ("[%06lx] %s,%d: mixer_clear_config",
11341     (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
11342     (char   *)(FILE_), __LINE__));
11343
11344   plci->li_notify_update = false;
11345   plci->li_plci_b_write_pos = 0;
11346   plci->li_plci_b_read_pos = 0;
11347   plci->li_plci_b_req_pos = 0;
11348   a = plci->adapter;
11349   if ((plci->li_bchannel_id != 0)
11350    && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11351   {
11352     i = a->li_base + (plci->li_bchannel_id - 1);
11353     li_config_table[i].curchnl = 0;
11354     li_config_table[i].channel = 0;
11355     li_config_table[i].chflags = 0;
11356     for (j = 0; j < li_total_channels; j++)
11357     {
11358       li_config_table[j].flag_table[i] = 0;
11359       li_config_table[i].flag_table[j] = 0;
11360       li_config_table[i].coef_table[j] = 0;
11361       li_config_table[j].coef_table[i] = 0;
11362     }
11363     if (!a->li_pri)
11364     {
11365       li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET;
11366       if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
11367       {
11368         i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
11369         li_config_table[i].curchnl = 0;
11370         li_config_table[i].channel = 0;
11371         li_config_table[i].chflags = 0;
11372         for (j = 0; j < li_total_channels; j++)
11373         {
11374           li_config_table[i].flag_table[j] = 0;
11375           li_config_table[j].flag_table[i] = 0;
11376           li_config_table[i].coef_table[j] = 0;
11377           li_config_table[j].coef_table[i] = 0;
11378         }
11379         if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
11380         {
11381           i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
11382           li_config_table[i].curchnl = 0;
11383           li_config_table[i].channel = 0;
11384           li_config_table[i].chflags = 0;
11385           for (j = 0; j < li_total_channels; j++)
11386           {
11387             li_config_table[i].flag_table[j] = 0;
11388             li_config_table[j].flag_table[i] = 0;
11389             li_config_table[i].coef_table[j] = 0;
11390             li_config_table[j].coef_table[i] = 0;
11391           }
11392         }
11393       }
11394     }
11395   }
11396 }
11397
11398
11399 static void mixer_prepare_switch (dword Id, PLCI   *plci)
11400 {
11401
11402   dbug (1, dprintf ("[%06lx] %s,%d: mixer_prepare_switch",
11403     UnMapId (Id), (char   *)(FILE_), __LINE__));
11404
11405   do
11406   {
11407     mixer_indication_coefs_set (Id, plci);
11408   } while (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos);
11409 }
11410
11411
11412 static word mixer_save_config (dword Id, PLCI   *plci, byte Rc)
11413 {
11414   DIVA_CAPI_ADAPTER   *a;
11415   word i, j;
11416
11417   dbug (1, dprintf ("[%06lx] %s,%d: mixer_save_config %02x %d",
11418     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
11419
11420   a = plci->adapter;
11421   if ((plci->li_bchannel_id != 0)
11422    && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11423   {
11424     i = a->li_base + (plci->li_bchannel_id - 1);
11425     for (j = 0; j < li_total_channels; j++)
11426     {
11427       li_config_table[i].coef_table[j] &= 0xf;
11428       li_config_table[j].coef_table[i] &= 0xf;
11429     }
11430     if (!a->li_pri)
11431       li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET;
11432   }
11433   return (GOOD);
11434 }
11435
11436
11437 static word mixer_restore_config (dword Id, PLCI   *plci, byte Rc)
11438 {
11439   DIVA_CAPI_ADAPTER   *a;
11440   word Info;
11441
11442   dbug (1, dprintf ("[%06lx] %s,%d: mixer_restore_config %02x %d",
11443     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
11444
11445   Info = GOOD;
11446   a = plci->adapter;
11447   if ((plci->B1_facilities & B1_FACILITY_MIXER)
11448    && (plci->li_bchannel_id != 0)
11449    && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11450   {
11451     switch (plci->adjust_b_state)
11452     {
11453     case ADJUST_B_RESTORE_MIXER_1:
11454       if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
11455       {
11456         plci->internal_command = plci->adjust_b_command;
11457         if (plci_nl_busy (plci))
11458         {
11459           plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_1;
11460           break;
11461         }
11462         xconnect_query_addresses (plci);
11463         plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_2;
11464         break;
11465       }
11466       plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5;
11467       Rc = OK;
11468     case ADJUST_B_RESTORE_MIXER_2:
11469     case ADJUST_B_RESTORE_MIXER_3:
11470     case ADJUST_B_RESTORE_MIXER_4:
11471       if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0))
11472       {
11473         dbug (1, dprintf ("[%06lx] %s,%d: Adjust B query addresses failed %02x",
11474           UnMapId (Id), (char   *)(FILE_), __LINE__, Rc));
11475         Info = _WRONG_STATE;
11476         break;
11477       }
11478       if (Rc == OK)
11479       {
11480         if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2)
11481           plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_3;
11482         else if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_4)
11483           plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5;
11484       }
11485       else if (Rc == 0)
11486       {
11487         if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2)
11488           plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_4;
11489         else if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_3)
11490           plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5;
11491       }
11492       if (plci->adjust_b_state != ADJUST_B_RESTORE_MIXER_5)
11493       {
11494         plci->internal_command = plci->adjust_b_command;
11495         break;
11496       }
11497     case ADJUST_B_RESTORE_MIXER_5:
11498       xconnect_write_coefs (plci, plci->adjust_b_command);
11499       plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_6;
11500       Rc = OK;
11501     case ADJUST_B_RESTORE_MIXER_6:
11502       if (!xconnect_write_coefs_process (Id, plci, Rc))
11503       {
11504         dbug (1, dprintf ("[%06lx] %s,%d: Write mixer coefs failed",
11505           UnMapId (Id), (char   *)(FILE_), __LINE__));
11506         Info = _FACILITY_NOT_SUPPORTED;
11507         break;
11508       }
11509       if (plci->internal_command)
11510         break;
11511       plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_7;
11512     case ADJUST_B_RESTORE_MIXER_7:
11513       break;
11514     }
11515   }
11516   return (Info);
11517 }
11518
11519
11520 static void mixer_command (dword Id, PLCI   *plci, byte Rc)
11521 {
11522   DIVA_CAPI_ADAPTER   *a;
11523   word i, internal_command, Info;
11524
11525   dbug (1, dprintf ("[%06lx] %s,%d: mixer_command %02x %04x %04x",
11526     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->internal_command,
11527     plci->li_cmd));
11528
11529   Info = GOOD;
11530   a = plci->adapter;
11531   internal_command = plci->internal_command;
11532   plci->internal_command = 0;
11533   switch (plci->li_cmd)
11534   {
11535   case LI_REQ_CONNECT:
11536   case LI_REQ_DISCONNECT:
11537   case LI_REQ_SILENT_UPDATE:
11538     switch (internal_command)
11539     {
11540     default:
11541       if (plci->li_channel_bits & LI_CHANNEL_INVOLVED)
11542       {
11543         adjust_b1_resource (Id, plci, NULL, (word)(plci->B1_facilities |
11544           B1_FACILITY_MIXER), MIXER_COMMAND_1);
11545       }
11546     case MIXER_COMMAND_1:
11547       if (plci->li_channel_bits & LI_CHANNEL_INVOLVED)
11548       {
11549         if (adjust_b_process (Id, plci, Rc) != GOOD)
11550         {
11551           dbug (1, dprintf ("[%06lx] %s,%d: Load mixer failed",
11552             UnMapId (Id), (char   *)(FILE_), __LINE__));
11553           Info = _FACILITY_NOT_SUPPORTED;
11554           break;
11555         }
11556         if (plci->internal_command)
11557           return;
11558       }
11559       plci->li_plci_b_req_pos = plci->li_plci_b_write_pos;
11560       if ((plci->li_channel_bits & LI_CHANNEL_INVOLVED)
11561        || ((get_b1_facilities (plci, plci->B1_resource) & B1_FACILITY_MIXER)
11562         && (add_b1_facilities (plci, plci->B1_resource, (word)(plci->B1_facilities &
11563          ~B1_FACILITY_MIXER)) == plci->B1_resource)))
11564       {
11565         xconnect_write_coefs (plci, MIXER_COMMAND_2);
11566       }
11567       else
11568       {
11569         do
11570         {
11571           mixer_indication_coefs_set (Id, plci);
11572         } while (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos);
11573       }
11574     case MIXER_COMMAND_2:
11575       if ((plci->li_channel_bits & LI_CHANNEL_INVOLVED)
11576        || ((get_b1_facilities (plci, plci->B1_resource) & B1_FACILITY_MIXER)
11577         && (add_b1_facilities (plci, plci->B1_resource, (word)(plci->B1_facilities &
11578          ~B1_FACILITY_MIXER)) == plci->B1_resource)))
11579       {
11580         if (!xconnect_write_coefs_process (Id, plci, Rc))
11581         {
11582           dbug (1, dprintf ("[%06lx] %s,%d: Write mixer coefs failed",
11583             UnMapId (Id), (char   *)(FILE_), __LINE__));
11584           if (plci->li_plci_b_write_pos != plci->li_plci_b_req_pos)
11585           {
11586             do
11587             {
11588               plci->li_plci_b_write_pos = (plci->li_plci_b_write_pos == 0) ?
11589                 LI_PLCI_B_QUEUE_ENTRIES-1 : plci->li_plci_b_write_pos - 1;
11590               i = (plci->li_plci_b_write_pos == 0) ?
11591                 LI_PLCI_B_QUEUE_ENTRIES-1 : plci->li_plci_b_write_pos - 1;
11592             } while ((plci->li_plci_b_write_pos != plci->li_plci_b_req_pos)
11593               && !(plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG));
11594           }
11595           Info = _FACILITY_NOT_SUPPORTED;
11596           break;
11597         }
11598         if (plci->internal_command)
11599           return;
11600       }
11601       if (!(plci->li_channel_bits & LI_CHANNEL_INVOLVED))
11602       {
11603         adjust_b1_resource (Id, plci, NULL, (word)(plci->B1_facilities &
11604           ~B1_FACILITY_MIXER), MIXER_COMMAND_3);
11605       }
11606     case MIXER_COMMAND_3:
11607       if (!(plci->li_channel_bits & LI_CHANNEL_INVOLVED))
11608       {
11609         if (adjust_b_process (Id, plci, Rc) != GOOD)
11610         {
11611           dbug (1, dprintf ("[%06lx] %s,%d: Unload mixer failed",
11612             UnMapId (Id), (char   *)(FILE_), __LINE__));
11613           Info = _FACILITY_NOT_SUPPORTED;
11614           break;
11615         }
11616         if (plci->internal_command)
11617           return;
11618       }
11619       break;
11620     }
11621     break;
11622   }
11623   if ((plci->li_bchannel_id == 0)
11624    || (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci))
11625   {
11626     dbug (1, dprintf ("[%06x] %s,%d: Channel id wiped out %d",
11627       UnMapId (Id), (char   *)(FILE_), __LINE__, (int)(plci->li_bchannel_id)));
11628   }
11629   else
11630   {
11631     i = a->li_base + (plci->li_bchannel_id - 1);
11632     li_config_table[i].curchnl = plci->li_channel_bits;
11633     if (!a->li_pri && (plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
11634     {
11635       i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
11636       li_config_table[i].curchnl = plci->li_channel_bits;
11637       if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
11638       {
11639         i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
11640         li_config_table[i].curchnl = plci->li_channel_bits;
11641       }
11642     }
11643   }
11644 }
11645
11646
11647 static void li_update_connect (dword Id, DIVA_CAPI_ADAPTER   *a, PLCI   *plci,
11648   dword plci_b_id, byte connect, dword li_flags)
11649 {
11650   word i, ch_a, ch_a_v, ch_a_s, ch_b, ch_b_v, ch_b_s;
11651   PLCI   *plci_b;
11652   DIVA_CAPI_ADAPTER   *a_b;
11653
11654   a_b = &(adapter[MapController ((byte)(plci_b_id & 0x7f)) - 1]);
11655   plci_b = &(a_b->plci[((plci_b_id >> 8) & 0xff) - 1]);
11656   ch_a = a->li_base + (plci->li_bchannel_id - 1);
11657   if (!a->li_pri && (plci->tel == ADV_VOICE)
11658    && (plci == a->AdvSignalPLCI) && (Id & EXT_CONTROLLER))
11659   {
11660     ch_a_v = ch_a + MIXER_IC_CHANNEL_BASE;
11661     ch_a_s = (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11662       a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id) : ch_a_v;
11663   }
11664   else
11665   {
11666     ch_a_v = ch_a;
11667     ch_a_s = ch_a;
11668   }
11669   ch_b = a_b->li_base + (plci_b->li_bchannel_id - 1);
11670   if (!a_b->li_pri && (plci_b->tel == ADV_VOICE)
11671    && (plci_b == a_b->AdvSignalPLCI) && (plci_b_id & EXT_CONTROLLER))
11672   {
11673     ch_b_v = ch_b + MIXER_IC_CHANNEL_BASE;
11674     ch_b_s = (a_b->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11675       a_b->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci_b->li_bchannel_id) : ch_b_v;
11676   }
11677   else
11678   {
11679     ch_b_v = ch_b;
11680     ch_b_s = ch_b;
11681   }
11682   if (connect)
11683   {
11684     li_config_table[ch_a].flag_table[ch_a_v] &= ~LI_FLAG_MONITOR;
11685     li_config_table[ch_a].flag_table[ch_a_s] &= ~LI_FLAG_MONITOR;
11686     li_config_table[ch_a_v].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11687     li_config_table[ch_a_s].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11688   }
11689   li_config_table[ch_a].flag_table[ch_b_v] &= ~LI_FLAG_MONITOR;
11690   li_config_table[ch_a].flag_table[ch_b_s] &= ~LI_FLAG_MONITOR;
11691   li_config_table[ch_b_v].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11692   li_config_table[ch_b_s].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11693   if (ch_a_v == ch_b_v)
11694   {
11695     li_config_table[ch_a_v].flag_table[ch_b_v] &= ~LI_FLAG_CONFERENCE;
11696     li_config_table[ch_a_s].flag_table[ch_b_s] &= ~LI_FLAG_CONFERENCE;
11697   }
11698   else
11699   {
11700     if (li_config_table[ch_a_v].flag_table[ch_b_v] & LI_FLAG_CONFERENCE)
11701     {
11702       for (i = 0; i < li_total_channels; i++)
11703       {
11704         if (i != ch_a_v)
11705           li_config_table[ch_a_v].flag_table[i] &= ~LI_FLAG_CONFERENCE;
11706       }
11707     }
11708     if (li_config_table[ch_a_s].flag_table[ch_b_v] & LI_FLAG_CONFERENCE)
11709     {
11710       for (i = 0; i < li_total_channels; i++)
11711       {
11712         if (i != ch_a_s)
11713           li_config_table[ch_a_s].flag_table[i] &= ~LI_FLAG_CONFERENCE;
11714       }
11715     }
11716     if (li_config_table[ch_b_v].flag_table[ch_a_v] & LI_FLAG_CONFERENCE)
11717     {
11718       for (i = 0; i < li_total_channels; i++)
11719       {
11720         if (i != ch_a_v)
11721           li_config_table[i].flag_table[ch_a_v] &= ~LI_FLAG_CONFERENCE;
11722       }
11723     }
11724     if (li_config_table[ch_b_v].flag_table[ch_a_s] & LI_FLAG_CONFERENCE)
11725     {
11726       for (i = 0; i < li_total_channels; i++)
11727       {
11728         if (i != ch_a_s)
11729           li_config_table[i].flag_table[ch_a_s] &= ~LI_FLAG_CONFERENCE;
11730       }
11731     }
11732   }
11733   if (li_flags & LI_FLAG_CONFERENCE_A_B)
11734   {
11735     li_config_table[ch_b_v].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11736     li_config_table[ch_b_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11737     li_config_table[ch_b_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11738     li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11739   }
11740   if (li_flags & LI_FLAG_CONFERENCE_B_A)
11741   {
11742     li_config_table[ch_a_v].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11743     li_config_table[ch_a_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11744     li_config_table[ch_a_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11745     li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11746   }
11747   if (li_flags & LI_FLAG_MONITOR_A)
11748   {
11749     li_config_table[ch_a].flag_table[ch_a_v] |= LI_FLAG_MONITOR;
11750     li_config_table[ch_a].flag_table[ch_a_s] |= LI_FLAG_MONITOR;
11751   }
11752   if (li_flags & LI_FLAG_MONITOR_B)
11753   {
11754     li_config_table[ch_a].flag_table[ch_b_v] |= LI_FLAG_MONITOR;
11755     li_config_table[ch_a].flag_table[ch_b_s] |= LI_FLAG_MONITOR;
11756   }
11757   if (li_flags & LI_FLAG_ANNOUNCEMENT_A)
11758   {
11759     li_config_table[ch_a_v].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11760     li_config_table[ch_a_s].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11761   }
11762   if (li_flags & LI_FLAG_ANNOUNCEMENT_B)
11763   {
11764     li_config_table[ch_b_v].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11765     li_config_table[ch_b_s].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11766   }
11767   if (li_flags & LI_FLAG_MIX_A)
11768   {
11769     li_config_table[ch_a_v].flag_table[ch_a] |= LI_FLAG_MIX;
11770     li_config_table[ch_a_s].flag_table[ch_a] |= LI_FLAG_MIX;
11771   }
11772   if (li_flags & LI_FLAG_MIX_B)
11773   {
11774     li_config_table[ch_b_v].flag_table[ch_a] |= LI_FLAG_MIX;
11775     li_config_table[ch_b_s].flag_table[ch_a] |= LI_FLAG_MIX;
11776   }
11777   if (ch_a_v != ch_a_s)
11778   {
11779     li_config_table[ch_a_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11780     li_config_table[ch_a_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11781   }
11782   if (ch_b_v != ch_b_s)
11783   {
11784     li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11785     li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11786   }
11787 }
11788
11789
11790 static void li2_update_connect (dword Id, DIVA_CAPI_ADAPTER   *a, PLCI   *plci,
11791   dword plci_b_id, byte connect, dword li_flags)
11792 {
11793   word ch_a, ch_a_v, ch_a_s, ch_b, ch_b_v, ch_b_s;
11794   PLCI   *plci_b;
11795   DIVA_CAPI_ADAPTER   *a_b;
11796
11797   a_b = &(adapter[MapController ((byte)(plci_b_id & 0x7f)) - 1]);
11798   plci_b = &(a_b->plci[((plci_b_id >> 8) & 0xff) - 1]);
11799   ch_a = a->li_base + (plci->li_bchannel_id - 1);
11800   if (!a->li_pri && (plci->tel == ADV_VOICE)
11801    && (plci == a->AdvSignalPLCI) && (Id & EXT_CONTROLLER))
11802   {
11803     ch_a_v = ch_a + MIXER_IC_CHANNEL_BASE;
11804     ch_a_s = (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11805       a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id) : ch_a_v;
11806   }
11807   else
11808   {
11809     ch_a_v = ch_a;
11810     ch_a_s = ch_a;
11811   }
11812   ch_b = a_b->li_base + (plci_b->li_bchannel_id - 1);
11813   if (!a_b->li_pri && (plci_b->tel == ADV_VOICE)
11814    && (plci_b == a_b->AdvSignalPLCI) && (plci_b_id & EXT_CONTROLLER))
11815   {
11816     ch_b_v = ch_b + MIXER_IC_CHANNEL_BASE;
11817     ch_b_s = (a_b->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11818       a_b->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci_b->li_bchannel_id) : ch_b_v;
11819   }
11820   else
11821   {
11822     ch_b_v = ch_b;
11823     ch_b_s = ch_b;
11824   }
11825   if (connect)
11826   {
11827     li_config_table[ch_b].flag_table[ch_b_v] &= ~LI_FLAG_MONITOR;
11828     li_config_table[ch_b].flag_table[ch_b_s] &= ~LI_FLAG_MONITOR;
11829     li_config_table[ch_b_v].flag_table[ch_b] &= ~LI_FLAG_MIX;
11830     li_config_table[ch_b_s].flag_table[ch_b] &= ~LI_FLAG_MIX;
11831     li_config_table[ch_b].flag_table[ch_b] &= ~LI_FLAG_PCCONNECT;
11832     li_config_table[ch_b].chflags &= ~(LI_CHFLAG_MONITOR | LI_CHFLAG_MIX | LI_CHFLAG_LOOP);
11833   }
11834   li_config_table[ch_b_v].flag_table[ch_a_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11835   li_config_table[ch_b_s].flag_table[ch_a_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11836   li_config_table[ch_b_v].flag_table[ch_a_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11837   li_config_table[ch_b_s].flag_table[ch_a_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11838   li_config_table[ch_a_v].flag_table[ch_b_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11839   li_config_table[ch_a_v].flag_table[ch_b_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11840   li_config_table[ch_a_s].flag_table[ch_b_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11841   li_config_table[ch_a_s].flag_table[ch_b_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11842   if (li_flags & LI2_FLAG_INTERCONNECT_A_B)
11843   {
11844     li_config_table[ch_b_v].flag_table[ch_a_v] |= LI_FLAG_INTERCONNECT;
11845     li_config_table[ch_b_s].flag_table[ch_a_v] |= LI_FLAG_INTERCONNECT;
11846     li_config_table[ch_b_v].flag_table[ch_a_s] |= LI_FLAG_INTERCONNECT;
11847     li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_INTERCONNECT;
11848   }
11849   if (li_flags & LI2_FLAG_INTERCONNECT_B_A)
11850   {
11851     li_config_table[ch_a_v].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11852     li_config_table[ch_a_v].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11853     li_config_table[ch_a_s].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11854     li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11855   }
11856   if (li_flags & LI2_FLAG_MONITOR_B)
11857   {
11858     li_config_table[ch_b].flag_table[ch_b_v] |= LI_FLAG_MONITOR;
11859     li_config_table[ch_b].flag_table[ch_b_s] |= LI_FLAG_MONITOR;
11860   }
11861   if (li_flags & LI2_FLAG_MIX_B)
11862   {
11863     li_config_table[ch_b_v].flag_table[ch_b] |= LI_FLAG_MIX;
11864     li_config_table[ch_b_s].flag_table[ch_b] |= LI_FLAG_MIX;
11865   }
11866   if (li_flags & LI2_FLAG_MONITOR_X)
11867     li_config_table[ch_b].chflags |= LI_CHFLAG_MONITOR;
11868   if (li_flags & LI2_FLAG_MIX_X)
11869     li_config_table[ch_b].chflags |= LI_CHFLAG_MIX;
11870   if (li_flags & LI2_FLAG_LOOP_B)
11871   {
11872     li_config_table[ch_b_v].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11873     li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11874     li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11875     li_config_table[ch_b_s].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11876   }
11877   if (li_flags & LI2_FLAG_LOOP_PC)
11878     li_config_table[ch_b].flag_table[ch_b] |= LI_FLAG_PCCONNECT;
11879   if (li_flags & LI2_FLAG_LOOP_X)
11880     li_config_table[ch_b].chflags |= LI_CHFLAG_LOOP;
11881   if (li_flags & LI2_FLAG_PCCONNECT_A_B)
11882     li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_PCCONNECT;
11883   if (li_flags & LI2_FLAG_PCCONNECT_B_A)
11884     li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_PCCONNECT;
11885   if (ch_a_v != ch_a_s)
11886   {
11887     li_config_table[ch_a_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11888     li_config_table[ch_a_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11889   }
11890   if (ch_b_v != ch_b_s)
11891   {
11892     li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11893     li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11894   }
11895 }
11896
11897
11898 static word li_check_main_plci (dword Id, PLCI   *plci)
11899 {
11900   if (plci == NULL)
11901   {
11902     dbug (1, dprintf ("[%06lx] %s,%d: Wrong PLCI",
11903       UnMapId (Id), (char   *)(FILE_), __LINE__));
11904     return (_WRONG_IDENTIFIER);
11905   }
11906   if (!plci->State
11907    || !plci->NL.Id || plci->nl_remove_id
11908    || (plci->li_bchannel_id == 0))
11909   {
11910     dbug (1, dprintf ("[%06lx] %s,%d: Wrong state",
11911       UnMapId (Id), (char   *)(FILE_), __LINE__));
11912     return (_WRONG_STATE);
11913   }
11914   li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci = plci;
11915   return (GOOD);
11916 }
11917
11918
11919 static PLCI   *li_check_plci_b (dword Id, PLCI   *plci,
11920   dword plci_b_id, word plci_b_write_pos, byte   *p_result)
11921 {
11922   byte ctlr_b;
11923   PLCI   *plci_b;
11924
11925   if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
11926     LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2)
11927   {
11928     dbug (1, dprintf ("[%06lx] %s,%d: LI request overrun",
11929       UnMapId (Id), (char   *)(FILE_), __LINE__));
11930     PUT_WORD (p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE);
11931     return (NULL);
11932   }
11933   ctlr_b = 0;
11934   if ((plci_b_id & 0x7f) != 0)
11935   {
11936     ctlr_b = MapController ((byte)(plci_b_id & 0x7f));
11937     if ((ctlr_b > max_adapter) || ((ctlr_b != 0) && (adapter[ctlr_b - 1].request == NULL)))
11938       ctlr_b = 0;
11939   }
11940   if ((ctlr_b == 0)
11941    || (((plci_b_id >> 8) & 0xff) == 0)
11942    || (((plci_b_id >> 8) & 0xff) > adapter[ctlr_b - 1].max_plci))
11943   {
11944     dbug (1, dprintf ("[%06lx] %s,%d: LI invalid second PLCI %08lx",
11945       UnMapId (Id), (char   *)(FILE_), __LINE__, plci_b_id));
11946     PUT_WORD (p_result, _WRONG_IDENTIFIER);
11947     return (NULL);
11948   }
11949   plci_b = &(adapter[ctlr_b - 1].plci[((plci_b_id >> 8) & 0xff) - 1]);
11950   if (!plci_b->State
11951    || !plci_b->NL.Id || plci_b->nl_remove_id
11952    || (plci_b->li_bchannel_id == 0))
11953   {
11954     dbug (1, dprintf ("[%06lx] %s,%d: LI peer in wrong state %08lx",
11955       UnMapId (Id), (char   *)(FILE_), __LINE__, plci_b_id));
11956     PUT_WORD (p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE);
11957     return (NULL);
11958   }
11959   li_config_table[plci_b->adapter->li_base + (plci_b->li_bchannel_id - 1)].plci = plci_b;
11960   if (((byte)(plci_b_id & ~EXT_CONTROLLER)) !=
11961     ((byte)(UnMapController (plci->adapter->Id) & ~EXT_CONTROLLER))
11962    && (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
11963     || !(plci_b->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)))
11964   {
11965     dbug (1, dprintf ("[%06lx] %s,%d: LI not on same ctrl %08lx",
11966       UnMapId (Id), (char   *)(FILE_), __LINE__, plci_b_id));
11967     PUT_WORD (p_result, _WRONG_IDENTIFIER);
11968     return (NULL);
11969   }
11970   if (!(get_b1_facilities (plci_b, add_b1_facilities (plci_b, plci_b->B1_resource,
11971     (word)(plci_b->B1_facilities | B1_FACILITY_MIXER))) & B1_FACILITY_MIXER))
11972   {
11973     dbug (1, dprintf ("[%06lx] %s,%d: Interconnect peer cannot mix %d",
11974       UnMapId (Id), (char   *)(FILE_), __LINE__, plci_b->B1_resource));
11975     PUT_WORD (p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE);
11976     return (NULL);
11977   }
11978   return (plci_b);
11979 }
11980
11981
11982 static PLCI   *li2_check_plci_b (dword Id, PLCI   *plci,
11983   dword plci_b_id, word plci_b_write_pos, byte   *p_result)
11984 {
11985   byte ctlr_b;
11986   PLCI   *plci_b;
11987
11988   if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
11989     LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2)
11990   {
11991     dbug (1, dprintf ("[%06lx] %s,%d: LI request overrun",
11992       UnMapId (Id), (char   *)(FILE_), __LINE__));
11993     PUT_WORD (p_result, _WRONG_STATE);
11994     return (NULL);
11995   }
11996   ctlr_b = 0;
11997   if ((plci_b_id & 0x7f) != 0)
11998   {
11999     ctlr_b = MapController ((byte)(plci_b_id & 0x7f));
12000     if ((ctlr_b > max_adapter) || ((ctlr_b != 0) && (adapter[ctlr_b - 1].request == NULL)))
12001       ctlr_b = 0;
12002   }
12003   if ((ctlr_b == 0)
12004    || (((plci_b_id >> 8) & 0xff) == 0)
12005    || (((plci_b_id >> 8) & 0xff) > adapter[ctlr_b - 1].max_plci))
12006   {
12007     dbug (1, dprintf ("[%06lx] %s,%d: LI invalid second PLCI %08lx",
12008       UnMapId (Id), (char   *)(FILE_), __LINE__, plci_b_id));
12009     PUT_WORD (p_result, _WRONG_IDENTIFIER);
12010     return (NULL);
12011   }
12012   plci_b = &(adapter[ctlr_b - 1].plci[((plci_b_id >> 8) & 0xff) - 1]);
12013   if (!plci_b->State
12014    || !plci_b->NL.Id || plci_b->nl_remove_id
12015    || (plci_b->li_bchannel_id == 0)
12016    || (li_config_table[plci_b->adapter->li_base + (plci_b->li_bchannel_id - 1)].plci != plci_b))
12017   {
12018     dbug (1, dprintf ("[%06lx] %s,%d: LI peer in wrong state %08lx",
12019       UnMapId (Id), (char   *)(FILE_), __LINE__, plci_b_id));
12020     PUT_WORD (p_result, _WRONG_STATE);
12021     return (NULL);
12022   }
12023   if (((byte)(plci_b_id & ~EXT_CONTROLLER)) !=
12024     ((byte)(UnMapController (plci->adapter->Id) & ~EXT_CONTROLLER))
12025    && (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12026     || !(plci_b->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)))
12027   {
12028     dbug (1, dprintf ("[%06lx] %s,%d: LI not on same ctrl %08lx",
12029       UnMapId (Id), (char   *)(FILE_), __LINE__, plci_b_id));
12030     PUT_WORD (p_result, _WRONG_IDENTIFIER);
12031     return (NULL);
12032   }
12033   if (!(get_b1_facilities (plci_b, add_b1_facilities (plci_b, plci_b->B1_resource,
12034     (word)(plci_b->B1_facilities | B1_FACILITY_MIXER))) & B1_FACILITY_MIXER))
12035   {
12036     dbug (1, dprintf ("[%06lx] %s,%d: Interconnect peer cannot mix %d",
12037       UnMapId (Id), (char   *)(FILE_), __LINE__, plci_b->B1_resource));
12038     PUT_WORD (p_result, _WRONG_STATE);
12039     return (NULL);
12040   }
12041   return (plci_b);
12042 }
12043
12044
12045 static byte mixer_request (dword Id, word Number, DIVA_CAPI_ADAPTER   *a, PLCI   *plci, APPL   *appl, API_PARSE *msg)
12046 {
12047   word Info;
12048   word i;
12049   dword d, li_flags, plci_b_id;
12050   PLCI   *plci_b;
12051     API_PARSE li_parms[3];
12052     API_PARSE li_req_parms[3];
12053     API_PARSE li_participant_struct[2];
12054     API_PARSE li_participant_parms[3];
12055   word participant_parms_pos;
12056   byte result_buffer[32];
12057   byte   *result;
12058   word result_pos;
12059   word plci_b_write_pos;
12060
12061   dbug (1, dprintf ("[%06lx] %s,%d: mixer_request",
12062     UnMapId (Id), (char   *)(FILE_), __LINE__));
12063
12064   Info = GOOD;
12065   result = result_buffer;
12066   result_buffer[0] = 0;
12067   if (!(a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED))
12068   {
12069     dbug (1, dprintf ("[%06lx] %s,%d: Facility not supported",
12070       UnMapId (Id), (char   *)(FILE_), __LINE__));
12071     Info = _FACILITY_NOT_SUPPORTED;
12072   }
12073   else if (api_parse (&msg[1].info[1], msg[1].length, "ws", li_parms))
12074   {
12075     dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
12076       UnMapId (Id), (char   *)(FILE_), __LINE__));
12077     Info = _WRONG_MESSAGE_FORMAT;
12078   }
12079   else
12080   {
12081     result_buffer[0] = 3;
12082     PUT_WORD (&result_buffer[1], GET_WORD (li_parms[0].info));
12083     result_buffer[3] = 0;
12084     switch (GET_WORD (li_parms[0].info))
12085     {
12086     case LI_GET_SUPPORTED_SERVICES:
12087       if (appl->appl_flags & APPL_FLAG_OLD_LI_SPEC)
12088       {
12089         result_buffer[0] = 17;
12090         result_buffer[3] = 14;
12091         PUT_WORD (&result_buffer[4], GOOD);
12092         d = 0;
12093         if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_CH)
12094           d |= LI_CONFERENCING_SUPPORTED;
12095         if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_PC)
12096           d |= LI_MONITORING_SUPPORTED;
12097         if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_CH)
12098           d |= LI_ANNOUNCEMENTS_SUPPORTED | LI_MIXING_SUPPORTED;
12099         if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12100           d |= LI_CROSS_CONTROLLER_SUPPORTED;
12101         PUT_DWORD (&result_buffer[6], d);
12102         if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12103         {
12104           d = 0;
12105           for (i = 0; i < li_total_channels; i++)
12106           {
12107             if ((li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12108              && (li_config_table[i].adapter->li_pri
12109               || (i < li_config_table[i].adapter->li_base + MIXER_BCHANNELS_BRI)))
12110             {
12111               d++;
12112             }
12113           }
12114         }
12115         else
12116         {
12117           d = a->li_pri ? a->li_channels : MIXER_BCHANNELS_BRI;
12118         }
12119         PUT_DWORD (&result_buffer[10], d / 2);
12120         PUT_DWORD (&result_buffer[14], d);
12121       }
12122       else
12123       {
12124         result_buffer[0] = 25;
12125         result_buffer[3] = 22;
12126         PUT_WORD (&result_buffer[4], GOOD);
12127         d = LI2_ASYMMETRIC_SUPPORTED | LI2_B_LOOPING_SUPPORTED | LI2_X_LOOPING_SUPPORTED;
12128         if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_PC)
12129           d |= LI2_MONITORING_SUPPORTED | LI2_REMOTE_MONITORING_SUPPORTED;
12130         if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_CH)
12131           d |= LI2_MIXING_SUPPORTED | LI2_REMOTE_MIXING_SUPPORTED;
12132         if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_PC)
12133           d |= LI2_PC_LOOPING_SUPPORTED;
12134         if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12135           d |= LI2_CROSS_CONTROLLER_SUPPORTED;
12136         PUT_DWORD (&result_buffer[6], d);
12137         d = a->li_pri ? a->li_channels : MIXER_BCHANNELS_BRI;
12138         PUT_DWORD (&result_buffer[10], d / 2);
12139         PUT_DWORD (&result_buffer[14], d - 1);
12140         if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12141         {
12142           d = 0;
12143           for (i = 0; i < li_total_channels; i++)
12144           {
12145             if ((li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12146              && (li_config_table[i].adapter->li_pri
12147               || (i < li_config_table[i].adapter->li_base + MIXER_BCHANNELS_BRI)))
12148             {
12149               d++;
12150             }
12151           }
12152         }
12153         PUT_DWORD (&result_buffer[18], d / 2);
12154         PUT_DWORD (&result_buffer[22], d - 1);
12155       }
12156       break;
12157
12158     case LI_REQ_CONNECT:
12159       if (li_parms[1].length == 8)
12160       {
12161         appl->appl_flags |= APPL_FLAG_OLD_LI_SPEC;
12162         if (api_parse (&li_parms[1].info[1], li_parms[1].length, "dd", li_req_parms))
12163         {
12164           dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
12165             UnMapId (Id), (char   *)(FILE_), __LINE__));
12166           Info = _WRONG_MESSAGE_FORMAT;
12167           break;
12168         }
12169         plci_b_id = GET_DWORD (li_req_parms[0].info) & 0xffff;
12170         li_flags = GET_DWORD (li_req_parms[1].info);
12171         Info = li_check_main_plci (Id, plci);
12172         result_buffer[0] = 9;
12173         result_buffer[3] = 6;
12174         PUT_DWORD (&result_buffer[4], plci_b_id);
12175         PUT_WORD (&result_buffer[8], GOOD);
12176         if (Info != GOOD)
12177           break;
12178         result = plci->saved_msg.info;
12179         for (i = 0; i <= result_buffer[0]; i++)
12180           result[i] = result_buffer[i];
12181         plci_b_write_pos = plci->li_plci_b_write_pos;
12182         plci_b = li_check_plci_b (Id, plci, plci_b_id, plci_b_write_pos, &result[8]);
12183         if (plci_b == NULL)
12184           break;
12185         li_update_connect (Id, a, plci, plci_b_id, true, li_flags);
12186         plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_LAST_FLAG;
12187         plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES-1) ? 0 : plci_b_write_pos + 1;
12188         plci->li_plci_b_write_pos = plci_b_write_pos;
12189       }
12190       else
12191       {
12192         appl->appl_flags &= ~APPL_FLAG_OLD_LI_SPEC;
12193         if (api_parse (&li_parms[1].info[1], li_parms[1].length, "ds", li_req_parms))
12194         {
12195           dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
12196             UnMapId (Id), (char   *)(FILE_), __LINE__));
12197           Info = _WRONG_MESSAGE_FORMAT;
12198           break;
12199         }
12200         li_flags = GET_DWORD (li_req_parms[0].info) & ~(LI2_FLAG_INTERCONNECT_A_B | LI2_FLAG_INTERCONNECT_B_A);
12201         Info = li_check_main_plci (Id, plci);
12202         result_buffer[0] = 7;
12203         result_buffer[3] = 4;
12204         PUT_WORD (&result_buffer[4], Info);
12205         result_buffer[6] = 0;
12206         if (Info != GOOD)
12207           break;
12208         result = plci->saved_msg.info;
12209         for (i = 0; i <= result_buffer[0]; i++)
12210           result[i] = result_buffer[i];
12211         plci_b_write_pos = plci->li_plci_b_write_pos;
12212         participant_parms_pos = 0;
12213         result_pos = 7;
12214         li2_update_connect (Id, a, plci, UnMapId (Id), true, li_flags);
12215         while (participant_parms_pos < li_req_parms[1].length)
12216         {
12217           result[result_pos] = 6;
12218           result_pos += 7;
12219           PUT_DWORD (&result[result_pos - 6], 0);
12220           PUT_WORD (&result[result_pos - 2], GOOD);
12221           if (api_parse (&li_req_parms[1].info[1 + participant_parms_pos],
12222             (word)(li_parms[1].length - participant_parms_pos), "s", li_participant_struct))
12223           {
12224             dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
12225               UnMapId (Id), (char   *)(FILE_), __LINE__));
12226             PUT_WORD (&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12227             break;
12228           }
12229           if (api_parse (&li_participant_struct[0].info[1],
12230             li_participant_struct[0].length, "dd", li_participant_parms))
12231           {
12232             dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
12233               UnMapId (Id), (char   *)(FILE_), __LINE__));
12234             PUT_WORD (&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12235             break;
12236           }
12237           plci_b_id = GET_DWORD (li_participant_parms[0].info) & 0xffff;
12238           li_flags = GET_DWORD (li_participant_parms[1].info);
12239           PUT_DWORD (&result[result_pos - 6], plci_b_id);
12240           if (sizeof(result) - result_pos < 7)
12241           {
12242             dbug (1, dprintf ("[%06lx] %s,%d: LI result overrun",
12243               UnMapId (Id), (char   *)(FILE_), __LINE__));
12244             PUT_WORD (&result[result_pos - 2], _WRONG_STATE);
12245             break;
12246           }
12247           plci_b = li2_check_plci_b (Id, plci, plci_b_id, plci_b_write_pos, &result[result_pos - 2]);
12248           if (plci_b != NULL)
12249           {
12250             li2_update_connect (Id, a, plci, plci_b_id, true, li_flags);
12251             plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id |
12252               ((li_flags & (LI2_FLAG_INTERCONNECT_A_B | LI2_FLAG_INTERCONNECT_B_A |
12253               LI2_FLAG_PCCONNECT_A_B | LI2_FLAG_PCCONNECT_B_A)) ? 0 : LI_PLCI_B_DISC_FLAG);
12254             plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES-1) ? 0 : plci_b_write_pos + 1;
12255           }
12256           participant_parms_pos = (word)((&li_participant_struct[0].info[1 + li_participant_struct[0].length]) -
12257             (&li_req_parms[1].info[1]));
12258         }
12259         result[0] = (byte)(result_pos - 1);
12260         result[3] = (byte)(result_pos - 4);
12261         result[6] = (byte)(result_pos - 7);
12262         i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES-1 : plci_b_write_pos - 1;
12263         if ((plci_b_write_pos == plci->li_plci_b_read_pos)
12264          || (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG))
12265         {
12266           plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_FLAG | LI_PLCI_B_LAST_FLAG;
12267           plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES-1) ? 0 : plci_b_write_pos + 1;
12268         }
12269         else
12270           plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG;
12271         plci->li_plci_b_write_pos = plci_b_write_pos;
12272       }
12273       mixer_calculate_coefs (a);
12274       plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel;
12275       mixer_notify_update (plci, true);
12276       sendf (appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
12277         "wwS", Info, SELECTOR_LINE_INTERCONNECT, result);
12278       plci->command = 0;
12279       plci->li_cmd = GET_WORD (li_parms[0].info);
12280       start_internal_command (Id, plci, mixer_command);
12281       return (false);
12282
12283     case LI_REQ_DISCONNECT:
12284       if (li_parms[1].length == 4)
12285       {
12286         appl->appl_flags |= APPL_FLAG_OLD_LI_SPEC;
12287         if (api_parse (&li_parms[1].info[1], li_parms[1].length, "d", li_req_parms))
12288         {
12289           dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
12290             UnMapId (Id), (char   *)(FILE_), __LINE__));
12291           Info = _WRONG_MESSAGE_FORMAT;
12292           break;
12293         }
12294         plci_b_id = GET_DWORD (li_req_parms[0].info) & 0xffff;
12295         Info = li_check_main_plci (Id, plci);
12296         result_buffer[0] = 9;
12297         result_buffer[3] = 6;
12298         PUT_DWORD (&result_buffer[4], GET_DWORD (li_req_parms[0].info));
12299         PUT_WORD (&result_buffer[8], GOOD);
12300         if (Info != GOOD)
12301           break;
12302         result = plci->saved_msg.info;
12303         for (i = 0; i <= result_buffer[0]; i++)
12304           result[i] = result_buffer[i];
12305         plci_b_write_pos = plci->li_plci_b_write_pos;
12306         plci_b = li_check_plci_b (Id, plci, plci_b_id, plci_b_write_pos, &result[8]);
12307         if (plci_b == NULL)
12308           break;
12309         li_update_connect (Id, a, plci, plci_b_id, false, 0);
12310         plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG | LI_PLCI_B_LAST_FLAG;
12311         plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES-1) ? 0 : plci_b_write_pos + 1;
12312         plci->li_plci_b_write_pos = plci_b_write_pos;
12313       }
12314       else
12315       {
12316         appl->appl_flags &= ~APPL_FLAG_OLD_LI_SPEC;
12317         if (api_parse (&li_parms[1].info[1], li_parms[1].length, "s", li_req_parms))
12318         {
12319           dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
12320             UnMapId (Id), (char   *)(FILE_), __LINE__));
12321           Info = _WRONG_MESSAGE_FORMAT;
12322           break;
12323         }
12324         Info = li_check_main_plci (Id, plci);
12325         result_buffer[0] = 7;
12326         result_buffer[3] = 4;
12327         PUT_WORD (&result_buffer[4], Info);
12328         result_buffer[6] = 0;
12329         if (Info != GOOD)
12330           break;
12331         result = plci->saved_msg.info;
12332         for (i = 0; i <= result_buffer[0]; i++)
12333           result[i] = result_buffer[i];
12334         plci_b_write_pos = plci->li_plci_b_write_pos;
12335         participant_parms_pos = 0;
12336         result_pos = 7;
12337         while (participant_parms_pos < li_req_parms[0].length)
12338         {
12339           result[result_pos] = 6;
12340           result_pos += 7;
12341           PUT_DWORD (&result[result_pos - 6], 0);
12342           PUT_WORD (&result[result_pos - 2], GOOD);
12343           if (api_parse (&li_req_parms[0].info[1 + participant_parms_pos],
12344             (word)(li_parms[1].length - participant_parms_pos), "s", li_participant_struct))
12345           {
12346             dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
12347               UnMapId (Id), (char   *)(FILE_), __LINE__));
12348             PUT_WORD (&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12349             break;
12350           }
12351           if (api_parse (&li_participant_struct[0].info[1],
12352             li_participant_struct[0].length, "d", li_participant_parms))
12353           {
12354             dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
12355               UnMapId (Id), (char   *)(FILE_), __LINE__));
12356             PUT_WORD (&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12357             break;
12358           }
12359           plci_b_id = GET_DWORD (li_participant_parms[0].info) & 0xffff;
12360           PUT_DWORD (&result[result_pos - 6], plci_b_id);
12361           if (sizeof(result) - result_pos < 7)
12362           {
12363             dbug (1, dprintf ("[%06lx] %s,%d: LI result overrun",
12364               UnMapId (Id), (char   *)(FILE_), __LINE__));
12365             PUT_WORD (&result[result_pos - 2], _WRONG_STATE);
12366             break;
12367           }
12368           plci_b = li2_check_plci_b (Id, plci, plci_b_id, plci_b_write_pos, &result[result_pos - 2]);
12369           if (plci_b != NULL)
12370           {
12371             li2_update_connect (Id, a, plci, plci_b_id, false, 0);
12372             plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG;
12373             plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES-1) ? 0 : plci_b_write_pos + 1;
12374           }
12375           participant_parms_pos = (word)((&li_participant_struct[0].info[1 + li_participant_struct[0].length]) -
12376             (&li_req_parms[0].info[1]));
12377         }
12378         result[0] = (byte)(result_pos - 1);
12379         result[3] = (byte)(result_pos - 4);
12380         result[6] = (byte)(result_pos - 7);
12381         i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES-1 : plci_b_write_pos - 1;
12382         if ((plci_b_write_pos == plci->li_plci_b_read_pos)
12383          || (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG))
12384         {
12385           plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_FLAG | LI_PLCI_B_LAST_FLAG;
12386           plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES-1) ? 0 : plci_b_write_pos + 1;
12387         }
12388         else
12389           plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG;
12390         plci->li_plci_b_write_pos = plci_b_write_pos;
12391       }
12392       mixer_calculate_coefs (a);
12393       plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel;
12394       mixer_notify_update (plci, true);
12395       sendf (appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
12396         "wwS", Info, SELECTOR_LINE_INTERCONNECT, result);
12397       plci->command = 0;
12398       plci->li_cmd = GET_WORD (li_parms[0].info);
12399       start_internal_command (Id, plci, mixer_command);
12400       return (false);
12401
12402     case LI_REQ_SILENT_UPDATE:
12403       if (!plci || !plci->State
12404        || !plci->NL.Id || plci->nl_remove_id
12405        || (plci->li_bchannel_id == 0)
12406        || (li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci != plci))
12407       {
12408         dbug (1, dprintf ("[%06lx] %s,%d: Wrong state",
12409           UnMapId (Id), (char   *)(FILE_), __LINE__));
12410         return (false);
12411       }
12412       plci_b_write_pos = plci->li_plci_b_write_pos;
12413       if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
12414         LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2)
12415       {
12416         dbug (1, dprintf ("[%06lx] %s,%d: LI request overrun",
12417           UnMapId (Id), (char   *)(FILE_), __LINE__));
12418         return (false);
12419       }
12420       i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES-1 : plci_b_write_pos - 1;
12421       if ((plci_b_write_pos == plci->li_plci_b_read_pos)
12422        || (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG))
12423       {
12424         plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_FLAG | LI_PLCI_B_LAST_FLAG;
12425         plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES-1) ? 0 : plci_b_write_pos + 1;
12426       }
12427       else
12428         plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG;
12429       plci->li_plci_b_write_pos = plci_b_write_pos;
12430       plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel;
12431       plci->command = 0;
12432       plci->li_cmd = GET_WORD (li_parms[0].info);
12433       start_internal_command (Id, plci, mixer_command);
12434       return (false);
12435
12436     default:
12437       dbug (1, dprintf ("[%06lx] %s,%d: LI unknown request %04x",
12438         UnMapId (Id), (char   *)(FILE_), __LINE__, GET_WORD (li_parms[0].info)));
12439       Info = _FACILITY_NOT_SUPPORTED;
12440     }
12441   }
12442   sendf (appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
12443     "wwS", Info, SELECTOR_LINE_INTERCONNECT, result);
12444   return (false);
12445 }
12446
12447
12448 static void mixer_indication_coefs_set (dword Id, PLCI   *plci)
12449 {
12450   dword d;
12451   DIVA_CAPI_ADAPTER   *a;
12452     byte result[12];
12453
12454   dbug (1, dprintf ("[%06lx] %s,%d: mixer_indication_coefs_set",
12455     UnMapId (Id), (char   *)(FILE_), __LINE__));
12456
12457   a = plci->adapter;
12458   if (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos)
12459   {
12460     do
12461     {
12462       d = plci->li_plci_b_queue[plci->li_plci_b_read_pos];
12463       if (!(d & LI_PLCI_B_SKIP_FLAG))
12464       {
12465         if (plci->appl->appl_flags & APPL_FLAG_OLD_LI_SPEC)
12466         {
12467           if (d & LI_PLCI_B_DISC_FLAG)
12468           {
12469             result[0] = 5;
12470             PUT_WORD (&result[1], LI_IND_DISCONNECT);
12471             result[3] = 2;
12472             PUT_WORD (&result[4], _LI_USER_INITIATED);
12473           }
12474           else
12475           {
12476             result[0] = 7;
12477             PUT_WORD (&result[1], LI_IND_CONNECT_ACTIVE);
12478             result[3] = 4;
12479             PUT_DWORD (&result[4], d & ~LI_PLCI_B_FLAG_MASK);
12480           }
12481         }
12482         else
12483         {
12484           if (d & LI_PLCI_B_DISC_FLAG)
12485           {
12486             result[0] = 9;
12487             PUT_WORD (&result[1], LI_IND_DISCONNECT);
12488             result[3] = 6;
12489             PUT_DWORD (&result[4], d & ~LI_PLCI_B_FLAG_MASK);
12490             PUT_WORD (&result[8], _LI_USER_INITIATED);
12491           }
12492           else
12493           {
12494             result[0] = 7;
12495             PUT_WORD (&result[1], LI_IND_CONNECT_ACTIVE);
12496             result[3] = 4;
12497             PUT_DWORD (&result[4], d & ~LI_PLCI_B_FLAG_MASK);
12498           }
12499         }
12500         sendf (plci->appl, _FACILITY_I, Id & 0xffffL, 0,
12501           "ws", SELECTOR_LINE_INTERCONNECT, result);
12502       }
12503       plci->li_plci_b_read_pos = (plci->li_plci_b_read_pos == LI_PLCI_B_QUEUE_ENTRIES-1) ?
12504         0 : plci->li_plci_b_read_pos + 1;
12505     } while (!(d & LI_PLCI_B_LAST_FLAG) && (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos));
12506   }
12507 }
12508
12509
12510 static void mixer_indication_xconnect_from (dword Id, PLCI   *plci, byte   *msg, word length)
12511 {
12512   word i, j, ch;
12513   struct xconnect_transfer_address_s s,   *p;
12514   DIVA_CAPI_ADAPTER   *a;
12515
12516   dbug (1, dprintf ("[%06lx] %s,%d: mixer_indication_xconnect_from %d",
12517     UnMapId (Id), (char   *)(FILE_), __LINE__, (int) length));
12518
12519   a = plci->adapter;
12520   i = 1;
12521   for (i = 1; i < length; i += 16)
12522   {
12523     s.card_address.low = msg[i] | (msg[i+1] << 8) | (((dword)(msg[i+2])) << 16) | (((dword)(msg[i+3])) << 24);
12524     s.card_address.high = msg[i+4] | (msg[i+5] << 8) | (((dword)(msg[i+6])) << 16) | (((dword)(msg[i+7])) << 24);
12525     s.offset = msg[i+8] | (msg[i+9] << 8) | (((dword)(msg[i+10])) << 16) | (((dword)(msg[i+11])) << 24);
12526     ch = msg[i+12] | (msg[i+13] << 8);
12527     j = ch & XCONNECT_CHANNEL_NUMBER_MASK;
12528     if (!a->li_pri && (plci->li_bchannel_id == 2))
12529       j = 1 - j;
12530     j += a->li_base;
12531     if (ch & XCONNECT_CHANNEL_PORT_PC)
12532       p = &(li_config_table[j].send_pc);
12533     else
12534       p = &(li_config_table[j].send_b);
12535     p->card_address.low = s.card_address.low;
12536     p->card_address.high = s.card_address.high;
12537     p->offset = s.offset;
12538     li_config_table[j].channel |= LI_CHANNEL_ADDRESSES_SET;
12539   }
12540   if (plci->internal_command_queue[0]
12541    && ((plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2)
12542     || (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_3)
12543     || (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_4)))
12544   {
12545     (*(plci->internal_command_queue[0]))(Id, plci, 0);
12546     if (!plci->internal_command)
12547       next_internal_command (Id, plci);
12548   }
12549   mixer_notify_update (plci, true);
12550 }
12551
12552
12553 static void mixer_indication_xconnect_to (dword Id, PLCI   *plci, byte   *msg, word length)
12554 {
12555
12556   dbug (1, dprintf ("[%06lx] %s,%d: mixer_indication_xconnect_to %d",
12557     UnMapId (Id), (char   *)(FILE_), __LINE__, (int) length));
12558
12559 }
12560
12561
12562 static byte mixer_notify_source_removed (PLCI   *plci, dword plci_b_id)
12563 {
12564   word plci_b_write_pos;
12565
12566   plci_b_write_pos = plci->li_plci_b_write_pos;
12567   if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
12568     LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 1)
12569   {
12570     dbug (1, dprintf ("[%06lx] %s,%d: LI request overrun",
12571       (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
12572       (char   *)(FILE_), __LINE__));
12573     return (false);
12574   }
12575   plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG;
12576   plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES-1) ? 0 : plci_b_write_pos + 1;
12577   plci->li_plci_b_write_pos = plci_b_write_pos;
12578   return (true);
12579 }
12580
12581
12582 static void mixer_remove (PLCI   *plci)
12583 {
12584   DIVA_CAPI_ADAPTER   *a;
12585   PLCI   *notify_plci;
12586   dword plci_b_id;
12587   word i, j;
12588
12589   dbug (1, dprintf ("[%06lx] %s,%d: mixer_remove",
12590     (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
12591     (char   *)(FILE_), __LINE__));
12592
12593   a = plci->adapter;
12594   plci_b_id = (plci->Id << 8) | UnMapController (plci->adapter->Id);
12595   if (a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED)
12596   {
12597     if ((plci->li_bchannel_id != 0)
12598      && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
12599     {
12600       i = a->li_base + (plci->li_bchannel_id - 1);
12601       if ((li_config_table[i].curchnl | li_config_table[i].channel) & LI_CHANNEL_INVOLVED)
12602       {
12603         for (j = 0; j < li_total_channels; j++)
12604         {
12605           if ((li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
12606            || (li_config_table[j].flag_table[i] & LI_FLAG_INTERCONNECT))
12607           {
12608             notify_plci = li_config_table[j].plci;
12609             if ((notify_plci != NULL)
12610              && (notify_plci != plci)
12611              && (notify_plci->appl != NULL)
12612              && !(notify_plci->appl->appl_flags & APPL_FLAG_OLD_LI_SPEC)
12613              && (notify_plci->State)
12614              && notify_plci->NL.Id && !notify_plci->nl_remove_id)
12615             {
12616               mixer_notify_source_removed (notify_plci, plci_b_id);
12617             }
12618           }
12619         }
12620         mixer_clear_config (plci);
12621         mixer_calculate_coefs (a);
12622         mixer_notify_update (plci, true);
12623       }
12624       li_config_table[i].plci = NULL;
12625       plci->li_bchannel_id = 0;
12626     }
12627   }
12628 }
12629
12630
12631 /*------------------------------------------------------------------*/
12632 /* Echo canceller facilities                                        */
12633 /*------------------------------------------------------------------*/
12634
12635
12636 static void ec_write_parameters (PLCI   *plci)
12637 {
12638   word w;
12639     byte parameter_buffer[6];
12640
12641   dbug (1, dprintf ("[%06lx] %s,%d: ec_write_parameters",
12642     (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
12643     (char   *)(FILE_), __LINE__));
12644
12645   parameter_buffer[0] = 5;
12646   parameter_buffer[1] = DSP_CTRL_SET_LEC_PARAMETERS;
12647   PUT_WORD (&parameter_buffer[2], plci->ec_idi_options);
12648   plci->ec_idi_options &= ~LEC_RESET_COEFFICIENTS;
12649   w = (plci->ec_tail_length == 0) ? 128 : plci->ec_tail_length;
12650   PUT_WORD (&parameter_buffer[4], w);
12651   add_p (plci, FTY, parameter_buffer);
12652   sig_req (plci, TEL_CTRL, 0);
12653   send_req (plci);
12654 }
12655
12656
12657 static void ec_clear_config (PLCI   *plci)
12658 {
12659
12660   dbug (1, dprintf ("[%06lx] %s,%d: ec_clear_config",
12661     (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
12662     (char   *)(FILE_), __LINE__));
12663
12664   plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER |
12665     LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING;
12666   plci->ec_tail_length = 0;
12667 }
12668
12669
12670 static void ec_prepare_switch (dword Id, PLCI   *plci)
12671 {
12672
12673   dbug (1, dprintf ("[%06lx] %s,%d: ec_prepare_switch",
12674     UnMapId (Id), (char   *)(FILE_), __LINE__));
12675
12676 }
12677
12678
12679 static word ec_save_config (dword Id, PLCI   *plci, byte Rc)
12680 {
12681
12682   dbug (1, dprintf ("[%06lx] %s,%d: ec_save_config %02x %d",
12683     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
12684
12685   return (GOOD);
12686 }
12687
12688
12689 static word ec_restore_config (dword Id, PLCI   *plci, byte Rc)
12690 {
12691   word Info;
12692
12693   dbug (1, dprintf ("[%06lx] %s,%d: ec_restore_config %02x %d",
12694     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
12695
12696   Info = GOOD;
12697   if (plci->B1_facilities & B1_FACILITY_EC)
12698   {
12699     switch (plci->adjust_b_state)
12700     {
12701     case ADJUST_B_RESTORE_EC_1:
12702       plci->internal_command = plci->adjust_b_command;
12703       if (plci->sig_req)
12704       {
12705         plci->adjust_b_state = ADJUST_B_RESTORE_EC_1;
12706         break;
12707       }
12708       ec_write_parameters (plci);
12709       plci->adjust_b_state = ADJUST_B_RESTORE_EC_2;
12710       break;
12711     case ADJUST_B_RESTORE_EC_2:
12712       if ((Rc != OK) && (Rc != OK_FC))
12713       {
12714         dbug (1, dprintf ("[%06lx] %s,%d: Restore EC failed %02x",
12715           UnMapId (Id), (char   *)(FILE_), __LINE__, Rc));
12716         Info = _WRONG_STATE;
12717         break;
12718       }
12719       break;
12720     }
12721   }
12722   return (Info);
12723 }
12724
12725
12726 static void ec_command (dword Id, PLCI   *plci, byte Rc)
12727 {
12728   word internal_command, Info;
12729     byte result[8];
12730
12731   dbug (1, dprintf ("[%06lx] %s,%d: ec_command %02x %04x %04x %04x %d",
12732     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->internal_command,
12733     plci->ec_cmd, plci->ec_idi_options, plci->ec_tail_length));
12734
12735   Info = GOOD;
12736   if (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC)
12737   {
12738     result[0] = 2;
12739     PUT_WORD (&result[1], EC_SUCCESS);
12740   }
12741   else
12742   {
12743     result[0] = 5;
12744     PUT_WORD (&result[1], plci->ec_cmd);
12745     result[3] = 2;
12746     PUT_WORD (&result[4], GOOD);
12747   }
12748   internal_command = plci->internal_command;
12749   plci->internal_command = 0;
12750   switch (plci->ec_cmd)
12751   {
12752   case EC_ENABLE_OPERATION:
12753   case EC_FREEZE_COEFFICIENTS:
12754   case EC_RESUME_COEFFICIENT_UPDATE:
12755   case EC_RESET_COEFFICIENTS:
12756     switch (internal_command)
12757     {
12758     default:
12759       adjust_b1_resource (Id, plci, NULL, (word)(plci->B1_facilities |
12760         B1_FACILITY_EC), EC_COMMAND_1);
12761     case EC_COMMAND_1:
12762       if (adjust_b_process (Id, plci, Rc) != GOOD)
12763       {
12764         dbug (1, dprintf ("[%06lx] %s,%d: Load EC failed",
12765           UnMapId (Id), (char   *)(FILE_), __LINE__));
12766         Info = _FACILITY_NOT_SUPPORTED;
12767         break;
12768       }
12769       if (plci->internal_command)
12770         return;
12771     case EC_COMMAND_2:
12772       if (plci->sig_req)
12773       {
12774         plci->internal_command = EC_COMMAND_2;
12775         return;
12776       }
12777       plci->internal_command = EC_COMMAND_3;
12778       ec_write_parameters (plci);
12779       return;
12780     case EC_COMMAND_3:
12781       if ((Rc != OK) && (Rc != OK_FC))
12782       {
12783         dbug (1, dprintf ("[%06lx] %s,%d: Enable EC failed %02x",
12784           UnMapId (Id), (char   *)(FILE_), __LINE__, Rc));
12785         Info = _FACILITY_NOT_SUPPORTED;
12786         break;
12787       }
12788       break;
12789     }
12790     break;
12791
12792   case EC_DISABLE_OPERATION:
12793     switch (internal_command)
12794     {
12795     default:
12796     case EC_COMMAND_1:
12797       if (plci->B1_facilities & B1_FACILITY_EC)
12798       {
12799         if (plci->sig_req)
12800         {
12801           plci->internal_command = EC_COMMAND_1;
12802           return;
12803         }
12804         plci->internal_command = EC_COMMAND_2;
12805         ec_write_parameters (plci);
12806         return;
12807       }
12808       Rc = OK;
12809     case EC_COMMAND_2:
12810       if ((Rc != OK) && (Rc != OK_FC))
12811       {
12812         dbug (1, dprintf ("[%06lx] %s,%d: Disable EC failed %02x",
12813           UnMapId (Id), (char   *)(FILE_), __LINE__, Rc));
12814         Info = _FACILITY_NOT_SUPPORTED;
12815         break;
12816       }
12817       adjust_b1_resource (Id, plci, NULL, (word)(plci->B1_facilities &
12818         ~B1_FACILITY_EC), EC_COMMAND_3);
12819     case EC_COMMAND_3:
12820       if (adjust_b_process (Id, plci, Rc) != GOOD)
12821       {
12822         dbug (1, dprintf ("[%06lx] %s,%d: Unload EC failed",
12823           UnMapId (Id), (char   *)(FILE_), __LINE__));
12824         Info = _FACILITY_NOT_SUPPORTED;
12825         break;
12826       }
12827       if (plci->internal_command)
12828         return;
12829       break;
12830     }
12831     break;
12832   }
12833   sendf (plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->number,
12834     "wws", Info, (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ?
12835     PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result);
12836 }
12837
12838
12839 static byte ec_request (dword Id, word Number, DIVA_CAPI_ADAPTER   *a, PLCI   *plci, APPL   *appl, API_PARSE *msg)
12840 {
12841   word Info;
12842   word opt;
12843     API_PARSE ec_parms[3];
12844     byte result[16];
12845
12846   dbug (1, dprintf ("[%06lx] %s,%d: ec_request",
12847     UnMapId (Id), (char   *)(FILE_), __LINE__));
12848
12849   Info = GOOD;
12850   result[0] = 0;
12851   if (!(a->man_profile.private_options & (1L << PRIVATE_ECHO_CANCELLER)))
12852   {
12853     dbug (1, dprintf ("[%06lx] %s,%d: Facility not supported",
12854       UnMapId (Id), (char   *)(FILE_), __LINE__));
12855     Info = _FACILITY_NOT_SUPPORTED;
12856   }
12857   else
12858   {
12859     if (appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC)
12860     {
12861       if (api_parse (&msg[1].info[1], msg[1].length, "w", ec_parms))
12862       {
12863         dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
12864           UnMapId (Id), (char   *)(FILE_), __LINE__));
12865         Info = _WRONG_MESSAGE_FORMAT;
12866       }
12867       else
12868       {
12869         if (plci == NULL)
12870         {
12871           dbug (1, dprintf ("[%06lx] %s,%d: Wrong PLCI",
12872             UnMapId (Id), (char   *)(FILE_), __LINE__));
12873           Info = _WRONG_IDENTIFIER;
12874         }
12875         else if (!plci->State || !plci->NL.Id || plci->nl_remove_id)
12876         {
12877           dbug (1, dprintf ("[%06lx] %s,%d: Wrong state",
12878             UnMapId (Id), (char   *)(FILE_), __LINE__));
12879           Info = _WRONG_STATE;
12880         }
12881         else
12882         {
12883           plci->command = 0;
12884           plci->ec_cmd = GET_WORD (ec_parms[0].info);
12885           plci->ec_idi_options &= ~(LEC_MANUAL_DISABLE | LEC_RESET_COEFFICIENTS);
12886           result[0] = 2;
12887           PUT_WORD (&result[1], EC_SUCCESS);
12888           if (msg[1].length >= 4)
12889           {
12890             opt = GET_WORD (&ec_parms[0].info[2]);
12891             plci->ec_idi_options &= ~(LEC_ENABLE_NONLINEAR_PROCESSING |
12892               LEC_ENABLE_2100HZ_DETECTOR | LEC_REQUIRE_2100HZ_REVERSALS);
12893             if (!(opt & EC_DISABLE_NON_LINEAR_PROCESSING))
12894               plci->ec_idi_options |= LEC_ENABLE_NONLINEAR_PROCESSING;
12895             if (opt & EC_DETECT_DISABLE_TONE)
12896               plci->ec_idi_options |= LEC_ENABLE_2100HZ_DETECTOR;
12897             if (!(opt & EC_DO_NOT_REQUIRE_REVERSALS))
12898               plci->ec_idi_options |= LEC_REQUIRE_2100HZ_REVERSALS;
12899             if (msg[1].length >= 6)
12900             {
12901               plci->ec_tail_length = GET_WORD (&ec_parms[0].info[4]);
12902             }
12903           }
12904           switch (plci->ec_cmd)
12905           {
12906           case EC_ENABLE_OPERATION:
12907             plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS;
12908             start_internal_command (Id, plci, ec_command);
12909             return (false);
12910
12911           case EC_DISABLE_OPERATION:
12912             plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER |
12913               LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING |
12914               LEC_RESET_COEFFICIENTS;
12915             start_internal_command (Id, plci, ec_command);
12916             return (false);
12917
12918           case EC_FREEZE_COEFFICIENTS:
12919             plci->ec_idi_options |= LEC_FREEZE_COEFFICIENTS;
12920             start_internal_command (Id, plci, ec_command);
12921             return (false);
12922
12923           case EC_RESUME_COEFFICIENT_UPDATE:
12924             plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS;
12925             start_internal_command (Id, plci, ec_command);
12926             return (false);
12927
12928           case EC_RESET_COEFFICIENTS:
12929             plci->ec_idi_options |= LEC_RESET_COEFFICIENTS;
12930             start_internal_command (Id, plci, ec_command);
12931             return (false);
12932
12933           default:
12934             dbug (1, dprintf ("[%06lx] %s,%d: EC unknown request %04x",
12935               UnMapId (Id), (char   *)(FILE_), __LINE__, plci->ec_cmd));
12936             PUT_WORD (&result[1], EC_UNSUPPORTED_OPERATION);
12937           }
12938         }
12939       }
12940     }
12941     else
12942     {
12943       if (api_parse (&msg[1].info[1], msg[1].length, "ws", ec_parms))
12944       {
12945         dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
12946           UnMapId (Id), (char   *)(FILE_), __LINE__));
12947         Info = _WRONG_MESSAGE_FORMAT;
12948       }
12949       else
12950       {
12951         if (GET_WORD (ec_parms[0].info) == EC_GET_SUPPORTED_SERVICES)
12952         {
12953           result[0] = 11;
12954           PUT_WORD (&result[1], EC_GET_SUPPORTED_SERVICES);
12955           result[3] = 8;
12956           PUT_WORD (&result[4], GOOD);
12957           PUT_WORD (&result[6], 0x0007);
12958           PUT_WORD (&result[8], LEC_MAX_SUPPORTED_TAIL_LENGTH);
12959           PUT_WORD (&result[10], 0);
12960         }
12961         else if (plci == NULL)
12962         {
12963           dbug (1, dprintf ("[%06lx] %s,%d: Wrong PLCI",
12964             UnMapId (Id), (char   *)(FILE_), __LINE__));
12965           Info = _WRONG_IDENTIFIER;
12966         }
12967         else if (!plci->State || !plci->NL.Id || plci->nl_remove_id)
12968         {
12969           dbug (1, dprintf ("[%06lx] %s,%d: Wrong state",
12970             UnMapId (Id), (char   *)(FILE_), __LINE__));
12971           Info = _WRONG_STATE;
12972         }
12973         else
12974         {
12975           plci->command = 0;
12976           plci->ec_cmd = GET_WORD (ec_parms[0].info);
12977           plci->ec_idi_options &= ~(LEC_MANUAL_DISABLE | LEC_RESET_COEFFICIENTS);
12978           result[0] = 5;
12979           PUT_WORD (&result[1], plci->ec_cmd);
12980           result[3] = 2;
12981           PUT_WORD (&result[4], GOOD);
12982           plci->ec_idi_options &= ~(LEC_ENABLE_NONLINEAR_PROCESSING |
12983             LEC_ENABLE_2100HZ_DETECTOR | LEC_REQUIRE_2100HZ_REVERSALS);
12984           plci->ec_tail_length = 0;
12985           if (ec_parms[1].length >= 2)
12986           {
12987             opt = GET_WORD (&ec_parms[1].info[1]);
12988             if (opt & EC_ENABLE_NON_LINEAR_PROCESSING)
12989               plci->ec_idi_options |= LEC_ENABLE_NONLINEAR_PROCESSING;
12990             if (opt & EC_DETECT_DISABLE_TONE)
12991               plci->ec_idi_options |= LEC_ENABLE_2100HZ_DETECTOR;
12992             if (!(opt & EC_DO_NOT_REQUIRE_REVERSALS))
12993               plci->ec_idi_options |= LEC_REQUIRE_2100HZ_REVERSALS;
12994             if (ec_parms[1].length >= 4)
12995             {
12996               plci->ec_tail_length = GET_WORD (&ec_parms[1].info[3]);
12997             }
12998           }
12999           switch (plci->ec_cmd)
13000           {
13001           case EC_ENABLE_OPERATION:
13002             plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS;
13003             start_internal_command (Id, plci, ec_command);
13004             return (false);
13005
13006           case EC_DISABLE_OPERATION:
13007             plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER |
13008               LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING |
13009               LEC_RESET_COEFFICIENTS;
13010             start_internal_command (Id, plci, ec_command);
13011             return (false);
13012
13013           default:
13014             dbug (1, dprintf ("[%06lx] %s,%d: EC unknown request %04x",
13015               UnMapId (Id), (char   *)(FILE_), __LINE__, plci->ec_cmd));
13016             PUT_WORD (&result[4], _FACILITY_SPECIFIC_FUNCTION_NOT_SUPP);
13017           }
13018         }
13019       }
13020     }
13021   }
13022   sendf (appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
13023     "wws", Info, (appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ?
13024     PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result);
13025   return (false);
13026 }
13027
13028
13029 static void ec_indication (dword Id, PLCI   *plci, byte   *msg, word length)
13030 {
13031     byte result[8];
13032
13033   dbug (1, dprintf ("[%06lx] %s,%d: ec_indication",
13034     UnMapId (Id), (char   *)(FILE_), __LINE__));
13035
13036   if (!(plci->ec_idi_options & LEC_MANUAL_DISABLE))
13037   {
13038     if (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC)
13039     {
13040       result[0] = 2;
13041       PUT_WORD (&result[1], 0);
13042       switch (msg[1])
13043       {
13044       case LEC_DISABLE_TYPE_CONTIGNUOUS_2100HZ:
13045         PUT_WORD (&result[1], EC_BYPASS_DUE_TO_CONTINUOUS_2100HZ);
13046         break;
13047       case LEC_DISABLE_TYPE_REVERSED_2100HZ:
13048         PUT_WORD (&result[1], EC_BYPASS_DUE_TO_REVERSED_2100HZ);
13049         break;
13050       case LEC_DISABLE_RELEASED:
13051         PUT_WORD (&result[1], EC_BYPASS_RELEASED);
13052         break;
13053       }
13054     }
13055     else
13056     {
13057       result[0] = 5;
13058       PUT_WORD (&result[1], EC_BYPASS_INDICATION);
13059       result[3] = 2;
13060       PUT_WORD (&result[4], 0);
13061       switch (msg[1])
13062       {
13063       case LEC_DISABLE_TYPE_CONTIGNUOUS_2100HZ:
13064         PUT_WORD (&result[4], EC_BYPASS_DUE_TO_CONTINUOUS_2100HZ);
13065         break;
13066       case LEC_DISABLE_TYPE_REVERSED_2100HZ:
13067         PUT_WORD (&result[4], EC_BYPASS_DUE_TO_REVERSED_2100HZ);
13068         break;
13069       case LEC_DISABLE_RELEASED:
13070         PUT_WORD (&result[4], EC_BYPASS_RELEASED);
13071         break;
13072       }
13073     }
13074     sendf (plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ?
13075       PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result);
13076   }
13077 }
13078
13079
13080
13081 /*------------------------------------------------------------------*/
13082 /* Advanced voice                                                   */
13083 /*------------------------------------------------------------------*/
13084
13085 static void adv_voice_write_coefs (PLCI   *plci, word write_command)
13086 {
13087   DIVA_CAPI_ADAPTER   *a;
13088   word i;
13089   byte *p;
13090
13091   word w, n, j, k;
13092   byte ch_map[MIXER_CHANNELS_BRI];
13093
13094     byte coef_buffer[ADV_VOICE_COEF_BUFFER_SIZE + 2];
13095
13096   dbug (1, dprintf ("[%06lx] %s,%d: adv_voice_write_coefs %d",
13097     (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
13098     (char   *)(FILE_), __LINE__, write_command));
13099
13100   a = plci->adapter;
13101   p = coef_buffer + 1;
13102   *(p++) = DSP_CTRL_OLD_SET_MIXER_COEFFICIENTS;
13103   i = 0;
13104   while (i + sizeof(word) <= a->adv_voice_coef_length)
13105   {
13106     PUT_WORD (p, GET_WORD (a->adv_voice_coef_buffer + i));
13107     p += 2;
13108     i += 2;
13109   }
13110   while (i < ADV_VOICE_OLD_COEF_COUNT * sizeof(word))
13111   {
13112     PUT_WORD (p, 0x8000);
13113     p += 2;
13114     i += 2;
13115   }
13116
13117   if (!a->li_pri && (plci->li_bchannel_id == 0))
13118   {
13119     if ((li_config_table[a->li_base].plci == NULL) && (li_config_table[a->li_base + 1].plci != NULL))
13120     {
13121       plci->li_bchannel_id = 1;
13122       li_config_table[a->li_base].plci = plci;
13123       dbug (1, dprintf ("[%06lx] %s,%d: adv_voice_set_bchannel_id %d",
13124         (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
13125         (char   *)(FILE_), __LINE__, plci->li_bchannel_id));
13126     }
13127     else if ((li_config_table[a->li_base].plci != NULL) && (li_config_table[a->li_base + 1].plci == NULL))
13128     {
13129       plci->li_bchannel_id = 2;
13130       li_config_table[a->li_base + 1].plci = plci;
13131       dbug (1, dprintf ("[%06lx] %s,%d: adv_voice_set_bchannel_id %d",
13132         (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
13133         (char   *)(FILE_), __LINE__, plci->li_bchannel_id));
13134     }
13135   }
13136   if (!a->li_pri && (plci->li_bchannel_id != 0)
13137    && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
13138   {
13139     i = a->li_base + (plci->li_bchannel_id - 1);
13140     switch (write_command)
13141     {
13142     case ADV_VOICE_WRITE_ACTIVATION:
13143       j = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
13144       k = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
13145       if (!(plci->B1_facilities & B1_FACILITY_MIXER))
13146       {
13147         li_config_table[j].flag_table[i] |= LI_FLAG_CONFERENCE | LI_FLAG_MIX;
13148         li_config_table[i].flag_table[j] |= LI_FLAG_CONFERENCE | LI_FLAG_MONITOR;
13149       }
13150       if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13151       {
13152         li_config_table[k].flag_table[i] |= LI_FLAG_CONFERENCE | LI_FLAG_MIX;
13153         li_config_table[i].flag_table[k] |= LI_FLAG_CONFERENCE | LI_FLAG_MONITOR;
13154         li_config_table[k].flag_table[j] |= LI_FLAG_CONFERENCE;
13155         li_config_table[j].flag_table[k] |= LI_FLAG_CONFERENCE;
13156       }
13157       mixer_calculate_coefs (a);
13158       li_config_table[i].curchnl = li_config_table[i].channel;
13159       li_config_table[j].curchnl = li_config_table[j].channel;
13160       if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13161         li_config_table[k].curchnl = li_config_table[k].channel;
13162       break;
13163
13164     case ADV_VOICE_WRITE_DEACTIVATION:
13165       for (j = 0; j < li_total_channels; j++)
13166       {
13167         li_config_table[i].flag_table[j] = 0;
13168         li_config_table[j].flag_table[i] = 0;
13169       }
13170       k = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
13171       for (j = 0; j < li_total_channels; j++)
13172       {
13173         li_config_table[k].flag_table[j] = 0;
13174         li_config_table[j].flag_table[k] = 0;
13175       }
13176       if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13177       {
13178         k = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
13179         for (j = 0; j < li_total_channels; j++)
13180         {
13181           li_config_table[k].flag_table[j] = 0;
13182           li_config_table[j].flag_table[k] = 0;
13183         }
13184       }
13185       mixer_calculate_coefs (a);
13186       break;
13187     }
13188     if (plci->B1_facilities & B1_FACILITY_MIXER)
13189     {
13190       w = 0;
13191       if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length)
13192         w = GET_WORD (a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE);
13193       if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
13194         w |= MIXER_FEATURE_ENABLE_TX_DATA;
13195       if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
13196         w |= MIXER_FEATURE_ENABLE_RX_DATA;
13197       *(p++) = (byte) w;
13198       *(p++) = (byte)(w >> 8);
13199       for (j = 0; j < sizeof(ch_map); j += 2)
13200       {
13201         ch_map[j] = (byte)(j + (plci->li_bchannel_id - 1));
13202         ch_map[j+1] = (byte)(j + (2 - plci->li_bchannel_id));
13203       }
13204       for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++)
13205       {
13206         i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch];
13207         j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch];
13208         if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED)
13209         {
13210           *(p++) = ((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01);
13211           w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
13212           li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4;
13213         }
13214         else
13215         {
13216           *(p++) = (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + n < a->adv_voice_coef_length) ?
13217             a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + n] : 0x00;
13218         }
13219       }
13220     }
13221     else
13222     {
13223       for (i = ADV_VOICE_NEW_COEF_BASE; i < a->adv_voice_coef_length; i++)
13224         *(p++) = a->adv_voice_coef_buffer[i];
13225     }
13226   }
13227   else
13228
13229   {
13230     for (i = ADV_VOICE_NEW_COEF_BASE; i < a->adv_voice_coef_length; i++)
13231       *(p++) = a->adv_voice_coef_buffer[i];
13232   }
13233   coef_buffer[0] = (p - coef_buffer) - 1;
13234   add_p (plci, FTY, coef_buffer);
13235   sig_req (plci, TEL_CTRL, 0);
13236   send_req (plci);
13237 }
13238
13239
13240 static void adv_voice_clear_config (PLCI   *plci)
13241 {
13242   DIVA_CAPI_ADAPTER   *a;
13243
13244   word i, j;
13245
13246
13247   dbug (1, dprintf ("[%06lx] %s,%d: adv_voice_clear_config",
13248     (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
13249     (char   *)(FILE_), __LINE__));
13250
13251   a = plci->adapter;
13252   if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
13253   {
13254     a->adv_voice_coef_length = 0;
13255
13256     if (!a->li_pri && (plci->li_bchannel_id != 0)
13257      && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
13258     {
13259       i = a->li_base + (plci->li_bchannel_id - 1);
13260       li_config_table[i].curchnl = 0;
13261       li_config_table[i].channel = 0;
13262       li_config_table[i].chflags = 0;
13263       for (j = 0; j < li_total_channels; j++)
13264       {
13265         li_config_table[i].flag_table[j] = 0;
13266         li_config_table[j].flag_table[i] = 0;
13267         li_config_table[i].coef_table[j] = 0;
13268         li_config_table[j].coef_table[i] = 0;
13269       }
13270       li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET;
13271       i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
13272       li_config_table[i].curchnl = 0;
13273       li_config_table[i].channel = 0;
13274       li_config_table[i].chflags = 0;
13275       for (j = 0; j < li_total_channels; j++)
13276       {
13277         li_config_table[i].flag_table[j] = 0;
13278         li_config_table[j].flag_table[i] = 0;
13279         li_config_table[i].coef_table[j] = 0;
13280         li_config_table[j].coef_table[i] = 0;
13281       }
13282       if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13283       {
13284         i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
13285         li_config_table[i].curchnl = 0;
13286         li_config_table[i].channel = 0;
13287         li_config_table[i].chflags = 0;
13288         for (j = 0; j < li_total_channels; j++)
13289         {
13290           li_config_table[i].flag_table[j] = 0;
13291           li_config_table[j].flag_table[i] = 0;
13292           li_config_table[i].coef_table[j] = 0;
13293           li_config_table[j].coef_table[i] = 0;
13294         }
13295       }
13296     }
13297
13298   }
13299 }
13300
13301
13302 static void adv_voice_prepare_switch (dword Id, PLCI   *plci)
13303 {
13304
13305   dbug (1, dprintf ("[%06lx] %s,%d: adv_voice_prepare_switch",
13306     UnMapId (Id), (char   *)(FILE_), __LINE__));
13307
13308 }
13309
13310
13311 static word adv_voice_save_config (dword Id, PLCI   *plci, byte Rc)
13312 {
13313
13314   dbug (1, dprintf ("[%06lx] %s,%d: adv_voice_save_config %02x %d",
13315     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
13316
13317   return (GOOD);
13318 }
13319
13320
13321 static word adv_voice_restore_config (dword Id, PLCI   *plci, byte Rc)
13322 {
13323   DIVA_CAPI_ADAPTER   *a;
13324   word Info;
13325
13326   dbug (1, dprintf ("[%06lx] %s,%d: adv_voice_restore_config %02x %d",
13327     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
13328
13329   Info = GOOD;
13330   a = plci->adapter;
13331   if ((plci->B1_facilities & B1_FACILITY_VOICE)
13332    && (plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
13333   {
13334     switch (plci->adjust_b_state)
13335     {
13336     case ADJUST_B_RESTORE_VOICE_1:
13337       plci->internal_command = plci->adjust_b_command;
13338       if (plci->sig_req)
13339       {
13340         plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_1;
13341         break;
13342       }
13343       adv_voice_write_coefs (plci, ADV_VOICE_WRITE_UPDATE);
13344       plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_2;
13345       break;
13346     case ADJUST_B_RESTORE_VOICE_2:
13347       if ((Rc != OK) && (Rc != OK_FC))
13348       {
13349         dbug (1, dprintf ("[%06lx] %s,%d: Restore voice config failed %02x",
13350           UnMapId (Id), (char   *)(FILE_), __LINE__, Rc));
13351         Info = _WRONG_STATE;
13352         break;
13353       }
13354       break;
13355     }
13356   }
13357   return (Info);
13358 }
13359
13360
13361
13362
13363 /*------------------------------------------------------------------*/
13364 /* B1 resource switching                                            */
13365 /*------------------------------------------------------------------*/
13366
13367 static byte b1_facilities_table[] =
13368 {
13369   0x00,  /* 0  No bchannel resources      */
13370   0x00,  /* 1  Codec (automatic law)      */
13371   0x00,  /* 2  Codec (A-law)              */
13372   0x00,  /* 3  Codec (y-law)              */
13373   0x00,  /* 4  HDLC for X.21              */
13374   0x00,  /* 5  HDLC                       */
13375   0x00,  /* 6  External Device 0          */
13376   0x00,  /* 7  External Device 1          */
13377   0x00,  /* 8  HDLC 56k                   */
13378   0x00,  /* 9  Transparent                */
13379   0x00,  /* 10 Loopback to network        */
13380   0x00,  /* 11 Test pattern to net        */
13381   0x00,  /* 12 Rate adaptation sync       */
13382   0x00,  /* 13 Rate adaptation async      */
13383   0x00,  /* 14 R-Interface                */
13384   0x00,  /* 15 HDLC 128k leased line      */
13385   0x00,  /* 16 FAX                        */
13386   0x00,  /* 17 Modem async                */
13387   0x00,  /* 18 Modem sync HDLC            */
13388   0x00,  /* 19 V.110 async HDLC           */
13389   0x12,  /* 20 Adv voice (Trans,mixer)    */
13390   0x00,  /* 21 Codec connected to IC      */
13391   0x0c,  /* 22 Trans,DTMF                 */
13392   0x1e,  /* 23 Trans,DTMF+mixer           */
13393   0x1f,  /* 24 Trans,DTMF+mixer+local     */
13394   0x13,  /* 25 Trans,mixer+local          */
13395   0x12,  /* 26 HDLC,mixer                 */
13396   0x12,  /* 27 HDLC 56k,mixer             */
13397   0x2c,  /* 28 Trans,LEC+DTMF             */
13398   0x3e,  /* 29 Trans,LEC+DTMF+mixer       */
13399   0x3f,  /* 30 Trans,LEC+DTMF+mixer+local */
13400   0x2c,  /* 31 RTP,LEC+DTMF               */
13401   0x3e,  /* 32 RTP,LEC+DTMF+mixer         */
13402   0x3f,  /* 33 RTP,LEC+DTMF+mixer+local   */
13403   0x00,  /* 34 Signaling task             */
13404   0x00,  /* 35 PIAFS                      */
13405   0x0c,  /* 36 Trans,DTMF+TONE            */
13406   0x1e,  /* 37 Trans,DTMF+TONE+mixer      */
13407   0x1f   /* 38 Trans,DTMF+TONE+mixer+local*/
13408 };
13409
13410
13411 static word get_b1_facilities (PLCI   * plci, byte b1_resource)
13412 {
13413   word b1_facilities;
13414
13415   b1_facilities = b1_facilities_table[b1_resource];
13416   if ((b1_resource == 9) || (b1_resource == 20) || (b1_resource == 25))
13417   {
13418
13419     if (!(((plci->requested_options_conn | plci->requested_options) & (1L << PRIVATE_DTMF_TONE))
13420        || (plci->appl && (plci->adapter->requested_options_table[plci->appl->Id-1] & (1L << PRIVATE_DTMF_TONE)))))
13421
13422     {
13423       if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_SEND)
13424         b1_facilities |= B1_FACILITY_DTMFX;
13425       if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE)
13426         b1_facilities |= B1_FACILITY_DTMFR;
13427     }
13428   }
13429   if ((b1_resource == 17) || (b1_resource == 18))
13430   {
13431     if (plci->adapter->manufacturer_features & (MANUFACTURER_FEATURE_V18 | MANUFACTURER_FEATURE_VOWN))
13432       b1_facilities |= B1_FACILITY_DTMFX | B1_FACILITY_DTMFR;
13433   }
13434 /*
13435   dbug (1, dprintf ("[%06lx] %s,%d: get_b1_facilities %d %04x",
13436     (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
13437     (char far *)(FILE_), __LINE__, b1_resource, b1_facilites));
13438 */
13439   return (b1_facilities);
13440 }
13441
13442
13443 static byte add_b1_facilities (PLCI   * plci, byte b1_resource, word b1_facilities)
13444 {
13445   byte b;
13446
13447   switch (b1_resource)
13448   {
13449   case 5:
13450   case 26:
13451     if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13452       b = 26;
13453     else
13454       b = 5;
13455     break;
13456
13457   case 8:
13458   case 27:
13459     if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13460       b = 27;
13461     else
13462       b = 8;
13463     break;
13464
13465   case 9:
13466   case 20:
13467   case 22:
13468   case 23:
13469   case 24:
13470   case 25:
13471   case 28:
13472   case 29:
13473   case 30:
13474   case 36:
13475   case 37:
13476   case 38:
13477     if (b1_facilities & B1_FACILITY_EC)
13478     {
13479       if (b1_facilities & B1_FACILITY_LOCAL)
13480         b = 30;
13481       else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13482         b = 29;
13483       else
13484         b = 28;
13485     }
13486
13487     else if ((b1_facilities & (B1_FACILITY_DTMFX | B1_FACILITY_DTMFR | B1_FACILITY_MIXER))
13488       && (((plci->requested_options_conn | plci->requested_options) & (1L << PRIVATE_DTMF_TONE))
13489        || (plci->appl && (plci->adapter->requested_options_table[plci->appl->Id-1] & (1L << PRIVATE_DTMF_TONE)))))
13490     {
13491       if (b1_facilities & B1_FACILITY_LOCAL)
13492         b = 38;
13493       else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13494         b = 37;
13495       else
13496         b = 36;
13497     }
13498
13499     else if (((plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_HARDDTMF)
13500       && !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE))
13501      || ((b1_facilities & B1_FACILITY_DTMFR)
13502       && ((b1_facilities & B1_FACILITY_MIXER)
13503        || !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE)))
13504      || ((b1_facilities & B1_FACILITY_DTMFX)
13505       && ((b1_facilities & B1_FACILITY_MIXER)
13506        || !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_SEND))))
13507     {
13508       if (b1_facilities & B1_FACILITY_LOCAL)
13509         b = 24;
13510       else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13511         b = 23;
13512       else
13513         b = 22;
13514     }
13515     else
13516     {
13517       if (b1_facilities & B1_FACILITY_LOCAL)
13518         b = 25;
13519       else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13520         b = 20;
13521       else
13522         b = 9;
13523     }
13524     break;
13525
13526   case 31:
13527   case 32:
13528   case 33:
13529     if (b1_facilities & B1_FACILITY_LOCAL)
13530       b = 33;
13531     else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13532       b = 32;
13533     else
13534       b = 31;
13535     break;
13536
13537   default:
13538     b = b1_resource;
13539   }
13540   dbug (1, dprintf ("[%06lx] %s,%d: add_b1_facilities %d %04x %d %04x",
13541     (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
13542     (char   *)(FILE_), __LINE__,
13543     b1_resource, b1_facilities, b, get_b1_facilities (plci, b)));
13544   return (b);
13545 }
13546
13547
13548 static void adjust_b1_facilities (PLCI   *plci, byte new_b1_resource, word new_b1_facilities)
13549 {
13550   word removed_facilities;
13551
13552   dbug (1, dprintf ("[%06lx] %s,%d: adjust_b1_facilities %d %04x %04x",
13553     (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
13554     (char   *)(FILE_), __LINE__, new_b1_resource, new_b1_facilities,
13555     new_b1_facilities & get_b1_facilities (plci, new_b1_resource)));
13556
13557   new_b1_facilities &= get_b1_facilities (plci, new_b1_resource);
13558   removed_facilities = plci->B1_facilities & ~new_b1_facilities;
13559
13560   if (removed_facilities & B1_FACILITY_EC)
13561     ec_clear_config (plci);
13562
13563
13564   if (removed_facilities & B1_FACILITY_DTMFR)
13565   {
13566     dtmf_rec_clear_config (plci);
13567     dtmf_parameter_clear_config (plci);
13568   }
13569   if (removed_facilities & B1_FACILITY_DTMFX)
13570     dtmf_send_clear_config (plci);
13571
13572
13573   if (removed_facilities & B1_FACILITY_MIXER)
13574     mixer_clear_config (plci);
13575
13576   if (removed_facilities & B1_FACILITY_VOICE)
13577     adv_voice_clear_config (plci);
13578   plci->B1_facilities = new_b1_facilities;
13579 }
13580
13581
13582 static void adjust_b_clear (PLCI   *plci)
13583 {
13584
13585   dbug (1, dprintf ("[%06lx] %s,%d: adjust_b_clear",
13586     (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
13587     (char   *)(FILE_), __LINE__));
13588
13589   plci->adjust_b_restore = false;
13590 }
13591
13592
13593 static word adjust_b_process (dword Id, PLCI   *plci, byte Rc)
13594 {
13595   word Info;
13596   byte b1_resource;
13597   NCCI   * ncci_ptr;
13598     API_PARSE bp[2];
13599
13600   dbug (1, dprintf ("[%06lx] %s,%d: adjust_b_process %02x %d",
13601     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
13602
13603   Info = GOOD;
13604   switch (plci->adjust_b_state)
13605   {
13606   case ADJUST_B_START:
13607     if ((plci->adjust_b_parms_msg == NULL)
13608      && (plci->adjust_b_mode & ADJUST_B_MODE_SWITCH_L1)
13609      && ((plci->adjust_b_mode & ~(ADJUST_B_MODE_SAVE | ADJUST_B_MODE_SWITCH_L1 |
13610       ADJUST_B_MODE_NO_RESOURCE | ADJUST_B_MODE_RESTORE)) == 0))
13611     {
13612       b1_resource = (plci->adjust_b_mode == ADJUST_B_MODE_NO_RESOURCE) ?
13613         0 : add_b1_facilities (plci, plci->B1_resource, plci->adjust_b_facilities);
13614       if (b1_resource == plci->B1_resource)
13615       {
13616         adjust_b1_facilities (plci, b1_resource, plci->adjust_b_facilities);
13617         break;
13618       }
13619       if (plci->adjust_b_facilities & ~get_b1_facilities (plci, b1_resource))
13620       {
13621         dbug (1, dprintf ("[%06lx] %s,%d: Adjust B nonsupported facilities %d %d %04x",
13622           UnMapId (Id), (char   *)(FILE_), __LINE__,
13623           plci->B1_resource, b1_resource, plci->adjust_b_facilities));
13624         Info = _WRONG_STATE;
13625         break;
13626       }
13627     }
13628     if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13629     {
13630
13631       mixer_prepare_switch (Id, plci);
13632
13633
13634       dtmf_prepare_switch (Id, plci);
13635       dtmf_parameter_prepare_switch (Id, plci);
13636
13637
13638       ec_prepare_switch (Id, plci);
13639
13640       adv_voice_prepare_switch (Id, plci);
13641     }
13642     plci->adjust_b_state = ADJUST_B_SAVE_MIXER_1;
13643     Rc = OK;
13644   case ADJUST_B_SAVE_MIXER_1:
13645     if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13646     {
13647
13648       Info = mixer_save_config (Id, plci, Rc);
13649       if ((Info != GOOD) || plci->internal_command)
13650         break;
13651
13652     }
13653     plci->adjust_b_state = ADJUST_B_SAVE_DTMF_1;
13654     Rc = OK;
13655   case ADJUST_B_SAVE_DTMF_1:
13656     if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13657     {
13658
13659       Info = dtmf_save_config (Id, plci, Rc);
13660       if ((Info != GOOD) || plci->internal_command)
13661         break;
13662
13663     }
13664     plci->adjust_b_state = ADJUST_B_REMOVE_L23_1;
13665   case ADJUST_B_REMOVE_L23_1:
13666     if ((plci->adjust_b_mode & ADJUST_B_MODE_REMOVE_L23)
13667      && plci->NL.Id && !plci->nl_remove_id)
13668     {
13669       plci->internal_command = plci->adjust_b_command;
13670       if (plci->adjust_b_ncci != 0)
13671       {
13672         ncci_ptr = &(plci->adapter->ncci[plci->adjust_b_ncci]);
13673         while (ncci_ptr->data_pending)
13674         {
13675           plci->data_sent_ptr = ncci_ptr->DBuffer[ncci_ptr->data_out].P;
13676           data_rc (plci, plci->adapter->ncci_ch[plci->adjust_b_ncci]);
13677         }
13678         while (ncci_ptr->data_ack_pending)
13679           data_ack (plci, plci->adapter->ncci_ch[plci->adjust_b_ncci]);
13680       }
13681       nl_req_ncci (plci, REMOVE,
13682         (byte)((plci->adjust_b_mode & ADJUST_B_MODE_CONNECT) ? plci->adjust_b_ncci : 0));
13683       send_req (plci);
13684       plci->adjust_b_state = ADJUST_B_REMOVE_L23_2;
13685       break;
13686     }
13687     plci->adjust_b_state = ADJUST_B_REMOVE_L23_2;
13688     Rc = OK;
13689   case ADJUST_B_REMOVE_L23_2:
13690     if ((Rc != OK) && (Rc != OK_FC))
13691     {
13692       dbug (1, dprintf ("[%06lx] %s,%d: Adjust B remove failed %02x",
13693         UnMapId (Id), (char   *)(FILE_), __LINE__, Rc));
13694       Info = _WRONG_STATE;
13695       break;
13696     }
13697     if (plci->adjust_b_mode & ADJUST_B_MODE_REMOVE_L23)
13698     {
13699       if (plci_nl_busy (plci))
13700       {
13701         plci->internal_command = plci->adjust_b_command;
13702         break;
13703       }
13704     }
13705     plci->adjust_b_state = ADJUST_B_SAVE_EC_1;
13706     Rc = OK;
13707   case ADJUST_B_SAVE_EC_1:
13708     if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13709     {
13710
13711       Info = ec_save_config (Id, plci, Rc);
13712       if ((Info != GOOD) || plci->internal_command)
13713         break;
13714
13715     }
13716     plci->adjust_b_state = ADJUST_B_SAVE_DTMF_PARAMETER_1;
13717     Rc = OK;
13718   case ADJUST_B_SAVE_DTMF_PARAMETER_1:
13719     if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13720     {
13721
13722       Info = dtmf_parameter_save_config (Id, plci, Rc);
13723       if ((Info != GOOD) || plci->internal_command)
13724         break;
13725
13726     }
13727     plci->adjust_b_state = ADJUST_B_SAVE_VOICE_1;
13728     Rc = OK;
13729   case ADJUST_B_SAVE_VOICE_1:
13730     if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13731     {
13732       Info = adv_voice_save_config (Id, plci, Rc);
13733       if ((Info != GOOD) || plci->internal_command)
13734         break;
13735     }
13736     plci->adjust_b_state = ADJUST_B_SWITCH_L1_1;
13737   case ADJUST_B_SWITCH_L1_1:
13738     if (plci->adjust_b_mode & ADJUST_B_MODE_SWITCH_L1)
13739     {
13740       if (plci->sig_req)
13741       {
13742         plci->internal_command = plci->adjust_b_command;
13743         break;
13744       }
13745       if (plci->adjust_b_parms_msg != NULL)
13746         api_load_msg (plci->adjust_b_parms_msg, bp);
13747       else
13748         api_load_msg (&plci->B_protocol, bp);
13749       Info = add_b1 (plci, bp,
13750         (word)((plci->adjust_b_mode & ADJUST_B_MODE_NO_RESOURCE) ? 2 : 0),
13751         plci->adjust_b_facilities);
13752       if (Info != GOOD)
13753       {
13754         dbug (1, dprintf ("[%06lx] %s,%d: Adjust B invalid L1 parameters %d %04x",
13755           UnMapId (Id), (char   *)(FILE_), __LINE__,
13756           plci->B1_resource, plci->adjust_b_facilities));
13757         break;
13758       }
13759       plci->internal_command = plci->adjust_b_command;
13760       sig_req (plci, RESOURCES, 0);
13761       send_req (plci);
13762       plci->adjust_b_state = ADJUST_B_SWITCH_L1_2;
13763       break;
13764     }
13765     plci->adjust_b_state = ADJUST_B_SWITCH_L1_2;
13766     Rc = OK;
13767   case ADJUST_B_SWITCH_L1_2:
13768     if ((Rc != OK) && (Rc != OK_FC))
13769     {
13770       dbug (1, dprintf ("[%06lx] %s,%d: Adjust B switch failed %02x %d %04x",
13771         UnMapId (Id), (char   *)(FILE_), __LINE__,
13772         Rc, plci->B1_resource, plci->adjust_b_facilities));
13773       Info = _WRONG_STATE;
13774       break;
13775     }
13776     plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_1;
13777     Rc = OK;
13778   case ADJUST_B_RESTORE_VOICE_1:
13779   case ADJUST_B_RESTORE_VOICE_2:
13780     if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13781     {
13782       Info = adv_voice_restore_config (Id, plci, Rc);
13783       if ((Info != GOOD) || plci->internal_command)
13784         break;
13785     }
13786     plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_1;
13787     Rc = OK;
13788   case ADJUST_B_RESTORE_DTMF_PARAMETER_1:
13789   case ADJUST_B_RESTORE_DTMF_PARAMETER_2:
13790     if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13791     {
13792
13793       Info = dtmf_parameter_restore_config (Id, plci, Rc);
13794       if ((Info != GOOD) || plci->internal_command)
13795         break;
13796
13797     }
13798     plci->adjust_b_state = ADJUST_B_RESTORE_EC_1;
13799     Rc = OK;
13800   case ADJUST_B_RESTORE_EC_1:
13801   case ADJUST_B_RESTORE_EC_2:
13802     if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13803     {
13804
13805       Info = ec_restore_config (Id, plci, Rc);
13806       if ((Info != GOOD) || plci->internal_command)
13807         break;
13808
13809     }
13810     plci->adjust_b_state = ADJUST_B_ASSIGN_L23_1;
13811   case ADJUST_B_ASSIGN_L23_1:
13812     if (plci->adjust_b_mode & ADJUST_B_MODE_ASSIGN_L23)
13813     {
13814       if (plci_nl_busy (plci))
13815       {
13816         plci->internal_command = plci->adjust_b_command;
13817         break;
13818       }
13819       if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT)
13820         plci->call_dir |= CALL_DIR_FORCE_OUTG_NL;
13821       if (plci->adjust_b_parms_msg != NULL)
13822         api_load_msg (plci->adjust_b_parms_msg, bp);
13823       else
13824         api_load_msg (&plci->B_protocol, bp);
13825       Info = add_b23 (plci, bp);
13826       if (Info != GOOD)
13827       {
13828         dbug (1, dprintf ("[%06lx] %s,%d: Adjust B invalid L23 parameters %04x",
13829           UnMapId (Id), (char   *)(FILE_), __LINE__, Info));
13830         break;
13831       }
13832       plci->internal_command = plci->adjust_b_command;
13833       nl_req_ncci (plci, ASSIGN, 0);
13834       send_req (plci);
13835       plci->adjust_b_state = ADJUST_B_ASSIGN_L23_2;
13836       break;
13837     }
13838     plci->adjust_b_state = ADJUST_B_ASSIGN_L23_2;
13839     Rc = ASSIGN_OK;
13840   case ADJUST_B_ASSIGN_L23_2:
13841     if ((Rc != OK) && (Rc != OK_FC) && (Rc != ASSIGN_OK))
13842     {
13843       dbug (1, dprintf ("[%06lx] %s,%d: Adjust B assign failed %02x",
13844         UnMapId (Id), (char   *)(FILE_), __LINE__, Rc));
13845       Info = _WRONG_STATE;
13846       break;
13847     }
13848     if (plci->adjust_b_mode & ADJUST_B_MODE_ASSIGN_L23)
13849     {
13850       if (Rc != ASSIGN_OK)
13851       {
13852         plci->internal_command = plci->adjust_b_command;
13853         break;
13854       }
13855     }
13856     if (plci->adjust_b_mode & ADJUST_B_MODE_USER_CONNECT)
13857     {
13858       plci->adjust_b_restore = true;
13859       break;
13860     }
13861     plci->adjust_b_state = ADJUST_B_CONNECT_1;
13862   case ADJUST_B_CONNECT_1:
13863     if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT)
13864     {
13865       plci->internal_command = plci->adjust_b_command;
13866       if (plci_nl_busy (plci))
13867         break;
13868       nl_req_ncci (plci, N_CONNECT, 0);
13869       send_req (plci);
13870       plci->adjust_b_state = ADJUST_B_CONNECT_2;
13871       break;
13872     }
13873     plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
13874     Rc = OK;
13875   case ADJUST_B_CONNECT_2:
13876   case ADJUST_B_CONNECT_3:
13877   case ADJUST_B_CONNECT_4:
13878     if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0))
13879     {
13880       dbug (1, dprintf ("[%06lx] %s,%d: Adjust B connect failed %02x",
13881         UnMapId (Id), (char   *)(FILE_), __LINE__, Rc));
13882       Info = _WRONG_STATE;
13883       break;
13884     }
13885     if (Rc == OK)
13886     {
13887       if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT)
13888       {
13889         get_ncci (plci, (byte)(Id >> 16), plci->adjust_b_ncci);
13890         Id = (Id & 0xffff) | (((dword)(plci->adjust_b_ncci)) << 16);
13891       }
13892       if (plci->adjust_b_state == ADJUST_B_CONNECT_2)
13893         plci->adjust_b_state = ADJUST_B_CONNECT_3;
13894       else if (plci->adjust_b_state == ADJUST_B_CONNECT_4)
13895         plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
13896     }
13897     else if (Rc == 0)
13898     {
13899       if (plci->adjust_b_state == ADJUST_B_CONNECT_2)
13900         plci->adjust_b_state = ADJUST_B_CONNECT_4;
13901       else if (plci->adjust_b_state == ADJUST_B_CONNECT_3)
13902         plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
13903     }
13904     if (plci->adjust_b_state != ADJUST_B_RESTORE_DTMF_1)
13905     {
13906       plci->internal_command = plci->adjust_b_command;
13907       break;
13908     }
13909     Rc = OK;
13910   case ADJUST_B_RESTORE_DTMF_1:
13911   case ADJUST_B_RESTORE_DTMF_2:
13912     if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13913     {
13914
13915       Info = dtmf_restore_config (Id, plci, Rc);
13916       if ((Info != GOOD) || plci->internal_command)
13917         break;
13918
13919     }
13920     plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_1;
13921     Rc = OK;
13922   case ADJUST_B_RESTORE_MIXER_1:
13923   case ADJUST_B_RESTORE_MIXER_2:
13924   case ADJUST_B_RESTORE_MIXER_3:
13925   case ADJUST_B_RESTORE_MIXER_4:
13926   case ADJUST_B_RESTORE_MIXER_5:
13927   case ADJUST_B_RESTORE_MIXER_6:
13928   case ADJUST_B_RESTORE_MIXER_7:
13929     if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13930     {
13931
13932       Info = mixer_restore_config (Id, plci, Rc);
13933       if ((Info != GOOD) || plci->internal_command)
13934         break;
13935
13936     }
13937     plci->adjust_b_state = ADJUST_B_END;
13938   case ADJUST_B_END:
13939     break;
13940   }
13941   return (Info);
13942 }
13943
13944
13945 static void adjust_b1_resource (dword Id, PLCI   *plci, API_SAVE   *bp_msg, word b1_facilities, word internal_command)
13946 {
13947
13948   dbug (1, dprintf ("[%06lx] %s,%d: adjust_b1_resource %d %04x",
13949     UnMapId (Id), (char   *)(FILE_), __LINE__,
13950     plci->B1_resource, b1_facilities));
13951
13952   plci->adjust_b_parms_msg = bp_msg;
13953   plci->adjust_b_facilities = b1_facilities;
13954   plci->adjust_b_command = internal_command;
13955   plci->adjust_b_ncci = (word)(Id >> 16);
13956   if ((bp_msg == NULL) && (plci->B1_resource == 0))
13957     plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_NO_RESOURCE | ADJUST_B_MODE_SWITCH_L1;
13958   else
13959     plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_SWITCH_L1 | ADJUST_B_MODE_RESTORE;
13960   plci->adjust_b_state = ADJUST_B_START;
13961   dbug (1, dprintf ("[%06lx] %s,%d: Adjust B1 resource %d %04x...",
13962     UnMapId (Id), (char   *)(FILE_), __LINE__,
13963     plci->B1_resource, b1_facilities));
13964 }
13965
13966
13967 static void adjust_b_restore (dword Id, PLCI   *plci, byte Rc)
13968 {
13969   word internal_command;
13970
13971   dbug (1, dprintf ("[%06lx] %s,%d: adjust_b_restore %02x %04x",
13972     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->internal_command));
13973
13974   internal_command = plci->internal_command;
13975   plci->internal_command = 0;
13976   switch (internal_command)
13977   {
13978   default:
13979     plci->command = 0;
13980     if (plci->req_in != 0)
13981     {
13982       plci->internal_command = ADJUST_B_RESTORE_1;
13983       break;
13984     }
13985     Rc = OK;
13986   case ADJUST_B_RESTORE_1:
13987     if ((Rc != OK) && (Rc != OK_FC))
13988     {
13989       dbug (1, dprintf ("[%06lx] %s,%d: Adjust B enqueued failed %02x",
13990         UnMapId (Id), (char   *)(FILE_), __LINE__, Rc));
13991     }
13992     plci->adjust_b_parms_msg = NULL;
13993     plci->adjust_b_facilities = plci->B1_facilities;
13994     plci->adjust_b_command = ADJUST_B_RESTORE_2;
13995     plci->adjust_b_ncci = (word)(Id >> 16);
13996     plci->adjust_b_mode = ADJUST_B_MODE_RESTORE;
13997     plci->adjust_b_state = ADJUST_B_START;
13998     dbug (1, dprintf ("[%06lx] %s,%d: Adjust B restore...",
13999       UnMapId (Id), (char   *)(FILE_), __LINE__));
14000   case ADJUST_B_RESTORE_2:
14001     if (adjust_b_process (Id, plci, Rc) != GOOD)
14002     {
14003       dbug (1, dprintf ("[%06lx] %s,%d: Adjust B restore failed",
14004         UnMapId (Id), (char   *)(FILE_), __LINE__));
14005     }
14006     if (plci->internal_command)
14007       break;
14008     break;
14009   }
14010 }
14011
14012
14013 static void reset_b3_command (dword Id, PLCI   *plci, byte Rc)
14014 {
14015   word Info;
14016   word internal_command;
14017
14018   dbug (1, dprintf ("[%06lx] %s,%d: reset_b3_command %02x %04x",
14019     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->internal_command));
14020
14021   Info = GOOD;
14022   internal_command = plci->internal_command;
14023   plci->internal_command = 0;
14024   switch (internal_command)
14025   {
14026   default:
14027     plci->command = 0;
14028     plci->adjust_b_parms_msg = NULL;
14029     plci->adjust_b_facilities = plci->B1_facilities;
14030     plci->adjust_b_command = RESET_B3_COMMAND_1;
14031     plci->adjust_b_ncci = (word)(Id >> 16);
14032     plci->adjust_b_mode = ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_CONNECT;
14033     plci->adjust_b_state = ADJUST_B_START;
14034     dbug (1, dprintf ("[%06lx] %s,%d: Reset B3...",
14035       UnMapId (Id), (char   *)(FILE_), __LINE__));
14036   case RESET_B3_COMMAND_1:
14037     Info = adjust_b_process (Id, plci, Rc);
14038     if (Info != GOOD)
14039     {
14040       dbug (1, dprintf ("[%06lx] %s,%d: Reset failed",
14041         UnMapId (Id), (char   *)(FILE_), __LINE__));
14042       break;
14043     }
14044     if (plci->internal_command)
14045       return;
14046     break;
14047   }
14048 /*  sendf (plci->appl, _RESET_B3_R | CONFIRM, Id, plci->number, "w", Info);*/
14049   sendf(plci->appl,_RESET_B3_I,Id,0,"s","");
14050 }
14051
14052
14053 static void select_b_command (dword Id, PLCI   *plci, byte Rc)
14054 {
14055   word Info;
14056   word internal_command;
14057   byte esc_chi[3];
14058
14059   dbug (1, dprintf ("[%06lx] %s,%d: select_b_command %02x %04x",
14060     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->internal_command));
14061
14062   Info = GOOD;
14063   internal_command = plci->internal_command;
14064   plci->internal_command = 0;
14065   switch (internal_command)
14066   {
14067   default:
14068     plci->command = 0;
14069     plci->adjust_b_parms_msg = &plci->saved_msg;
14070     if ((plci->tel == ADV_VOICE) && (plci == plci->adapter->AdvSignalPLCI))
14071       plci->adjust_b_facilities = plci->B1_facilities | B1_FACILITY_VOICE;
14072     else
14073       plci->adjust_b_facilities = plci->B1_facilities & ~B1_FACILITY_VOICE;
14074     plci->adjust_b_command = SELECT_B_COMMAND_1;
14075     plci->adjust_b_ncci = (word)(Id >> 16);
14076     if (plci->saved_msg.parms[0].length == 0)
14077     {
14078       plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_SWITCH_L1 |
14079         ADJUST_B_MODE_NO_RESOURCE;
14080     }
14081     else
14082     {
14083       plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_SWITCH_L1 |
14084         ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_USER_CONNECT | ADJUST_B_MODE_RESTORE;
14085     }
14086     plci->adjust_b_state = ADJUST_B_START;
14087     dbug (1, dprintf ("[%06lx] %s,%d: Select B protocol...",
14088       UnMapId (Id), (char   *)(FILE_), __LINE__));
14089   case SELECT_B_COMMAND_1:
14090     Info = adjust_b_process (Id, plci, Rc);
14091     if (Info != GOOD)
14092     {
14093       dbug (1, dprintf ("[%06lx] %s,%d: Select B protocol failed",
14094         UnMapId (Id), (char   *)(FILE_), __LINE__));
14095       break;
14096     }
14097     if (plci->internal_command)
14098       return;
14099     if (plci->tel == ADV_VOICE)
14100     {
14101       esc_chi[0] = 0x02;
14102       esc_chi[1] = 0x18;
14103       esc_chi[2] = plci->b_channel;
14104       SetVoiceChannel (plci->adapter->AdvCodecPLCI, esc_chi, plci->adapter);
14105     }
14106     break;
14107   }
14108   sendf (plci->appl, _SELECT_B_REQ | CONFIRM, Id, plci->number, "w", Info);
14109 }
14110
14111
14112 static void fax_connect_ack_command (dword Id, PLCI   *plci, byte Rc)
14113 {
14114   word Info;
14115   word internal_command;
14116
14117   dbug (1, dprintf ("[%06lx] %s,%d: fax_connect_ack_command %02x %04x",
14118     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->internal_command));
14119
14120   Info = GOOD;
14121   internal_command = plci->internal_command;
14122   plci->internal_command = 0;
14123   switch (internal_command)
14124   {
14125   default:
14126     plci->command = 0;
14127   case FAX_CONNECT_ACK_COMMAND_1:
14128     if (plci_nl_busy (plci))
14129     {
14130       plci->internal_command = FAX_CONNECT_ACK_COMMAND_1;
14131       return;
14132     }
14133     plci->internal_command = FAX_CONNECT_ACK_COMMAND_2;
14134     plci->NData[0].P = plci->fax_connect_info_buffer;
14135     plci->NData[0].PLength = plci->fax_connect_info_length;
14136     plci->NL.X = plci->NData;
14137     plci->NL.ReqCh = 0;
14138     plci->NL.Req = plci->nl_req = (byte) N_CONNECT_ACK;
14139     plci->adapter->request (&plci->NL);
14140     return;
14141   case FAX_CONNECT_ACK_COMMAND_2:
14142     if ((Rc != OK) && (Rc != OK_FC))
14143     {
14144       dbug (1, dprintf ("[%06lx] %s,%d: FAX issue CONNECT ACK failed %02x",
14145         UnMapId (Id), (char   *)(FILE_), __LINE__, Rc));
14146       break;
14147     }
14148   }
14149   if ((plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
14150    && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
14151   {
14152     if (plci->B3_prot == 4)
14153       sendf(plci->appl,_CONNECT_B3_ACTIVE_I,Id,0,"s","");
14154     else
14155       sendf(plci->appl,_CONNECT_B3_ACTIVE_I,Id,0,"S",plci->ncpi_buffer);
14156     plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
14157   }
14158 }
14159
14160
14161 static void fax_edata_ack_command (dword Id, PLCI   *plci, byte Rc)
14162 {
14163   word Info;
14164   word internal_command;
14165
14166   dbug (1, dprintf ("[%06lx] %s,%d: fax_edata_ack_command %02x %04x",
14167     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->internal_command));
14168
14169   Info = GOOD;
14170   internal_command = plci->internal_command;
14171   plci->internal_command = 0;
14172   switch (internal_command)
14173   {
14174   default:
14175     plci->command = 0;
14176   case FAX_EDATA_ACK_COMMAND_1:
14177     if (plci_nl_busy (plci))
14178     {
14179       plci->internal_command = FAX_EDATA_ACK_COMMAND_1;
14180       return;
14181     }
14182     plci->internal_command = FAX_EDATA_ACK_COMMAND_2;
14183     plci->NData[0].P = plci->fax_connect_info_buffer;
14184     plci->NData[0].PLength = plci->fax_edata_ack_length;
14185     plci->NL.X = plci->NData;
14186     plci->NL.ReqCh = 0;
14187     plci->NL.Req = plci->nl_req = (byte) N_EDATA;
14188     plci->adapter->request (&plci->NL);
14189     return;
14190   case FAX_EDATA_ACK_COMMAND_2:
14191     if ((Rc != OK) && (Rc != OK_FC))
14192     {
14193       dbug (1, dprintf ("[%06lx] %s,%d: FAX issue EDATA ACK failed %02x",
14194         UnMapId (Id), (char   *)(FILE_), __LINE__, Rc));
14195       break;
14196     }
14197   }
14198 }
14199
14200
14201 static void fax_connect_info_command (dword Id, PLCI   *plci, byte Rc)
14202 {
14203   word Info;
14204   word internal_command;
14205
14206   dbug (1, dprintf ("[%06lx] %s,%d: fax_connect_info_command %02x %04x",
14207     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->internal_command));
14208
14209   Info = GOOD;
14210   internal_command = plci->internal_command;
14211   plci->internal_command = 0;
14212   switch (internal_command)
14213   {
14214   default:
14215     plci->command = 0;
14216   case FAX_CONNECT_INFO_COMMAND_1:
14217     if (plci_nl_busy (plci))
14218     {
14219       plci->internal_command = FAX_CONNECT_INFO_COMMAND_1;
14220       return;
14221     }
14222     plci->internal_command = FAX_CONNECT_INFO_COMMAND_2;
14223     plci->NData[0].P = plci->fax_connect_info_buffer;
14224     plci->NData[0].PLength = plci->fax_connect_info_length;
14225     plci->NL.X = plci->NData;
14226     plci->NL.ReqCh = 0;
14227     plci->NL.Req = plci->nl_req = (byte) N_EDATA;
14228     plci->adapter->request (&plci->NL);
14229     return;
14230   case FAX_CONNECT_INFO_COMMAND_2:
14231     if ((Rc != OK) && (Rc != OK_FC))
14232     {
14233       dbug (1, dprintf ("[%06lx] %s,%d: FAX setting connect info failed %02x",
14234         UnMapId (Id), (char   *)(FILE_), __LINE__, Rc));
14235       Info = _WRONG_STATE;
14236       break;
14237     }
14238     if (plci_nl_busy (plci))
14239     {
14240       plci->internal_command = FAX_CONNECT_INFO_COMMAND_2;
14241       return;
14242     }
14243     plci->command = _CONNECT_B3_R;
14244     nl_req_ncci (plci, N_CONNECT, 0);
14245     send_req (plci);
14246     return;
14247   }
14248   sendf (plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info);
14249 }
14250
14251
14252 static void fax_adjust_b23_command (dword Id, PLCI   *plci, byte Rc)
14253 {
14254   word Info;
14255   word internal_command;
14256
14257   dbug (1, dprintf ("[%06lx] %s,%d: fax_adjust_b23_command %02x %04x",
14258     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->internal_command));
14259
14260   Info = GOOD;
14261   internal_command = plci->internal_command;
14262   plci->internal_command = 0;
14263   switch (internal_command)
14264   {
14265   default:
14266     plci->command = 0;
14267     plci->adjust_b_parms_msg = NULL;
14268     plci->adjust_b_facilities = plci->B1_facilities;
14269     plci->adjust_b_command = FAX_ADJUST_B23_COMMAND_1;
14270     plci->adjust_b_ncci = (word)(Id >> 16);
14271     plci->adjust_b_mode = ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_ASSIGN_L23;
14272     plci->adjust_b_state = ADJUST_B_START;
14273     dbug (1, dprintf ("[%06lx] %s,%d: FAX adjust B23...",
14274       UnMapId (Id), (char   *)(FILE_), __LINE__));
14275   case FAX_ADJUST_B23_COMMAND_1:
14276     Info = adjust_b_process (Id, plci, Rc);
14277     if (Info != GOOD)
14278     {
14279       dbug (1, dprintf ("[%06lx] %s,%d: FAX adjust failed",
14280         UnMapId (Id), (char   *)(FILE_), __LINE__));
14281       break;
14282     }
14283     if (plci->internal_command)
14284       return;
14285   case FAX_ADJUST_B23_COMMAND_2:
14286     if (plci_nl_busy (plci))
14287     {
14288       plci->internal_command = FAX_ADJUST_B23_COMMAND_2;
14289       return;
14290     }
14291     plci->command = _CONNECT_B3_R;
14292     nl_req_ncci (plci, N_CONNECT, 0);
14293     send_req (plci);
14294     return;
14295   }
14296   sendf (plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info);
14297 }
14298
14299
14300 static void fax_disconnect_command (dword Id, PLCI   *plci, byte Rc)
14301 {
14302   word internal_command;
14303
14304   dbug (1, dprintf ("[%06lx] %s,%d: fax_disconnect_command %02x %04x",
14305     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->internal_command));
14306
14307   internal_command = plci->internal_command;
14308   plci->internal_command = 0;
14309   switch (internal_command)
14310   {
14311   default:
14312     plci->command = 0;
14313     plci->internal_command = FAX_DISCONNECT_COMMAND_1;
14314     return;
14315   case FAX_DISCONNECT_COMMAND_1:
14316   case FAX_DISCONNECT_COMMAND_2:
14317   case FAX_DISCONNECT_COMMAND_3:
14318     if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0))
14319     {
14320       dbug (1, dprintf ("[%06lx] %s,%d: FAX disconnect EDATA failed %02x",
14321         UnMapId (Id), (char   *)(FILE_), __LINE__, Rc));
14322       break;
14323     }
14324     if (Rc == OK)
14325     {
14326       if ((internal_command == FAX_DISCONNECT_COMMAND_1)
14327        || (internal_command == FAX_DISCONNECT_COMMAND_2))
14328       {
14329         plci->internal_command = FAX_DISCONNECT_COMMAND_2;
14330       }
14331     }
14332     else if (Rc == 0)
14333     {
14334       if (internal_command == FAX_DISCONNECT_COMMAND_1)
14335         plci->internal_command = FAX_DISCONNECT_COMMAND_3;
14336     }
14337     return;
14338   }
14339 }
14340
14341
14342
14343 static void rtp_connect_b3_req_command (dword Id, PLCI   *plci, byte Rc)
14344 {
14345   word Info;
14346   word internal_command;
14347
14348   dbug (1, dprintf ("[%06lx] %s,%d: rtp_connect_b3_req_command %02x %04x",
14349     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->internal_command));
14350
14351   Info = GOOD;
14352   internal_command = plci->internal_command;
14353   plci->internal_command = 0;
14354   switch (internal_command)
14355   {
14356   default:
14357     plci->command = 0;
14358   case RTP_CONNECT_B3_REQ_COMMAND_1:
14359     if (plci_nl_busy (plci))
14360     {
14361       plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_1;
14362       return;
14363     }
14364     plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_2;
14365     nl_req_ncci (plci, N_CONNECT, 0);
14366     send_req (plci);
14367     return;
14368   case RTP_CONNECT_B3_REQ_COMMAND_2:
14369     if ((Rc != OK) && (Rc != OK_FC))
14370     {
14371       dbug (1, dprintf ("[%06lx] %s,%d: RTP setting connect info failed %02x",
14372         UnMapId (Id), (char   *)(FILE_), __LINE__, Rc));
14373       Info = _WRONG_STATE;
14374       break;
14375     }
14376     if (plci_nl_busy (plci))
14377     {
14378       plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_2;
14379       return;
14380     }
14381     plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_3;
14382     plci->NData[0].PLength = plci->internal_req_buffer[0];
14383     plci->NData[0].P = plci->internal_req_buffer + 1;
14384     plci->NL.X = plci->NData;
14385     plci->NL.ReqCh = 0;
14386     plci->NL.Req = plci->nl_req = (byte) N_UDATA;
14387     plci->adapter->request (&plci->NL);
14388     break;
14389   case RTP_CONNECT_B3_REQ_COMMAND_3:
14390     return;
14391   }
14392   sendf (plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info);
14393 }
14394
14395
14396 static void rtp_connect_b3_res_command (dword Id, PLCI   *plci, byte Rc)
14397 {
14398   word Info;
14399   word internal_command;
14400
14401   dbug (1, dprintf ("[%06lx] %s,%d: rtp_connect_b3_res_command %02x %04x",
14402     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->internal_command));
14403
14404   Info = GOOD;
14405   internal_command = plci->internal_command;
14406   plci->internal_command = 0;
14407   switch (internal_command)
14408   {
14409   default:
14410     plci->command = 0;
14411   case RTP_CONNECT_B3_RES_COMMAND_1:
14412     if (plci_nl_busy (plci))
14413     {
14414       plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_1;
14415       return;
14416     }
14417     plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_2;
14418     nl_req_ncci (plci, N_CONNECT_ACK, (byte)(Id >> 16));
14419     send_req (plci);
14420     return;
14421   case RTP_CONNECT_B3_RES_COMMAND_2:
14422     if ((Rc != OK) && (Rc != OK_FC))
14423     {
14424       dbug (1, dprintf ("[%06lx] %s,%d: RTP setting connect resp info failed %02x",
14425         UnMapId (Id), (char   *)(FILE_), __LINE__, Rc));
14426       Info = _WRONG_STATE;
14427       break;
14428     }
14429     if (plci_nl_busy (plci))
14430     {
14431       plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_2;
14432       return;
14433     }
14434     sendf (plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
14435     plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_3;
14436     plci->NData[0].PLength = plci->internal_req_buffer[0];
14437     plci->NData[0].P = plci->internal_req_buffer + 1;
14438     plci->NL.X = plci->NData;
14439     plci->NL.ReqCh = 0;
14440     plci->NL.Req = plci->nl_req = (byte) N_UDATA;
14441     plci->adapter->request (&plci->NL);
14442     return;
14443   case RTP_CONNECT_B3_RES_COMMAND_3:
14444     return;
14445   }
14446 }
14447
14448
14449
14450 static void hold_save_command (dword Id, PLCI   *plci, byte Rc)
14451 {
14452     byte SS_Ind[] = "\x05\x02\x00\x02\x00\x00"; /* Hold_Ind struct*/
14453   word Info;
14454   word internal_command;
14455
14456   dbug (1, dprintf ("[%06lx] %s,%d: hold_save_command %02x %04x",
14457     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->internal_command));
14458
14459   Info = GOOD;
14460   internal_command = plci->internal_command;
14461   plci->internal_command = 0;
14462   switch (internal_command)
14463   {
14464   default:
14465     if (!plci->NL.Id)
14466       break;
14467     plci->command = 0;
14468     plci->adjust_b_parms_msg = NULL;
14469     plci->adjust_b_facilities = plci->B1_facilities;
14470     plci->adjust_b_command = HOLD_SAVE_COMMAND_1;
14471     plci->adjust_b_ncci = (word)(Id >> 16);
14472     plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23;
14473     plci->adjust_b_state = ADJUST_B_START;
14474     dbug (1, dprintf ("[%06lx] %s,%d: HOLD save...",
14475       UnMapId (Id), (char   *)(FILE_), __LINE__));
14476   case HOLD_SAVE_COMMAND_1:
14477     Info = adjust_b_process (Id, plci, Rc);
14478     if (Info != GOOD)
14479     {
14480       dbug (1, dprintf ("[%06lx] %s,%d: HOLD save failed",
14481         UnMapId (Id), (char   *)(FILE_), __LINE__));
14482       break;
14483     }
14484     if (plci->internal_command)
14485       return;
14486   }
14487   sendf (plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", 3, SS_Ind);
14488 }
14489
14490
14491 static void retrieve_restore_command (dword Id, PLCI   *plci, byte Rc)
14492 {
14493     byte SS_Ind[] = "\x05\x03\x00\x02\x00\x00"; /* Retrieve_Ind struct*/
14494   word Info;
14495   word internal_command;
14496
14497   dbug (1, dprintf ("[%06lx] %s,%d: retrieve_restore_command %02x %04x",
14498     UnMapId (Id), (char   *)(FILE_), __LINE__, Rc, plci->internal_command));
14499
14500   Info = GOOD;
14501   internal_command = plci->internal_command;
14502   plci->internal_command = 0;
14503   switch (internal_command)
14504   {
14505   default:
14506     plci->command = 0;
14507     plci->adjust_b_parms_msg = NULL;
14508     plci->adjust_b_facilities = plci->B1_facilities;
14509     plci->adjust_b_command = RETRIEVE_RESTORE_COMMAND_1;
14510     plci->adjust_b_ncci = (word)(Id >> 16);
14511     plci->adjust_b_mode = ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_USER_CONNECT | ADJUST_B_MODE_RESTORE;
14512     plci->adjust_b_state = ADJUST_B_START;
14513     dbug (1, dprintf ("[%06lx] %s,%d: RETRIEVE restore...",
14514       UnMapId (Id), (char   *)(FILE_), __LINE__));
14515   case RETRIEVE_RESTORE_COMMAND_1:
14516     Info = adjust_b_process (Id, plci, Rc);
14517     if (Info != GOOD)
14518     {
14519       dbug (1, dprintf ("[%06lx] %s,%d: RETRIEVE restore failed",
14520         UnMapId (Id), (char   *)(FILE_), __LINE__));
14521       break;
14522     }
14523     if (plci->internal_command)
14524       return;
14525   }
14526   sendf (plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", 3, SS_Ind);
14527 }
14528
14529
14530 static void init_b1_config (PLCI   *plci)
14531 {
14532
14533   dbug (1, dprintf ("[%06lx] %s,%d: init_b1_config",
14534     (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
14535     (char   *)(FILE_), __LINE__));
14536
14537   plci->B1_resource = 0;
14538   plci->B1_facilities = 0;
14539
14540   plci->li_bchannel_id = 0;
14541   mixer_clear_config (plci);
14542
14543
14544   ec_clear_config (plci);
14545
14546
14547   dtmf_rec_clear_config (plci);
14548   dtmf_send_clear_config (plci);
14549   dtmf_parameter_clear_config (plci);
14550
14551   adv_voice_clear_config (plci);
14552   adjust_b_clear (plci);
14553 }
14554
14555
14556 static void clear_b1_config (PLCI   *plci)
14557 {
14558
14559   dbug (1, dprintf ("[%06lx] %s,%d: clear_b1_config",
14560     (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
14561     (char   *)(FILE_), __LINE__));
14562
14563   adv_voice_clear_config (plci);
14564   adjust_b_clear (plci);
14565
14566   ec_clear_config (plci);
14567
14568
14569   dtmf_rec_clear_config (plci);
14570   dtmf_send_clear_config (plci);
14571   dtmf_parameter_clear_config (plci);
14572
14573
14574   if ((plci->li_bchannel_id != 0)
14575    && (li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci == plci))
14576   {
14577     mixer_clear_config (plci);
14578     li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci = NULL;
14579     plci->li_bchannel_id = 0;
14580   }
14581
14582   plci->B1_resource = 0;
14583   plci->B1_facilities = 0;
14584 }
14585
14586
14587 /* -----------------------------------------------------------------
14588                 XON protocol local helpers
14589    ----------------------------------------------------------------- */
14590 static void channel_flow_control_remove (PLCI   * plci) {
14591   DIVA_CAPI_ADAPTER   * a = plci->adapter;
14592   word i;
14593   for(i=1;i<MAX_NL_CHANNEL+1;i++) {
14594     if (a->ch_flow_plci[i] == plci->Id) {
14595       a->ch_flow_plci[i] = 0;
14596       a->ch_flow_control[i] = 0;
14597     }
14598   }
14599 }
14600
14601 static void channel_x_on (PLCI   * plci, byte ch) {
14602   DIVA_CAPI_ADAPTER   * a = plci->adapter;
14603   if (a->ch_flow_control[ch] & N_XON_SENT) {
14604     a->ch_flow_control[ch] &= ~N_XON_SENT;
14605   }
14606 }
14607
14608 static void channel_x_off (PLCI   * plci, byte ch, byte flag) {
14609   DIVA_CAPI_ADAPTER   * a = plci->adapter;
14610   if ((a->ch_flow_control[ch] & N_RX_FLOW_CONTROL_MASK) == 0) {
14611     a->ch_flow_control[ch] |= (N_CH_XOFF | flag);
14612     a->ch_flow_plci[ch] = plci->Id;
14613     a->ch_flow_control_pending++;
14614   }
14615 }
14616
14617 static void channel_request_xon (PLCI   * plci, byte ch) {
14618   DIVA_CAPI_ADAPTER   * a = plci->adapter;
14619
14620   if (a->ch_flow_control[ch] & N_CH_XOFF) {
14621     a->ch_flow_control[ch] |= N_XON_REQ;
14622     a->ch_flow_control[ch] &= ~N_CH_XOFF;
14623     a->ch_flow_control[ch] &= ~N_XON_CONNECT_IND;
14624   }
14625 }
14626
14627 static void channel_xmit_extended_xon (PLCI   * plci) {
14628   DIVA_CAPI_ADAPTER   * a;
14629   int max_ch = ARRAY_SIZE(a->ch_flow_control);
14630   int i, one_requested = 0;
14631
14632   if ((!plci) || (!plci->Id) || ((a = plci->adapter) == NULL)) {
14633     return;
14634   }
14635
14636   for (i = 0; i < max_ch; i++) {
14637     if ((a->ch_flow_control[i] & N_CH_XOFF) &&
14638         (a->ch_flow_control[i] & N_XON_CONNECT_IND) &&
14639         (plci->Id == a->ch_flow_plci[i])) {
14640       channel_request_xon (plci, (byte)i);
14641       one_requested = 1;
14642     }
14643   }
14644
14645   if (one_requested) {
14646     channel_xmit_xon (plci);
14647   }
14648 }
14649
14650 /*
14651   Try to xmit next X_ON
14652   */
14653 static int find_channel_with_pending_x_on (DIVA_CAPI_ADAPTER   * a, PLCI   * plci) {
14654   int max_ch = ARRAY_SIZE(a->ch_flow_control);
14655   int i;
14656
14657   if (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL)) {
14658     return (0);
14659   }
14660
14661   if (a->last_flow_control_ch >= max_ch) {
14662     a->last_flow_control_ch = 1;
14663   }
14664   for (i=a->last_flow_control_ch; i < max_ch; i++) {
14665     if ((a->ch_flow_control[i] & N_XON_REQ) &&
14666         (plci->Id == a->ch_flow_plci[i])) {
14667       a->last_flow_control_ch = i+1;
14668       return (i);
14669     }
14670   }
14671
14672   for (i = 1; i < a->last_flow_control_ch; i++) {
14673     if ((a->ch_flow_control[i] & N_XON_REQ) &&
14674         (plci->Id == a->ch_flow_plci[i])) {
14675       a->last_flow_control_ch = i+1;
14676       return (i);
14677     }
14678   }
14679
14680   return (0);
14681 }
14682
14683 static void channel_xmit_xon (PLCI   * plci) {
14684   DIVA_CAPI_ADAPTER   * a = plci->adapter;
14685   byte ch;
14686
14687   if (plci->nl_req || !plci->NL.Id || plci->nl_remove_id) {
14688     return;
14689   }
14690   if ((ch = (byte)find_channel_with_pending_x_on (a, plci)) == 0) {
14691     return;
14692   }
14693   a->ch_flow_control[ch] &= ~N_XON_REQ;
14694   a->ch_flow_control[ch] |= N_XON_SENT;
14695
14696   plci->NL.Req = plci->nl_req = (byte)N_XON;
14697   plci->NL.ReqCh         = ch;
14698   plci->NL.X             = plci->NData;
14699   plci->NL.XNum          = 1;
14700   plci->NData[0].P       = &plci->RBuffer[0];
14701   plci->NData[0].PLength = 0;
14702
14703   plci->adapter->request(&plci->NL);
14704 }
14705
14706 static int channel_can_xon (PLCI   * plci, byte ch) {
14707   APPL   * APPLptr;
14708   DIVA_CAPI_ADAPTER   * a;
14709   word NCCIcode;
14710   dword count;
14711   word Num;
14712   word i;
14713
14714   APPLptr = plci->appl;
14715   a = plci->adapter;
14716
14717   if (!APPLptr)
14718     return (0);
14719
14720   NCCIcode = a->ch_ncci[ch] | (((word) a->Id) << 8);
14721
14722                 /* count all buffers within the Application pool    */
14723                 /* belonging to the same NCCI. XON if a first is    */
14724                 /* used.                                            */
14725   count = 0;
14726   Num = 0xffff;
14727   for(i=0; i<APPLptr->MaxBuffer; i++) {
14728     if(NCCIcode==APPLptr->DataNCCI[i]) count++;
14729     if(!APPLptr->DataNCCI[i] && Num==0xffff) Num = i;
14730   }
14731   if ((count > 2) || (Num == 0xffff)) {
14732     return (0);
14733   }
14734   return (1);
14735 }
14736
14737
14738 /*------------------------------------------------------------------*/
14739
14740 static word CPN_filter_ok(byte   *cpn,DIVA_CAPI_ADAPTER   * a,word offset)
14741 {
14742   return 1;
14743 }
14744
14745
14746
14747 /**********************************************************************************/
14748 /* function groups the listening applications according to the CIP mask and the   */
14749 /* Info_Mask. Each group gets just one Connect_Ind. Some application manufacturer */
14750 /* are not multi-instance capable, so they start e.g. 30 applications what causes */
14751 /* big problems on application level (one call, 30 Connect_Ind, ect). The         */
14752 /* function must be enabled by setting "a->group_optimization_enabled" from the   */
14753 /* OS specific part (per adapter).                                                */
14754 /**********************************************************************************/
14755 static void group_optimization(DIVA_CAPI_ADAPTER   * a, PLCI   * plci)
14756 {
14757   word i,j,k,busy,group_found;
14758   dword info_mask_group[MAX_CIP_TYPES];
14759   dword cip_mask_group[MAX_CIP_TYPES];
14760   word appl_number_group_type[MAX_APPL];
14761   PLCI   *auxplci;
14762
14763   set_group_ind_mask (plci); /* all APPLs within this inc. call are allowed to dial in */
14764
14765   if(!a->group_optimization_enabled)
14766   {
14767     dbug(1,dprintf("No group optimization"));
14768     return;
14769   }
14770
14771   dbug(1,dprintf("Group optimization = 0x%x...", a->group_optimization_enabled));
14772
14773   for(i=0;i<MAX_CIP_TYPES;i++)
14774   {
14775     info_mask_group[i] = 0;
14776     cip_mask_group [i] = 0;
14777   }
14778   for(i=0;i<MAX_APPL;i++)
14779   {
14780     appl_number_group_type[i] = 0;
14781   }
14782   for(i=0; i<max_appl; i++) /* check if any multi instance capable application is present */
14783   {  /* group_optimization set to 1 means not to optimize multi-instance capable applications (default) */
14784     if(application[i].Id && (application[i].MaxNCCI) > 1 && (a->CIP_Mask[i])  && (a->group_optimization_enabled ==1) )
14785     {
14786       dbug(1,dprintf("Multi-Instance capable, no optimization required"));
14787       return; /* allow good application unfiltered access */
14788     }
14789   }
14790   for(i=0; i<max_appl; i++) /* Build CIP Groups */
14791   {
14792     if(application[i].Id && a->CIP_Mask[i] )
14793     {
14794       for(k=0,busy=false; k<a->max_plci; k++)
14795       {
14796         if(a->plci[k].Id)
14797         {
14798           auxplci = &a->plci[k];
14799           if(auxplci->appl == &application[i]) /* application has a busy PLCI */
14800           {
14801             busy = true;
14802             dbug(1,dprintf("Appl 0x%x is busy",i+1));
14803           }
14804           else if(test_c_ind_mask_bit (auxplci, i)) /* application has an incoming call pending */
14805           {
14806             busy = true;
14807             dbug(1,dprintf("Appl 0x%x has inc. call pending",i+1));
14808           }
14809         }
14810       }
14811
14812       for(j=0,group_found=0; j<=(MAX_CIP_TYPES) && !busy &&!group_found; j++)     /* build groups with free applications only */
14813       {
14814         if(j==MAX_CIP_TYPES)       /* all groups are in use but group still not found */
14815         {                           /* the MAX_CIP_TYPES group enables all calls because of field overflow */
14816           appl_number_group_type[i] = MAX_CIP_TYPES;
14817           group_found=true;
14818           dbug(1,dprintf("Field overflow appl 0x%x",i+1));
14819         }
14820         else if( (info_mask_group[j]==a->CIP_Mask[i]) && (cip_mask_group[j]==a->Info_Mask[i]) )
14821         {                                      /* is group already present ?                  */
14822           appl_number_group_type[i] = j|0x80;  /* store the group number for each application */
14823           group_found=true;
14824           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]));
14825         }
14826         else if(!info_mask_group[j])
14827         {                                      /* establish a new group                       */
14828           appl_number_group_type[i] = j|0x80;  /* store the group number for each application */
14829           info_mask_group[j] = a->CIP_Mask[i]; /* store the new CIP mask for the new group    */
14830           cip_mask_group[j] = a->Info_Mask[i]; /* store the new Info_Mask for this new group  */
14831           group_found=true;
14832           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]));
14833         }
14834       }
14835     }
14836   }
14837
14838   for(i=0; i<max_appl; i++) /* Build group_optimization_mask_table */
14839   {
14840     if(appl_number_group_type[i]) /* application is free, has listens and is member of a group */
14841     {
14842       if(appl_number_group_type[i] == MAX_CIP_TYPES)
14843       {
14844         dbug(1,dprintf("OverflowGroup 0x%x, valid appl = 0x%x, call enabled",appl_number_group_type[i],i+1));
14845       }
14846       else
14847       {
14848         dbug(1,dprintf("Group 0x%x, valid appl = 0x%x",appl_number_group_type[i],i+1));
14849         for(j=i+1; j<max_appl; j++)   /* search other group members and mark them as busy        */
14850         {
14851           if(appl_number_group_type[i] == appl_number_group_type[j])
14852           {
14853             dbug(1,dprintf("Appl 0x%x is member of group 0x%x, no call",j+1,appl_number_group_type[j]));
14854             clear_group_ind_mask_bit (plci, j);           /* disable call on other group members */
14855             appl_number_group_type[j] = 0;       /* remove disabled group member from group list */
14856           }
14857         }
14858       }
14859     }
14860     else                                                 /* application should not get a call */
14861     {
14862       clear_group_ind_mask_bit (plci, i);
14863     }
14864   }
14865
14866 }
14867
14868
14869
14870 /* OS notifies the driver about a application Capi_Register */
14871 word CapiRegister(word id)
14872 {
14873   word i,j,appls_found;
14874
14875   PLCI   *plci;
14876   DIVA_CAPI_ADAPTER   *a;
14877
14878   for(i=0,appls_found=0; i<max_appl; i++)
14879   {
14880     if( application[i].Id && (application[i].Id!=id) )
14881     {
14882       appls_found++;                       /* an application has been found */
14883     }
14884   }
14885
14886   if(appls_found) return true;
14887   for(i=0; i<max_adapter; i++)                   /* scan all adapters...    */
14888   {
14889     a = &adapter[i];
14890     if(a->request)
14891     {
14892       if(a->flag_dynamic_l1_down)  /* remove adapter from L1 tristate (Huntgroup) */
14893       {
14894         if(!appls_found)           /* first application does a capi register   */
14895         {
14896           if((j=get_plci(a)))                    /* activate L1 of all adapters */
14897           {
14898             plci = &a->plci[j-1];
14899             plci->command = 0;
14900             add_p(plci,OAD,"\x01\xfd");
14901             add_p(plci,CAI,"\x01\x80");
14902             add_p(plci,UID,"\x06\x43\x61\x70\x69\x32\x30");
14903             add_p(plci,SHIFT|6,NULL);
14904             add_p(plci,SIN,"\x02\x00\x00");
14905             plci->internal_command = START_L1_SIG_ASSIGN_PEND;
14906             sig_req(plci,ASSIGN,DSIG_ID);
14907             add_p(plci,FTY,"\x02\xff\x07"); /* l1 start */
14908             sig_req(plci,SIG_CTRL,0);
14909             send_req(plci);
14910           }
14911         }
14912       }
14913     }
14914   }
14915   return false;
14916 }
14917
14918 /*------------------------------------------------------------------*/
14919
14920 /* Functions for virtual Switching e.g. Transfer by join, Conference */
14921
14922 static void VSwitchReqInd(PLCI   *plci, dword Id, byte   **parms)
14923 {
14924  word i;
14925  /* Format of vswitch_t:
14926  0 byte length
14927  1 byte VSWITCHIE
14928  2 byte VSWITCH_REQ/VSWITCH_IND
14929  3 byte reserved
14930  4 word VSwitchcommand
14931  6 word returnerror
14932  8... Params
14933  */
14934  if(!plci ||
14935   !plci->appl ||
14936   !plci->State ||
14937   plci->Sig.Ind==NCR_FACILITY
14938   )
14939   return;
14940
14941  for(i=0;i<MAX_MULTI_IE;i++)
14942  {
14943         if(!parms[i][0]) continue;
14944   if(parms[i][0]<7)
14945   {
14946    parms[i][0]=0; /* kill it */
14947    continue;
14948   }
14949   dbug(1,dprintf("VSwitchReqInd(%d)",parms[i][4]));
14950   switch(parms[i][4])
14951   {
14952   case VSJOIN:
14953    if(!plci->relatedPTYPLCI ||
14954     (plci->ptyState!=S_ECT && plci->relatedPTYPLCI->ptyState!=S_ECT))
14955    { /* Error */
14956     break;
14957    }
14958    /* remember all necessary informations */
14959    if(parms[i][0]!=11 || parms[i][8]!=3) /* Length Test */
14960    {
14961     break;
14962    }
14963    if(parms[i][2]==VSWITCH_IND && parms[i][9]==1)
14964    {   /* first indication after ECT-Request on Consultation Call */
14965     plci->vswitchstate=parms[i][9];
14966     parms[i][9]=2; /* State */
14967     /* now ask first Call to join */
14968    }
14969    else if(parms[i][2]==VSWITCH_REQ && parms[i][9]==3)
14970    { /* Answer of VSWITCH_REQ from first Call */
14971     plci->vswitchstate=parms[i][9];
14972     /* tell consultation call to join
14973     and the protocol capabilities of the first call */
14974    }
14975    else
14976    { /* Error */
14977     break;
14978    }
14979    plci->vsprot=parms[i][10]; /* protocol */
14980    plci->vsprotdialect=parms[i][11]; /* protocoldialect */
14981    /* send join request to related PLCI */
14982    parms[i][1]=VSWITCHIE;
14983    parms[i][2]=VSWITCH_REQ;
14984
14985    plci->relatedPTYPLCI->command = 0;
14986    plci->relatedPTYPLCI->internal_command = VSWITCH_REQ_PEND;
14987    add_p(plci->relatedPTYPLCI,ESC,&parms[i][0]);
14988    sig_req(plci->relatedPTYPLCI,VSWITCH_REQ,0);
14989    send_req(plci->relatedPTYPLCI);
14990    break;
14991   case VSTRANSPORT:
14992   default:
14993    if(plci->relatedPTYPLCI &&
14994     plci->vswitchstate==3 &&
14995     plci->relatedPTYPLCI->vswitchstate==3)
14996    {
14997     add_p(plci->relatedPTYPLCI,ESC,&parms[i][0]);
14998     sig_req(plci->relatedPTYPLCI,VSWITCH_REQ,0);
14999     send_req(plci->relatedPTYPLCI);
15000    }
15001    break;
15002   }
15003   parms[i][0]=0; /* kill it */
15004  }
15005 }
15006
15007
15008 /*------------------------------------------------------------------*/
15009
15010 static int diva_get_dma_descriptor (PLCI   *plci, dword   *dma_magic) {
15011   ENTITY e;
15012   IDI_SYNC_REQ* pReq = (IDI_SYNC_REQ*)&e;
15013
15014   if (!(diva_xdi_extended_features & DIVA_CAPI_XDI_PROVIDES_RX_DMA)) {
15015     return (-1);
15016   }
15017
15018   pReq->xdi_dma_descriptor_operation.Req = 0;
15019   pReq->xdi_dma_descriptor_operation.Rc = IDI_SYNC_REQ_DMA_DESCRIPTOR_OPERATION;
15020
15021   pReq->xdi_dma_descriptor_operation.info.operation =     IDI_SYNC_REQ_DMA_DESCRIPTOR_ALLOC;
15022   pReq->xdi_dma_descriptor_operation.info.descriptor_number  = -1;
15023   pReq->xdi_dma_descriptor_operation.info.descriptor_address = NULL;
15024   pReq->xdi_dma_descriptor_operation.info.descriptor_magic   = 0;
15025
15026   e.user[0] = plci->adapter->Id - 1;
15027   plci->adapter->request((ENTITY*)pReq);
15028
15029   if (!pReq->xdi_dma_descriptor_operation.info.operation &&
15030       (pReq->xdi_dma_descriptor_operation.info.descriptor_number >= 0) &&
15031       pReq->xdi_dma_descriptor_operation.info.descriptor_magic) {
15032     *dma_magic = pReq->xdi_dma_descriptor_operation.info.descriptor_magic;
15033     dbug(3,dprintf("dma_alloc, a:%d (%d-%08x)",
15034          plci->adapter->Id,
15035          pReq->xdi_dma_descriptor_operation.info.descriptor_number,
15036          *dma_magic));
15037     return (pReq->xdi_dma_descriptor_operation.info.descriptor_number);
15038   } else {
15039     dbug(1,dprintf("dma_alloc failed"));
15040     return (-1);
15041   }
15042 }
15043
15044 static void diva_free_dma_descriptor (PLCI   *plci, int nr) {
15045   ENTITY e;
15046   IDI_SYNC_REQ* pReq = (IDI_SYNC_REQ*)&e;
15047
15048   if (nr < 0) {
15049     return;
15050   }
15051
15052   pReq->xdi_dma_descriptor_operation.Req = 0;
15053   pReq->xdi_dma_descriptor_operation.Rc = IDI_SYNC_REQ_DMA_DESCRIPTOR_OPERATION;
15054
15055   pReq->xdi_dma_descriptor_operation.info.operation =                                                IDI_SYNC_REQ_DMA_DESCRIPTOR_FREE;
15056   pReq->xdi_dma_descriptor_operation.info.descriptor_number  = nr;
15057   pReq->xdi_dma_descriptor_operation.info.descriptor_address = NULL;
15058   pReq->xdi_dma_descriptor_operation.info.descriptor_magic   = 0;
15059
15060   e.user[0] = plci->adapter->Id - 1;
15061   plci->adapter->request((ENTITY*)pReq);
15062
15063   if (!pReq->xdi_dma_descriptor_operation.info.operation) {
15064     dbug(1,dprintf("dma_free(%d)", nr));
15065   } else {
15066     dbug(1,dprintf("dma_free failed (%d)", nr));
15067   }
15068 }
15069
15070 /*------------------------------------------------------------------*/