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         word i, j, k;
1151         dword d;
1152         char *p;
1153         char buf[40];
1154
1155         for (i = 0; i < C_IND_MASK_DWORDS; i += 4)
1156         {
1157                 p = buf + 36;
1158                 *p = '\0';
1159                 for (j = 0; j < 4; j++)
1160                 {
1161                         if (i + j < C_IND_MASK_DWORDS)
1162                         {
1163                                 d = plci->c_ind_mask_table[i + j];
1164                                 for (k = 0; k < 8; k++)
1165                                 {
1166                                         *(--p) = hex_asc_lo(d);
1167                                         d >>= 4;
1168                                 }
1169                         }
1170                         else if (i != 0)
1171                         {
1172                                 for (k = 0; k < 8; k++)
1173                                         *(--p) = ' ';
1174                         }
1175                         *(--p) = ' ';
1176                 }
1177                 dbug(1, dprintf("c_ind_mask =%s", (char *) p));
1178         }
1179 }
1180
1181
1182
1183
1184
1185 #define dump_plcis(a)
1186
1187
1188
1189 /*------------------------------------------------------------------*/
1190 /* translation function for each message                            */
1191 /*------------------------------------------------------------------*/
1192
1193 static byte connect_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1194                         PLCI *plci, APPL *appl, API_PARSE *parms)
1195 {
1196         word ch;
1197         word i;
1198         word Info;
1199         byte LinkLayer;
1200         API_PARSE *ai;
1201         API_PARSE *bp;
1202         API_PARSE ai_parms[5];
1203         word channel = 0;
1204         dword ch_mask;
1205         byte m;
1206         static byte esc_chi[35] = {0x02, 0x18, 0x01};
1207         static byte lli[2] = {0x01, 0x00};
1208         byte noCh = 0;
1209         word dir = 0;
1210         byte *p_chi = "";
1211
1212         for (i = 0; i < 5; i++) ai_parms[i].length = 0;
1213
1214         dbug(1, dprintf("connect_req(%d)", parms->length));
1215         Info = _WRONG_IDENTIFIER;
1216         if (a)
1217         {
1218                 if (a->adapter_disabled)
1219                 {
1220                         dbug(1, dprintf("adapter disabled"));
1221                         Id = ((word)1 << 8) | a->Id;
1222                         sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", 0);
1223                         sendf(appl, _DISCONNECT_I, Id, 0, "w", _L1_ERROR);
1224                         return false;
1225                 }
1226                 Info = _OUT_OF_PLCI;
1227                 if ((i = get_plci(a)))
1228                 {
1229                         Info = 0;
1230                         plci = &a->plci[i - 1];
1231                         plci->appl = appl;
1232                         plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
1233                         /* check 'external controller' bit for codec support */
1234                         if (Id & EXT_CONTROLLER)
1235                         {
1236                                 if (AdvCodecSupport(a, plci, appl, 0))
1237                                 {
1238                                         plci->Id = 0;
1239                                         sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", _WRONG_IDENTIFIER);
1240                                         return 2;
1241                                 }
1242                         }
1243                         ai = &parms[9];
1244                         bp = &parms[5];
1245                         ch = 0;
1246                         if (bp->length)LinkLayer = bp->info[3];
1247                         else LinkLayer = 0;
1248                         if (ai->length)
1249                         {
1250                                 ch = 0xffff;
1251                                 if (!api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms))
1252                                 {
1253                                         ch = 0;
1254                                         if (ai_parms[0].length)
1255                                         {
1256                                                 ch = GET_WORD(ai_parms[0].info + 1);
1257                                                 if (ch > 4) ch = 0; /* safety -> ignore ChannelID */
1258                                                 if (ch == 4) /* explizit CHI in message */
1259                                                 {
1260                                                         /* check length of B-CH struct */
1261                                                         if ((ai_parms[0].info)[3] >= 1)
1262                                                         {
1263                                                                 if ((ai_parms[0].info)[4] == CHI)
1264                                                                 {
1265                                                                         p_chi = &((ai_parms[0].info)[5]);
1266                                                                 }
1267                                                                 else
1268                                                                 {
1269                                                                         p_chi = &((ai_parms[0].info)[3]);
1270                                                                 }
1271                                                                 if (p_chi[0] > 35) /* check length of channel ID */
1272                                                                 {
1273                                                                         Info = _WRONG_MESSAGE_FORMAT;
1274                                                                 }
1275                                                         }
1276                                                         else Info = _WRONG_MESSAGE_FORMAT;
1277                                                 }
1278
1279                                                 if (ch == 3 && ai_parms[0].length >= 7 && ai_parms[0].length <= 36)
1280                                                 {
1281                                                         dir = GET_WORD(ai_parms[0].info + 3);
1282                                                         ch_mask = 0;
1283                                                         m = 0x3f;
1284                                                         for (i = 0; i + 5 <= ai_parms[0].length; i++)
1285                                                         {
1286                                                                 if (ai_parms[0].info[i + 5] != 0)
1287                                                                 {
1288                                                                         if ((ai_parms[0].info[i + 5] | m) != 0xff)
1289                                                                                 Info = _WRONG_MESSAGE_FORMAT;
1290                                                                         else
1291                                                                         {
1292                                                                                 if (ch_mask == 0)
1293                                                                                         channel = i;
1294                                                                                 ch_mask |= 1L << i;
1295                                                                         }
1296                                                                 }
1297                                                                 m = 0;
1298                                                         }
1299                                                         if (ch_mask == 0)
1300                                                                 Info = _WRONG_MESSAGE_FORMAT;
1301                                                         if (!Info)
1302                                                         {
1303                                                                 if ((ai_parms[0].length == 36) || (ch_mask != ((dword)(1L << channel))))
1304                                                                 {
1305                                                                         esc_chi[0] = (byte)(ai_parms[0].length - 2);
1306                                                                         for (i = 0; i + 5 <= ai_parms[0].length; i++)
1307                                                                                 esc_chi[i + 3] = ai_parms[0].info[i + 5];
1308                                                                 }
1309                                                                 else
1310                                                                         esc_chi[0] = 2;
1311                                                                 esc_chi[2] = (byte)channel;
1312                                                                 plci->b_channel = (byte)channel; /* not correct for ETSI ch 17..31 */
1313                                                                 add_p(plci, LLI, lli);
1314                                                                 add_p(plci, ESC, esc_chi);
1315                                                                 plci->State = LOCAL_CONNECT;
1316                                                                 if (!dir) plci->call_dir |= CALL_DIR_FORCE_OUTG_NL;     /* dir 0=DTE, 1=DCE */
1317                                                         }
1318                                                 }
1319                                         }
1320                                 }
1321                                 else  Info = _WRONG_MESSAGE_FORMAT;
1322                         }
1323
1324                         dbug(1, dprintf("ch=%x,dir=%x,p_ch=%d", ch, dir, channel));
1325                         plci->command = _CONNECT_R;
1326                         plci->number = Number;
1327                         /* x.31 or D-ch free SAPI in LinkLayer? */
1328                         if (ch == 1 && LinkLayer != 3 && LinkLayer != 12) noCh = true;
1329                         if ((ch == 0 || ch == 2 || noCh || ch == 3 || ch == 4) && !Info)
1330                         {
1331                                 /* B-channel used for B3 connections (ch==0), or no B channel    */
1332                                 /* is used (ch==2) or perm. connection (3) is used  do a CALL    */
1333                                 if (noCh) Info = add_b1(plci, &parms[5], 2, 0);    /* no resource    */
1334                                 else     Info = add_b1(plci, &parms[5], ch, 0);
1335                                 add_s(plci, OAD, &parms[2]);
1336                                 add_s(plci, OSA, &parms[4]);
1337                                 add_s(plci, BC, &parms[6]);
1338                                 add_s(plci, LLC, &parms[7]);
1339                                 add_s(plci, HLC, &parms[8]);
1340                                 if (a->Info_Mask[appl->Id - 1] & 0x200)
1341                                 {
1342                                         /* early B3 connect (CIP mask bit 9) no release after a disc */
1343                                         add_p(plci, LLI, "\x01\x01");
1344                                 }
1345                                 if (GET_WORD(parms[0].info) < 29) {
1346                                         add_p(plci, BC, cip_bc[GET_WORD(parms[0].info)][a->u_law]);
1347                                         add_p(plci, HLC, cip_hlc[GET_WORD(parms[0].info)]);
1348                                 }
1349                                 add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
1350                                 sig_req(plci, ASSIGN, DSIG_ID);
1351                         }
1352                         else if (ch == 1) {
1353
1354                                 /* D-Channel used for B3 connections */
1355                                 plci->Sig.Id = 0xff;
1356                                 Info = 0;
1357                         }
1358
1359                         if (!Info && ch != 2 && !noCh) {
1360                                 Info = add_b23(plci, &parms[5]);
1361                                 if (!Info) {
1362                                         if (!(plci->tel && !plci->adv_nl))nl_req_ncci(plci, ASSIGN, 0);
1363                                 }
1364                         }
1365
1366                         if (!Info)
1367                         {
1368                                 if (ch == 0 || ch == 2 || ch == 3 || noCh || ch == 4)
1369                                 {
1370                                         if (plci->spoofed_msg == SPOOFING_REQUIRED)
1371                                         {
1372                                                 api_save_msg(parms, "wsssssssss", &plci->saved_msg);
1373                                                 plci->spoofed_msg = CALL_REQ;
1374                                                 plci->internal_command = BLOCK_PLCI;
1375                                                 plci->command = 0;
1376                                                 dbug(1, dprintf("Spoof"));
1377                                                 send_req(plci);
1378                                                 return false;
1379                                         }
1380                                         if (ch == 4)add_p(plci, CHI, p_chi);
1381                                         add_s(plci, CPN, &parms[1]);
1382                                         add_s(plci, DSA, &parms[3]);
1383                                         if (noCh) add_p(plci, ESC, "\x02\x18\xfd");  /* D-channel, no B-L3 */
1384                                         add_ai(plci, &parms[9]);
1385                                         if (!dir)sig_req(plci, CALL_REQ, 0);
1386                                         else
1387                                         {
1388                                                 plci->command = PERM_LIST_REQ;
1389                                                 plci->appl = appl;
1390                                                 sig_req(plci, LISTEN_REQ, 0);
1391                                                 send_req(plci);
1392                                                 return false;
1393                                         }
1394                                 }
1395                                 send_req(plci);
1396                                 return false;
1397                         }
1398                         plci->Id = 0;
1399                 }
1400         }
1401         sendf(appl,
1402               _CONNECT_R | CONFIRM,
1403               Id,
1404               Number,
1405               "w", Info);
1406         return 2;
1407 }
1408
1409 static byte connect_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1410                         PLCI *plci, APPL *appl, API_PARSE *parms)
1411 {
1412         word i, Info;
1413         word Reject;
1414         static byte cau_t[] = {0, 0, 0x90, 0x91, 0xac, 0x9d, 0x86, 0xd8, 0x9b};
1415         static byte esc_t[] = {0x03, 0x08, 0x00, 0x00};
1416         API_PARSE *ai;
1417         API_PARSE ai_parms[5];
1418         word ch = 0;
1419
1420         if (!plci) {
1421                 dbug(1, dprintf("connect_res(no plci)"));
1422                 return 0;  /* no plci, no send */
1423         }
1424
1425         dbug(1, dprintf("connect_res(State=0x%x)", plci->State));
1426         for (i = 0; i < 5; i++) ai_parms[i].length = 0;
1427         ai = &parms[5];
1428         dbug(1, dprintf("ai->length=%d", ai->length));
1429
1430         if (ai->length)
1431         {
1432                 if (!api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms))
1433                 {
1434                         dbug(1, dprintf("ai_parms[0].length=%d/0x%x", ai_parms[0].length, GET_WORD(ai_parms[0].info + 1)));
1435                         ch = 0;
1436                         if (ai_parms[0].length)
1437                         {
1438                                 ch = GET_WORD(ai_parms[0].info + 1);
1439                                 dbug(1, dprintf("BCH-I=0x%x", ch));
1440                         }
1441                 }
1442         }
1443
1444         if (plci->State == INC_CON_CONNECTED_ALERT)
1445         {
1446                 dbug(1, dprintf("Connected Alert Call_Res"));
1447                 if (a->Info_Mask[appl->Id - 1] & 0x200)
1448                 {
1449                         /* early B3 connect (CIP mask bit 9) no release after a disc */
1450                         add_p(plci, LLI, "\x01\x01");
1451                 }
1452                 add_s(plci, CONN_NR, &parms[2]);
1453                 add_s(plci, LLC, &parms[4]);
1454                 add_ai(plci, &parms[5]);
1455                 plci->State = INC_CON_ACCEPT;
1456                 sig_req(plci, CALL_RES, 0);
1457                 return 1;
1458         }
1459         else if (plci->State == INC_CON_PENDING || plci->State == INC_CON_ALERT) {
1460                 clear_c_ind_mask_bit(plci, (word)(appl->Id - 1));
1461                 dump_c_ind_mask(plci);
1462                 Reject = GET_WORD(parms[0].info);
1463                 dbug(1, dprintf("Reject=0x%x", Reject));
1464                 if (Reject)
1465                 {
1466                         if (c_ind_mask_empty(plci))
1467                         {
1468                                 if ((Reject & 0xff00) == 0x3400)
1469                                 {
1470                                         esc_t[2] = ((byte)(Reject & 0x00ff)) | 0x80;
1471                                         add_p(plci, ESC, esc_t);
1472                                         add_ai(plci, &parms[5]);
1473                                         sig_req(plci, REJECT, 0);
1474                                 }
1475                                 else if (Reject == 1 || Reject >= 9)
1476                                 {
1477                                         add_ai(plci, &parms[5]);
1478                                         sig_req(plci, HANGUP, 0);
1479                                 }
1480                                 else
1481                                 {
1482                                         esc_t[2] = cau_t[(Reject&0x000f)];
1483                                         add_p(plci, ESC, esc_t);
1484                                         add_ai(plci, &parms[5]);
1485                                         sig_req(plci, REJECT, 0);
1486                                 }
1487                                 plci->appl = appl;
1488                         }
1489                         else
1490                         {
1491                                 sendf(appl, _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED);
1492                         }
1493                 }
1494                 else {
1495                         plci->appl = appl;
1496                         if (Id & EXT_CONTROLLER) {
1497                                 if (AdvCodecSupport(a, plci, appl, 0)) {
1498                                         dbug(1, dprintf("connect_res(error from AdvCodecSupport)"));
1499                                         sig_req(plci, HANGUP, 0);
1500                                         return 1;
1501                                 }
1502                                 if (plci->tel == ADV_VOICE && a->AdvCodecPLCI)
1503                                 {
1504                                         Info = add_b23(plci, &parms[1]);
1505                                         if (Info)
1506                                         {
1507                                                 dbug(1, dprintf("connect_res(error from add_b23)"));
1508                                                 sig_req(plci, HANGUP, 0);
1509                                                 return 1;
1510                                         }
1511                                         if (plci->adv_nl)
1512                                         {
1513                                                 nl_req_ncci(plci, ASSIGN, 0);
1514                                         }
1515                                 }
1516                         }
1517                         else
1518                         {
1519                                 plci->tel = 0;
1520                                 if (ch != 2)
1521                                 {
1522                                         Info = add_b23(plci, &parms[1]);
1523                                         if (Info)
1524                                         {
1525                                                 dbug(1, dprintf("connect_res(error from add_b23 2)"));
1526                                                 sig_req(plci, HANGUP, 0);
1527                                                 return 1;
1528                                         }
1529                                 }
1530                                 nl_req_ncci(plci, ASSIGN, 0);
1531                         }
1532
1533                         if (plci->spoofed_msg == SPOOFING_REQUIRED)
1534                         {
1535                                 api_save_msg(parms, "wsssss", &plci->saved_msg);
1536                                 plci->spoofed_msg = CALL_RES;
1537                                 plci->internal_command = BLOCK_PLCI;
1538                                 plci->command = 0;
1539                                 dbug(1, dprintf("Spoof"));
1540                         }
1541                         else
1542                         {
1543                                 add_b1(plci, &parms[1], ch, plci->B1_facilities);
1544                                 if (a->Info_Mask[appl->Id - 1] & 0x200)
1545                                 {
1546                                         /* early B3 connect (CIP mask bit 9) no release after a disc */
1547                                         add_p(plci, LLI, "\x01\x01");
1548                                 }
1549                                 add_s(plci, CONN_NR, &parms[2]);
1550                                 add_s(plci, LLC, &parms[4]);
1551                                 add_ai(plci, &parms[5]);
1552                                 plci->State = INC_CON_ACCEPT;
1553                                 sig_req(plci, CALL_RES, 0);
1554                         }
1555
1556                         for (i = 0; i < max_appl; i++) {
1557                                 if (test_c_ind_mask_bit(plci, i)) {
1558                                         sendf(&application[i], _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED);
1559                                 }
1560                         }
1561                 }
1562         }
1563         return 1;
1564 }
1565
1566 static byte connect_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1567                           PLCI *plci, APPL *appl, API_PARSE *msg)
1568 {
1569         dbug(1, dprintf("connect_a_res"));
1570         return false;
1571 }
1572
1573 static byte disconnect_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1574                            PLCI *plci, APPL *appl, API_PARSE *msg)
1575 {
1576         word Info;
1577         word i;
1578
1579         dbug(1, dprintf("disconnect_req"));
1580
1581         Info = _WRONG_IDENTIFIER;
1582
1583         if (plci)
1584         {
1585                 if (plci->State == INC_CON_PENDING || plci->State == INC_CON_ALERT)
1586                 {
1587                         clear_c_ind_mask_bit(plci, (word)(appl->Id - 1));
1588                         plci->appl = appl;
1589                         for (i = 0; i < max_appl; i++)
1590                         {
1591                                 if (test_c_ind_mask_bit(plci, i))
1592                                         sendf(&application[i], _DISCONNECT_I, Id, 0, "w", 0);
1593                         }
1594                         plci->State = OUTG_DIS_PENDING;
1595                 }
1596                 if (plci->Sig.Id && plci->appl)
1597                 {
1598                         Info = 0;
1599                         if (plci->Sig.Id != 0xff)
1600                         {
1601                                 if (plci->State != INC_DIS_PENDING)
1602                                 {
1603                                         add_ai(plci, &msg[0]);
1604                                         sig_req(plci, HANGUP, 0);
1605                                         plci->State = OUTG_DIS_PENDING;
1606                                         return 1;
1607                                 }
1608                         }
1609                         else
1610                         {
1611                                 if (plci->NL.Id && !plci->nl_remove_id)
1612                                 {
1613                                         mixer_remove(plci);
1614                                         nl_req_ncci(plci, REMOVE, 0);
1615                                         sendf(appl, _DISCONNECT_R | CONFIRM, Id, Number, "w", 0);
1616                                         sendf(appl, _DISCONNECT_I, Id, 0, "w", 0);
1617                                         plci->State = INC_DIS_PENDING;
1618                                 }
1619                                 return 1;
1620                         }
1621                 }
1622         }
1623
1624         if (!appl)  return false;
1625         sendf(appl, _DISCONNECT_R | CONFIRM, Id, Number, "w", Info);
1626         return false;
1627 }
1628
1629 static byte disconnect_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1630                            PLCI *plci, APPL *appl, API_PARSE *msg)
1631 {
1632         dbug(1, dprintf("disconnect_res"));
1633         if (plci)
1634         {
1635                 /* clear ind mask bit, just in case of collsion of          */
1636                 /* DISCONNECT_IND and CONNECT_RES                           */
1637                 clear_c_ind_mask_bit(plci, (word)(appl->Id - 1));
1638                 ncci_free_receive_buffers(plci, 0);
1639                 if (plci_remove_check(plci))
1640                 {
1641                         return 0;
1642                 }
1643                 if (plci->State == INC_DIS_PENDING
1644                     || plci->State == SUSPENDING) {
1645                         if (c_ind_mask_empty(plci)) {
1646                                 if (plci->State != SUSPENDING) plci->State = IDLE;
1647                                 dbug(1, dprintf("chs=%d", plci->channels));
1648                                 if (!plci->channels) {
1649                                         plci_remove(plci);
1650                                 }
1651                         }
1652                 }
1653         }
1654         return 0;
1655 }
1656
1657 static byte listen_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1658                        PLCI *plci, APPL *appl, API_PARSE *parms)
1659 {
1660         word Info;
1661         byte i;
1662
1663         dbug(1, dprintf("listen_req(Appl=0x%x)", appl->Id));
1664
1665         Info = _WRONG_IDENTIFIER;
1666         if (a) {
1667                 Info = 0;
1668                 a->Info_Mask[appl->Id - 1] = GET_DWORD(parms[0].info);
1669                 a->CIP_Mask[appl->Id - 1] = GET_DWORD(parms[1].info);
1670                 dbug(1, dprintf("CIP_MASK=0x%lx", GET_DWORD(parms[1].info)));
1671                 if (a->Info_Mask[appl->Id - 1] & 0x200) { /* early B3 connect provides */
1672                         a->Info_Mask[appl->Id - 1] |=  0x10;   /* call progression infos    */
1673                 }
1674
1675                 /* check if external controller listen and switch listen on or off*/
1676                 if (Id&EXT_CONTROLLER && GET_DWORD(parms[1].info)) {
1677                         if (a->profile.Global_Options & ON_BOARD_CODEC) {
1678                                 dummy_plci.State = IDLE;
1679                                 a->codec_listen[appl->Id - 1] = &dummy_plci;
1680                                 a->TelOAD[0] = (byte)(parms[3].length);
1681                                 for (i = 1; parms[3].length >= i && i < 22; i++) {
1682                                         a->TelOAD[i] = parms[3].info[i];
1683                                 }
1684                                 a->TelOAD[i] = 0;
1685                                 a->TelOSA[0] = (byte)(parms[4].length);
1686                                 for (i = 1; parms[4].length >= i && i < 22; i++) {
1687                                         a->TelOSA[i] = parms[4].info[i];
1688                                 }
1689                                 a->TelOSA[i] = 0;
1690                         }
1691                         else Info = 0x2002; /* wrong controller, codec not supported */
1692                 }
1693                 else{               /* clear listen */
1694                         a->codec_listen[appl->Id - 1] = (PLCI *)0;
1695                 }
1696         }
1697         sendf(appl,
1698               _LISTEN_R | CONFIRM,
1699               Id,
1700               Number,
1701               "w", Info);
1702
1703         if (a) listen_check(a);
1704         return false;
1705 }
1706
1707 static byte info_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1708                      PLCI *plci, APPL *appl, API_PARSE *msg)
1709 {
1710         word i;
1711         API_PARSE *ai;
1712         PLCI *rc_plci = NULL;
1713         API_PARSE ai_parms[5];
1714         word Info = 0;
1715
1716         dbug(1, dprintf("info_req"));
1717         for (i = 0; i < 5; i++) ai_parms[i].length = 0;
1718
1719         ai = &msg[1];
1720
1721         if (ai->length)
1722         {
1723                 if (api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms))
1724                 {
1725                         dbug(1, dprintf("AddInfo wrong"));
1726                         Info = _WRONG_MESSAGE_FORMAT;
1727                 }
1728         }
1729         if (!a) Info = _WRONG_STATE;
1730
1731         if (!Info && plci)
1732         {                /* no fac, with CPN, or KEY */
1733                 rc_plci = plci;
1734                 if (!ai_parms[3].length && plci->State && (msg[0].length || ai_parms[1].length))
1735                 {
1736                         /* overlap sending option */
1737                         dbug(1, dprintf("OvlSnd"));
1738                         add_s(plci, CPN, &msg[0]);
1739                         add_s(plci, KEY, &ai_parms[1]);
1740                         sig_req(plci, INFO_REQ, 0);
1741                         send_req(plci);
1742                         return false;
1743                 }
1744
1745                 if (plci->State && ai_parms[2].length)
1746                 {
1747                         /* User_Info option */
1748                         dbug(1, dprintf("UUI"));
1749                         add_s(plci, UUI, &ai_parms[2]);
1750                         sig_req(plci, USER_DATA, 0);
1751                 }
1752                 else if (plci->State && ai_parms[3].length)
1753                 {
1754                         /* Facility option */
1755                         dbug(1, dprintf("FAC"));
1756                         add_s(plci, CPN, &msg[0]);
1757                         add_ai(plci, &msg[1]);
1758                         sig_req(plci, FACILITY_REQ, 0);
1759                 }
1760                 else
1761                 {
1762                         Info = _WRONG_STATE;
1763                 }
1764         }
1765         else if ((ai_parms[1].length || ai_parms[2].length || ai_parms[3].length) && !Info)
1766         {
1767                 /* NCR_Facility option -> send UUI and Keypad too */
1768                 dbug(1, dprintf("NCR_FAC"));
1769                 if ((i = get_plci(a)))
1770                 {
1771                         rc_plci = &a->plci[i - 1];
1772                         appl->NullCREnable = true;
1773                         rc_plci->internal_command = C_NCR_FAC_REQ;
1774                         rc_plci->appl = appl;
1775                         add_p(rc_plci, CAI, "\x01\x80");
1776                         add_p(rc_plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
1777                         sig_req(rc_plci, ASSIGN, DSIG_ID);
1778                         send_req(rc_plci);
1779                 }
1780                 else
1781                 {
1782                         Info = _OUT_OF_PLCI;
1783                 }
1784
1785                 if (!Info)
1786                 {
1787                         add_s(rc_plci, CPN, &msg[0]);
1788                         add_ai(rc_plci, &msg[1]);
1789                         sig_req(rc_plci, NCR_FACILITY, 0);
1790                         send_req(rc_plci);
1791                         return false;
1792                         /* for application controlled supplementary services    */
1793                 }
1794         }
1795
1796         if (!rc_plci)
1797         {
1798                 Info = _WRONG_MESSAGE_FORMAT;
1799         }
1800
1801         if (!Info)
1802         {
1803                 send_req(rc_plci);
1804         }
1805         else
1806         {  /* appl is not assigned to a PLCI or error condition */
1807                 dbug(1, dprintf("localInfoCon"));
1808                 sendf(appl,
1809                       _INFO_R | CONFIRM,
1810                       Id,
1811                       Number,
1812                       "w", Info);
1813         }
1814         return false;
1815 }
1816
1817 static byte info_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1818                      PLCI *plci, APPL *appl, API_PARSE *msg)
1819 {
1820         dbug(1, dprintf("info_res"));
1821         return false;
1822 }
1823
1824 static byte alert_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1825                       PLCI *plci, APPL *appl, API_PARSE *msg)
1826 {
1827         word Info;
1828         byte ret;
1829
1830         dbug(1, dprintf("alert_req"));
1831
1832         Info = _WRONG_IDENTIFIER;
1833         ret = false;
1834         if (plci) {
1835                 Info = _ALERT_IGNORED;
1836                 if (plci->State != INC_CON_ALERT) {
1837                         Info = _WRONG_STATE;
1838                         if (plci->State == INC_CON_PENDING) {
1839                                 Info = 0;
1840                                 plci->State = INC_CON_ALERT;
1841                                 add_ai(plci, &msg[0]);
1842                                 sig_req(plci, CALL_ALERT, 0);
1843                                 ret = 1;
1844                         }
1845                 }
1846         }
1847         sendf(appl,
1848               _ALERT_R | CONFIRM,
1849               Id,
1850               Number,
1851               "w", Info);
1852         return ret;
1853 }
1854
1855 static byte facility_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1856                          PLCI *plci, APPL *appl, API_PARSE *msg)
1857 {
1858         word Info = 0;
1859         word i    = 0;
1860
1861         word selector;
1862         word SSreq;
1863         long relatedPLCIvalue;
1864         DIVA_CAPI_ADAPTER *relatedadapter;
1865         byte *SSparms  = "";
1866         byte RCparms[]  = "\x05\x00\x00\x02\x00\x00";
1867         byte SSstruct[] = "\x09\x00\x00\x06\x00\x00\x00\x00\x00\x00";
1868         API_PARSE *parms;
1869         API_PARSE ss_parms[11];
1870         PLCI *rplci;
1871         byte cai[15];
1872         dword d;
1873         API_PARSE dummy;
1874
1875         dbug(1, dprintf("facility_req"));
1876         for (i = 0; i < 9; i++) ss_parms[i].length = 0;
1877
1878         parms = &msg[1];
1879
1880         if (!a)
1881         {
1882                 dbug(1, dprintf("wrong Ctrl"));
1883                 Info = _WRONG_IDENTIFIER;
1884         }
1885
1886         selector = GET_WORD(msg[0].info);
1887
1888         if (!Info)
1889         {
1890                 switch (selector)
1891                 {
1892                 case SELECTOR_HANDSET:
1893                         Info = AdvCodecSupport(a, plci, appl, HOOK_SUPPORT);
1894                         break;
1895
1896                 case SELECTOR_SU_SERV:
1897                         if (!msg[1].length)
1898                         {
1899                                 Info = _WRONG_MESSAGE_FORMAT;
1900                                 break;
1901                         }
1902                         SSreq = GET_WORD(&(msg[1].info[1]));
1903                         PUT_WORD(&RCparms[1], SSreq);
1904                         SSparms = RCparms;
1905                         switch (SSreq)
1906                         {
1907                         case S_GET_SUPPORTED_SERVICES:
1908                                 if ((i = get_plci(a)))
1909                                 {
1910                                         rplci = &a->plci[i - 1];
1911                                         rplci->appl = appl;
1912                                         add_p(rplci, CAI, "\x01\x80");
1913                                         add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
1914                                         sig_req(rplci, ASSIGN, DSIG_ID);
1915                                         send_req(rplci);
1916                                 }
1917                                 else
1918                                 {
1919                                         PUT_DWORD(&SSstruct[6], MASK_TERMINAL_PORTABILITY);
1920                                         SSparms = (byte *)SSstruct;
1921                                         break;
1922                                 }
1923                                 rplci->internal_command = GETSERV_REQ_PEND;
1924                                 rplci->number = Number;
1925                                 rplci->appl = appl;
1926                                 sig_req(rplci, S_SUPPORTED, 0);
1927                                 send_req(rplci);
1928                                 return false;
1929                                 break;
1930
1931                         case S_LISTEN:
1932                                 if (parms->length == 7)
1933                                 {
1934                                         if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms))
1935                                         {
1936                                                 dbug(1, dprintf("format wrong"));
1937                                                 Info = _WRONG_MESSAGE_FORMAT;
1938                                                 break;
1939                                         }
1940                                 }
1941                                 else
1942                                 {
1943                                         Info = _WRONG_MESSAGE_FORMAT;
1944                                         break;
1945                                 }
1946                                 a->Notification_Mask[appl->Id - 1] = GET_DWORD(ss_parms[2].info);
1947                                 if (a->Notification_Mask[appl->Id - 1] & SMASK_MWI) /* MWI active? */
1948                                 {
1949                                         if ((i = get_plci(a)))
1950                                         {
1951                                                 rplci = &a->plci[i - 1];
1952                                                 rplci->appl = appl;
1953                                                 add_p(rplci, CAI, "\x01\x80");
1954                                                 add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
1955                                                 sig_req(rplci, ASSIGN, DSIG_ID);
1956                                                 send_req(rplci);
1957                                         }
1958                                         else
1959                                         {
1960                                                 break;
1961                                         }
1962                                         rplci->internal_command = GET_MWI_STATE;
1963                                         rplci->number = Number;
1964                                         sig_req(rplci, MWI_POLL, 0);
1965                                         send_req(rplci);
1966                                 }
1967                                 break;
1968
1969                         case S_HOLD:
1970                                 api_parse(&parms->info[1], (word)parms->length, "ws", ss_parms);
1971                                 if (plci && plci->State && plci->SuppState == IDLE)
1972                                 {
1973                                         plci->SuppState = HOLD_REQUEST;
1974                                         plci->command = C_HOLD_REQ;
1975                                         add_s(plci, CAI, &ss_parms[1]);
1976                                         sig_req(plci, CALL_HOLD, 0);
1977                                         send_req(plci);
1978                                         return false;
1979                                 }
1980                                 else Info = 0x3010;                    /* wrong state           */
1981                                 break;
1982                         case S_RETRIEVE:
1983                                 if (plci && plci->State && plci->SuppState == CALL_HELD)
1984                                 {
1985                                         if (Id & EXT_CONTROLLER)
1986                                         {
1987                                                 if (AdvCodecSupport(a, plci, appl, 0))
1988                                                 {
1989                                                         Info = 0x3010;                    /* wrong state           */
1990                                                         break;
1991                                                 }
1992                                         }
1993                                         else plci->tel = 0;
1994
1995                                         plci->SuppState = RETRIEVE_REQUEST;
1996                                         plci->command = C_RETRIEVE_REQ;
1997                                         if (plci->spoofed_msg == SPOOFING_REQUIRED)
1998                                         {
1999                                                 plci->spoofed_msg = CALL_RETRIEVE;
2000                                                 plci->internal_command = BLOCK_PLCI;
2001                                                 plci->command = 0;
2002                                                 dbug(1, dprintf("Spoof"));
2003                                                 return false;
2004                                         }
2005                                         else
2006                                         {
2007                                                 sig_req(plci, CALL_RETRIEVE, 0);
2008                                                 send_req(plci);
2009                                                 return false;
2010                                         }
2011                                 }
2012                                 else Info = 0x3010;                    /* wrong state           */
2013                                 break;
2014                         case S_SUSPEND:
2015                                 if (parms->length)
2016                                 {
2017                                         if (api_parse(&parms->info[1], (word)parms->length, "wbs", ss_parms))
2018                                         {
2019                                                 dbug(1, dprintf("format wrong"));
2020                                                 Info = _WRONG_MESSAGE_FORMAT;
2021                                                 break;
2022                                         }
2023                                 }
2024                                 if (plci && plci->State)
2025                                 {
2026                                         add_s(plci, CAI, &ss_parms[2]);
2027                                         plci->command = SUSPEND_REQ;
2028                                         sig_req(plci, SUSPEND, 0);
2029                                         plci->State = SUSPENDING;
2030                                         send_req(plci);
2031                                 }
2032                                 else Info = 0x3010;                    /* wrong state           */
2033                                 break;
2034
2035                         case S_RESUME:
2036                                 if (!(i = get_plci(a)))
2037                                 {
2038                                         Info = _OUT_OF_PLCI;
2039                                         break;
2040                                 }
2041                                 rplci = &a->plci[i - 1];
2042                                 rplci->appl = appl;
2043                                 rplci->number = Number;
2044                                 rplci->tel = 0;
2045                                 rplci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
2046                                 /* check 'external controller' bit for codec support */
2047                                 if (Id & EXT_CONTROLLER)
2048                                 {
2049                                         if (AdvCodecSupport(a, rplci, appl, 0))
2050                                         {
2051                                                 rplci->Id = 0;
2052                                                 Info = 0x300A;
2053                                                 break;
2054                                         }
2055                                 }
2056                                 if (parms->length)
2057                                 {
2058                                         if (api_parse(&parms->info[1], (word)parms->length, "wbs", ss_parms))
2059                                         {
2060                                                 dbug(1, dprintf("format wrong"));
2061                                                 rplci->Id = 0;
2062                                                 Info = _WRONG_MESSAGE_FORMAT;
2063                                                 break;
2064                                         }
2065                                 }
2066                                 dummy.length = 0;
2067                                 dummy.info = "\x00";
2068                                 add_b1(rplci, &dummy, 0, 0);
2069                                 if (a->Info_Mask[appl->Id - 1] & 0x200)
2070                                 {
2071                                         /* early B3 connect (CIP mask bit 9) no release after a disc */
2072                                         add_p(rplci, LLI, "\x01\x01");
2073                                 }
2074                                 add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
2075                                 sig_req(rplci, ASSIGN, DSIG_ID);
2076                                 send_req(rplci);
2077                                 add_s(rplci, CAI, &ss_parms[2]);
2078                                 rplci->command = RESUME_REQ;
2079                                 sig_req(rplci, RESUME, 0);
2080                                 rplci->State = RESUMING;
2081                                 send_req(rplci);
2082                                 break;
2083
2084                         case S_CONF_BEGIN: /* Request */
2085                         case S_CONF_DROP:
2086                         case S_CONF_ISOLATE:
2087                         case S_CONF_REATTACH:
2088                                 if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms))
2089                                 {
2090                                         dbug(1, dprintf("format wrong"));
2091                                         Info = _WRONG_MESSAGE_FORMAT;
2092                                         break;
2093                                 }
2094                                 if (plci && plci->State && ((plci->SuppState == IDLE) || (plci->SuppState == CALL_HELD)))
2095                                 {
2096                                         d = GET_DWORD(ss_parms[2].info);
2097                                         if (d >= 0x80)
2098                                         {
2099                                                 dbug(1, dprintf("format wrong"));
2100                                                 Info = _WRONG_MESSAGE_FORMAT;
2101                                                 break;
2102                                         }
2103                                         plci->ptyState = (byte)SSreq;
2104                                         plci->command = 0;
2105                                         cai[0] = 2;
2106                                         switch (SSreq)
2107                                         {
2108                                         case S_CONF_BEGIN:
2109                                                 cai[1] = CONF_BEGIN;
2110                                                 plci->internal_command = CONF_BEGIN_REQ_PEND;
2111                                                 break;
2112                                         case S_CONF_DROP:
2113                                                 cai[1] = CONF_DROP;
2114                                                 plci->internal_command = CONF_DROP_REQ_PEND;
2115                                                 break;
2116                                         case S_CONF_ISOLATE:
2117                                                 cai[1] = CONF_ISOLATE;
2118                                                 plci->internal_command = CONF_ISOLATE_REQ_PEND;
2119                                                 break;
2120                                         case S_CONF_REATTACH:
2121                                                 cai[1] = CONF_REATTACH;
2122                                                 plci->internal_command = CONF_REATTACH_REQ_PEND;
2123                                                 break;
2124                                         }
2125                                         cai[2] = (byte)d; /* Conference Size resp. PartyId */
2126                                         add_p(plci, CAI, cai);
2127                                         sig_req(plci, S_SERVICE, 0);
2128                                         send_req(plci);
2129                                         return false;
2130                                 }
2131                                 else Info = 0x3010;                    /* wrong state           */
2132                                 break;
2133
2134                         case S_ECT:
2135                         case S_3PTY_BEGIN:
2136                         case S_3PTY_END:
2137                         case S_CONF_ADD:
2138                                 if (parms->length == 7)
2139                                 {
2140                                         if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms))
2141                                         {
2142                                                 dbug(1, dprintf("format wrong"));
2143                                                 Info = _WRONG_MESSAGE_FORMAT;
2144                                                 break;
2145                                         }
2146                                 }
2147                                 else if (parms->length == 8) /* workaround for the T-View-S */
2148                                 {
2149                                         if (api_parse(&parms->info[1], (word)parms->length, "wbdb", ss_parms))
2150                                         {
2151                                                 dbug(1, dprintf("format wrong"));
2152                                                 Info = _WRONG_MESSAGE_FORMAT;
2153                                                 break;
2154                                         }
2155                                 }
2156                                 else
2157                                 {
2158                                         Info = _WRONG_MESSAGE_FORMAT;
2159                                         break;
2160                                 }
2161                                 if (!msg[1].length)
2162                                 {
2163                                         Info = _WRONG_MESSAGE_FORMAT;
2164                                         break;
2165                                 }
2166                                 if (!plci)
2167                                 {
2168                                         Info = _WRONG_IDENTIFIER;
2169                                         break;
2170                                 }
2171                                 relatedPLCIvalue = GET_DWORD(ss_parms[2].info);
2172                                 relatedPLCIvalue &= 0x0000FFFF;
2173                                 dbug(1, dprintf("PTY/ECT/addCONF,relPLCI=%lx", relatedPLCIvalue));
2174                                 /* controller starts with 0 up to (max_adapter - 1) */
2175                                 if (((relatedPLCIvalue & 0x7f) == 0)
2176                                     || (MapController((byte)(relatedPLCIvalue & 0x7f)) == 0)
2177                                     || (MapController((byte)(relatedPLCIvalue & 0x7f)) > max_adapter))
2178                                 {
2179                                         if (SSreq == S_3PTY_END)
2180                                         {
2181                                                 dbug(1, dprintf("wrong Controller use 2nd PLCI=PLCI"));
2182                                                 rplci = plci;
2183                                         }
2184                                         else
2185                                         {
2186                                                 Info = 0x3010;                    /* wrong state           */
2187                                                 break;
2188                                         }
2189                                 }
2190                                 else
2191                                 {
2192                                         relatedadapter = &adapter[MapController((byte)(relatedPLCIvalue & 0x7f)) - 1];
2193                                         relatedPLCIvalue >>= 8;
2194                                         /* find PLCI PTR*/
2195                                         for (i = 0, rplci = NULL; i < relatedadapter->max_plci; i++)
2196                                         {
2197                                                 if (relatedadapter->plci[i].Id == (byte)relatedPLCIvalue)
2198                                                 {
2199                                                         rplci = &relatedadapter->plci[i];
2200                                                 }
2201                                         }
2202                                         if (!rplci || !relatedPLCIvalue)
2203                                         {
2204                                                 if (SSreq == S_3PTY_END)
2205                                                 {
2206                                                         dbug(1, dprintf("use 2nd PLCI=PLCI"));
2207                                                         rplci = plci;
2208                                                 }
2209                                                 else
2210                                                 {
2211                                                         Info = 0x3010;                    /* wrong state           */
2212                                                         break;
2213                                                 }
2214                                         }
2215                                 }
2216 /*
2217   dbug(1, dprintf("rplci:%x", rplci));
2218   dbug(1, dprintf("plci:%x", plci));
2219   dbug(1, dprintf("rplci->ptyState:%x", rplci->ptyState));
2220   dbug(1, dprintf("plci->ptyState:%x", plci->ptyState));
2221   dbug(1, dprintf("SSreq:%x", SSreq));
2222   dbug(1, dprintf("rplci->internal_command:%x", rplci->internal_command));
2223   dbug(1, dprintf("rplci->appl:%x", rplci->appl));
2224   dbug(1, dprintf("rplci->Id:%x", rplci->Id));
2225 */
2226                                 /* send PTY/ECT req, cannot check all states because of US stuff */
2227                                 if (!rplci->internal_command && rplci->appl)
2228                                 {
2229                                         plci->command = 0;
2230                                         rplci->relatedPTYPLCI = plci;
2231                                         plci->relatedPTYPLCI = rplci;
2232                                         rplci->ptyState = (byte)SSreq;
2233                                         if (SSreq == S_ECT)
2234                                         {
2235                                                 rplci->internal_command = ECT_REQ_PEND;
2236                                                 cai[1] = ECT_EXECUTE;
2237
2238                                                 rplci->vswitchstate = 0;
2239                                                 rplci->vsprot = 0;
2240                                                 rplci->vsprotdialect = 0;
2241                                                 plci->vswitchstate = 0;
2242                                                 plci->vsprot = 0;
2243                                                 plci->vsprotdialect = 0;
2244
2245                                         }
2246                                         else if (SSreq == S_CONF_ADD)
2247                                         {
2248                                                 rplci->internal_command = CONF_ADD_REQ_PEND;
2249                                                 cai[1] = CONF_ADD;
2250                                         }
2251                                         else
2252                                         {
2253                                                 rplci->internal_command = PTY_REQ_PEND;
2254                                                 cai[1] = (byte)(SSreq - 3);
2255                                         }
2256                                         rplci->number = Number;
2257                                         if (plci != rplci) /* explicit invocation */
2258                                         {
2259                                                 cai[0] = 2;
2260                                                 cai[2] = plci->Sig.Id;
2261                                                 dbug(1, dprintf("explicit invocation"));
2262                                         }
2263                                         else
2264                                         {
2265                                                 dbug(1, dprintf("implicit invocation"));
2266                                                 cai[0] = 1;
2267                                         }
2268                                         add_p(rplci, CAI, cai);
2269                                         sig_req(rplci, S_SERVICE, 0);
2270                                         send_req(rplci);
2271                                         return false;
2272                                 }
2273                                 else
2274                                 {
2275                                         dbug(0, dprintf("Wrong line"));
2276                                         Info = 0x3010;                    /* wrong state           */
2277                                         break;
2278                                 }
2279                                 break;
2280
2281                         case S_CALL_DEFLECTION:
2282                                 if (api_parse(&parms->info[1], (word)parms->length, "wbwss", ss_parms))
2283                                 {
2284                                         dbug(1, dprintf("format wrong"));
2285                                         Info = _WRONG_MESSAGE_FORMAT;
2286                                         break;
2287                                 }
2288                                 if (!plci)
2289                                 {
2290                                         Info = _WRONG_IDENTIFIER;
2291                                         break;
2292                                 }
2293                                 /* reuse unused screening indicator */
2294                                 ss_parms[3].info[3] = (byte)GET_WORD(&(ss_parms[2].info[0]));
2295                                 plci->command = 0;
2296                                 plci->internal_command = CD_REQ_PEND;
2297                                 appl->CDEnable = true;
2298                                 cai[0] = 1;
2299                                 cai[1] = CALL_DEFLECTION;
2300                                 add_p(plci, CAI, cai);
2301                                 add_p(plci, CPN, ss_parms[3].info);
2302                                 sig_req(plci, S_SERVICE, 0);
2303                                 send_req(plci);
2304                                 return false;
2305                                 break;
2306
2307                         case S_CALL_FORWARDING_START:
2308                                 if (api_parse(&parms->info[1], (word)parms->length, "wbdwwsss", ss_parms))
2309                                 {
2310                                         dbug(1, dprintf("format wrong"));
2311                                         Info = _WRONG_MESSAGE_FORMAT;
2312                                         break;
2313                                 }
2314
2315                                 if ((i = get_plci(a)))
2316                                 {
2317                                         rplci = &a->plci[i - 1];
2318                                         rplci->appl = appl;
2319                                         add_p(rplci, CAI, "\x01\x80");
2320                                         add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
2321                                         sig_req(rplci, ASSIGN, DSIG_ID);
2322                                         send_req(rplci);
2323                                 }
2324                                 else
2325                                 {
2326                                         Info = _OUT_OF_PLCI;
2327                                         break;
2328                                 }
2329
2330                                 /* reuse unused screening indicator */
2331                                 rplci->internal_command = CF_START_PEND;
2332                                 rplci->appl = appl;
2333                                 rplci->number = Number;
2334                                 appl->S_Handle = GET_DWORD(&(ss_parms[2].info[0]));
2335                                 cai[0] = 2;
2336                                 cai[1] = 0x70 | (byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */
2337                                 cai[2] = (byte)GET_WORD(&(ss_parms[4].info[0])); /* Basic Service */
2338                                 add_p(rplci, CAI, cai);
2339                                 add_p(rplci, OAD, ss_parms[5].info);
2340                                 add_p(rplci, CPN, ss_parms[6].info);
2341                                 sig_req(rplci, S_SERVICE, 0);
2342                                 send_req(rplci);
2343                                 return false;
2344                                 break;
2345
2346                         case S_INTERROGATE_DIVERSION:
2347                         case S_INTERROGATE_NUMBERS:
2348                         case S_CALL_FORWARDING_STOP:
2349                         case S_CCBS_REQUEST:
2350                         case S_CCBS_DEACTIVATE:
2351                         case S_CCBS_INTERROGATE:
2352                                 switch (SSreq)
2353                                 {
2354                                 case S_INTERROGATE_NUMBERS:
2355                                         if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms))
2356                                         {
2357                                                 dbug(0, dprintf("format wrong"));
2358                                                 Info = _WRONG_MESSAGE_FORMAT;
2359                                         }
2360                                         break;
2361                                 case S_CCBS_REQUEST:
2362                                 case S_CCBS_DEACTIVATE:
2363                                         if (api_parse(&parms->info[1], (word)parms->length, "wbdw", ss_parms))
2364                                         {
2365                                                 dbug(0, dprintf("format wrong"));
2366                                                 Info = _WRONG_MESSAGE_FORMAT;
2367                                         }
2368                                         break;
2369                                 case S_CCBS_INTERROGATE:
2370                                         if (api_parse(&parms->info[1], (word)parms->length, "wbdws", ss_parms))
2371                                         {
2372                                                 dbug(0, dprintf("format wrong"));
2373                                                 Info = _WRONG_MESSAGE_FORMAT;
2374                                         }
2375                                         break;
2376                                 default:
2377                                         if (api_parse(&parms->info[1], (word)parms->length, "wbdwws", ss_parms))
2378                                         {
2379                                                 dbug(0, dprintf("format wrong"));
2380                                                 Info = _WRONG_MESSAGE_FORMAT;
2381                                                 break;
2382                                         }
2383                                         break;
2384                                 }
2385
2386                                 if (Info) break;
2387                                 if ((i = get_plci(a)))
2388                                 {
2389                                         rplci = &a->plci[i - 1];
2390                                         switch (SSreq)
2391                                         {
2392                                         case S_INTERROGATE_DIVERSION: /* use cai with S_SERVICE below */
2393                                                 cai[1] = 0x60 | (byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */
2394                                                 rplci->internal_command = INTERR_DIVERSION_REQ_PEND; /* move to rplci if assigned */
2395                                                 break;
2396                                         case S_INTERROGATE_NUMBERS: /* use cai with S_SERVICE below */
2397                                                 cai[1] = DIVERSION_INTERROGATE_NUM; /* Function */
2398                                                 rplci->internal_command = INTERR_NUMBERS_REQ_PEND; /* move to rplci if assigned */
2399                                                 break;
2400                                         case S_CALL_FORWARDING_STOP:
2401                                                 rplci->internal_command = CF_STOP_PEND;
2402                                                 cai[1] = 0x80 | (byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */
2403                                                 break;
2404                                         case S_CCBS_REQUEST:
2405                                                 cai[1] = CCBS_REQUEST;
2406                                                 rplci->internal_command = CCBS_REQUEST_REQ_PEND;
2407                                                 break;
2408                                         case S_CCBS_DEACTIVATE:
2409                                                 cai[1] = CCBS_DEACTIVATE;
2410                                                 rplci->internal_command = CCBS_DEACTIVATE_REQ_PEND;
2411                                                 break;
2412                                         case S_CCBS_INTERROGATE:
2413                                                 cai[1] = CCBS_INTERROGATE;
2414                                                 rplci->internal_command = CCBS_INTERROGATE_REQ_PEND;
2415                                                 break;
2416                                         default:
2417                                                 cai[1] = 0;
2418                                                 break;
2419                                         }
2420                                         rplci->appl = appl;
2421                                         rplci->number = Number;
2422                                         add_p(rplci, CAI, "\x01\x80");
2423                                         add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
2424                                         sig_req(rplci, ASSIGN, DSIG_ID);
2425                                         send_req(rplci);
2426                                 }
2427                                 else
2428                                 {
2429                                         Info = _OUT_OF_PLCI;
2430                                         break;
2431                                 }
2432
2433                                 appl->S_Handle = GET_DWORD(&(ss_parms[2].info[0]));
2434                                 switch (SSreq)
2435                                 {
2436                                 case S_INTERROGATE_NUMBERS:
2437                                         cai[0] = 1;
2438                                         add_p(rplci, CAI, cai);
2439                                         break;
2440                                 case S_CCBS_REQUEST:
2441                                 case S_CCBS_DEACTIVATE:
2442                                         cai[0] = 3;
2443                                         PUT_WORD(&cai[2], GET_WORD(&(ss_parms[3].info[0])));
2444                                         add_p(rplci, CAI, cai);
2445                                         break;
2446                                 case S_CCBS_INTERROGATE:
2447                                         cai[0] = 3;
2448                                         PUT_WORD(&cai[2], GET_WORD(&(ss_parms[3].info[0])));
2449                                         add_p(rplci, CAI, cai);
2450                                         add_p(rplci, OAD, ss_parms[4].info);
2451                                         break;
2452                                 default:
2453                                         cai[0] = 2;
2454                                         cai[2] = (byte)GET_WORD(&(ss_parms[4].info[0])); /* Basic Service */
2455                                         add_p(rplci, CAI, cai);
2456                                         add_p(rplci, OAD, ss_parms[5].info);
2457                                         break;
2458                                 }
2459
2460                                 sig_req(rplci, S_SERVICE, 0);
2461                                 send_req(rplci);
2462                                 return false;
2463                                 break;
2464
2465                         case S_MWI_ACTIVATE:
2466                                 if (api_parse(&parms->info[1], (word)parms->length, "wbwdwwwssss", ss_parms))
2467                                 {
2468                                         dbug(1, dprintf("format wrong"));
2469                                         Info = _WRONG_MESSAGE_FORMAT;
2470                                         break;
2471                                 }
2472                                 if (!plci)
2473                                 {
2474                                         if ((i = get_plci(a)))
2475                                         {
2476                                                 rplci = &a->plci[i - 1];
2477                                                 rplci->appl = appl;
2478                                                 rplci->cr_enquiry = true;
2479                                                 add_p(rplci, CAI, "\x01\x80");
2480                                                 add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
2481                                                 sig_req(rplci, ASSIGN, DSIG_ID);
2482                                                 send_req(rplci);
2483                                         }
2484                                         else
2485                                         {
2486                                                 Info = _OUT_OF_PLCI;
2487                                                 break;
2488                                         }
2489                                 }
2490                                 else
2491                                 {
2492                                         rplci = plci;
2493                                         rplci->cr_enquiry = false;
2494                                 }
2495
2496                                 rplci->command = 0;
2497                                 rplci->internal_command = MWI_ACTIVATE_REQ_PEND;
2498                                 rplci->appl = appl;
2499                                 rplci->number = Number;
2500
2501                                 cai[0] = 13;
2502                                 cai[1] = ACTIVATION_MWI; /* Function */
2503                                 PUT_WORD(&cai[2], GET_WORD(&(ss_parms[2].info[0]))); /* Basic Service */
2504                                 PUT_DWORD(&cai[4], GET_DWORD(&(ss_parms[3].info[0]))); /* Number of Messages */
2505                                 PUT_WORD(&cai[8], GET_WORD(&(ss_parms[4].info[0]))); /* Message Status */
2506                                 PUT_WORD(&cai[10], GET_WORD(&(ss_parms[5].info[0]))); /* Message Reference */
2507                                 PUT_WORD(&cai[12], GET_WORD(&(ss_parms[6].info[0]))); /* Invocation Mode */
2508                                 add_p(rplci, CAI, cai);
2509                                 add_p(rplci, CPN, ss_parms[7].info); /* Receiving User Number */
2510                                 add_p(rplci, OAD, ss_parms[8].info); /* Controlling User Number */
2511                                 add_p(rplci, OSA, ss_parms[9].info); /* Controlling User Provided Number */
2512                                 add_p(rplci, UID, ss_parms[10].info); /* Time */
2513                                 sig_req(rplci, S_SERVICE, 0);
2514                                 send_req(rplci);
2515                                 return false;
2516
2517                         case S_MWI_DEACTIVATE:
2518                                 if (api_parse(&parms->info[1], (word)parms->length, "wbwwss", ss_parms))
2519                                 {
2520                                         dbug(1, dprintf("format wrong"));
2521                                         Info = _WRONG_MESSAGE_FORMAT;
2522                                         break;
2523                                 }
2524                                 if (!plci)
2525                                 {
2526                                         if ((i = get_plci(a)))
2527                                         {
2528                                                 rplci = &a->plci[i - 1];
2529                                                 rplci->appl = appl;
2530                                                 rplci->cr_enquiry = true;
2531                                                 add_p(rplci, CAI, "\x01\x80");
2532                                                 add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
2533                                                 sig_req(rplci, ASSIGN, DSIG_ID);
2534                                                 send_req(rplci);
2535                                         }
2536                                         else
2537                                         {
2538                                                 Info = _OUT_OF_PLCI;
2539                                                 break;
2540                                         }
2541                                 }
2542                                 else
2543                                 {
2544                                         rplci = plci;
2545                                         rplci->cr_enquiry = false;
2546                                 }
2547
2548                                 rplci->command = 0;
2549                                 rplci->internal_command = MWI_DEACTIVATE_REQ_PEND;
2550                                 rplci->appl = appl;
2551                                 rplci->number = Number;
2552
2553                                 cai[0] = 5;
2554                                 cai[1] = DEACTIVATION_MWI; /* Function */
2555                                 PUT_WORD(&cai[2], GET_WORD(&(ss_parms[2].info[0]))); /* Basic Service */
2556                                 PUT_WORD(&cai[4], GET_WORD(&(ss_parms[3].info[0]))); /* Invocation Mode */
2557                                 add_p(rplci, CAI, cai);
2558                                 add_p(rplci, CPN, ss_parms[4].info); /* Receiving User Number */
2559                                 add_p(rplci, OAD, ss_parms[5].info); /* Controlling User Number */
2560                                 sig_req(rplci, S_SERVICE, 0);
2561                                 send_req(rplci);
2562                                 return false;
2563
2564                         default:
2565                                 Info = 0x300E;  /* not supported */
2566                                 break;
2567                         }
2568                         break; /* case SELECTOR_SU_SERV: end */
2569
2570
2571                 case SELECTOR_DTMF:
2572                         return (dtmf_request(Id, Number, a, plci, appl, msg));
2573
2574
2575
2576                 case SELECTOR_LINE_INTERCONNECT:
2577                         return (mixer_request(Id, Number, a, plci, appl, msg));
2578
2579
2580
2581                 case PRIV_SELECTOR_ECHO_CANCELLER:
2582                         appl->appl_flags |= APPL_FLAG_PRIV_EC_SPEC;
2583                         return (ec_request(Id, Number, a, plci, appl, msg));
2584
2585                 case SELECTOR_ECHO_CANCELLER:
2586                         appl->appl_flags &= ~APPL_FLAG_PRIV_EC_SPEC;
2587                         return (ec_request(Id, Number, a, plci, appl, msg));
2588
2589
2590                 case SELECTOR_V42BIS:
2591                 default:
2592                         Info = _FACILITY_NOT_SUPPORTED;
2593                         break;
2594                 } /* end of switch (selector) */
2595         }
2596
2597         dbug(1, dprintf("SendFacRc"));
2598         sendf(appl,
2599               _FACILITY_R | CONFIRM,
2600               Id,
2601               Number,
2602               "wws", Info, selector, SSparms);
2603         return false;
2604 }
2605
2606 static byte facility_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2607                          PLCI *plci, APPL *appl, API_PARSE *msg)
2608 {
2609         dbug(1, dprintf("facility_res"));
2610         return false;
2611 }
2612
2613 static byte connect_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2614                            PLCI *plci, APPL *appl, API_PARSE *parms)
2615 {
2616         word Info = 0;
2617         byte req;
2618         byte len;
2619         word w;
2620         word fax_control_bits, fax_feature_bits, fax_info_change;
2621         API_PARSE *ncpi;
2622         byte pvc[2];
2623
2624         API_PARSE fax_parms[9];
2625         word i;
2626
2627
2628         dbug(1, dprintf("connect_b3_req"));
2629         if (plci)
2630         {
2631                 if ((plci->State == IDLE) || (plci->State == OUTG_DIS_PENDING)
2632                     || (plci->State == INC_DIS_PENDING) || (plci->SuppState != IDLE))
2633                 {
2634                         Info = _WRONG_STATE;
2635                 }
2636                 else
2637                 {
2638                         /* local reply if assign unsuccessful
2639                            or B3 protocol allows only one layer 3 connection
2640                            and already connected
2641                            or B2 protocol not any LAPD
2642                            and connect_b3_req contradicts originate/answer direction */
2643                         if (!plci->NL.Id
2644                             || (((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE))
2645                                 && ((plci->channels != 0)
2646                                     || (((plci->B2_prot != B2_SDLC) && (plci->B2_prot != B2_LAPD) && (plci->B2_prot != B2_LAPD_FREE_SAPI_SEL))
2647                                         && ((plci->call_dir & CALL_DIR_ANSWER) && !(plci->call_dir & CALL_DIR_FORCE_OUTG_NL))))))
2648                         {
2649                                 dbug(1, dprintf("B3 already connected=%d or no NL.Id=0x%x, dir=%d sstate=0x%x",
2650                                                 plci->channels, plci->NL.Id, plci->call_dir, plci->SuppState));
2651                                 Info = _WRONG_STATE;
2652                                 sendf(appl,
2653                                       _CONNECT_B3_R | CONFIRM,
2654                                       Id,
2655                                       Number,
2656                                       "w", Info);
2657                                 return false;
2658                         }
2659                         plci->requested_options_conn = 0;
2660
2661                         req = N_CONNECT;
2662                         ncpi = &parms[0];
2663                         if (plci->B3_prot == 2 || plci->B3_prot == 3)
2664                         {
2665                                 if (ncpi->length > 2)
2666                                 {
2667                                         /* check for PVC */
2668                                         if (ncpi->info[2] || ncpi->info[3])
2669                                         {
2670                                                 pvc[0] = ncpi->info[3];
2671                                                 pvc[1] = ncpi->info[2];
2672                                                 add_d(plci, 2, pvc);
2673                                                 req = N_RESET;
2674                                         }
2675                                         else
2676                                         {
2677                                                 if (ncpi->info[1] & 1) req = N_CONNECT | N_D_BIT;
2678                                                 add_d(plci, (word)(ncpi->length - 3), &ncpi->info[4]);
2679                                         }
2680                                 }
2681                         }
2682                         else if (plci->B3_prot == 5)
2683                         {
2684                                 if (plci->NL.Id && !plci->nl_remove_id)
2685                                 {
2686                                         fax_control_bits = GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low);
2687                                         fax_feature_bits = GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->feature_bits_low);
2688                                         if (!(fax_control_bits & T30_CONTROL_BIT_MORE_DOCUMENTS)
2689                                             || (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS))
2690                                         {
2691                                                 len = offsetof(T30_INFO, universal_6);
2692                                                 fax_info_change = false;
2693                                                 if (ncpi->length >= 4)
2694                                                 {
2695                                                         w = GET_WORD(&ncpi->info[3]);
2696                                                         if ((w & 0x0001) != ((word)(((T30_INFO *)(plci->fax_connect_info_buffer))->resolution & 0x0001)))
2697                                                         {
2698                                                                 ((T30_INFO *)(plci->fax_connect_info_buffer))->resolution =
2699                                                                         (byte)((((T30_INFO *)(plci->fax_connect_info_buffer))->resolution & ~T30_RESOLUTION_R8_0770_OR_200) |
2700                                                                                ((w & 0x0001) ? T30_RESOLUTION_R8_0770_OR_200 : 0));
2701                                                                 fax_info_change = true;
2702                                                         }
2703                                                         fax_control_bits &= ~(T30_CONTROL_BIT_REQUEST_POLLING | T30_CONTROL_BIT_MORE_DOCUMENTS);
2704                                                         if (w & 0x0002)  /* Fax-polling request */
2705                                                                 fax_control_bits |= T30_CONTROL_BIT_REQUEST_POLLING;
2706                                                         if ((w & 0x0004) /* Request to send / poll another document */
2707                                                             && (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_MORE_DOCUMENTS))
2708                                                         {
2709                                                                 fax_control_bits |= T30_CONTROL_BIT_MORE_DOCUMENTS;
2710                                                         }
2711                                                         if (ncpi->length >= 6)
2712                                                         {
2713                                                                 w = GET_WORD(&ncpi->info[5]);
2714                                                                 if (((byte) w) != ((T30_INFO *)(plci->fax_connect_info_buffer))->data_format)
2715                                                                 {
2716                                                                         ((T30_INFO *)(plci->fax_connect_info_buffer))->data_format = (byte) w;
2717                                                                         fax_info_change = true;
2718                                                                 }
2719
2720                                                                 if ((a->man_profile.private_options & (1L << PRIVATE_FAX_SUB_SEP_PWD))
2721                                                                     && (GET_WORD(&ncpi->info[5]) & 0x8000)) /* Private SEP/SUB/PWD enable */
2722                                                                 {
2723                                                                         plci->requested_options_conn |= (1L << PRIVATE_FAX_SUB_SEP_PWD);
2724                                                                 }
2725                                                                 if ((a->man_profile.private_options & (1L << PRIVATE_FAX_NONSTANDARD))
2726                                                                     && (GET_WORD(&ncpi->info[5]) & 0x4000)) /* Private non-standard facilities enable */
2727                                                                 {
2728                                                                         plci->requested_options_conn |= (1L << PRIVATE_FAX_NONSTANDARD);
2729                                                                 }
2730                                                                 fax_control_bits &= ~(T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_SEL_POLLING |
2731                                                                                       T30_CONTROL_BIT_ACCEPT_PASSWORD);
2732                                                                 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id - 1])
2733                                                                     & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
2734                                                                 {
2735                                                                         if (api_parse(&ncpi->info[1], ncpi->length, "wwwwsss", fax_parms))
2736                                                                                 Info = _WRONG_MESSAGE_FORMAT;
2737                                                                         else
2738                                                                         {
2739                                                                                 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id - 1])
2740                                                                                     & (1L << PRIVATE_FAX_SUB_SEP_PWD))
2741                                                                                 {
2742                                                                                         fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_PASSWORD;
2743                                                                                         if (fax_control_bits & T30_CONTROL_BIT_ACCEPT_POLLING)
2744                                                                                                 fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SEL_POLLING;
2745                                                                                 }
2746                                                                                 w = fax_parms[4].length;
2747                                                                                 if (w > 20)
2748                                                                                         w = 20;
2749                                                                                 ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id_len = (byte) w;
2750                                                                                 for (i = 0; i < w; i++)
2751                                                                                         ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id[i] = fax_parms[4].info[1 + i];
2752                                                                                 ((T30_INFO *)(plci->fax_connect_info_buffer))->head_line_len = 0;
2753                                                                                 len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
2754                                                                                 w = fax_parms[5].length;
2755                                                                                 if (w > 20)
2756                                                                                         w = 20;
2757                                                                                 plci->fax_connect_info_buffer[len++] = (byte) w;
2758                                                                                 for (i = 0; i < w; i++)
2759                                                                                         plci->fax_connect_info_buffer[len++] = fax_parms[5].info[1 + i];
2760                                                                                 w = fax_parms[6].length;
2761                                                                                 if (w > 20)
2762                                                                                         w = 20;
2763                                                                                 plci->fax_connect_info_buffer[len++] = (byte) w;
2764                                                                                 for (i = 0; i < w; i++)
2765                                                                                         plci->fax_connect_info_buffer[len++] = fax_parms[6].info[1 + i];
2766                                                                                 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id - 1])
2767                                                                                     & (1L << PRIVATE_FAX_NONSTANDARD))
2768                                                                                 {
2769                                                                                         if (api_parse(&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms))
2770                                                                                         {
2771                                                                                                 dbug(1, dprintf("non-standard facilities info missing or wrong format"));
2772                                                                                                 plci->fax_connect_info_buffer[len++] = 0;
2773                                                                                         }
2774                                                                                         else
2775                                                                                         {
2776                                                                                                 if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2))
2777                                                                                                         plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]);
2778                                                                                                 plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length);
2779                                                                                                 for (i = 0; i < fax_parms[7].length; i++)
2780                                                                                                         plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1 + i];
2781                                                                                         }
2782                                                                                 }
2783                                                                         }
2784                                                                 }
2785                                                                 else
2786                                                                 {
2787                                                                         len = offsetof(T30_INFO, universal_6);
2788                                                                 }
2789                                                                 fax_info_change = true;
2790
2791                                                         }
2792                                                         if (fax_control_bits != GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low))
2793                                                         {
2794                                                                 PUT_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low, fax_control_bits);
2795                                                                 fax_info_change = true;
2796                                                         }
2797                                                 }
2798                                                 if (Info == GOOD)
2799                                                 {
2800                                                         plci->fax_connect_info_length = len;
2801                                                         if (fax_info_change)
2802                                                         {
2803                                                                 if (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS)
2804                                                                 {
2805                                                                         start_internal_command(Id, plci, fax_connect_info_command);
2806                                                                         return false;
2807                                                                 }
2808                                                                 else
2809                                                                 {
2810                                                                         start_internal_command(Id, plci, fax_adjust_b23_command);
2811                                                                         return false;
2812                                                                 }
2813                                                         }
2814                                                 }
2815                                         }
2816                                         else  Info = _WRONG_STATE;
2817                                 }
2818                                 else  Info = _WRONG_STATE;
2819                         }
2820
2821                         else if (plci->B3_prot == B3_RTP)
2822                         {
2823                                 plci->internal_req_buffer[0] = ncpi->length + 1;
2824                                 plci->internal_req_buffer[1] = UDATA_REQUEST_RTP_RECONFIGURE;
2825                                 for (w = 0; w < ncpi->length; w++)
2826                                         plci->internal_req_buffer[2 + w] = ncpi->info[1 + w];
2827                                 start_internal_command(Id, plci, rtp_connect_b3_req_command);
2828                                 return false;
2829                         }
2830
2831                         if (!Info)
2832                         {
2833                                 nl_req_ncci(plci, req, 0);
2834                                 return 1;
2835                         }
2836                 }
2837         }
2838         else Info = _WRONG_IDENTIFIER;
2839
2840         sendf(appl,
2841               _CONNECT_B3_R | CONFIRM,
2842               Id,
2843               Number,
2844               "w", Info);
2845         return false;
2846 }
2847
2848 static byte connect_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2849                            PLCI *plci, APPL *appl, API_PARSE *parms)
2850 {
2851         word ncci;
2852         API_PARSE *ncpi;
2853         byte req;
2854
2855         word w;
2856
2857
2858         API_PARSE fax_parms[9];
2859         word i;
2860         byte len;
2861
2862
2863         dbug(1, dprintf("connect_b3_res"));
2864
2865         ncci = (word)(Id >> 16);
2866         if (plci && ncci) {
2867                 if (a->ncci_state[ncci] == INC_CON_PENDING) {
2868                         if (GET_WORD(&parms[0].info[0]) != 0)
2869                         {
2870                                 a->ncci_state[ncci] = OUTG_REJ_PENDING;
2871                                 channel_request_xon(plci, a->ncci_ch[ncci]);
2872                                 channel_xmit_xon(plci);
2873                                 cleanup_ncci_data(plci, ncci);
2874                                 nl_req_ncci(plci, N_DISC, (byte)ncci);
2875                                 return 1;
2876                         }
2877                         a->ncci_state[ncci] = INC_ACT_PENDING;
2878
2879                         req = N_CONNECT_ACK;
2880                         ncpi = &parms[1];
2881                         if ((plci->B3_prot == 4) || (plci->B3_prot == 5) || (plci->B3_prot == 7))
2882                         {
2883
2884                                 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id - 1])
2885                                     & (1L << PRIVATE_FAX_NONSTANDARD))
2886                                 {
2887                                         if (((plci->B3_prot == 4) || (plci->B3_prot == 5))
2888                                             && (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF)
2889                                             && (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP))
2890                                         {
2891                                                 len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
2892                                                 if (plci->fax_connect_info_length < len)
2893                                                 {
2894                                                         ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id_len = 0;
2895                                                         ((T30_INFO *)(plci->fax_connect_info_buffer))->head_line_len = 0;
2896                                                 }
2897                                                 if (api_parse(&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms))
2898                                                 {
2899                                                         dbug(1, dprintf("non-standard facilities info missing or wrong format"));
2900                                                 }
2901                                                 else
2902                                                 {
2903                                                         if (plci->fax_connect_info_length <= len)
2904                                                                 plci->fax_connect_info_buffer[len] = 0;
2905                                                         len += 1 + plci->fax_connect_info_buffer[len];
2906                                                         if (plci->fax_connect_info_length <= len)
2907                                                                 plci->fax_connect_info_buffer[len] = 0;
2908                                                         len += 1 + plci->fax_connect_info_buffer[len];
2909                                                         if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2))
2910                                                                 plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]);
2911                                                         plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length);
2912                                                         for (i = 0; i < fax_parms[7].length; i++)
2913                                                                 plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1 + i];
2914                                                 }
2915                                                 plci->fax_connect_info_length = len;
2916                                                 ((T30_INFO *)(plci->fax_connect_info_buffer))->code = 0;
2917                                                 start_internal_command(Id, plci, fax_connect_ack_command);
2918                                                 return false;
2919                                         }
2920                                 }
2921
2922                                 nl_req_ncci(plci, req, (byte)ncci);
2923                                 if ((plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
2924                                     && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
2925                                 {
2926                                         if (plci->B3_prot == 4)
2927                                                 sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
2928                                         else
2929                                                 sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
2930                                         plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
2931                                 }
2932                         }
2933
2934                         else if (plci->B3_prot == B3_RTP)
2935                         {
2936                                 plci->internal_req_buffer[0] = ncpi->length + 1;
2937                                 plci->internal_req_buffer[1] = UDATA_REQUEST_RTP_RECONFIGURE;
2938                                 for (w = 0; w < ncpi->length; w++)
2939                                         plci->internal_req_buffer[2 + w] = ncpi->info[1+w];
2940                                 start_internal_command(Id, plci, rtp_connect_b3_res_command);
2941                                 return false;
2942                         }
2943
2944                         else
2945                         {
2946                                 if (ncpi->length > 2) {
2947                                         if (ncpi->info[1] & 1) req = N_CONNECT_ACK | N_D_BIT;
2948                                         add_d(plci, (word)(ncpi->length - 3), &ncpi->info[4]);
2949                                 }
2950                                 nl_req_ncci(plci, req, (byte)ncci);
2951                                 sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
2952                                 if (plci->adjust_b_restore)
2953                                 {
2954                                         plci->adjust_b_restore = false;
2955                                         start_internal_command(Id, plci, adjust_b_restore);
2956                                 }
2957                         }
2958                         return 1;
2959                 }
2960         }
2961         return false;
2962 }
2963
2964 static byte connect_b3_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2965                              PLCI *plci, APPL *appl, API_PARSE *parms)
2966 {
2967         word ncci;
2968
2969         ncci = (word)(Id >> 16);
2970         dbug(1, dprintf("connect_b3_a_res(ncci=0x%x)", ncci));
2971
2972         if (plci && ncci && (plci->State != IDLE) && (plci->State != INC_DIS_PENDING)
2973             && (plci->State != OUTG_DIS_PENDING))
2974         {
2975                 if (a->ncci_state[ncci] == INC_ACT_PENDING) {
2976                         a->ncci_state[ncci] = CONNECTED;
2977                         if (plci->State != INC_CON_CONNECTED_ALERT) plci->State = CONNECTED;
2978                         channel_request_xon(plci, a->ncci_ch[ncci]);
2979                         channel_xmit_xon(plci);
2980                 }
2981         }
2982         return false;
2983 }
2984
2985 static byte disconnect_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2986                               PLCI *plci, APPL *appl, API_PARSE *parms)
2987 {
2988         word Info;
2989         word ncci;
2990         API_PARSE *ncpi;
2991
2992         dbug(1, dprintf("disconnect_b3_req"));
2993
2994         Info = _WRONG_IDENTIFIER;
2995         ncci = (word)(Id >> 16);
2996         if (plci && ncci)
2997         {
2998                 Info = _WRONG_STATE;
2999                 if ((a->ncci_state[ncci] == CONNECTED)
3000                     || (a->ncci_state[ncci] == OUTG_CON_PENDING)
3001                     || (a->ncci_state[ncci] == INC_CON_PENDING)
3002                     || (a->ncci_state[ncci] == INC_ACT_PENDING))
3003                 {
3004                         a->ncci_state[ncci] = OUTG_DIS_PENDING;
3005                         channel_request_xon(plci, a->ncci_ch[ncci]);
3006                         channel_xmit_xon(plci);
3007
3008                         if (a->ncci[ncci].data_pending
3009                             && ((plci->B3_prot == B3_TRANSPARENT)
3010                                 || (plci->B3_prot == B3_T30)
3011                                 || (plci->B3_prot == B3_T30_WITH_EXTENSIONS)))
3012                         {
3013                                 plci->send_disc = (byte)ncci;
3014                                 plci->command = 0;
3015                                 return false;
3016                         }
3017                         else
3018                         {
3019                                 cleanup_ncci_data(plci, ncci);
3020
3021                                 if (plci->B3_prot == 2 || plci->B3_prot == 3)
3022                                 {
3023                                         ncpi = &parms[0];
3024                                         if (ncpi->length > 3)
3025                                         {
3026                                                 add_d(plci, (word)(ncpi->length - 3), (byte *)&(ncpi->info[4]));
3027                                         }
3028                                 }
3029                                 nl_req_ncci(plci, N_DISC, (byte)ncci);
3030                         }
3031                         return 1;
3032                 }
3033         }
3034         sendf(appl,
3035               _DISCONNECT_B3_R | CONFIRM,
3036               Id,
3037               Number,
3038               "w", Info);
3039         return false;
3040 }
3041
3042 static byte disconnect_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3043                               PLCI *plci, APPL *appl, API_PARSE *parms)
3044 {
3045         word ncci;
3046         word i;
3047
3048         ncci = (word)(Id >> 16);
3049         dbug(1, dprintf("disconnect_b3_res(ncci=0x%x", ncci));
3050         if (plci && ncci) {
3051                 plci->requested_options_conn = 0;
3052                 plci->fax_connect_info_length = 0;
3053                 plci->ncpi_state = 0x00;
3054                 if (((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE))
3055                     && ((plci->B2_prot != B2_LAPD) && (plci->B2_prot != B2_LAPD_FREE_SAPI_SEL)))
3056                 {
3057                         plci->call_dir |= CALL_DIR_FORCE_OUTG_NL;
3058                 }
3059                 for (i = 0; i < MAX_CHANNELS_PER_PLCI && plci->inc_dis_ncci_table[i] != (byte)ncci; i++);
3060                 if (i < MAX_CHANNELS_PER_PLCI) {
3061                         if (plci->channels)plci->channels--;
3062                         for (; i < MAX_CHANNELS_PER_PLCI - 1; i++) plci->inc_dis_ncci_table[i] = plci->inc_dis_ncci_table[i + 1];
3063                         plci->inc_dis_ncci_table[MAX_CHANNELS_PER_PLCI - 1] = 0;
3064
3065                         ncci_free_receive_buffers(plci, ncci);
3066
3067                         if ((plci->State == IDLE || plci->State == SUSPENDING) && !plci->channels) {
3068                                 if (plci->State == SUSPENDING) {
3069                                         sendf(plci->appl,
3070                                               _FACILITY_I,
3071                                               Id & 0xffffL,
3072                                               0,
3073                                               "ws", (word)3, "\x03\x04\x00\x00");
3074                                         sendf(plci->appl, _DISCONNECT_I, Id & 0xffffL, 0, "w", 0);
3075                                 }
3076                                 plci_remove(plci);
3077                                 plci->State = IDLE;
3078                         }
3079                 }
3080                 else
3081                 {
3082                         if ((a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
3083                             && ((plci->B3_prot == 4) || (plci->B3_prot == 5))
3084                             && (a->ncci_state[ncci] == INC_DIS_PENDING))
3085                         {
3086                                 ncci_free_receive_buffers(plci, ncci);
3087
3088                                 nl_req_ncci(plci, N_EDATA, (byte)ncci);
3089
3090                                 plci->adapter->ncci_state[ncci] = IDLE;
3091                                 start_internal_command(Id, plci, fax_disconnect_command);
3092                                 return 1;
3093                         }
3094                 }
3095         }
3096         return false;
3097 }
3098
3099 static byte data_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3100                         PLCI *plci, APPL *appl, API_PARSE *parms)
3101 {
3102         NCCI *ncci_ptr;
3103         DATA_B3_DESC *data;
3104         word Info;
3105         word ncci;
3106         word i;
3107
3108         dbug(1, dprintf("data_b3_req"));
3109
3110         Info = _WRONG_IDENTIFIER;
3111         ncci = (word)(Id >> 16);
3112         dbug(1, dprintf("ncci=0x%x, plci=0x%x", ncci, plci));
3113
3114         if (plci && ncci)
3115         {
3116                 Info = _WRONG_STATE;
3117                 if ((a->ncci_state[ncci] == CONNECTED)
3118                     || (a->ncci_state[ncci] == INC_ACT_PENDING))
3119                 {
3120                         /* queue data */
3121                         ncci_ptr = &(a->ncci[ncci]);
3122                         i = ncci_ptr->data_out + ncci_ptr->data_pending;
3123                         if (i >= MAX_DATA_B3)
3124                                 i -= MAX_DATA_B3;
3125                         data = &(ncci_ptr->DBuffer[i]);
3126                         data->Number = Number;
3127                         if ((((byte *)(parms[0].info)) >= ((byte *)(plci->msg_in_queue)))
3128                             && (((byte *)(parms[0].info)) < ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
3129                         {
3130
3131                                 data->P = (byte *)(long)(*((dword *)(parms[0].info)));
3132
3133                         }
3134                         else
3135                                 data->P = TransmitBufferSet(appl, *(dword *)parms[0].info);
3136                         data->Length = GET_WORD(parms[1].info);
3137                         data->Handle = GET_WORD(parms[2].info);
3138                         data->Flags = GET_WORD(parms[3].info);
3139                         (ncci_ptr->data_pending)++;
3140
3141                         /* check for delivery confirmation */
3142                         if (data->Flags & 0x0004)
3143                         {
3144                                 i = ncci_ptr->data_ack_out + ncci_ptr->data_ack_pending;
3145                                 if (i >= MAX_DATA_ACK)
3146                                         i -= MAX_DATA_ACK;
3147                                 ncci_ptr->DataAck[i].Number = data->Number;
3148                                 ncci_ptr->DataAck[i].Handle = data->Handle;
3149                                 (ncci_ptr->data_ack_pending)++;
3150                         }
3151
3152                         send_data(plci);
3153                         return false;
3154                 }
3155         }
3156         if (appl)
3157         {
3158                 if (plci)
3159                 {
3160                         if ((((byte *)(parms[0].info)) >= ((byte *)(plci->msg_in_queue)))
3161                             && (((byte *)(parms[0].info)) < ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
3162                         {
3163
3164                                 TransmitBufferFree(appl, (byte *)(long)(*((dword *)(parms[0].info))));
3165
3166                         }
3167                 }
3168                 sendf(appl,
3169                       _DATA_B3_R | CONFIRM,
3170                       Id,
3171                       Number,
3172                       "ww", GET_WORD(parms[2].info), Info);
3173         }
3174         return false;
3175 }
3176
3177 static byte data_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3178                         PLCI *plci, APPL *appl, API_PARSE *parms)
3179 {
3180         word n;
3181         word ncci;
3182         word NCCIcode;
3183
3184         dbug(1, dprintf("data_b3_res"));
3185
3186         ncci = (word)(Id >> 16);
3187         if (plci && ncci) {
3188                 n = GET_WORD(parms[0].info);
3189                 dbug(1, dprintf("free(%d)", n));
3190                 NCCIcode = ncci | (((word) a->Id) << 8);
3191                 if (n < appl->MaxBuffer &&
3192                     appl->DataNCCI[n] == NCCIcode &&
3193                     (byte)(appl->DataFlags[n] >> 8) == plci->Id) {
3194                         dbug(1, dprintf("found"));
3195                         appl->DataNCCI[n] = 0;
3196
3197                         if (channel_can_xon(plci, a->ncci_ch[ncci])) {
3198                                 channel_request_xon(plci, a->ncci_ch[ncci]);
3199                         }
3200                         channel_xmit_xon(plci);
3201
3202                         if (appl->DataFlags[n] & 4) {
3203                                 nl_req_ncci(plci, N_DATA_ACK, (byte)ncci);
3204                                 return 1;
3205                         }
3206                 }
3207         }
3208         return false;
3209 }
3210
3211 static byte reset_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3212                          PLCI *plci, APPL *appl, API_PARSE *parms)
3213 {
3214         word Info;
3215         word ncci;
3216
3217         dbug(1, dprintf("reset_b3_req"));
3218
3219         Info = _WRONG_IDENTIFIER;
3220         ncci = (word)(Id >> 16);
3221         if (plci && ncci)
3222         {
3223                 Info = _WRONG_STATE;
3224                 switch (plci->B3_prot)
3225                 {
3226                 case B3_ISO8208:
3227                 case B3_X25_DCE:
3228                         if (a->ncci_state[ncci] == CONNECTED)
3229                         {
3230                                 nl_req_ncci(plci, N_RESET, (byte)ncci);
3231                                 send_req(plci);
3232                                 Info = GOOD;
3233                         }
3234                         break;
3235                 case B3_TRANSPARENT:
3236                         if (a->ncci_state[ncci] == CONNECTED)
3237                         {
3238                                 start_internal_command(Id, plci, reset_b3_command);
3239                                 Info = GOOD;
3240                         }
3241                         break;
3242                 }
3243         }
3244         /* reset_b3 must result in a reset_b3_con & reset_b3_Ind */
3245         sendf(appl,
3246               _RESET_B3_R | CONFIRM,
3247               Id,
3248               Number,
3249               "w", Info);
3250         return false;
3251 }
3252
3253 static byte reset_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3254                          PLCI *plci, APPL *appl, API_PARSE *parms)
3255 {
3256         word ncci;
3257
3258         dbug(1, dprintf("reset_b3_res"));
3259
3260         ncci = (word)(Id >> 16);
3261         if (plci && ncci) {
3262                 switch (plci->B3_prot)
3263                 {
3264                 case B3_ISO8208:
3265                 case B3_X25_DCE:
3266                         if (a->ncci_state[ncci] == INC_RES_PENDING)
3267                         {
3268                                 a->ncci_state[ncci] = CONNECTED;
3269                                 nl_req_ncci(plci, N_RESET_ACK, (byte)ncci);
3270                                 return true;
3271                         }
3272                         break;
3273                 }
3274         }
3275         return false;
3276 }
3277
3278 static byte connect_b3_t90_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3279                                  PLCI *plci, APPL *appl, API_PARSE *parms)
3280 {
3281         word ncci;
3282         API_PARSE *ncpi;
3283         byte req;
3284
3285         dbug(1, dprintf("connect_b3_t90_a_res"));
3286
3287         ncci = (word)(Id >> 16);
3288         if (plci && ncci) {
3289                 if (a->ncci_state[ncci] == INC_ACT_PENDING) {
3290                         a->ncci_state[ncci] = CONNECTED;
3291                 }
3292                 else if (a->ncci_state[ncci] == INC_CON_PENDING) {
3293                         a->ncci_state[ncci] = CONNECTED;
3294
3295                         req = N_CONNECT_ACK;
3296
3297                         /* parms[0]==0 for CAPI original message definition! */
3298                         if (parms[0].info) {
3299                                 ncpi = &parms[1];
3300                                 if (ncpi->length > 2) {
3301                                         if (ncpi->info[1] & 1) req = N_CONNECT_ACK | N_D_BIT;
3302                                         add_d(plci, (word)(ncpi->length - 3), &ncpi->info[4]);
3303                                 }
3304                         }
3305                         nl_req_ncci(plci, req, (byte)ncci);
3306                         return 1;
3307                 }
3308         }
3309         return false;
3310 }
3311
3312
3313 static byte select_b_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3314                          PLCI *plci, APPL *appl, API_PARSE *msg)
3315 {
3316         word Info = 0;
3317         word i;
3318         byte tel;
3319         API_PARSE bp_parms[7];
3320
3321         if (!plci || !msg)
3322         {
3323                 Info = _WRONG_IDENTIFIER;
3324         }
3325         else
3326         {
3327                 dbug(1, dprintf("select_b_req[%d],PLCI=0x%x,Tel=0x%x,NL=0x%x,appl=0x%x,sstate=0x%x",
3328                                 msg->length, plci->Id, plci->tel, plci->NL.Id, plci->appl, plci->SuppState));
3329                 dbug(1, dprintf("PlciState=0x%x", plci->State));
3330                 for (i = 0; i < 7; i++) bp_parms[i].length = 0;
3331
3332                 /* check if no channel is open, no B3 connected only */
3333                 if ((plci->State == IDLE) || (plci->State == OUTG_DIS_PENDING) || (plci->State == INC_DIS_PENDING)
3334                     || (plci->SuppState != IDLE) || plci->channels || plci->nl_remove_id)
3335                 {
3336                         Info = _WRONG_STATE;
3337                 }
3338                 /* check message format and fill bp_parms pointer */
3339                 else if (msg->length && api_parse(&msg->info[1], (word)msg->length, "wwwsss", bp_parms))
3340                 {
3341                         Info = _WRONG_MESSAGE_FORMAT;
3342                 }
3343                 else
3344                 {
3345                         if ((plci->State == INC_CON_PENDING) || (plci->State == INC_CON_ALERT)) /* send alert tone inband to the network, */
3346                         {                                                                  /* e.g. Qsig or RBS or Cornet-N or xess PRI */
3347                                 if (Id & EXT_CONTROLLER)
3348                                 {
3349                                         sendf(appl, _SELECT_B_REQ | CONFIRM, Id, Number, "w", 0x2002); /* wrong controller */
3350                                         return 0;
3351                                 }
3352                                 plci->State = INC_CON_CONNECTED_ALERT;
3353                                 plci->appl = appl;
3354                                 clear_c_ind_mask_bit(plci, (word)(appl->Id - 1));
3355                                 dump_c_ind_mask(plci);
3356                                 for (i = 0; i < max_appl; i++) /* disconnect the other appls */
3357                                 {                         /* its quasi a connect        */
3358                                         if (test_c_ind_mask_bit(plci, i))
3359                                                 sendf(&application[i], _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED);
3360                                 }
3361                         }
3362
3363                         api_save_msg(msg, "s", &plci->saved_msg);
3364                         tel = plci->tel;
3365                         if (Id & EXT_CONTROLLER)
3366                         {
3367                                 if (tel) /* external controller in use by this PLCI */
3368                                 {
3369                                         if (a->AdvSignalAppl && a->AdvSignalAppl != appl)
3370                                         {
3371                                                 dbug(1, dprintf("Ext_Ctrl in use 1"));
3372                                                 Info = _WRONG_STATE;
3373                                         }
3374                                 }
3375                                 else  /* external controller NOT in use by this PLCI ? */
3376                                 {
3377                                         if (a->AdvSignalPLCI)
3378                                         {
3379                                                 dbug(1, dprintf("Ext_Ctrl in use 2"));
3380                                                 Info = _WRONG_STATE;
3381                                         }
3382                                         else /* activate the codec */
3383                                         {
3384                                                 dbug(1, dprintf("Ext_Ctrl start"));
3385                                                 if (AdvCodecSupport(a, plci, appl, 0))
3386                                                 {
3387                                                         dbug(1, dprintf("Error in codec procedures"));
3388                                                         Info = _WRONG_STATE;
3389                                                 }
3390                                                 else if (plci->spoofed_msg == SPOOFING_REQUIRED) /* wait until codec is active */
3391                                                 {
3392                                                         plci->spoofed_msg = AWAITING_SELECT_B;
3393                                                         plci->internal_command = BLOCK_PLCI; /* lock other commands */
3394                                                         plci->command = 0;
3395                                                         dbug(1, dprintf("continue if codec loaded"));
3396                                                         return false;
3397                                                 }
3398                                         }
3399                                 }
3400                         }
3401                         else /* external controller bit is OFF */
3402                         {
3403                                 if (tel) /* external controller in use, need to switch off */
3404                                 {
3405                                         if (a->AdvSignalAppl == appl)
3406                                         {
3407                                                 CodecIdCheck(a, plci);
3408                                                 plci->tel = 0;
3409                                                 plci->adv_nl = 0;
3410                                                 dbug(1, dprintf("Ext_Ctrl disable"));
3411                                         }
3412                                         else
3413                                         {
3414                                                 dbug(1, dprintf("Ext_Ctrl not requested"));
3415                                         }
3416                                 }
3417                         }
3418                         if (!Info)
3419                         {
3420                                 if (plci->call_dir & CALL_DIR_OUT)
3421                                         plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
3422                                 else if (plci->call_dir & CALL_DIR_IN)
3423                                         plci->call_dir = CALL_DIR_IN | CALL_DIR_ANSWER;
3424                                 start_internal_command(Id, plci, select_b_command);
3425                                 return false;
3426                         }
3427                 }
3428         }
3429         sendf(appl, _SELECT_B_REQ | CONFIRM, Id, Number, "w", Info);
3430         return false;
3431 }
3432
3433 static byte manufacturer_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3434                              PLCI *plci, APPL *appl, API_PARSE *parms)
3435 {
3436         word command;
3437         word i;
3438         word ncci;
3439         API_PARSE *m;
3440         API_PARSE m_parms[5];
3441         word codec;
3442         byte req;
3443         byte ch;
3444         byte dir;
3445         static byte chi[2] = {0x01, 0x00};
3446         static byte lli[2] = {0x01, 0x00};
3447         static byte codec_cai[2] = {0x01, 0x01};
3448         static byte null_msg = {0};
3449         static API_PARSE null_parms = { 0, &null_msg };
3450         PLCI *v_plci;
3451         word Info = 0;
3452
3453         dbug(1, dprintf("manufacturer_req"));
3454         for (i = 0; i < 5; i++) m_parms[i].length = 0;
3455
3456         if (GET_DWORD(parms[0].info) != _DI_MANU_ID) {
3457                 Info = _WRONG_MESSAGE_FORMAT;
3458         }
3459         command = GET_WORD(parms[1].info);
3460         m = &parms[2];
3461         if (!Info)
3462         {
3463                 switch (command) {
3464                 case _DI_ASSIGN_PLCI:
3465                         if (api_parse(&m->info[1], (word)m->length, "wbbs", m_parms)) {
3466                                 Info = _WRONG_MESSAGE_FORMAT;
3467                                 break;
3468                         }
3469                         codec = GET_WORD(m_parms[0].info);
3470                         ch = m_parms[1].info[0];
3471                         dir = m_parms[2].info[0];
3472                         if ((i = get_plci(a))) {
3473                                 plci = &a->plci[i - 1];
3474                                 plci->appl = appl;
3475                                 plci->command = _MANUFACTURER_R;
3476                                 plci->m_command = command;
3477                                 plci->number = Number;
3478                                 plci->State = LOCAL_CONNECT;
3479                                 Id = (((word)plci->Id << 8) | plci->adapter->Id | 0x80);
3480                                 dbug(1, dprintf("ManCMD,plci=0x%x", Id));
3481
3482                                 if ((ch == 1 || ch == 2) && (dir <= 2)) {
3483                                         chi[1] = (byte)(0x80 | ch);
3484                                         lli[1] = 0;
3485                                         plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
3486                                         switch (codec)
3487                                         {
3488                                         case 0:
3489                                                 Info = add_b1(plci, &m_parms[3], 0, 0);
3490                                                 break;
3491                                         case 1:
3492                                                 add_p(plci, CAI, codec_cai);
3493                                                 break;
3494                                                 /* manual 'swich on' to the codec support without signalling */
3495                                                 /* first 'assign plci' with this function, then use */
3496                                         case 2:
3497                                                 if (AdvCodecSupport(a, plci, appl, 0)) {
3498                                                         Info = _RESOURCE_ERROR;
3499                                                 }
3500                                                 else {
3501                                                         Info = add_b1(plci, &null_parms, 0, B1_FACILITY_LOCAL);
3502                                                         lli[1] = 0x10; /* local call codec stream */
3503                                                 }
3504                                                 break;
3505                                         }
3506
3507                                         plci->State = LOCAL_CONNECT;
3508                                         plci->manufacturer = true;
3509                                         plci->command = _MANUFACTURER_R;
3510                                         plci->m_command = command;
3511                                         plci->number = Number;
3512
3513                                         if (!Info)
3514                                         {
3515                                                 add_p(plci, LLI, lli);
3516                                                 add_p(plci, CHI, chi);
3517                                                 add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
3518                                                 sig_req(plci, ASSIGN, DSIG_ID);
3519
3520                                                 if (!codec)
3521                                                 {
3522                                                         Info = add_b23(plci, &m_parms[3]);
3523                                                         if (!Info)
3524                                                         {
3525                                                                 nl_req_ncci(plci, ASSIGN, 0);
3526                                                                 send_req(plci);
3527                                                         }
3528                                                 }
3529                                                 if (!Info)
3530                                                 {
3531                                                         dbug(1, dprintf("dir=0x%x,spoof=0x%x", dir, plci->spoofed_msg));
3532                                                         if (plci->spoofed_msg == SPOOFING_REQUIRED)
3533                                                         {
3534                                                                 api_save_msg(m_parms, "wbbs", &plci->saved_msg);
3535                                                                 plci->spoofed_msg = AWAITING_MANUF_CON;
3536                                                                 plci->internal_command = BLOCK_PLCI; /* reject other req meanwhile */
3537                                                                 plci->command = 0;
3538                                                                 send_req(plci);
3539                                                                 return false;
3540                                                         }
3541                                                         if (dir == 1) {
3542                                                                 sig_req(plci, CALL_REQ, 0);
3543                                                         }
3544                                                         else if (!dir) {
3545                                                                 sig_req(plci, LISTEN_REQ, 0);
3546                                                         }
3547                                                         send_req(plci);
3548                                                 }
3549                                                 else
3550                                                 {
3551                                                         sendf(appl,
3552                                                               _MANUFACTURER_R | CONFIRM,
3553                                                               Id,
3554                                                               Number,
3555                                                               "dww", _DI_MANU_ID, command, Info);
3556                                                         return 2;
3557                                                 }
3558                                         }
3559                                 }
3560                         }
3561                         else  Info = _OUT_OF_PLCI;
3562                         break;
3563
3564                 case _DI_IDI_CTRL:
3565                         if (!plci)
3566                         {
3567                                 Info = _WRONG_IDENTIFIER;
3568                                 break;
3569                         }
3570                         if (api_parse(&m->info[1], (word)m->length, "bs", m_parms)) {
3571                                 Info = _WRONG_MESSAGE_FORMAT;
3572                                 break;
3573                         }
3574                         req = m_parms[0].info[0];
3575                         plci->command = _MANUFACTURER_R;
3576                         plci->m_command = command;
3577                         plci->number = Number;
3578                         if (req == CALL_REQ)
3579                         {
3580                                 plci->b_channel = getChannel(&m_parms[1]);
3581                                 mixer_set_bchannel_id_esc(plci, plci->b_channel);
3582                                 if (plci->spoofed_msg == SPOOFING_REQUIRED)
3583                                 {
3584                                         plci->spoofed_msg = CALL_REQ | AWAITING_MANUF_CON;
3585                                         plci->internal_command = BLOCK_PLCI; /* reject other req meanwhile */
3586                                         plci->command = 0;
3587                                         break;
3588                                 }
3589                         }
3590                         else if (req == LAW_REQ)
3591                         {
3592                                 plci->cr_enquiry = true;
3593                         }
3594                         add_ss(plci, FTY, &m_parms[1]);
3595                         sig_req(plci, req, 0);
3596                         send_req(plci);
3597                         if (req == HANGUP)
3598                         {
3599                                 if (plci->NL.Id && !plci->nl_remove_id)
3600                                 {
3601                                         if (plci->channels)
3602                                         {
3603                                                 for (ncci = 1; ncci < MAX_NCCI + 1; ncci++)
3604                                                 {
3605                                                         if ((a->ncci_plci[ncci] == plci->Id) && (a->ncci_state[ncci] == CONNECTED))
3606                                                         {
3607                                                                 a->ncci_state[ncci] = OUTG_DIS_PENDING;
3608                                                                 cleanup_ncci_data(plci, ncci);
3609                                                                 nl_req_ncci(plci, N_DISC, (byte)ncci);
3610                                                         }
3611                                                 }
3612                                         }
3613                                         mixer_remove(plci);
3614                                         nl_req_ncci(plci, REMOVE, 0);
3615                                         send_req(plci);
3616                                 }
3617                         }
3618                         break;
3619
3620                 case _DI_SIG_CTRL:
3621                         /* signalling control for loop activation B-channel */
3622                         if (!plci)
3623                         {
3624                                 Info = _WRONG_IDENTIFIER;
3625                                 break;
3626                         }
3627                         if (m->length) {
3628                                 plci->command = _MANUFACTURER_R;
3629                                 plci->number = Number;
3630                                 add_ss(plci, FTY, m);
3631                                 sig_req(plci, SIG_CTRL, 0);
3632                                 send_req(plci);
3633                         }
3634                         else Info = _WRONG_MESSAGE_FORMAT;
3635                         break;
3636
3637                 case _DI_RXT_CTRL:
3638                         /* activation control for receiver/transmitter B-channel */
3639                         if (!plci)
3640                         {
3641                                 Info = _WRONG_IDENTIFIER;
3642                                 break;
3643                         }
3644                         if (m->length) {
3645                                 plci->command = _MANUFACTURER_R;
3646                                 plci->number = Number;
3647                                 add_ss(plci, FTY, m);
3648                                 sig_req(plci, DSP_CTRL, 0);
3649                                 send_req(plci);
3650                         }
3651                         else Info = _WRONG_MESSAGE_FORMAT;
3652                         break;
3653
3654                 case _DI_ADV_CODEC:
3655                 case _DI_DSP_CTRL:
3656                         /* TEL_CTRL commands to support non standard adjustments: */
3657                         /* Ring on/off, Handset micro volume, external micro vol. */
3658                         /* handset+external speaker volume, receiver+transm. gain,*/
3659                         /* handsfree on (hookinfo off), set mixer command         */
3660
3661                         if (command == _DI_ADV_CODEC)
3662                         {
3663                                 if (!a->AdvCodecPLCI) {
3664                                         Info = _WRONG_STATE;
3665                                         break;
3666                                 }
3667                                 v_plci = a->AdvCodecPLCI;
3668                         }
3669                         else
3670                         {
3671                                 if (plci
3672                                     && (m->length >= 3)
3673                                     && (m->info[1] == 0x1c)
3674                                     && (m->info[2] >= 1))
3675                                 {
3676                                         if (m->info[3] == DSP_CTRL_OLD_SET_MIXER_COEFFICIENTS)
3677                                         {
3678                                                 if ((plci->tel != ADV_VOICE) || (plci != a->AdvSignalPLCI))
3679                                                 {
3680                                                         Info = _WRONG_STATE;
3681                                                         break;
3682                                                 }
3683                                                 a->adv_voice_coef_length = m->info[2] - 1;
3684                                                 if (a->adv_voice_coef_length > m->length - 3)
3685                                                         a->adv_voice_coef_length = (byte)(m->length - 3);
3686                                                 if (a->adv_voice_coef_length > ADV_VOICE_COEF_BUFFER_SIZE)
3687                                                         a->adv_voice_coef_length = ADV_VOICE_COEF_BUFFER_SIZE;
3688                                                 for (i = 0; i < a->adv_voice_coef_length; i++)
3689                                                         a->adv_voice_coef_buffer[i] = m->info[4 + i];
3690                                                 if (plci->B1_facilities & B1_FACILITY_VOICE)
3691                                                         adv_voice_write_coefs(plci, ADV_VOICE_WRITE_UPDATE);
3692                                                 break;
3693                                         }
3694                                         else if (m->info[3] == DSP_CTRL_SET_DTMF_PARAMETERS)
3695                                         {
3696                                                 if (!(a->manufacturer_features & MANUFACTURER_FEATURE_DTMF_PARAMETERS))
3697                                                 {
3698                                                         Info = _FACILITY_NOT_SUPPORTED;
3699                                                         break;
3700                                                 }
3701
3702                                                 plci->dtmf_parameter_length = m->info[2] - 1;
3703                                                 if (plci->dtmf_parameter_length > m->length - 3)
3704                                                         plci->dtmf_parameter_length = (byte)(m->length - 3);
3705                                                 if (plci->dtmf_parameter_length > DTMF_PARAMETER_BUFFER_SIZE)
3706                                                         plci->dtmf_parameter_length = DTMF_PARAMETER_BUFFER_SIZE;
3707                                                 for (i = 0; i < plci->dtmf_parameter_length; i++)
3708                                                         plci->dtmf_parameter_buffer[i] = m->info[4 + i];
3709                                                 if (plci->B1_facilities & B1_FACILITY_DTMFR)
3710                                                         dtmf_parameter_write(plci);
3711                                                 break;
3712
3713                                         }
3714                                 }
3715                                 v_plci = plci;
3716                         }
3717
3718                         if (!v_plci)
3719                         {
3720                                 Info = _WRONG_IDENTIFIER;
3721                                 break;
3722                         }
3723                         if (m->length) {
3724                                 add_ss(v_plci, FTY, m);
3725                                 sig_req(v_plci, TEL_CTRL, 0);
3726                                 send_req(v_plci);
3727                         }
3728                         else Info = _WRONG_MESSAGE_FORMAT;
3729
3730                         break;
3731
3732                 case _DI_OPTIONS_REQUEST:
3733                         if (api_parse(&m->info[1], (word)m->length, "d", m_parms)) {
3734                                 Info = _WRONG_MESSAGE_FORMAT;
3735                                 break;
3736                         }
3737                         if (GET_DWORD(m_parms[0].info) & ~a->man_profile.private_options)
3738                         {
3739                                 Info = _FACILITY_NOT_SUPPORTED;
3740                                 break;
3741                         }
3742                         a->requested_options_table[appl->Id - 1] = GET_DWORD(m_parms[0].info);
3743                         break;
3744
3745
3746
3747                 default:
3748                         Info = _WRONG_MESSAGE_FORMAT;
3749                         break;
3750                 }
3751         }
3752
3753         sendf(appl,
3754               _MANUFACTURER_R | CONFIRM,
3755               Id,
3756               Number,
3757               "dww", _DI_MANU_ID, command, Info);
3758         return false;
3759 }
3760
3761
3762 static byte manufacturer_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3763                              PLCI *plci, APPL *appl, API_PARSE *msg)
3764 {
3765         word indication;
3766
3767         API_PARSE m_parms[3];
3768         API_PARSE *ncpi;
3769         API_PARSE fax_parms[9];
3770         word i;
3771         byte len;
3772
3773
3774         dbug(1, dprintf("manufacturer_res"));
3775
3776         if ((msg[0].length == 0)
3777             || (msg[1].length == 0)
3778             || (GET_DWORD(msg[0].info) != _DI_MANU_ID))
3779         {
3780                 return false;
3781         }
3782         indication = GET_WORD(msg[1].info);
3783         switch (indication)
3784         {
3785
3786         case _DI_NEGOTIATE_B3:
3787                 if (!plci)
3788                         break;
3789                 if (((plci->B3_prot != 4) && (plci->B3_prot != 5))
3790                     || !(plci->ncpi_state & NCPI_NEGOTIATE_B3_SENT))
3791                 {
3792                         dbug(1, dprintf("wrong state for NEGOTIATE_B3 parameters"));
3793                         break;
3794                 }
3795                 if (api_parse(&msg[2].info[1], msg[2].length, "ws", m_parms))
3796                 {
3797                         dbug(1, dprintf("wrong format in NEGOTIATE_B3 parameters"));
3798                         break;
3799                 }
3800                 ncpi = &m_parms[1];
3801                 len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
3802                 if (plci->fax_connect_info_length < len)
3803                 {
3804                         ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id_len = 0;
3805                         ((T30_INFO *)(plci->fax_connect_info_buffer))->head_line_len = 0;
3806                 }
3807                 if (api_parse(&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms))
3808                 {
3809                         dbug(1, dprintf("non-standard facilities info missing or wrong format"));
3810                 }
3811                 else
3812                 {
3813                         if (plci->fax_connect_info_length <= len)
3814                                 plci->fax_connect_info_buffer[len] = 0;
3815                         len += 1 + plci->fax_connect_info_buffer[len];
3816                         if (plci->fax_connect_info_length <= len)
3817                                 plci->fax_connect_info_buffer[len] = 0;
3818                         len += 1 + plci->fax_connect_info_buffer[len];
3819                         if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2))
3820                                 plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]);
3821                         plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length);
3822                         for (i = 0; i < fax_parms[7].length; i++)
3823                                 plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1 + i];
3824                 }
3825                 plci->fax_connect_info_length = len;
3826                 plci->fax_edata_ack_length = plci->fax_connect_info_length;
3827                 start_internal_command(Id, plci, fax_edata_ack_command);
3828                 break;
3829
3830         }
3831         return false;
3832 }
3833
3834 /*------------------------------------------------------------------*/
3835 /* IDI callback function                                            */
3836 /*------------------------------------------------------------------*/
3837
3838 void callback(ENTITY *e)
3839 {
3840         DIVA_CAPI_ADAPTER *a;
3841         APPL *appl;
3842         PLCI *plci;
3843         CAPI_MSG *m;
3844         word i, j;
3845         byte rc;
3846         byte ch;
3847         byte req;
3848         byte global_req;
3849         int no_cancel_rc;
3850
3851         dbug(1, dprintf("%x:CB(%x:Req=%x,Rc=%x,Ind=%x)",
3852                         (e->user[0] + 1) & 0x7fff, e->Id, e->Req, e->Rc, e->Ind));
3853
3854         a = &(adapter[(byte)e->user[0]]);
3855         plci = &(a->plci[e->user[1]]);
3856         no_cancel_rc = DIVA_CAPI_SUPPORTS_NO_CANCEL(a);
3857
3858         /*
3859           If new protocol code and new XDI is used then CAPI should work
3860           fully in accordance with IDI cpec an look on callback field instead
3861           of Rc field for return codes.
3862         */
3863         if (((e->complete == 0xff) && no_cancel_rc) ||
3864             (e->Rc && !no_cancel_rc)) {
3865                 rc = e->Rc;
3866                 ch = e->RcCh;
3867                 req = e->Req;
3868                 e->Rc = 0;
3869
3870                 if (e->user[0] & 0x8000)
3871                 {
3872                         /*
3873                           If REMOVE request was sent then we have to wait until
3874                           return code with Id set to zero arrives.
3875                           All other return codes should be ignored.
3876                         */
3877                         if (req == REMOVE)
3878                         {
3879                                 if (e->Id)
3880                                 {
3881                                         dbug(1, dprintf("cancel RC in REMOVE state"));
3882                                         return;
3883                                 }
3884                                 channel_flow_control_remove(plci);
3885                                 for (i = 0; i < 256; i++)
3886                                 {
3887                                         if (a->FlowControlIdTable[i] == plci->nl_remove_id)
3888                                                 a->FlowControlIdTable[i] = 0;
3889                                 }
3890                                 plci->nl_remove_id = 0;
3891                                 if (plci->rx_dma_descriptor > 0) {
3892                                         diva_free_dma_descriptor(plci, plci->rx_dma_descriptor - 1);
3893                                         plci->rx_dma_descriptor = 0;
3894                                 }
3895                         }
3896                         if (rc == OK_FC)
3897                         {
3898                                 a->FlowControlIdTable[ch] = e->Id;
3899                                 a->FlowControlSkipTable[ch] = 0;
3900
3901                                 a->ch_flow_control[ch] |= N_OK_FC_PENDING;
3902                                 a->ch_flow_plci[ch] = plci->Id;
3903                                 plci->nl_req = 0;
3904                         }
3905                         else
3906                         {
3907                                 /*
3908                                   Cancel return codes self, if feature was requested
3909                                 */
3910                                 if (no_cancel_rc && (a->FlowControlIdTable[ch] == e->Id) && e->Id) {
3911                                         a->FlowControlIdTable[ch] = 0;
3912                                         if ((rc == OK) && a->FlowControlSkipTable[ch]) {
3913                                                 dbug(3, dprintf("XDI CAPI: RC cancelled Id:0x02, Ch:%02x", e->Id, ch));
3914                                                 return;
3915                                         }
3916                                 }
3917
3918                                 if (a->ch_flow_control[ch] & N_OK_FC_PENDING)
3919                                 {
3920                                         a->ch_flow_control[ch] &= ~N_OK_FC_PENDING;
3921                                         if (ch == e->ReqCh)
3922                                                 plci->nl_req = 0;
3923                                 }
3924                                 else
3925                                         plci->nl_req = 0;
3926                         }
3927                         if (plci->nl_req)
3928                                 control_rc(plci, 0, rc, ch, 0, true);
3929                         else
3930                         {
3931                                 if (req == N_XON)
3932                                 {
3933                                         channel_x_on(plci, ch);
3934                                         if (plci->internal_command)
3935                                                 control_rc(plci, req, rc, ch, 0, true);
3936                                 }
3937                                 else
3938                                 {
3939                                         if (plci->nl_global_req)
3940                                         {
3941                                                 global_req = plci->nl_global_req;
3942                                                 plci->nl_global_req = 0;
3943                                                 if (rc != ASSIGN_OK) {
3944                                                         e->Id = 0;
3945                                                         if (plci->rx_dma_descriptor > 0) {
3946                                                                 diva_free_dma_descriptor(plci, plci->rx_dma_descriptor - 1);
3947                                                                 plci->rx_dma_descriptor = 0;
3948                                                         }
3949                                                 }
3950                                                 channel_xmit_xon(plci);
3951                                                 control_rc(plci, 0, rc, ch, global_req, true);
3952                                         }
3953                                         else if (plci->data_sent)
3954                                         {
3955                                                 channel_xmit_xon(plci);
3956                                                 plci->data_sent = false;
3957                                                 plci->NL.XNum = 1;
3958                                                 data_rc(plci, ch);
3959                                                 if (plci->internal_command)
3960                                                         control_rc(plci, req, rc, ch, 0, true);
3961                                         }
3962                                         else
3963                                         {
3964                                                 channel_xmit_xon(plci);
3965                                                 control_rc(plci, req, rc, ch, 0, true);
3966                                         }
3967                                 }
3968                         }
3969                 }
3970                 else
3971                 {
3972                         /*
3973                           If REMOVE request was sent then we have to wait until
3974                           return code with Id set to zero arrives.
3975                           All other return codes should be ignored.
3976                         */
3977                         if (req == REMOVE)
3978                         {
3979                                 if (e->Id)
3980                                 {
3981                                         dbug(1, dprintf("cancel RC in REMOVE state"));
3982                                         return;
3983                                 }
3984                                 plci->sig_remove_id = 0;
3985                         }
3986                         plci->sig_req = 0;
3987                         if (plci->sig_global_req)
3988                         {
3989                                 global_req = plci->sig_global_req;
3990                                 plci->sig_global_req = 0;
3991                                 if (rc != ASSIGN_OK)
3992                                         e->Id = 0;
3993                                 channel_xmit_xon(plci);
3994                                 control_rc(plci, 0, rc, ch, global_req, false);
3995                         }
3996                         else
3997                         {
3998                                 channel_xmit_xon(plci);
3999                                 control_rc(plci, req, rc, ch, 0, false);
4000                         }
4001                 }
4002                 /*
4003                   Again: in accordance with IDI spec Rc and Ind can't be delivered in the
4004                   same callback. Also if new XDI and protocol code used then jump
4005                   direct to finish.
4006                 */
4007                 if (no_cancel_rc) {
4008                         channel_xmit_xon(plci);
4009                         goto capi_callback_suffix;
4010                 }
4011         }
4012
4013         channel_xmit_xon(plci);
4014
4015         if (e->Ind) {
4016                 if (e->user[0] & 0x8000) {
4017                         byte Ind = e->Ind & 0x0f;
4018                         byte Ch = e->IndCh;
4019                         if (((Ind == N_DISC) || (Ind == N_DISC_ACK)) &&
4020                             (a->ch_flow_plci[Ch] == plci->Id)) {
4021                                 if (a->ch_flow_control[Ch] & N_RX_FLOW_CONTROL_MASK) {
4022                                         dbug(3, dprintf("XDI CAPI: I: pending N-XON Ch:%02x", Ch));
4023                                 }
4024                                 a->ch_flow_control[Ch] &= ~N_RX_FLOW_CONTROL_MASK;
4025                         }
4026                         nl_ind(plci);
4027                         if ((e->RNR != 1) &&
4028                             (a->ch_flow_plci[Ch] == plci->Id) &&
4029                             (a->ch_flow_control[Ch] & N_RX_FLOW_CONTROL_MASK)) {
4030                                 a->ch_flow_control[Ch] &= ~N_RX_FLOW_CONTROL_MASK;
4031                                 dbug(3, dprintf("XDI CAPI: I: remove faked N-XON Ch:%02x", Ch));
4032                         }
4033                 } else {
4034                         sig_ind(plci);
4035                 }
4036                 e->Ind = 0;
4037         }
4038
4039 capi_callback_suffix:
4040
4041         while (!plci->req_in
4042                && !plci->internal_command
4043                && (plci->msg_in_write_pos != plci->msg_in_read_pos))
4044         {
4045                 j = (plci->msg_in_read_pos == plci->msg_in_wrap_pos) ? 0 : plci->msg_in_read_pos;
4046
4047                 i = (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[j]))->header.length + 3) & 0xfffc;
4048
4049                 m = (CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[j]);
4050                 appl = *((APPL **)(&((byte *)(plci->msg_in_queue))[j + i]));
4051                 dbug(1, dprintf("dequeue msg(0x%04x) - write=%d read=%d wrap=%d",
4052                                 m->header.command, plci->msg_in_write_pos, plci->msg_in_read_pos, plci->msg_in_wrap_pos));
4053                 if (plci->msg_in_read_pos == plci->msg_in_wrap_pos)
4054                 {
4055                         plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
4056                         plci->msg_in_read_pos = i + MSG_IN_OVERHEAD;
4057                 }
4058                 else
4059                 {
4060                         plci->msg_in_read_pos = j + i + MSG_IN_OVERHEAD;
4061                 }
4062                 if (plci->msg_in_read_pos == plci->msg_in_write_pos)
4063                 {
4064                         plci->msg_in_write_pos = MSG_IN_QUEUE_SIZE;
4065                         plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
4066                 }
4067                 else if (plci->msg_in_read_pos == plci->msg_in_wrap_pos)
4068                 {
4069                         plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
4070                         plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
4071                 }
4072                 i = api_put(appl, m);
4073                 if (i != 0)
4074                 {
4075                         if (m->header.command == _DATA_B3_R)
4076
4077                                 TransmitBufferFree(appl, (byte *)(long)(m->info.data_b3_req.Data));
4078
4079                         dbug(1, dprintf("Error 0x%04x from msg(0x%04x)", i, m->header.command));
4080                         break;
4081                 }
4082
4083                 if (plci->li_notify_update)
4084                 {
4085                         plci->li_notify_update = false;
4086                         mixer_notify_update(plci, false);
4087                 }
4088
4089         }
4090         send_data(plci);
4091         send_req(plci);
4092 }
4093
4094
4095 static void control_rc(PLCI *plci, byte req, byte rc, byte ch, byte global_req,
4096                        byte nl_rc)
4097 {
4098         dword Id;
4099         dword rId;
4100         word Number;
4101         word Info = 0;
4102         word i;
4103         word ncci;
4104         DIVA_CAPI_ADAPTER *a;
4105         APPL *appl;
4106         PLCI *rplci;
4107         byte SSparms[] = "\x05\x00\x00\x02\x00\x00";
4108         byte SSstruct[] = "\x09\x00\x00\x06\x00\x00\x00\x00\x00\x00";
4109
4110         if (!plci) {
4111                 dbug(0, dprintf("A: control_rc, no plci %02x:%02x:%02x:%02x:%02x", req, rc, ch, global_req, nl_rc));
4112                 return;
4113         }
4114         dbug(1, dprintf("req0_in/out=%d/%d", plci->req_in, plci->req_out));
4115         if (plci->req_in != plci->req_out)
4116         {
4117                 if (nl_rc || (global_req != ASSIGN) || (rc == ASSIGN_OK))
4118                 {
4119                         dbug(1, dprintf("req_1return"));
4120                         return;
4121                 }
4122                 /* cancel outstanding request on the PLCI after SIG ASSIGN failure */
4123         }
4124         plci->req_in = plci->req_in_start = plci->req_out = 0;
4125         dbug(1, dprintf("control_rc"));
4126
4127         appl = plci->appl;
4128         a = plci->adapter;
4129         ncci = a->ch_ncci[ch];
4130         if (appl)
4131         {
4132                 Id = (((dword)(ncci ? ncci : ch)) << 16) | ((word)plci->Id << 8) | a->Id;
4133                 if (plci->tel && plci->SuppState != CALL_HELD) Id |= EXT_CONTROLLER;
4134                 Number = plci->number;
4135                 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));
4136                 dbug(1, dprintf("channels=0x%x", plci->channels));
4137                 if (plci_remove_check(plci))
4138                         return;
4139                 if (req == REMOVE && rc == ASSIGN_OK)
4140                 {
4141                         sig_req(plci, HANGUP, 0);
4142                         sig_req(plci, REMOVE, 0);
4143                         send_req(plci);
4144                 }
4145                 if (plci->command)
4146                 {
4147                         switch (plci->command)
4148                         {
4149                         case C_HOLD_REQ:
4150                                 dbug(1, dprintf("HoldRC=0x%x", rc));
4151                                 SSparms[1] = (byte)S_HOLD;
4152                                 if (rc != OK)
4153                                 {
4154                                         plci->SuppState = IDLE;
4155                                         Info = 0x2001;
4156                                 }
4157                                 sendf(appl, _FACILITY_R | CONFIRM, Id, Number, "wws", Info, 3, SSparms);
4158                                 break;
4159
4160                         case C_RETRIEVE_REQ:
4161                                 dbug(1, dprintf("RetrieveRC=0x%x", rc));
4162                                 SSparms[1] = (byte)S_RETRIEVE;
4163                                 if (rc != OK)
4164                                 {
4165                                         plci->SuppState = CALL_HELD;
4166                                         Info = 0x2001;
4167                                 }
4168                                 sendf(appl, _FACILITY_R | CONFIRM, Id, Number, "wws", Info, 3, SSparms);
4169                                 break;
4170
4171                         case _INFO_R:
4172                                 dbug(1, dprintf("InfoRC=0x%x", rc));
4173                                 if (rc != OK) Info = _WRONG_STATE;
4174                                 sendf(appl, _INFO_R | CONFIRM, Id, Number, "w", Info);
4175                                 break;
4176
4177                         case _CONNECT_R:
4178                                 dbug(1, dprintf("Connect_R=0x%x/0x%x/0x%x/0x%x", req, rc, global_req, nl_rc));
4179                                 if (plci->State == INC_DIS_PENDING)
4180                                         break;
4181                                 if (plci->Sig.Id != 0xff)
4182                                 {
4183                                         if (((global_req == ASSIGN) && (rc != ASSIGN_OK))
4184                                             || (!nl_rc && (req == CALL_REQ) && (rc != OK)))
4185                                         {
4186                                                 dbug(1, dprintf("No more IDs/Call_Req failed"));
4187                                                 sendf(appl, _CONNECT_R | CONFIRM, Id & 0xffL, Number, "w", _OUT_OF_PLCI);
4188                                                 plci_remove(plci);
4189                                                 plci->State = IDLE;
4190                                                 break;
4191                                         }
4192                                         if (plci->State != LOCAL_CONNECT) plci->State = OUTG_CON_PENDING;
4193                                         sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", 0);
4194                                 }
4195                                 else /* D-ch activation */
4196                                 {
4197                                         if (rc != ASSIGN_OK)
4198                                         {
4199                                                 dbug(1, dprintf("No more IDs/X.25 Call_Req failed"));
4200                                                 sendf(appl, _CONNECT_R | CONFIRM, Id & 0xffL, Number, "w", _OUT_OF_PLCI);
4201                                                 plci_remove(plci);
4202                                                 plci->State = IDLE;
4203                                                 break;
4204                                         }
4205                                         sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", 0);
4206                                         sendf(plci->appl, _CONNECT_ACTIVE_I, Id, 0, "sss", "", "", "");
4207                                         plci->State = INC_ACT_PENDING;
4208                                 }
4209                                 break;
4210
4211                         case _CONNECT_I | RESPONSE:
4212                                 if (plci->State != INC_DIS_PENDING)
4213                                         plci->State = INC_CON_ACCEPT;
4214                                 break;
4215
4216                         case _DISCONNECT_R:
4217                                 if (plci->State == INC_DIS_PENDING)
4218                                         break;
4219                                 if (plci->Sig.Id != 0xff)
4220                                 {
4221                                         plci->State = OUTG_DIS_PENDING;
4222                                         sendf(appl, _DISCONNECT_R | CONFIRM, Id, Number, "w", 0);
4223                                 }
4224                                 break;
4225
4226                         case SUSPEND_REQ:
4227                                 break;
4228
4229                         case RESUME_REQ:
4230                                 break;
4231
4232                         case _CONNECT_B3_R:
4233                                 if (rc != OK)
4234                                 {
4235                                         sendf(appl, _CONNECT_B3_R | CONFIRM, Id, Number, "w", _WRONG_IDENTIFIER);
4236                                         break;
4237                                 }
4238                                 ncci = get_ncci(plci, ch, 0);
4239                                 Id = (Id & 0xffff) | (((dword) ncci) << 16);
4240                                 plci->channels++;
4241                                 if (req == N_RESET)
4242                                 {
4243                                         a->ncci_state[ncci] = INC_ACT_PENDING;
4244                                         sendf(appl, _CONNECT_B3_R | CONFIRM, Id, Number, "w", 0);
4245                                         sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
4246                                 }
4247                                 else
4248                                 {
4249                                         a->ncci_state[ncci] = OUTG_CON_PENDING;
4250                                         sendf(appl, _CONNECT_B3_R | CONFIRM, Id, Number, "w", 0);
4251                                 }
4252                                 break;
4253
4254                         case _CONNECT_B3_I | RESPONSE:
4255                                 break;
4256
4257                         case _RESET_B3_R:
4258 /*        sendf(appl, _RESET_B3_R | CONFIRM, Id, Number, "w", 0);*/
4259                                 break;
4260
4261                         case _DISCONNECT_B3_R:
4262                                 sendf(appl, _DISCONNECT_B3_R | CONFIRM, Id, Number, "w", 0);
4263                                 break;
4264
4265                         case _MANUFACTURER_R:
4266                                 break;
4267
4268                         case PERM_LIST_REQ:
4269                                 if (rc != OK)
4270                                 {
4271                                         Info = _WRONG_IDENTIFIER;
4272                                         sendf(plci->appl, _CONNECT_R | CONFIRM, Id, Number, "w", Info);
4273                                         plci_remove(plci);
4274                                 }
4275                                 else
4276                                         sendf(plci->appl, _CONNECT_R | CONFIRM, Id, Number, "w", Info);
4277                                 break;
4278
4279                         default:
4280                                 break;
4281                         }
4282                         plci->command = 0;
4283                 }
4284                 else if (plci->internal_command)
4285                 {
4286                         switch (plci->internal_command)
4287                         {
4288                         case BLOCK_PLCI:
4289                                 return;
4290
4291                         case GET_MWI_STATE:
4292                                 if (rc == OK) /* command supported, wait for indication */
4293                                 {
4294                                         return;
4295                                 }
4296                                 plci_remove(plci);
4297                                 break;
4298
4299                                 /* Get Supported Services */
4300                         case GETSERV_REQ_PEND:
4301                                 if (rc == OK) /* command supported, wait for indication */
4302                                 {
4303                                         break;
4304                                 }
4305                                 PUT_DWORD(&SSstruct[6], MASK_TERMINAL_PORTABILITY);
4306                                 sendf(appl, _FACILITY_R | CONFIRM, Id, Number, "wws", 0, 3, SSstruct);
4307                                 plci_remove(plci);
4308                                 break;
4309
4310                         case INTERR_DIVERSION_REQ_PEND:      /* Interrogate Parameters        */
4311                         case INTERR_NUMBERS_REQ_PEND:
4312                         case CF_START_PEND:                  /* Call Forwarding Start pending */
4313                         case CF_STOP_PEND:                   /* Call Forwarding Stop pending  */
4314                         case CCBS_REQUEST_REQ_PEND:
4315                         case CCBS_DEACTIVATE_REQ_PEND:
4316                         case CCBS_INTERROGATE_REQ_PEND:
4317                                 switch (plci->internal_command)
4318                                 {
4319                                 case INTERR_DIVERSION_REQ_PEND:
4320                                         SSparms[1] = S_INTERROGATE_DIVERSION;
4321                                         break;
4322                                 case INTERR_NUMBERS_REQ_PEND:
4323                                         SSparms[1] = S_INTERROGATE_NUMBERS;
4324                                         break;
4325                                 case CF_START_PEND:
4326                                         SSparms[1] = S_CALL_FORWARDING_START;
4327                                         break;
4328                                 case CF_STOP_PEND:
4329                                         SSparms[1] = S_CALL_FORWARDING_STOP;
4330                                         break;
4331                                 case CCBS_REQUEST_REQ_PEND:
4332                                         SSparms[1] = S_CCBS_REQUEST;
4333                                         break;
4334                                 case CCBS_DEACTIVATE_REQ_PEND:
4335                                         SSparms[1] = S_CCBS_DEACTIVATE;
4336                                         break;
4337                                 case CCBS_INTERROGATE_REQ_PEND:
4338                                         SSparms[1] = S_CCBS_INTERROGATE;
4339                                         break;
4340                                 }
4341                                 if (global_req == ASSIGN)
4342                                 {
4343                                         dbug(1, dprintf("AssignDiversion_RC=0x%x/0x%x", req, rc));
4344                                         return;
4345                                 }
4346                                 if (!plci->appl) break;
4347                                 if (rc == ISDN_GUARD_REJ)
4348                                 {
4349                                         Info = _CAPI_GUARD_ERROR;
4350                                 }
4351                                 else if (rc != OK)
4352                                 {
4353                                         Info = _SUPPLEMENTARY_SERVICE_NOT_SUPPORTED;
4354                                 }
4355                                 sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0x7,
4356                                       plci->number, "wws", Info, (word)3, SSparms);
4357                                 if (Info) plci_remove(plci);
4358                                 break;
4359
4360                                 /* 3pty conference pending */
4361                         case PTY_REQ_PEND:
4362                                 if (!plci->relatedPTYPLCI) break;
4363                                 rplci = plci->relatedPTYPLCI;
4364                                 SSparms[1] = plci->ptyState;
4365                                 rId = ((word)rplci->Id << 8) | rplci->adapter->Id;
4366                                 if (rplci->tel) rId |= EXT_CONTROLLER;
4367                                 if (rc != OK)
4368                                 {
4369                                         Info = 0x300E; /* not supported */
4370                                         plci->relatedPTYPLCI = NULL;
4371                                         plci->ptyState = 0;
4372                                 }
4373                                 sendf(rplci->appl,
4374                                       _FACILITY_R | CONFIRM,
4375                                       rId,
4376                                       plci->number,
4377                                       "wws", Info, (word)3, SSparms);
4378                                 break;
4379
4380                                 /* Explicit Call Transfer pending */
4381                         case ECT_REQ_PEND:
4382                                 dbug(1, dprintf("ECT_RC=0x%x/0x%x", req, rc));
4383                                 if (!plci->relatedPTYPLCI) break;
4384                                 rplci = plci->relatedPTYPLCI;
4385                                 SSparms[1] = S_ECT;
4386                                 rId = ((word)rplci->Id << 8) | rplci->adapter->Id;
4387                                 if (rplci->tel) rId |= EXT_CONTROLLER;
4388                                 if (rc != OK)
4389                                 {
4390                                         Info = 0x300E; /* not supported */
4391                                         plci->relatedPTYPLCI = NULL;
4392                                         plci->ptyState = 0;
4393                                 }
4394                                 sendf(rplci->appl,
4395                                       _FACILITY_R | CONFIRM,
4396                                       rId,
4397                                       plci->number,
4398                                       "wws", Info, (word)3, SSparms);
4399                                 break;
4400
4401                         case _MANUFACTURER_R:
4402                                 dbug(1, dprintf("_Manufacturer_R=0x%x/0x%x", req, rc));
4403                                 if ((global_req == ASSIGN) && (rc != ASSIGN_OK))
4404                                 {
4405                                         dbug(1, dprintf("No more IDs"));
4406                                         sendf(appl, _MANUFACTURER_R | CONFIRM, Id, Number, "dww", _DI_MANU_ID, _MANUFACTURER_R, _OUT_OF_PLCI);
4407                                         plci_remove(plci);  /* after codec init, internal codec commands pending */
4408                                 }
4409                                 break;
4410
4411                         case _CONNECT_R:
4412                                 dbug(1, dprintf("_Connect_R=0x%x/0x%x", req, rc));
4413                                 if ((global_req == ASSIGN) && (rc != ASSIGN_OK))
4414                                 {
4415                                         dbug(1, dprintf("No more IDs"));
4416                                         sendf(appl, _CONNECT_R | CONFIRM, Id & 0xffL, Number, "w", _OUT_OF_PLCI);
4417                                         plci_remove(plci);  /* after codec init, internal codec commands pending */
4418                                 }
4419                                 break;
4420
4421                         case PERM_COD_HOOK:                     /* finished with Hook_Ind */
4422                                 return;
4423
4424                         case PERM_COD_CALL:
4425                                 dbug(1, dprintf("***Codec Connect_Pending A, Rc = 0x%x", rc));
4426                                 plci->internal_command = PERM_COD_CONN_PEND;
4427                                 return;
4428
4429                         case PERM_COD_ASSIGN:
4430                                 dbug(1, dprintf("***Codec Assign A, Rc = 0x%x", rc));
4431                                 if (rc != ASSIGN_OK) break;
4432                                 sig_req(plci, CALL_REQ, 0);
4433                                 send_req(plci);
4434                                 plci->internal_command = PERM_COD_CALL;
4435                                 return;
4436
4437                                 /* Null Call Reference Request pending */
4438                         case C_NCR_FAC_REQ:
4439                                 dbug(1, dprintf("NCR_FAC=0x%x/0x%x", req, rc));
4440                                 if (global_req == ASSIGN)
4441                                 {
4442                                         if (rc == ASSIGN_OK)
4443                                         {
4444                                                 return;
4445                                         }
4446                                         else
4447                                         {
4448                                                 sendf(appl, _INFO_R | CONFIRM, Id & 0xf, Number, "w", _WRONG_STATE);
4449                                                 appl->NullCREnable = false;
4450                                                 plci_remove(plci);
4451                                         }
4452                                 }
4453                                 else if (req == NCR_FACILITY)
4454                                 {
4455                                         if (rc == OK)
4456                                         {
4457                                                 sendf(appl, _INFO_R | CONFIRM, Id & 0xf, Number, "w", 0);
4458                                         }
4459                                         else
4460                                         {
4461                                                 sendf(appl, _INFO_R | CONFIRM, Id & 0xf, Number, "w", _WRONG_STATE);
4462                                                 appl->NullCREnable = false;
4463                                         }
4464                                         plci_remove(plci);
4465                                 }
4466                                 break;
4467
4468                         case HOOK_ON_REQ:
4469                                 if (plci->channels)
4470                                 {
4471                                         if (a->ncci_state[ncci] == CONNECTED)
4472                                         {
4473                                                 a->ncci_state[ncci] = OUTG_DIS_PENDING;
4474                                                 cleanup_ncci_data(plci, ncci);
4475                                                 nl_req_ncci(plci, N_DISC, (byte)ncci);
4476                                         }
4477                                         break;
4478                                 }
4479                                 break;
4480
4481                         case HOOK_OFF_REQ:
4482                                 if (plci->State == INC_DIS_PENDING)
4483                                         break;
4484                                 sig_req(plci, CALL_REQ, 0);
4485                                 send_req(plci);
4486                                 plci->State = OUTG_CON_PENDING;
4487                                 break;
4488
4489
4490                         case MWI_ACTIVATE_REQ_PEND:
4491                         case MWI_DEACTIVATE_REQ_PEND:
4492                                 if (global_req == ASSIGN && rc == ASSIGN_OK)
4493                                 {
4494                                         dbug(1, dprintf("MWI_REQ assigned"));
4495                                         return;
4496                                 }
4497                                 else if (rc != OK)
4498                                 {
4499                                         if (rc == WRONG_IE)
4500                                         {
4501                                                 Info = 0x2007; /* Illegal message parameter coding */
4502                                                 dbug(1, dprintf("MWI_REQ invalid parameter"));
4503                                         }
4504                                         else
4505                                         {
4506                                                 Info = 0x300B; /* not supported */
4507                                                 dbug(1, dprintf("MWI_REQ not supported"));
4508                                         }
4509                                         /* 0x3010: Request not allowed in this state */
4510                                         PUT_WORD(&SSparms[4], 0x300E); /* SS not supported */
4511
4512                                 }
4513                                 if (plci->internal_command == MWI_ACTIVATE_REQ_PEND)
4514                                 {
4515                                         PUT_WORD(&SSparms[1], S_MWI_ACTIVATE);
4516                                 }
4517                                 else PUT_WORD(&SSparms[1], S_MWI_DEACTIVATE);
4518
4519                                 if (plci->cr_enquiry)
4520                                 {
4521                                         sendf(plci->appl,
4522                                               _FACILITY_R | CONFIRM,
4523                                               Id & 0xf,
4524                                               plci->number,
4525                                               "wws", Info, (word)3, SSparms);
4526                                         if (rc != OK) plci_remove(plci);
4527                                 }
4528                                 else
4529                                 {
4530                                         sendf(plci->appl,
4531                                               _FACILITY_R | CONFIRM,
4532                                               Id,
4533                                               plci->number,
4534                                               "wws", Info, (word)3, SSparms);
4535                                 }
4536                                 break;
4537
4538                         case CONF_BEGIN_REQ_PEND:
4539                         case CONF_ADD_REQ_PEND:
4540                         case CONF_SPLIT_REQ_PEND:
4541                         case CONF_DROP_REQ_PEND:
4542                         case CONF_ISOLATE_REQ_PEND:
4543                         case CONF_REATTACH_REQ_PEND:
4544                                 dbug(1, dprintf("CONF_RC=0x%x/0x%x", req, rc));
4545                                 if ((plci->internal_command == CONF_ADD_REQ_PEND) && (!plci->relatedPTYPLCI)) break;
4546                                 rplci = plci;
4547                                 rId = Id;
4548                                 switch (plci->internal_command)
4549                                 {
4550                                 case CONF_BEGIN_REQ_PEND:
4551                                         SSparms[1] = S_CONF_BEGIN;
4552                                         break;
4553                                 case CONF_ADD_REQ_PEND:
4554                                         SSparms[1] = S_CONF_ADD;
4555                                         rplci = plci->relatedPTYPLCI;
4556                                         rId = ((word)rplci->Id << 8) | rplci->adapter->Id;
4557                                         break;
4558                                 case CONF_SPLIT_REQ_PEND:
4559                                         SSparms[1] = S_CONF_SPLIT;
4560                                         break;
4561                                 case CONF_DROP_REQ_PEND:
4562                                         SSparms[1] = S_CONF_DROP;
4563                                         break;
4564                                 case CONF_ISOLATE_REQ_PEND:
4565                                         SSparms[1] = S_CONF_ISOLATE;
4566                                         break;
4567                                 case CONF_REATTACH_REQ_PEND:
4568                                         SSparms[1] = S_CONF_REATTACH;
4569                                         break;
4570                                 }
4571
4572                                 if (rc != OK)
4573                                 {
4574                                         Info = 0x300E; /* not supported */
4575                                         plci->relatedPTYPLCI = NULL;
4576                                         plci->ptyState = 0;
4577                                 }
4578                                 sendf(rplci->appl,
4579                                       _FACILITY_R | CONFIRM,
4580                                       rId,
4581                                       plci->number,
4582                                       "wws", Info, (word)3, SSparms);
4583                                 break;
4584
4585                         case VSWITCH_REQ_PEND:
4586                                 if (rc != OK)
4587                                 {
4588                                         if (plci->relatedPTYPLCI)
4589                                         {
4590                                                 plci->relatedPTYPLCI->vswitchstate = 0;
4591                                                 plci->relatedPTYPLCI->vsprot = 0;
4592                                                 plci->relatedPTYPLCI->vsprotdialect = 0;
4593                                         }
4594                                         plci->vswitchstate = 0;
4595                                         plci->vsprot = 0;
4596                                         plci->vsprotdialect = 0;
4597                                 }
4598                                 else
4599                                 {
4600                                         if (plci->relatedPTYPLCI &&
4601                                             plci->vswitchstate == 1 &&
4602                                             plci->relatedPTYPLCI->vswitchstate == 3) /* join complete */
4603                                                 plci->vswitchstate = 3;
4604                                 }
4605                                 break;
4606
4607                                 /* Call Deflection Request pending (SSCT) */
4608                         case CD_REQ_PEND:
4609                                 SSparms[1] = S_CALL_DEFLECTION;
4610                                 if (rc != OK)
4611                                 {
4612                                         Info = 0x300E; /* not supported */
4613                                         plci->appl->CDEnable = 0;
4614                                 }
4615                                 sendf(plci->appl, _FACILITY_R | CONFIRM, Id,
4616                                       plci->number, "wws", Info, (word)3, SSparms);
4617                                 break;
4618
4619                         case RTP_CONNECT_B3_REQ_COMMAND_2:
4620                                 if (rc == OK)
4621                                 {
4622                                         ncci = get_ncci(plci, ch, 0);
4623                                         Id = (Id & 0xffff) | (((dword) ncci) << 16);
4624                                         plci->channels++;
4625                                         a->ncci_state[ncci] = OUTG_CON_PENDING;
4626                                 }
4627
4628                         default:
4629                                 if (plci->internal_command_queue[0])
4630                                 {
4631                                         (*(plci->internal_command_queue[0]))(Id, plci, rc);
4632                                         if (plci->internal_command)
4633                                                 return;
4634                                 }
4635                                 break;
4636                         }
4637                         next_internal_command(Id, plci);
4638                 }
4639         }
4640         else /* appl==0 */
4641         {
4642                 Id = ((word)plci->Id << 8) | plci->adapter->Id;
4643                 if (plci->tel) Id |= EXT_CONTROLLER;
4644
4645                 switch (plci->internal_command)
4646                 {
4647                 case BLOCK_PLCI:
4648                         return;
4649
4650                 case START_L1_SIG_ASSIGN_PEND:
4651                 case REM_L1_SIG_ASSIGN_PEND:
4652                         if (global_req == ASSIGN)
4653                         {
4654                                 break;
4655                         }
4656                         else
4657                         {
4658                                 dbug(1, dprintf("***L1 Req rem PLCI"));
4659                                 plci->internal_command = 0;
4660                                 sig_req(plci, REMOVE, 0);
4661                                 send_req(plci);
4662                         }
4663                         break;
4664
4665                         /* Call Deflection Request pending, just no appl ptr assigned */
4666                 case CD_REQ_PEND:
4667                         SSparms[1] = S_CALL_DEFLECTION;
4668                         if (rc != OK)
4669                         {
4670                                 Info = 0x300E; /* not supported */
4671                         }
4672                         for (i = 0; i < max_appl; i++)
4673                         {
4674                                 if (application[i].CDEnable)
4675                                 {
4676                                         if (!application[i].Id) application[i].CDEnable = 0;
4677                                         else
4678                                         {
4679                                                 sendf(&application[i], _FACILITY_R | CONFIRM, Id,
4680                                                       plci->number, "wws", Info, (word)3, SSparms);
4681                                                 if (Info) application[i].CDEnable = 0;
4682                                         }
4683                                 }
4684                         }
4685                         plci->internal_command = 0;
4686                         break;
4687
4688                 case PERM_COD_HOOK:                   /* finished with Hook_Ind */
4689                         return;
4690
4691                 case PERM_COD_CALL:
4692                         plci->internal_command = PERM_COD_CONN_PEND;
4693                         dbug(1, dprintf("***Codec Connect_Pending, Rc = 0x%x", rc));
4694                         return;
4695
4696                 case PERM_COD_ASSIGN:
4697                         dbug(1, dprintf("***Codec Assign, Rc = 0x%x", rc));
4698                         plci->internal_command = 0;
4699                         if (rc != ASSIGN_OK) break;
4700                         plci->internal_command = PERM_COD_CALL;
4701                         sig_req(plci, CALL_REQ, 0);
4702                         send_req(plci);
4703                         return;
4704
4705                 case LISTEN_SIG_ASSIGN_PEND:
4706                         if (rc == ASSIGN_OK)
4707                         {
4708                                 plci->internal_command = 0;
4709                                 dbug(1, dprintf("ListenCheck, new SIG_ID = 0x%x", plci->Sig.Id));
4710                                 add_p(plci, ESC, "\x02\x18\x00");             /* support call waiting */
4711                                 sig_req(plci, INDICATE_REQ, 0);
4712                                 send_req(plci);
4713                         }
4714                         else
4715                         {
4716                                 dbug(1, dprintf("ListenCheck failed (assignRc=0x%x)", rc));
4717                                 a->listen_active--;
4718                                 plci_remove(plci);
4719                                 plci->State = IDLE;
4720                         }
4721                         break;
4722
4723                 case USELAW_REQ:
4724                         if (global_req == ASSIGN)
4725                         {
4726                                 if (rc == ASSIGN_OK)
4727                                 {
4728                                         sig_req(plci, LAW_REQ, 0);
4729                                         send_req(plci);
4730                                         dbug(1, dprintf("Auto-Law assigned"));
4731                                 }
4732                                 else
4733                                 {
4734                                         dbug(1, dprintf("Auto-Law assign failed"));
4735                                         a->automatic_law = 3;
4736                                         plci->internal_command = 0;
4737                                         a->automatic_lawPLCI = NULL;
4738                                 }
4739                                 break;
4740                         }
4741                         else if (req == LAW_REQ && rc == OK)
4742                         {
4743                                 dbug(1, dprintf("Auto-Law initiated"));
4744                                 a->automatic_law = 2;
4745                                 plci->internal_command = 0;
4746                         }
4747                         else
4748                         {
4749                                 dbug(1, dprintf("Auto-Law not supported"));
4750                                 a->automatic_law = 3;
4751                                 plci->internal_command = 0;
4752                                 sig_req(plci, REMOVE, 0);
4753                                 send_req(plci);
4754                                 a->automatic_lawPLCI = NULL;
4755                         }
4756                         break;
4757                 }
4758                 plci_remove_check(plci);
4759         }
4760 }
4761
4762 static void data_rc(PLCI *plci, byte ch)
4763 {
4764         dword Id;
4765         DIVA_CAPI_ADAPTER *a;
4766         NCCI *ncci_ptr;
4767         DATA_B3_DESC *data;
4768         word ncci;
4769
4770         if (plci->appl)
4771         {
4772                 TransmitBufferFree(plci->appl, plci->data_sent_ptr);
4773                 a = plci->adapter;
4774                 ncci = a->ch_ncci[ch];
4775                 if (ncci && (a->ncci_plci[ncci] == plci->Id))
4776                 {
4777                         ncci_ptr = &(a->ncci[ncci]);
4778                         dbug(1, dprintf("data_out=%d, data_pending=%d", ncci_ptr->data_out, ncci_ptr->data_pending));
4779                         if (ncci_ptr->data_pending)
4780                         {
4781                                 data = &(ncci_ptr->DBuffer[ncci_ptr->data_out]);
4782                                 if (!(data->Flags & 4) && a->ncci_state[ncci])
4783                                 {
4784                                         Id = (((dword)ncci) << 16) | ((word)plci->Id << 8) | a->Id;
4785                                         if (plci->tel) Id |= EXT_CONTROLLER;
4786                                         sendf(plci->appl, _DATA_B3_R | CONFIRM, Id, data->Number,
4787                                               "ww", data->Handle, 0);
4788                                 }
4789                                 (ncci_ptr->data_out)++;
4790                                 if (ncci_ptr->data_out == MAX_DATA_B3)
4791                                         ncci_ptr->data_out = 0;
4792                                 (ncci_ptr->data_pending)--;
4793                         }
4794                 }
4795         }
4796 }
4797
4798 static void data_ack(PLCI *plci, byte ch)
4799 {
4800         dword Id;
4801         DIVA_CAPI_ADAPTER *a;
4802         NCCI *ncci_ptr;
4803         word ncci;
4804
4805         a = plci->adapter;
4806         ncci = a->ch_ncci[ch];
4807         ncci_ptr = &(a->ncci[ncci]);
4808         if (ncci_ptr->data_ack_pending)
4809         {
4810                 if (a->ncci_state[ncci] && (a->ncci_plci[ncci] == plci->Id))
4811                 {
4812                         Id = (((dword)ncci) << 16) | ((word)plci->Id << 8) | a->Id;
4813                         if (plci->tel) Id |= EXT_CONTROLLER;
4814                         sendf(plci->appl, _DATA_B3_R | CONFIRM, Id, ncci_ptr->DataAck[ncci_ptr->data_ack_out].Number,
4815                               "ww", ncci_ptr->DataAck[ncci_ptr->data_ack_out].Handle, 0);
4816                 }
4817                 (ncci_ptr->data_ack_out)++;
4818                 if (ncci_ptr->data_ack_out == MAX_DATA_ACK)
4819                         ncci_ptr->data_ack_out = 0;
4820                 (ncci_ptr->data_ack_pending)--;
4821         }
4822 }
4823
4824 static void sig_ind(PLCI *plci)
4825 {
4826         dword x_Id;
4827         dword Id;
4828         dword rId;
4829         word i;
4830         word cip;
4831         dword cip_mask;
4832         byte *ie;
4833         DIVA_CAPI_ADAPTER *a;
4834         API_PARSE saved_parms[MAX_MSG_PARMS + 1];
4835 #define MAXPARMSIDS 31
4836         byte *parms[MAXPARMSIDS];
4837         byte *add_i[4];
4838         byte *multi_fac_parms[MAX_MULTI_IE];
4839         byte *multi_pi_parms[MAX_MULTI_IE];
4840         byte *multi_ssext_parms[MAX_MULTI_IE];
4841         byte *multi_CiPN_parms[MAX_MULTI_IE];
4842
4843         byte *multi_vswitch_parms[MAX_MULTI_IE];
4844
4845         byte ai_len;
4846         byte *esc_chi = "";
4847         byte *esc_law = "";
4848         byte *pty_cai = "";
4849         byte *esc_cr  = "";
4850         byte *esc_profile = "";
4851
4852         byte facility[256];
4853         PLCI *tplci = NULL;
4854         byte chi[] = "\x02\x18\x01";
4855         byte voice_cai[]  = "\x06\x14\x00\x00\x00\x00\x08";
4856         byte resume_cau[] = "\x05\x05\x00\x02\x00\x00";
4857         /* ESC_MSGTYPE must be the last but one message, a new IE has to be */
4858         /* included before the ESC_MSGTYPE and MAXPARMSIDS has to be incremented */
4859         /* SMSG is situated at the end because its 0 (for compatibility reasons */
4860         /* (see Info_Mask Bit 4, first IE. then the message type)           */
4861         word parms_id[] =
4862                 {MAXPARMSIDS, CPN, 0xff, DSA, OSA, BC, LLC, HLC, ESC_CAUSE, DSP, DT, CHA,
4863                  UUI, CONG_RR, CONG_RNR, ESC_CHI, KEY, CHI, CAU, ESC_LAW,
4864                  RDN, RDX, CONN_NR, RIN, NI, CAI, ESC_CR,
4865                  CST, ESC_PROFILE, 0xff, ESC_MSGTYPE, SMSG};
4866         /* 14 FTY repl by ESC_CHI */
4867         /* 18 PI  repl by ESC_LAW */
4868         /* removed OAD changed to 0xff for future use, OAD is multiIE now */
4869         word multi_fac_id[] = {1, FTY};
4870         word multi_pi_id[]  = {1, PI};
4871         word multi_CiPN_id[]  = {1, OAD};
4872         word multi_ssext_id[]  = {1, ESC_SSEXT};
4873
4874         word multi_vswitch_id[]  = {1, ESC_VSWITCH};
4875
4876         byte *cau;
4877         word ncci;
4878         byte SS_Ind[] = "\x05\x02\x00\x02\x00\x00"; /* Hold_Ind struct*/
4879         byte CF_Ind[] = "\x09\x02\x00\x06\x00\x00\x00\x00\x00\x00";
4880         byte Interr_Err_Ind[] = "\x0a\x02\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
4881         byte CONF_Ind[] = "\x09\x16\x00\x06\x00\x00\x00\x00\x00\x00";
4882         byte force_mt_info = false;
4883         byte dir;
4884         dword d;
4885         word w;
4886
4887         a = plci->adapter;
4888         Id = ((word)plci->Id << 8) | a->Id;
4889         PUT_WORD(&SS_Ind[4], 0x0000);
4890
4891         if (plci->sig_remove_id)
4892         {
4893                 plci->Sig.RNR = 2; /* discard */
4894                 dbug(1, dprintf("SIG discard while remove pending"));
4895                 return;
4896         }
4897         if (plci->tel && plci->SuppState != CALL_HELD) Id |= EXT_CONTROLLER;
4898         dbug(1, dprintf("SigInd-Id=%08lx,plci=%x,tel=%x,state=0x%x,channels=%d,Discflowcl=%d",
4899                         Id, plci->Id, plci->tel, plci->State, plci->channels, plci->hangup_flow_ctrl_timer));
4900         if (plci->Sig.Ind == CALL_HOLD_ACK && plci->channels)
4901         {
4902                 plci->Sig.RNR = 1;
4903                 return;
4904         }
4905         if (plci->Sig.Ind == HANGUP && plci->channels)
4906         {
4907                 plci->Sig.RNR = 1;
4908                 plci->hangup_flow_ctrl_timer++;
4909                 /* recover the network layer after timeout */
4910                 if (plci->hangup_flow_ctrl_timer == 100)
4911                 {
4912                         dbug(1, dprintf("Exceptional disc"));
4913                         plci->Sig.RNR = 0;
4914                         plci->hangup_flow_ctrl_timer = 0;
4915                         for (ncci = 1; ncci < MAX_NCCI + 1; ncci++)
4916                         {
4917                                 if (a->ncci_plci[ncci] == plci->Id)
4918                                 {
4919                                         cleanup_ncci_data(plci, ncci);
4920                                         if (plci->channels)plci->channels--;
4921                                         if (plci->appl)
4922                                                 sendf(plci->appl, _DISCONNECT_B3_I, (((dword) ncci) << 16) | Id, 0, "ws", 0, "");
4923                                 }
4924                         }
4925                         if (plci->appl)
4926                                 sendf(plci->appl, _DISCONNECT_I, Id, 0, "w", 0);
4927                         plci_remove(plci);
4928                         plci->State = IDLE;
4929                 }
4930                 return;
4931         }
4932
4933         /* do first parse the info with no OAD in, because OAD will be converted */
4934         /* first the multiple facility IE, then mult. progress ind.              */
4935         /* then the parameters for the info_ind + conn_ind                       */
4936         IndParse(plci, multi_fac_id, multi_fac_parms, MAX_MULTI_IE);
4937         IndParse(plci, multi_pi_id, multi_pi_parms, MAX_MULTI_IE);
4938         IndParse(plci, multi_ssext_id, multi_ssext_parms, MAX_MULTI_IE);
4939
4940         IndParse(plci, multi_vswitch_id, multi_vswitch_parms, MAX_MULTI_IE);
4941
4942         IndParse(plci, parms_id, parms, 0);
4943         IndParse(plci, multi_CiPN_id, multi_CiPN_parms, MAX_MULTI_IE);
4944         esc_chi  = parms[14];
4945         esc_law  = parms[18];
4946         pty_cai  = parms[24];
4947         esc_cr   = parms[25];
4948         esc_profile = parms[27];
4949         if (esc_cr[0] && plci)
4950         {
4951                 if (plci->cr_enquiry && plci->appl)
4952                 {
4953                         plci->cr_enquiry = false;
4954                         /* d = MANU_ID            */
4955                         /* w = m_command          */
4956                         /* b = total length       */
4957                         /* b = indication type    */
4958                         /* b = length of all IEs  */
4959                         /* b = IE1                */
4960                         /* S = IE1 length + cont. */
4961                         /* b = IE2                */
4962                         /* S = IE2 length + cont. */
4963                         sendf(plci->appl,
4964                               _MANUFACTURER_I,
4965                               Id,
4966                               0,
4967                               "dwbbbbSbS", _DI_MANU_ID, plci->m_command,
4968                               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);
4969                 }
4970         }
4971         /* create the additional info structure                                  */
4972         add_i[1] = parms[15]; /* KEY of additional info */
4973         add_i[2] = parms[11]; /* UUI of additional info */
4974         ai_len = AddInfo(add_i, multi_fac_parms, esc_chi, facility);
4975
4976         /* the ESC_LAW indicates if u-Law or a-Law is actually used by the card  */
4977         /* indication returns by the card if requested by the function           */
4978         /* AutomaticLaw() after driver init                                      */
4979         if (a->automatic_law < 4)
4980         {
4981                 if (esc_law[0]) {
4982                         if (esc_law[2]) {
4983                                 dbug(0, dprintf("u-Law selected"));
4984                                 a->u_law = 1;
4985                         }
4986                         else {
4987                                 dbug(0, dprintf("a-Law selected"));
4988                                 a->u_law = 0;
4989                         }
4990                         a->automatic_law = 4;
4991                         if (plci == a->automatic_lawPLCI) {
4992                                 plci->internal_command = 0;
4993                                 sig_req(plci, REMOVE, 0);
4994                                 send_req(plci);
4995                                 a->automatic_lawPLCI = NULL;
4996                         }
4997                 }
4998                 if (esc_profile[0])
4999                 {
5000                         dbug(1, dprintf("[%06x] CardProfile: %lx %lx %lx %lx %lx",
5001                                         UnMapController(a->Id), GET_DWORD(&esc_profile[6]),
5002                                         GET_DWORD(&esc_profile[10]), GET_DWORD(&esc_profile[14]),
5003                                         GET_DWORD(&esc_profile[18]), GET_DWORD(&esc_profile[46])));
5004
5005                         a->profile.Global_Options &= 0x000000ffL;
5006                         a->profile.B1_Protocols &= 0x000003ffL;
5007                         a->profile.B2_Protocols &= 0x00001fdfL;
5008                         a->profile.B3_Protocols &= 0x000000b7L;
5009
5010                         a->profile.Global_Options &= GET_DWORD(&esc_profile[6]) |
5011                                 GL_BCHANNEL_OPERATION_SUPPORTED;
5012                         a->profile.B1_Protocols &= GET_DWORD(&esc_profile[10]);
5013                         a->profile.B2_Protocols &= GET_DWORD(&esc_profile[14]);
5014                         a->profile.B3_Protocols &= GET_DWORD(&esc_profile[18]);
5015                         a->manufacturer_features = GET_DWORD(&esc_profile[46]);
5016                         a->man_profile.private_options = 0;
5017
5018                         if (a->manufacturer_features & MANUFACTURER_FEATURE_ECHO_CANCELLER)
5019                         {
5020                                 a->man_profile.private_options |= 1L << PRIVATE_ECHO_CANCELLER;
5021                                 a->profile.Global_Options |= GL_ECHO_CANCELLER_SUPPORTED;
5022                         }
5023
5024
5025                         if (a->manufacturer_features & MANUFACTURER_FEATURE_RTP)
5026                                 a->man_profile.private_options |= 1L << PRIVATE_RTP;
5027                         a->man_profile.rtp_primary_payloads = GET_DWORD(&esc_profile[50]);
5028                         a->man_profile.rtp_additional_payloads = GET_DWORD(&esc_profile[54]);
5029
5030
5031                         if (a->manufacturer_features & MANUFACTURER_FEATURE_T38)
5032                                 a->man_profile.private_options |= 1L << PRIVATE_T38;
5033
5034
5035                         if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_SUB_SEP_PWD)
5036                                 a->man_profile.private_options |= 1L << PRIVATE_FAX_SUB_SEP_PWD;
5037
5038
5039                         if (a->manufacturer_features & MANUFACTURER_FEATURE_V18)
5040                                 a->man_profile.private_options |= 1L << PRIVATE_V18;
5041
5042
5043                         if (a->manufacturer_features & MANUFACTURER_FEATURE_DTMF_TONE)
5044                                 a->man_profile.private_options |= 1L << PRIVATE_DTMF_TONE;
5045
5046
5047                         if (a->manufacturer_features & MANUFACTURER_FEATURE_PIAFS)
5048                                 a->man_profile.private_options |= 1L << PRIVATE_PIAFS;
5049
5050
5051                         if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
5052                                 a->man_profile.private_options |= 1L << PRIVATE_FAX_PAPER_FORMATS;
5053
5054
5055                         if (a->manufacturer_features & MANUFACTURER_FEATURE_VOWN)
5056                                 a->man_profile.private_options |= 1L << PRIVATE_VOWN;
5057
5058
5059                         if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_NONSTANDARD)
5060                                 a->man_profile.private_options |= 1L << PRIVATE_FAX_NONSTANDARD;
5061
5062                 }
5063                 else
5064                 {
5065                         a->profile.Global_Options &= 0x0000007fL;
5066                         a->profile.B1_Protocols &= 0x000003dfL;
5067                         a->profile.B2_Protocols &= 0x00001adfL;
5068                         a->profile.B3_Protocols &= 0x000000b7L;
5069                         a->manufacturer_features &= MANUFACTURER_FEATURE_HARDDTMF;
5070                 }
5071                 if (a->manufacturer_features & (MANUFACTURER_FEATURE_HARDDTMF |
5072                                                 MANUFACTURER_FEATURE_SOFTDTMF_SEND | MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE))
5073                 {
5074                         a->profile.Global_Options |= GL_DTMF_SUPPORTED;
5075                 }
5076                 a->manufacturer_features &= ~MANUFACTURER_FEATURE_OOB_CHANNEL;
5077                 dbug(1, dprintf("[%06x] Profile: %lx %lx %lx %lx %lx",
5078                                 UnMapController(a->Id), a->profile.Global_Options,
5079                                 a->profile.B1_Protocols, a->profile.B2_Protocols,
5080                                 a->profile.B3_Protocols, a->manufacturer_features));
5081         }
5082         /* codec plci for the handset/hook state support is just an internal id  */
5083         if (plci != a->AdvCodecPLCI)
5084         {
5085                 force_mt_info = SendMultiIE(plci, Id, multi_fac_parms, FTY, 0x20, 0);
5086                 force_mt_info |= SendMultiIE(plci, Id, multi_pi_parms, PI, 0x210, 0);
5087                 SendSSExtInd(NULL, plci, Id, multi_ssext_parms);
5088                 SendInfo(plci, Id, parms, force_mt_info);
5089
5090                 VSwitchReqInd(plci, Id, multi_vswitch_parms);
5091
5092         }
5093
5094         /* switch the codec to the b-channel                                     */
5095         if (esc_chi[0] && plci && !plci->SuppState) {
5096                 plci->b_channel = esc_chi[esc_chi[0]]&0x1f;
5097                 mixer_set_bchannel_id_esc(plci, plci->b_channel);
5098                 dbug(1, dprintf("storeChannel=0x%x", plci->b_channel));
5099                 if (plci->tel == ADV_VOICE && plci->appl) {
5100                         SetVoiceChannel(a->AdvCodecPLCI, esc_chi, a);
5101                 }
5102         }
5103
5104         if (plci->appl) plci->appl->Number++;
5105
5106         switch (plci->Sig.Ind) {
5107                 /* Response to Get_Supported_Services request */
5108         case S_SUPPORTED:
5109                 dbug(1, dprintf("S_Supported"));
5110                 if (!plci->appl) break;
5111                 if (pty_cai[0] == 4)
5112                 {
5113                         PUT_DWORD(&CF_Ind[6], GET_DWORD(&pty_cai[1]));
5114                 }
5115                 else
5116                 {
5117                         PUT_DWORD(&CF_Ind[6], MASK_TERMINAL_PORTABILITY | MASK_HOLD_RETRIEVE);
5118                 }
5119                 PUT_WORD(&CF_Ind[1], 0);
5120                 PUT_WORD(&CF_Ind[4], 0);
5121                 sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0x7, plci->number, "wws", 0, 3, CF_Ind);
5122                 plci_remove(plci);
5123                 break;
5124
5125                 /* Supplementary Service rejected */
5126         case S_SERVICE_REJ:
5127                 dbug(1, dprintf("S_Reject=0x%x", pty_cai[5]));
5128                 if (!pty_cai[0]) break;
5129                 switch (pty_cai[5])
5130                 {
5131                 case ECT_EXECUTE:
5132                 case THREE_PTY_END:
5133                 case THREE_PTY_BEGIN:
5134                         if (!plci->relatedPTYPLCI) break;
5135                         tplci = plci->relatedPTYPLCI;
5136                         rId = ((word)tplci->Id << 8) | tplci->adapter->Id;
5137                         if (tplci->tel) rId |= EXT_CONTROLLER;
5138                         if (pty_cai[5] == ECT_EXECUTE)
5139                         {
5140                                 PUT_WORD(&SS_Ind[1], S_ECT);
5141
5142                                 plci->vswitchstate = 0;
5143                                 plci->relatedPTYPLCI->vswitchstate = 0;
5144
5145                         }
5146                         else
5147                         {
5148                                 PUT_WORD(&SS_Ind[1], pty_cai[5] + 3);
5149                         }
5150                         if (pty_cai[2] != 0xff)
5151                         {
5152                                 PUT_WORD(&SS_Ind[4], 0x3600 | (word)pty_cai[2]);
5153                         }
5154                         else
5155                         {
5156                                 PUT_WORD(&SS_Ind[4], 0x300E);
5157                         }
5158                         plci->relatedPTYPLCI = NULL;
5159                         plci->ptyState = 0;
5160                         sendf(tplci->appl, _FACILITY_I, rId, 0, "ws", 3, SS_Ind);
5161                         break;
5162
5163                 case CALL_DEFLECTION:
5164                         if (pty_cai[2] != 0xff)
5165                         {
5166                                 PUT_WORD(&SS_Ind[4], 0x3600 | (word)pty_cai[2]);
5167                         }
5168                         else
5169                         {
5170                                 PUT_WORD(&SS_Ind[4], 0x300E);
5171                         }
5172                         PUT_WORD(&SS_Ind[1], pty_cai[5]);
5173                         for (i = 0; i < max_appl; i++)
5174                         {
5175                                 if (application[i].CDEnable)
5176                                 {
5177                                         if (application[i].Id) sendf(&application[i], _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5178                                         application[i].CDEnable = false;
5179                                 }
5180                         }
5181                         break;
5182
5183                 case DEACTIVATION_DIVERSION:
5184                 case ACTIVATION_DIVERSION:
5185                 case DIVERSION_INTERROGATE_CFU:
5186                 case DIVERSION_INTERROGATE_CFB:
5187                 case DIVERSION_INTERROGATE_CFNR:
5188                 case DIVERSION_INTERROGATE_NUM:
5189                 case CCBS_REQUEST:
5190                 case CCBS_DEACTIVATE:
5191                 case CCBS_INTERROGATE:
5192                         if (!plci->appl) break;
5193                         if (pty_cai[2] != 0xff)
5194                         {
5195                                 PUT_WORD(&Interr_Err_Ind[4], 0x3600 | (word)pty_cai[2]);
5196                         }
5197                         else
5198                         {
5199                                 PUT_WORD(&Interr_Err_Ind[4], 0x300E);
5200                         }
5201                         switch (pty_cai[5])
5202                         {
5203                         case DEACTIVATION_DIVERSION:
5204                                 dbug(1, dprintf("Deact_Div"));
5205                                 Interr_Err_Ind[0] = 0x9;
5206                                 Interr_Err_Ind[3] = 0x6;
5207                                 PUT_WORD(&Interr_Err_Ind[1], S_CALL_FORWARDING_STOP);
5208                                 break;
5209                         case ACTIVATION_DIVERSION:
5210                                 dbug(1, dprintf("Act_Div"));
5211                                 Interr_Err_Ind[0] = 0x9;
5212                                 Interr_Err_Ind[3] = 0x6;
5213                                 PUT_WORD(&Interr_Err_Ind[1], S_CALL_FORWARDING_START);
5214                                 break;
5215                         case DIVERSION_INTERROGATE_CFU:
5216                         case DIVERSION_INTERROGATE_CFB:
5217                         case DIVERSION_INTERROGATE_CFNR:
5218                                 dbug(1, dprintf("Interr_Div"));
5219                                 Interr_Err_Ind[0] = 0xa;
5220                                 Interr_Err_Ind[3] = 0x7;
5221                                 PUT_WORD(&Interr_Err_Ind[1], S_INTERROGATE_DIVERSION);
5222                                 break;
5223                         case DIVERSION_INTERROGATE_NUM:
5224                                 dbug(1, dprintf("Interr_Num"));
5225                                 Interr_Err_Ind[0] = 0xa;
5226                                 Interr_Err_Ind[3] = 0x7;
5227                                 PUT_WORD(&Interr_Err_Ind[1], S_INTERROGATE_NUMBERS);
5228                                 break;
5229                         case CCBS_REQUEST:
5230                                 dbug(1, dprintf("CCBS Request"));
5231                                 Interr_Err_Ind[0] = 0xd;
5232                                 Interr_Err_Ind[3] = 0xa;
5233                                 PUT_WORD(&Interr_Err_Ind[1], S_CCBS_REQUEST);
5234                                 break;
5235                         case CCBS_DEACTIVATE:
5236                                 dbug(1, dprintf("CCBS Deactivate"));
5237                                 Interr_Err_Ind[0] = 0x9;
5238                                 Interr_Err_Ind[3] = 0x6;
5239                                 PUT_WORD(&Interr_Err_Ind[1], S_CCBS_DEACTIVATE);
5240                                 break;
5241                         case CCBS_INTERROGATE:
5242                                 dbug(1, dprintf("CCBS Interrogate"));
5243                                 Interr_Err_Ind[0] = 0xb;
5244                                 Interr_Err_Ind[3] = 0x8;
5245                                 PUT_WORD(&Interr_Err_Ind[1], S_CCBS_INTERROGATE);
5246                                 break;
5247                         }
5248                         PUT_DWORD(&Interr_Err_Ind[6], plci->appl->S_Handle);
5249                         sendf(plci->appl, _FACILITY_I, Id & 0x7, 0, "ws", 3, Interr_Err_Ind);
5250                         plci_remove(plci);
5251                         break;
5252                 case ACTIVATION_MWI:
5253                 case DEACTIVATION_MWI:
5254                         if (pty_cai[5] == ACTIVATION_MWI)
5255                         {
5256                                 PUT_WORD(&SS_Ind[1], S_MWI_ACTIVATE);
5257                         }
5258                         else PUT_WORD(&SS_Ind[1], S_MWI_DEACTIVATE);
5259
5260                         if (pty_cai[2] != 0xff)
5261                         {
5262                                 PUT_WORD(&SS_Ind[4], 0x3600 | (word)pty_cai[2]);
5263                         }
5264                         else
5265                         {
5266                                 PUT_WORD(&SS_Ind[4], 0x300E);
5267                         }
5268
5269                         if (plci->cr_enquiry)
5270                         {
5271                                 sendf(plci->appl, _FACILITY_I, Id & 0xf, 0, "ws", 3, SS_Ind);
5272                                 plci_remove(plci);
5273                         }
5274                         else
5275                         {
5276                                 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5277                         }
5278                         break;
5279                 case CONF_ADD: /* ERROR */
5280                 case CONF_BEGIN:
5281                 case CONF_DROP:
5282                 case CONF_ISOLATE:
5283                 case CONF_REATTACH:
5284                         CONF_Ind[0] = 9;
5285                         CONF_Ind[3] = 6;
5286                         switch (pty_cai[5])
5287                         {
5288                         case CONF_BEGIN:
5289                                 PUT_WORD(&CONF_Ind[1], S_CONF_BEGIN);
5290                                 plci->ptyState = 0;
5291                                 break;
5292                         case CONF_DROP:
5293                                 CONF_Ind[0] = 5;
5294                                 CONF_Ind[3] = 2;
5295                                 PUT_WORD(&CONF_Ind[1], S_CONF_DROP);
5296                                 plci->ptyState = CONNECTED;
5297                                 break;
5298                         case CONF_ISOLATE:
5299                                 CONF_Ind[0] = 5;
5300                                 CONF_Ind[3] = 2;
5301                                 PUT_WORD(&CONF_Ind[1], S_CONF_ISOLATE);
5302                                 plci->ptyState = CONNECTED;
5303                                 break;
5304                         case CONF_REATTACH:
5305                                 CONF_Ind[0] = 5;
5306                                 CONF_Ind[3] = 2;
5307                                 PUT_WORD(&CONF_Ind[1], S_CONF_REATTACH);
5308                                 plci->ptyState = CONNECTED;
5309                                 break;
5310                         case CONF_ADD:
5311                                 PUT_WORD(&CONF_Ind[1], S_CONF_ADD);
5312                                 plci->relatedPTYPLCI = NULL;
5313                                 tplci = plci->relatedPTYPLCI;
5314                                 if (tplci) tplci->ptyState = CONNECTED;
5315                                 plci->ptyState = CONNECTED;
5316                                 break;
5317                         }
5318
5319                         if (pty_cai[2] != 0xff)
5320                         {
5321                                 PUT_WORD(&CONF_Ind[4], 0x3600 | (word)pty_cai[2]);
5322                         }
5323                         else
5324                         {
5325                                 PUT_WORD(&CONF_Ind[4], 0x3303); /* Time-out: network did not respond
5326                                                                   within the required time */
5327                         }
5328
5329                         PUT_DWORD(&CONF_Ind[6], 0x0);
5330                         sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, CONF_Ind);
5331                         break;
5332                 }
5333                 break;
5334
5335                 /* Supplementary Service indicates success */
5336         case S_SERVICE:
5337                 dbug(1, dprintf("Service_Ind"));
5338                 PUT_WORD(&CF_Ind[4], 0);
5339                 switch (pty_cai[5])
5340                 {
5341                 case THREE_PTY_END:
5342                 case THREE_PTY_BEGIN:
5343                 case ECT_EXECUTE:
5344                         if (!plci->relatedPTYPLCI) break;
5345                         tplci = plci->relatedPTYPLCI;
5346                         rId = ((word)tplci->Id << 8) | tplci->adapter->Id;
5347                         if (tplci->tel) rId |= EXT_CONTROLLER;
5348                         if (pty_cai[5] == ECT_EXECUTE)
5349                         {
5350                                 PUT_WORD(&SS_Ind[1], S_ECT);
5351
5352                                 if (plci->vswitchstate != 3)
5353                                 {
5354
5355                                         plci->ptyState = IDLE;
5356                                         plci->relatedPTYPLCI = NULL;
5357                                         plci->ptyState = 0;
5358
5359                                 }
5360
5361                                 dbug(1, dprintf("ECT OK"));
5362                                 sendf(tplci->appl, _FACILITY_I, rId, 0, "ws", 3, SS_Ind);
5363
5364
5365
5366                         }
5367                         else
5368                         {
5369                                 switch (plci->ptyState)
5370                                 {
5371                                 case S_3PTY_BEGIN:
5372                                         plci->ptyState = CONNECTED;
5373                                         dbug(1, dprintf("3PTY ON"));
5374                                         break;
5375
5376                                 case S_3PTY_END:
5377                                         plci->ptyState = IDLE;
5378                                         plci->relatedPTYPLCI = NULL;
5379                                         plci->ptyState = 0;
5380                                         dbug(1, dprintf("3PTY OFF"));
5381                                         break;
5382                                 }
5383                                 PUT_WORD(&SS_Ind[1], pty_cai[5] + 3);
5384                                 sendf(tplci->appl, _FACILITY_I, rId, 0, "ws", 3, SS_Ind);
5385                         }
5386                         break;
5387
5388                 case CALL_DEFLECTION:
5389                         PUT_WORD(&SS_Ind[1], pty_cai[5]);
5390                         for (i = 0; i < max_appl; i++)
5391                         {
5392                                 if (application[i].CDEnable)
5393                                 {
5394                                         if (application[i].Id) sendf(&application[i], _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5395                                         application[i].CDEnable = false;
5396                                 }
5397                         }
5398                         break;
5399
5400                 case DEACTIVATION_DIVERSION:
5401                 case ACTIVATION_DIVERSION:
5402                         if (!plci->appl) break;
5403                         PUT_WORD(&CF_Ind[1], pty_cai[5] + 2);
5404                         PUT_DWORD(&CF_Ind[6], plci->appl->S_Handle);
5405                         sendf(plci->appl, _FACILITY_I, Id & 0x7, 0, "ws", 3, CF_Ind);
5406                         plci_remove(plci);
5407                         break;
5408
5409                 case DIVERSION_INTERROGATE_CFU:
5410                 case DIVERSION_INTERROGATE_CFB:
5411                 case DIVERSION_INTERROGATE_CFNR:
5412                 case DIVERSION_INTERROGATE_NUM:
5413                 case CCBS_REQUEST:
5414                 case CCBS_DEACTIVATE:
5415                 case CCBS_INTERROGATE:
5416                         if (!plci->appl) break;
5417                         switch (pty_cai[5])
5418                         {
5419                         case DIVERSION_INTERROGATE_CFU:
5420                         case DIVERSION_INTERROGATE_CFB:
5421                         case DIVERSION_INTERROGATE_CFNR:
5422                                 dbug(1, dprintf("Interr_Div"));
5423                                 PUT_WORD(&pty_cai[1], S_INTERROGATE_DIVERSION);
5424                                 pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
5425                                 break;
5426                         case DIVERSION_INTERROGATE_NUM:
5427                                 dbug(1, dprintf("Interr_Num"));
5428                                 PUT_WORD(&pty_cai[1], S_INTERROGATE_NUMBERS);
5429                                 pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
5430                                 break;
5431                         case CCBS_REQUEST:
5432                                 dbug(1, dprintf("CCBS Request"));
5433                                 PUT_WORD(&pty_cai[1], S_CCBS_REQUEST);
5434                                 pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
5435                                 break;
5436                         case CCBS_DEACTIVATE:
5437                                 dbug(1, dprintf("CCBS Deactivate"));
5438                                 PUT_WORD(&pty_cai[1], S_CCBS_DEACTIVATE);
5439                                 pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
5440                                 break;
5441                         case CCBS_INTERROGATE:
5442                                 dbug(1, dprintf("CCBS Interrogate"));
5443                                 PUT_WORD(&pty_cai[1], S_CCBS_INTERROGATE);
5444                                 pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
5445                                 break;
5446                         }
5447                         PUT_WORD(&pty_cai[4], 0); /* Supplementary Service Reason */
5448                         PUT_DWORD(&pty_cai[6], plci->appl->S_Handle);
5449                         sendf(plci->appl, _FACILITY_I, Id & 0x7, 0, "wS", 3, pty_cai);
5450                         plci_remove(plci);
5451                         break;
5452
5453                 case ACTIVATION_MWI:
5454                 case DEACTIVATION_MWI:
5455                         if (pty_cai[5] == ACTIVATION_MWI)
5456                         {
5457                                 PUT_WORD(&SS_Ind[1], S_MWI_ACTIVATE);
5458                         }
5459                         else PUT_WORD(&SS_Ind[1], S_MWI_DEACTIVATE);
5460                         if (plci->cr_enquiry)
5461                         {
5462                                 sendf(plci->appl, _FACILITY_I, Id & 0xf, 0, "ws", 3, SS_Ind);
5463                                 plci_remove(plci);
5464                         }
5465                         else
5466                         {
5467                                 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5468                         }
5469                         break;
5470                 case MWI_INDICATION:
5471                         if (pty_cai[0] >= 0x12)
5472                         {
5473                                 PUT_WORD(&pty_cai[3], S_MWI_INDICATE);
5474                                 pty_cai[2] = pty_cai[0] - 2; /* len Parameter */
5475                                 pty_cai[5] = pty_cai[0] - 5; /* Supplementary Service-specific parameter len */
5476                                 if (plci->appl && (a->Notification_Mask[plci->appl->Id - 1] & SMASK_MWI))
5477                                 {
5478                                         if (plci->internal_command == GET_MWI_STATE) /* result on Message Waiting Listen */
5479                                         {
5480                                                 sendf(plci->appl, _FACILITY_I, Id & 0xf, 0, "wS", 3, &pty_cai[2]);
5481                                                 plci_remove(plci);
5482                                                 return;
5483                                         }
5484                                         else sendf(plci->appl, _FACILITY_I, Id, 0, "wS", 3, &pty_cai[2]);
5485                                         pty_cai[0] = 0;
5486                                 }
5487                                 else
5488                                 {
5489                                         for (i = 0; i < max_appl; i++)
5490                                         {
5491                                                 if (a->Notification_Mask[i]&SMASK_MWI)
5492                                                 {
5493                                                         sendf(&application[i], _FACILITY_I, Id & 0x7, 0, "wS", 3, &pty_cai[2]);
5494                                                         pty_cai[0] = 0;
5495                                                 }
5496                                         }
5497                                 }
5498
5499                                 if (!pty_cai[0])
5500                                 { /* acknowledge */
5501                                         facility[2] = 0; /* returncode */
5502                                 }
5503                                 else facility[2] = 0xff;
5504                         }
5505                         else
5506                         {
5507                                 /* reject */
5508                                 facility[2] = 0xff; /* returncode */
5509                         }
5510                         facility[0] = 2;
5511                         facility[1] = MWI_RESPONSE; /* Function */
5512                         add_p(plci, CAI, facility);
5513                         add_p(plci, ESC, multi_ssext_parms[0]); /* remembered parameter -> only one possible */
5514                         sig_req(plci, S_SERVICE, 0);
5515                         send_req(plci);
5516                         plci->command = 0;
5517                         next_internal_command(Id, plci);
5518                         break;
5519                 case CONF_ADD: /* OK */
5520                 case CONF_BEGIN:
5521                 case CONF_DROP:
5522                 case CONF_ISOLATE:
5523                 case CONF_REATTACH:
5524                 case CONF_PARTYDISC:
5525                         CONF_Ind[0] = 9;
5526                         CONF_Ind[3] = 6;
5527                         switch (pty_cai[5])
5528                         {
5529                         case CONF_BEGIN:
5530                                 PUT_WORD(&CONF_Ind[1], S_CONF_BEGIN);
5531                                 if (pty_cai[0] == 6)
5532                                 {
5533                                         d = pty_cai[6];
5534                                         PUT_DWORD(&CONF_Ind[6], d); /* PartyID */
5535                                 }
5536                                 else
5537                                 {
5538                                         PUT_DWORD(&CONF_Ind[6], 0x0);
5539                                 }
5540                                 break;
5541                         case CONF_ISOLATE:
5542                                 PUT_WORD(&CONF_Ind[1], S_CONF_ISOLATE);
5543                                 CONF_Ind[0] = 5;
5544                                 CONF_Ind[3] = 2;
5545                                 break;
5546                         case CONF_REATTACH:
5547                                 PUT_WORD(&CONF_Ind[1], S_CONF_REATTACH);
5548                                 CONF_Ind[0] = 5;
5549                                 CONF_Ind[3] = 2;
5550                                 break;
5551                         case CONF_DROP:
5552                                 PUT_WORD(&CONF_Ind[1], S_CONF_DROP);
5553                                 CONF_Ind[0] = 5;
5554                                 CONF_Ind[3] = 2;
5555                                 break;
5556                         case CONF_ADD:
5557                                 PUT_WORD(&CONF_Ind[1], S_CONF_ADD);
5558                                 d = pty_cai[6];
5559                                 PUT_DWORD(&CONF_Ind[6], d); /* PartyID */
5560                                 tplci = plci->relatedPTYPLCI;
5561                                 if (tplci) tplci->ptyState = CONNECTED;
5562                                 break;
5563                         case CONF_PARTYDISC:
5564                                 CONF_Ind[0] = 7;
5565                                 CONF_Ind[3] = 4;
5566                                 PUT_WORD(&CONF_Ind[1], S_CONF_PARTYDISC);
5567                                 d = pty_cai[6];
5568                                 PUT_DWORD(&CONF_Ind[4], d); /* PartyID */
5569                                 break;
5570                         }
5571                         plci->ptyState = CONNECTED;
5572                         sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, CONF_Ind);
5573                         break;
5574                 case CCBS_INFO_RETAIN:
5575                 case CCBS_ERASECALLLINKAGEID:
5576                 case CCBS_STOP_ALERTING:
5577                         CONF_Ind[0] = 5;
5578                         CONF_Ind[3] = 2;
5579                         switch (pty_cai[5])
5580                         {
5581                         case CCBS_INFO_RETAIN:
5582                                 PUT_WORD(&CONF_Ind[1], S_CCBS_INFO_RETAIN);
5583                                 break;
5584                         case CCBS_STOP_ALERTING:
5585                                 PUT_WORD(&CONF_Ind[1], S_CCBS_STOP_ALERTING);
5586                                 break;
5587                         case CCBS_ERASECALLLINKAGEID:
5588                                 PUT_WORD(&CONF_Ind[1], S_CCBS_ERASECALLLINKAGEID);
5589                                 CONF_Ind[0] = 7;
5590                                 CONF_Ind[3] = 4;
5591                                 CONF_Ind[6] = 0;
5592                                 CONF_Ind[7] = 0;
5593                                 break;
5594                         }
5595                         w = pty_cai[6];
5596                         PUT_WORD(&CONF_Ind[4], w); /* PartyID */
5597
5598                         if (plci->appl && (a->Notification_Mask[plci->appl->Id - 1] & SMASK_CCBS))
5599                         {
5600                                 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, CONF_Ind);
5601                         }
5602                         else
5603                         {
5604                                 for (i = 0; i < max_appl; i++)
5605                                         if (a->Notification_Mask[i] & SMASK_CCBS)
5606                                                 sendf(&application[i], _FACILITY_I, Id & 0x7, 0, "ws", 3, CONF_Ind);
5607                         }
5608                         break;
5609                 }
5610                 break;
5611         case CALL_HOLD_REJ:
5612                 cau = parms[7];
5613                 if (cau)
5614                 {
5615                         i = _L3_CAUSE | cau[2];
5616                         if (cau[2] == 0) i = 0x3603;
5617                 }
5618                 else
5619                 {
5620                         i = 0x3603;
5621                 }
5622                 PUT_WORD(&SS_Ind[1], S_HOLD);
5623                 PUT_WORD(&SS_Ind[4], i);
5624                 if (plci->SuppState == HOLD_REQUEST)
5625                 {
5626                         plci->SuppState = IDLE;
5627                         sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5628                 }
5629                 break;
5630
5631         case CALL_HOLD_ACK:
5632                 if (plci->SuppState == HOLD_REQUEST)
5633                 {
5634                         plci->SuppState = CALL_HELD;
5635                         CodecIdCheck(a, plci);
5636                         start_internal_command(Id, plci, hold_save_command);
5637                 }
5638                 break;
5639
5640         case CALL_RETRIEVE_REJ:
5641                 cau = parms[7];
5642                 if (cau)
5643                 {
5644                         i = _L3_CAUSE | cau[2];
5645                         if (cau[2] == 0) i = 0x3603;
5646                 }
5647                 else
5648                 {
5649                         i = 0x3603;
5650                 }
5651                 PUT_WORD(&SS_Ind[1], S_RETRIEVE);
5652                 PUT_WORD(&SS_Ind[4], i);
5653                 if (plci->SuppState == RETRIEVE_REQUEST)
5654                 {
5655                         plci->SuppState = CALL_HELD;
5656                         CodecIdCheck(a, plci);
5657                         sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5658                 }
5659                 break;
5660
5661         case CALL_RETRIEVE_ACK:
5662                 PUT_WORD(&SS_Ind[1], S_RETRIEVE);
5663                 if (plci->SuppState == RETRIEVE_REQUEST)
5664                 {
5665                         plci->SuppState = IDLE;
5666                         plci->call_dir |= CALL_DIR_FORCE_OUTG_NL;
5667                         plci->b_channel = esc_chi[esc_chi[0]]&0x1f;
5668                         if (plci->tel)
5669                         {
5670                                 mixer_set_bchannel_id_esc(plci, plci->b_channel);
5671                                 dbug(1, dprintf("RetrChannel=0x%x", plci->b_channel));
5672                                 SetVoiceChannel(a->AdvCodecPLCI, esc_chi, a);
5673                                 if (plci->B2_prot == B2_TRANSPARENT && plci->B3_prot == B3_TRANSPARENT)
5674                                 {
5675                                         dbug(1, dprintf("Get B-ch"));
5676                                         start_internal_command(Id, plci, retrieve_restore_command);
5677                                 }
5678                                 else
5679                                         sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5680                         }
5681                         else
5682                                 start_internal_command(Id, plci, retrieve_restore_command);
5683                 }
5684                 break;
5685
5686         case INDICATE_IND:
5687                 if (plci->State != LISTENING) {
5688                         sig_req(plci, HANGUP, 0);
5689                         send_req(plci);
5690                         break;
5691                 }
5692                 cip = find_cip(a, parms[4], parms[6]);
5693                 cip_mask = 1L << cip;
5694                 dbug(1, dprintf("cip=%d,cip_mask=%lx", cip, cip_mask));
5695                 clear_c_ind_mask(plci);
5696                 if (!remove_started && !a->adapter_disabled)
5697                 {
5698                         set_c_ind_mask_bit(plci, MAX_APPL);
5699                         group_optimization(a, plci);
5700                         for (i = 0; i < max_appl; i++) {
5701                                 if (application[i].Id
5702                                     && (a->CIP_Mask[i] & 1 || a->CIP_Mask[i] & cip_mask)
5703                                     && CPN_filter_ok(parms[0], a, i)
5704                                     && test_group_ind_mask_bit(plci, i)) {
5705                                         dbug(1, dprintf("storedcip_mask[%d]=0x%lx", i, a->CIP_Mask[i]));
5706                                         set_c_ind_mask_bit(plci, i);
5707                                         dump_c_ind_mask(plci);
5708                                         plci->State = INC_CON_PENDING;
5709                                         plci->call_dir = (plci->call_dir & ~(CALL_DIR_OUT | CALL_DIR_ORIGINATE)) |
5710                                                 CALL_DIR_IN | CALL_DIR_ANSWER;
5711                                         if (esc_chi[0]) {
5712                                                 plci->b_channel = esc_chi[esc_chi[0]] & 0x1f;
5713                                                 mixer_set_bchannel_id_esc(plci, plci->b_channel);
5714                                         }
5715                                         /* if a listen on the ext controller is done, check if hook states */
5716                                         /* are supported or if just a on board codec must be activated     */
5717                                         if (a->codec_listen[i] && !a->AdvSignalPLCI) {
5718                                                 if (a->profile.Global_Options & HANDSET)
5719                                                         plci->tel = ADV_VOICE;
5720                                                 else if (a->profile.Global_Options & ON_BOARD_CODEC)
5721                                                         plci->tel = CODEC;
5722                                                 if (plci->tel) Id |= EXT_CONTROLLER;
5723                                                 a->codec_listen[i] = plci;
5724                                         }
5725
5726                                         sendf(&application[i], _CONNECT_I, Id, 0,
5727                                               "wSSSSSSSbSSSSS", cip,    /* CIP                 */
5728                                               parms[0],    /* CalledPartyNumber   */
5729                                               multi_CiPN_parms[0],    /* CallingPartyNumber  */
5730                                               parms[2],    /* CalledPartySubad    */
5731                                               parms[3],    /* CallingPartySubad   */
5732                                               parms[4],    /* BearerCapability    */
5733                                               parms[5],    /* LowLC               */
5734                                               parms[6],    /* HighLC              */
5735                                               ai_len,      /* nested struct add_i */
5736                                               add_i[0],    /* B channel info    */
5737                                               add_i[1],    /* keypad facility   */
5738                                               add_i[2],    /* user user data    */
5739                                               add_i[3],    /* nested facility   */
5740                                               multi_CiPN_parms[1]    /* second CiPN(SCR)   */
5741                                                 );
5742                                         SendSSExtInd(&application[i],
5743                                                      plci,
5744                                                      Id,
5745                                                      multi_ssext_parms);
5746                                         SendSetupInfo(&application[i],
5747                                                       plci,
5748                                                       Id,
5749                                                       parms,
5750                                                       SendMultiIE(plci, Id, multi_pi_parms, PI, 0x210, true));
5751                                 }
5752                         }
5753                         clear_c_ind_mask_bit(plci, MAX_APPL);
5754                         dump_c_ind_mask(plci);
5755                 }
5756                 if (c_ind_mask_empty(plci)) {
5757                         sig_req(plci, HANGUP, 0);
5758                         send_req(plci);
5759                         plci->State = IDLE;
5760                 }
5761                 plci->notifiedcall = 0;
5762                 a->listen_active--;
5763                 listen_check(a);
5764                 break;
5765
5766         case CALL_PEND_NOTIFY:
5767                 plci->notifiedcall = 1;
5768                 listen_check(a);
5769                 break;
5770
5771         case CALL_IND:
5772         case CALL_CON:
5773                 if (plci->State == ADVANCED_VOICE_SIG || plci->State == ADVANCED_VOICE_NOSIG)
5774                 {
5775                         if (plci->internal_command == PERM_COD_CONN_PEND)
5776                         {
5777                                 if (plci->State == ADVANCED_VOICE_NOSIG)
5778                                 {
5779                                         dbug(1, dprintf("***Codec OK"));
5780                                         if (a->AdvSignalPLCI)
5781                                         {
5782                                                 tplci = a->AdvSignalPLCI;
5783                                                 if (tplci->spoofed_msg)
5784                                                 {
5785                                                         dbug(1, dprintf("***Spoofed Msg(0x%x)", tplci->spoofed_msg));
5786                                                         tplci->command = 0;
5787                                                         tplci->internal_command = 0;
5788                                                         x_Id = ((word)tplci->Id << 8) | tplci->adapter->Id | 0x80;
5789                                                         switch (tplci->spoofed_msg)
5790                                                         {
5791                                                         case CALL_RES:
5792                                                                 tplci->command = _CONNECT_I | RESPONSE;
5793                                                                 api_load_msg(&tplci->saved_msg, saved_parms);
5794                                                                 add_b1(tplci, &saved_parms[1], 0, tplci->B1_facilities);
5795                                                                 if (tplci->adapter->Info_Mask[tplci->appl->Id - 1] & 0x200)
5796                                                                 {
5797                                                                         /* early B3 connect (CIP mask bit 9) no release after a disc */
5798                                                                         add_p(tplci, LLI, "\x01\x01");
5799                                                                 }
5800                                                                 add_s(tplci, CONN_NR, &saved_parms[2]);
5801                                                                 add_s(tplci, LLC, &saved_parms[4]);
5802                                                                 add_ai(tplci, &saved_parms[5]);
5803                                                                 tplci->State = INC_CON_ACCEPT;
5804                                                                 sig_req(tplci, CALL_RES, 0);
5805                                                                 send_req(tplci);
5806                                                                 break;
5807
5808                                                         case AWAITING_SELECT_B:
5809                                                                 dbug(1, dprintf("Select_B continue"));
5810                                                                 start_internal_command(x_Id, tplci, select_b_command);
5811                                                                 break;
5812
5813                                                         case AWAITING_MANUF_CON: /* Get_Plci per Manufacturer_Req to ext controller */
5814                                                                 if (!tplci->Sig.Id)
5815                                                                 {
5816                                                                         dbug(1, dprintf("No SigID!"));
5817                                                                         sendf(tplci->appl, _MANUFACTURER_R | CONFIRM, x_Id, tplci->number, "dww", _DI_MANU_ID, _MANUFACTURER_R, _OUT_OF_PLCI);
5818                                                                         plci_remove(tplci);
5819                                                                         break;
5820                                                                 }
5821                                                                 tplci->command = _MANUFACTURER_R;
5822                                                                 api_load_msg(&tplci->saved_msg, saved_parms);
5823                                                                 dir = saved_parms[2].info[0];
5824                                                                 if (dir == 1) {
5825                                                                         sig_req(tplci, CALL_REQ, 0);
5826                                                                 }
5827                                                                 else if (!dir) {
5828                                                                         sig_req(tplci, LISTEN_REQ, 0);
5829                                                                 }
5830                                                                 send_req(tplci);
5831                                                                 sendf(tplci->appl, _MANUFACTURER_R | CONFIRM, x_Id, tplci->number, "dww", _DI_MANU_ID, _MANUFACTURER_R, 0);
5832                                                                 break;
5833
5834                                                         case (CALL_REQ | AWAITING_MANUF_CON):
5835                                                                 sig_req(tplci, CALL_REQ, 0);
5836                                                                 send_req(tplci);
5837                                                                 break;
5838
5839                                                         case CALL_REQ:
5840                                                                 if (!tplci->Sig.Id)
5841                                                                 {
5842                                                                         dbug(1, dprintf("No SigID!"));
5843                                                                         sendf(tplci->appl, _CONNECT_R | CONFIRM, tplci->adapter->Id, 0, "w", _OUT_OF_PLCI);
5844                                                                         plci_remove(tplci);
5845                                                                         break;
5846                                                                 }
5847                                                                 tplci->command = _CONNECT_R;
5848                                                                 api_load_msg(&tplci->saved_msg, saved_parms);
5849                                                                 add_s(tplci, CPN, &saved_parms[1]);
5850                                                                 add_s(tplci, DSA, &saved_parms[3]);
5851                                                                 add_ai(tplci, &saved_parms[9]);
5852                                                                 sig_req(tplci, CALL_REQ, 0);
5853                                                                 send_req(tplci);
5854                                                                 break;
5855
5856                                                         case CALL_RETRIEVE:
5857                                                                 tplci->command = C_RETRIEVE_REQ;
5858                                                                 sig_req(tplci, CALL_RETRIEVE, 0);
5859                                                                 send_req(tplci);
5860                                                                 break;
5861                                                         }
5862                                                         tplci->spoofed_msg = 0;
5863                                                         if (tplci->internal_command == 0)
5864                                                                 next_internal_command(x_Id, tplci);
5865                                                 }
5866                                         }
5867                                         next_internal_command(Id, plci);
5868                                         break;
5869                                 }
5870                                 dbug(1, dprintf("***Codec Hook Init Req"));
5871                                 plci->internal_command = PERM_COD_HOOK;
5872                                 add_p(plci, FTY, "\x01\x09");             /* Get Hook State*/
5873                                 sig_req(plci, TEL_CTRL, 0);
5874                                 send_req(plci);
5875                         }
5876                 }
5877                 else if (plci->command != _MANUFACTURER_R  /* old style permanent connect */
5878                          && plci->State != INC_ACT_PENDING)
5879                 {
5880                         mixer_set_bchannel_id_esc(plci, plci->b_channel);
5881                         if (plci->tel == ADV_VOICE && plci->SuppState == IDLE) /* with permanent codec switch on immediately */
5882                         {
5883                                 chi[2] = plci->b_channel;
5884                                 SetVoiceChannel(a->AdvCodecPLCI, chi, a);
5885                         }
5886                         sendf(plci->appl, _CONNECT_ACTIVE_I, Id, 0, "Sss", parms[21], "", "");
5887                         plci->State = INC_ACT_PENDING;
5888                 }
5889                 break;
5890
5891         case TEL_CTRL:
5892                 ie = multi_fac_parms[0]; /* inspect the facility hook indications */
5893                 if (plci->State == ADVANCED_VOICE_SIG && ie[0]) {
5894                         switch (ie[1] & 0x91) {
5895                         case 0x80:   /* hook off */
5896                         case 0x81:
5897                                 if (plci->internal_command == PERM_COD_HOOK)
5898                                 {
5899                                         dbug(1, dprintf("init:hook_off"));
5900                                         plci->hook_state = ie[1];
5901                                         next_internal_command(Id, plci);
5902                                         break;
5903                                 }
5904                                 else /* ignore doubled hook indications */
5905                                 {
5906                                         if (((plci->hook_state) & 0xf0) == 0x80)
5907                                         {
5908                                                 dbug(1, dprintf("ignore hook"));
5909                                                 break;
5910                                         }
5911                                         plci->hook_state = ie[1]&0x91;
5912                                 }
5913                                 /* check for incoming call pending */
5914                                 /* and signal '+'.Appl must decide */
5915                                 /* with connect_res if call must   */
5916                                 /* accepted or not                 */
5917                                 for (i = 0, tplci = NULL; i < max_appl; i++) {
5918                                         if (a->codec_listen[i]
5919                                             && (a->codec_listen[i]->State == INC_CON_PENDING
5920                                                 || a->codec_listen[i]->State == INC_CON_ALERT)) {
5921                                                 tplci = a->codec_listen[i];
5922                                                 tplci->appl = &application[i];
5923                                         }
5924                                 }
5925                                 /* no incoming call, do outgoing call */
5926                                 /* and signal '+' if outg. setup   */
5927                                 if (!a->AdvSignalPLCI && !tplci) {
5928                                         if ((i = get_plci(a))) {
5929                                                 a->AdvSignalPLCI = &a->plci[i - 1];
5930                                                 tplci = a->AdvSignalPLCI;
5931                                                 tplci->tel  = ADV_VOICE;
5932                                                 PUT_WORD(&voice_cai[5], a->AdvSignalAppl->MaxDataLength);
5933                                                 if (a->Info_Mask[a->AdvSignalAppl->Id - 1] & 0x200) {
5934                                                         /* early B3 connect (CIP mask bit 9) no release after a disc */
5935                                                         add_p(tplci, LLI, "\x01\x01");
5936                                                 }
5937                                                 add_p(tplci, CAI, voice_cai);
5938                                                 add_p(tplci, OAD, a->TelOAD);
5939                                                 add_p(tplci, OSA, a->TelOSA);
5940                                                 add_p(tplci, SHIFT | 6, NULL);
5941                                                 add_p(tplci, SIN, "\x02\x01\x00");
5942                                                 add_p(tplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
5943                                                 sig_req(tplci, ASSIGN, DSIG_ID);
5944                                                 a->AdvSignalPLCI->internal_command = HOOK_OFF_REQ;
5945                                                 a->AdvSignalPLCI->command = 0;
5946                                                 tplci->appl = a->AdvSignalAppl;
5947                                                 tplci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
5948                                                 send_req(tplci);
5949                                         }
5950
5951                                 }
5952
5953                                 if (!tplci) break;
5954                                 Id = ((word)tplci->Id << 8) | a->Id;
5955                                 Id |= EXT_CONTROLLER;
5956                                 sendf(tplci->appl,
5957                                       _FACILITY_I,
5958                                       Id,
5959                                       0,
5960                                       "ws", (word)0, "\x01+");
5961                                 break;
5962
5963                         case 0x90:   /* hook on  */
5964                         case 0x91:
5965                                 if (plci->internal_command == PERM_COD_HOOK)
5966                                 {
5967                                         dbug(1, dprintf("init:hook_on"));
5968                                         plci->hook_state = ie[1] & 0x91;
5969                                         next_internal_command(Id, plci);
5970                                         break;
5971                                 }
5972                                 else /* ignore doubled hook indications */
5973                                 {
5974                                         if (((plci->hook_state) & 0xf0) == 0x90) break;
5975                                         plci->hook_state = ie[1] & 0x91;
5976                                 }
5977                                 /* hangup the adv. voice call and signal '-' to the appl */
5978                                 if (a->AdvSignalPLCI) {
5979                                         Id = ((word)a->AdvSignalPLCI->Id << 8) | a->Id;
5980                                         if (plci->tel) Id |= EXT_CONTROLLER;
5981                                         sendf(a->AdvSignalAppl,
5982                                               _FACILITY_I,
5983                                               Id,
5984                                               0,
5985                                               "ws", (word)0, "\x01-");
5986                                         a->AdvSignalPLCI->internal_command = HOOK_ON_REQ;
5987                                         a->AdvSignalPLCI->command = 0;
5988                                         sig_req(a->AdvSignalPLCI, HANGUP, 0);
5989                                         send_req(a->AdvSignalPLCI);
5990                                 }
5991                                 break;
5992                         }
5993                 }
5994                 break;
5995
5996         case RESUME:
5997                 clear_c_ind_mask_bit(plci, (word)(plci->appl->Id - 1));
5998                 PUT_WORD(&resume_cau[4], GOOD);
5999                 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", (word)3, resume_cau);
6000                 break;
6001
6002         case SUSPEND:
6003                 clear_c_ind_mask(plci);
6004
6005                 if (plci->NL.Id && !plci->nl_remove_id) {
6006                         mixer_remove(plci);
6007                         nl_req_ncci(plci, REMOVE, 0);
6008                 }
6009                 if (!plci->sig_remove_id) {
6010                         plci->internal_command = 0;
6011                         sig_req(plci, REMOVE, 0);
6012                 }
6013                 send_req(plci);
6014                 if (!plci->channels) {
6015                         sendf(plci->appl, _FACILITY_I, Id, 0, "ws", (word)3, "\x05\x04\x00\x02\x00\x00");
6016                         sendf(plci->appl, _DISCONNECT_I, Id, 0, "w", 0);
6017                 }
6018                 break;
6019
6020         case SUSPEND_REJ:
6021                 break;
6022
6023         case HANGUP:
6024                 plci->hangup_flow_ctrl_timer = 0;
6025                 if (plci->manufacturer && plci->State == LOCAL_CONNECT) break;
6026                 cau = parms[7];
6027                 if (cau) {
6028                         i = _L3_CAUSE | cau[2];
6029                         if (cau[2] == 0) i = 0;
6030                         else if (cau[2] == 8) i = _L1_ERROR;
6031                         else if (cau[2] == 9 || cau[2] == 10) i = _L2_ERROR;
6032                         else if (cau[2] == 5) i = _CAPI_GUARD_ERROR;
6033                 }
6034                 else {
6035                         i = _L3_ERROR;
6036                 }
6037
6038                 if (plci->State == INC_CON_PENDING || plci->State == INC_CON_ALERT)
6039                 {
6040                         for (i = 0; i < max_appl; i++)
6041                         {
6042                                 if (test_c_ind_mask_bit(plci, i))
6043                                         sendf(&application[i], _DISCONNECT_I, Id, 0, "w", 0);
6044                         }
6045                 }
6046                 else
6047                 {
6048                         clear_c_ind_mask(plci);
6049                 }
6050                 if (!plci->appl)
6051                 {
6052                         if (plci->State == LISTENING)
6053                         {
6054                                 plci->notifiedcall = 0;
6055                                 a->listen_active--;
6056                         }
6057                         plci->State = INC_DIS_PENDING;
6058                         if (c_ind_mask_empty(plci))
6059                         {
6060                                 plci->State = IDLE;
6061                                 if (plci->NL.Id && !plci->nl_remove_id)
6062                                 {
6063                                         mixer_remove(plci);
6064                                         nl_req_ncci(plci, REMOVE, 0);
6065                                 }
6066                                 if (!plci->sig_remove_id)
6067                                 {
6068                                         plci->internal_command = 0;
6069                                         sig_req(plci, REMOVE, 0);
6070                                 }
6071                                 send_req(plci);
6072                         }
6073                 }
6074                 else
6075                 {
6076                         /* collision of DISCONNECT or CONNECT_RES with HANGUP can   */
6077                         /* result in a second HANGUP! Don't generate another        */
6078                         /* DISCONNECT                                               */
6079                         if (plci->State != IDLE && plci->State != INC_DIS_PENDING)
6080                         {
6081                                 if (plci->State == RESUMING)
6082                                 {
6083                                         PUT_WORD(&resume_cau[4], i);
6084                                         sendf(plci->appl, _FACILITY_I, Id, 0, "ws", (word)3, resume_cau);
6085                                 }
6086                                 plci->State = INC_DIS_PENDING;
6087                                 sendf(plci->appl, _DISCONNECT_I, Id, 0, "w", i);
6088                         }
6089                 }
6090                 break;
6091
6092         case SSEXT_IND:
6093                 SendSSExtInd(NULL, plci, Id, multi_ssext_parms);
6094                 break;
6095
6096         case VSWITCH_REQ:
6097                 VSwitchReqInd(plci, Id, multi_vswitch_parms);
6098                 break;
6099         case VSWITCH_IND:
6100                 if (plci->relatedPTYPLCI &&
6101                     plci->vswitchstate == 3 &&
6102                     plci->relatedPTYPLCI->vswitchstate == 3 &&
6103                     parms[MAXPARMSIDS - 1][0])
6104                 {
6105                         add_p(plci->relatedPTYPLCI, SMSG, parms[MAXPARMSIDS - 1]);
6106                         sig_req(plci->relatedPTYPLCI, VSWITCH_REQ, 0);
6107                         send_req(plci->relatedPTYPLCI);
6108                 }
6109                 else VSwitchReqInd(plci, Id, multi_vswitch_parms);
6110                 break;
6111
6112         }
6113 }
6114
6115
6116 static void SendSetupInfo(APPL *appl, PLCI *plci, dword Id, byte **parms, byte Info_Sent_Flag)
6117 {
6118         word i;
6119         byte *ie;
6120         word Info_Number;
6121         byte *Info_Element;
6122         word Info_Mask = 0;
6123
6124         dbug(1, dprintf("SetupInfo"));
6125
6126         for (i = 0; i < MAXPARMSIDS; i++) {
6127                 ie = parms[i];
6128                 Info_Number = 0;
6129                 Info_Element = ie;
6130                 if (ie[0]) {
6131                         switch (i) {
6132                         case 0:
6133                                 dbug(1, dprintf("CPN "));
6134                                 Info_Number = 0x0070;
6135                                 Info_Mask = 0x80;
6136                                 Info_Sent_Flag = true;
6137                                 break;
6138                         case 8:  /* display      */
6139                                 dbug(1, dprintf("display(%d)", i));
6140                                 Info_Number = 0x0028;
6141                                 Info_Mask = 0x04;
6142                                 Info_Sent_Flag = true;
6143                                 break;
6144                         case 16: /* Channel Id */
6145                                 dbug(1, dprintf("CHI"));
6146                                 Info_Number = 0x0018;
6147                                 Info_Mask = 0x100;
6148                                 Info_Sent_Flag = true;
6149                                 mixer_set_bchannel_id(plci, Info_Element);
6150                                 break;
6151                         case 19: /* Redirected Number */
6152                                 dbug(1, dprintf("RDN"));
6153                                 Info_Number = 0x0074;
6154                                 Info_Mask = 0x400;
6155                                 Info_Sent_Flag = true;
6156                                 break;
6157                         case 20: /* Redirected Number extended */
6158                                 dbug(1, dprintf("RDX"));
6159                                 Info_Number = 0x0073;
6160                                 Info_Mask = 0x400;
6161                                 Info_Sent_Flag = true;
6162                                 break;
6163                         case 22: /* Redirecing Number  */
6164                                 dbug(1, dprintf("RIN"));
6165                                 Info_Number = 0x0076;
6166                                 Info_Mask = 0x400;
6167                                 Info_Sent_Flag = true;
6168                                 break;
6169                         default:
6170                                 Info_Number = 0;
6171                                 break;
6172                         }
6173                 }
6174
6175                 if (i == MAXPARMSIDS - 2) { /* to indicate the message type "Setup" */
6176                         Info_Number = 0x8000 | 5;
6177                         Info_Mask = 0x10;
6178                         Info_Element = "";
6179                 }
6180
6181                 if (Info_Sent_Flag && Info_Number) {
6182                         if (plci->adapter->Info_Mask[appl->Id - 1] & Info_Mask) {
6183                                 sendf(appl, _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
6184                         }
6185                 }
6186         }
6187 }
6188
6189
6190 static void SendInfo(PLCI *plci, dword Id, byte **parms, byte iesent)
6191 {
6192         word i;
6193         word j;
6194         word k;
6195         byte *ie;
6196         word Info_Number;
6197         byte *Info_Element;
6198         word Info_Mask = 0;
6199         static byte charges[5] = {4, 0, 0, 0, 0};
6200         static byte cause[] = {0x02, 0x80, 0x00};
6201         APPL *appl;
6202
6203         dbug(1, dprintf("InfoParse "));
6204
6205         if (
6206                 !plci->appl
6207                 && !plci->State
6208                 && plci->Sig.Ind != NCR_FACILITY
6209                 )
6210         {
6211                 dbug(1, dprintf("NoParse "));
6212                 return;
6213         }
6214         cause[2] = 0;
6215         for (i = 0; i < MAXPARMSIDS; i++) {
6216                 ie = parms[i];
6217                 Info_Number = 0;
6218                 Info_Element = ie;
6219                 if (ie[0]) {
6220                         switch (i) {
6221                         case 0:
6222                                 dbug(1, dprintf("CPN "));
6223                                 Info_Number = 0x0070;
6224                                 Info_Mask   = 0x80;
6225                                 break;
6226                         case 7: /* ESC_CAU */
6227                                 dbug(1, dprintf("cau(0x%x)", ie[2]));
6228                                 Info_Number = 0x0008;
6229                                 Info_Mask = 0x00;
6230                                 cause[2] = ie[2];
6231                                 Info_Element = NULL;
6232                                 break;
6233                         case 8:  /* display      */
6234                                 dbug(1, dprintf("display(%d)", i));
6235                                 Info_Number = 0x0028;
6236                                 Info_Mask = 0x04;
6237                                 break;
6238                         case 9:  /* Date display */
6239                                 dbug(1, dprintf("date(%d)", i));
6240                                 Info_Number = 0x0029;
6241                                 Info_Mask = 0x02;
6242                                 break;
6243                         case 10: /* charges */
6244                                 for (j = 0; j < 4; j++) charges[1 + j] = 0;
6245                                 for (j = 0; j < ie[0] && !(ie[1 + j] & 0x80); j++);
6246                                 for (k = 1, j++; j < ie[0] && k <= 4; j++, k++) charges[k] = ie[1 + j];
6247                                 Info_Number = 0x4000;
6248                                 Info_Mask = 0x40;
6249                                 Info_Element = charges;
6250                                 break;
6251                         case 11: /* user user info */
6252                                 dbug(1, dprintf("uui"));
6253                                 Info_Number = 0x007E;
6254                                 Info_Mask = 0x08;
6255                                 break;
6256                         case 12: /* congestion receiver ready */
6257                                 dbug(1, dprintf("clRDY"));
6258                                 Info_Number = 0x00B0;
6259                                 Info_Mask = 0x08;
6260                                 Info_Element = "";
6261                                 break;
6262                         case 13: /* congestion receiver not ready */
6263                                 dbug(1, dprintf("clNRDY"));
6264                                 Info_Number = 0x00BF;
6265                                 Info_Mask = 0x08;
6266                                 Info_Element = "";
6267                                 break;
6268                         case 15: /* Keypad Facility */
6269                                 dbug(1, dprintf("KEY"));
6270                                 Info_Number = 0x002C;
6271                                 Info_Mask = 0x20;
6272                                 break;
6273                         case 16: /* Channel Id */
6274                                 dbug(1, dprintf("CHI"));
6275                                 Info_Number = 0x0018;
6276                                 Info_Mask = 0x100;
6277                                 mixer_set_bchannel_id(plci, Info_Element);
6278                                 break;
6279                         case 17: /* if no 1tr6 cause, send full cause, else esc_cause */
6280                                 dbug(1, dprintf("q9cau(0x%x)", ie[2]));
6281                                 if (!cause[2] || cause[2] < 0x80) break;  /* eg. layer 1 error */
6282                                 Info_Number = 0x0008;
6283                                 Info_Mask = 0x01;
6284                                 if (cause[2] != ie[2]) Info_Element = cause;
6285                                 break;
6286                         case 19: /* Redirected Number */
6287                                 dbug(1, dprintf("RDN"));
6288                                 Info_Number = 0x0074;
6289                                 Info_Mask = 0x400;
6290                                 break;
6291                         case 22: /* Redirecing Number  */
6292                                 dbug(1, dprintf("RIN"));
6293                                 Info_Number = 0x0076;
6294                                 Info_Mask = 0x400;
6295                                 break;
6296                         case 23: /* Notification Indicator  */
6297                                 dbug(1, dprintf("NI"));
6298                                 Info_Number = (word)NI;
6299                                 Info_Mask = 0x210;
6300                                 break;
6301                         case 26: /* Call State  */
6302                                 dbug(1, dprintf("CST"));
6303                                 Info_Number = (word)CST;
6304                                 Info_Mask = 0x01; /* do with cause i.e. for now */
6305                                 break;
6306                         case MAXPARMSIDS - 2:  /* Escape Message Type, must be the last indication */
6307                                 dbug(1, dprintf("ESC/MT[0x%x]", ie[3]));
6308                                 Info_Number = 0x8000 | ie[3];
6309                                 if (iesent) Info_Mask = 0xffff;
6310                                 else  Info_Mask = 0x10;
6311                                 Info_Element = "";
6312                                 break;
6313                         default:
6314                                 Info_Number  = 0;
6315                                 Info_Mask    = 0;
6316                                 Info_Element = "";
6317                                 break;
6318                         }
6319                 }
6320
6321                 if (plci->Sig.Ind == NCR_FACILITY)           /* check controller broadcast */
6322                 {
6323                         for (j = 0; j < max_appl; j++)
6324                         {
6325                                 appl = &application[j];
6326                                 if (Info_Number
6327                                     && appl->Id
6328                                     && plci->adapter->Info_Mask[appl->Id - 1] & Info_Mask)
6329                                 {
6330                                         dbug(1, dprintf("NCR_Ind"));
6331                                         iesent = true;
6332                                         sendf(&application[j], _INFO_I, Id & 0x0f, 0, "wS", Info_Number, Info_Element);
6333                                 }
6334                         }
6335                 }
6336                 else if (!plci->appl)
6337                 { /* overlap receiving broadcast */
6338                         if (Info_Number == CPN
6339                             || Info_Number == KEY
6340                             || Info_Number == NI
6341                             || Info_Number == DSP
6342                             || Info_Number == UUI)
6343                         {
6344                                 for (j = 0; j < max_appl; j++)
6345                                 {
6346                                         if (test_c_ind_mask_bit(plci, j))
6347                                         {
6348                                                 dbug(1, dprintf("Ovl_Ind"));
6349                                                 iesent = true;
6350                                                 sendf(&application[j], _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
6351                                         }
6352                                 }
6353                         }
6354                 }               /* all other signalling states */
6355                 else if (Info_Number
6356                          && plci->adapter->Info_Mask[plci->appl->Id - 1] & Info_Mask)
6357                 {
6358                         dbug(1, dprintf("Std_Ind"));
6359                         iesent = true;
6360                         sendf(plci->appl, _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
6361                 }
6362         }
6363 }
6364
6365
6366 static byte SendMultiIE(PLCI *plci, dword Id, byte **parms, byte ie_type,
6367                         dword info_mask, byte setupParse)
6368 {
6369         word i;
6370         word j;
6371         byte *ie;
6372         word Info_Number;
6373         byte *Info_Element;
6374         APPL *appl;
6375         word Info_Mask = 0;
6376         byte iesent = 0;
6377
6378         if (
6379                 !plci->appl
6380                 && !plci->State
6381                 && plci->Sig.Ind != NCR_FACILITY
6382                 && !setupParse
6383                 )
6384         {
6385                 dbug(1, dprintf("NoM-IEParse "));
6386                 return 0;
6387         }
6388         dbug(1, dprintf("M-IEParse "));
6389
6390         for (i = 0; i < MAX_MULTI_IE; i++)
6391         {
6392                 ie = parms[i];
6393                 Info_Number = 0;
6394                 Info_Element = ie;
6395                 if (ie[0])
6396                 {
6397                         dbug(1, dprintf("[Ind0x%x]:IE=0x%x", plci->Sig.Ind, ie_type));
6398                         Info_Number = (word)ie_type;
6399                         Info_Mask = (word)info_mask;
6400                 }
6401
6402                 if (plci->Sig.Ind == NCR_FACILITY)           /* check controller broadcast */
6403                 {
6404                         for (j = 0; j < max_appl; j++)
6405                         {
6406                                 appl = &application[j];
6407                                 if (Info_Number
6408                                     && appl->Id
6409                                     && plci->adapter->Info_Mask[appl->Id - 1] & Info_Mask)
6410                                 {
6411                                         iesent = true;
6412                                         dbug(1, dprintf("Mlt_NCR_Ind"));
6413                                         sendf(&application[j], _INFO_I, Id & 0x0f, 0, "wS", Info_Number, Info_Element);
6414                                 }
6415                         }
6416                 }
6417                 else if (!plci->appl && Info_Number)
6418                 {                                        /* overlap receiving broadcast */
6419                         for (j = 0; j < max_appl; j++)
6420                         {
6421                                 if (test_c_ind_mask_bit(plci, j))
6422                                 {
6423                                         iesent = true;
6424                                         dbug(1, dprintf("Mlt_Ovl_Ind"));
6425                                         sendf(&application[j] , _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
6426                                 }
6427                         }
6428                 }                                        /* all other signalling states */
6429                 else if (Info_Number
6430                          && plci->adapter->Info_Mask[plci->appl->Id - 1] & Info_Mask)
6431                 {
6432                         iesent = true;
6433                         dbug(1, dprintf("Mlt_Std_Ind"));
6434                         sendf(plci->appl, _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
6435                 }
6436         }
6437         return iesent;
6438 }
6439
6440 static void SendSSExtInd(APPL *appl, PLCI *plci, dword Id, byte **parms)
6441 {
6442         word i;
6443         /* Format of multi_ssext_parms[i][]:
6444            0 byte length
6445            1 byte SSEXTIE
6446            2 byte SSEXT_REQ/SSEXT_IND
6447            3 byte length
6448            4 word SSExtCommand
6449            6... Params
6450         */
6451         if (
6452                 plci
6453                 && plci->State
6454                 && plci->Sig.Ind != NCR_FACILITY
6455                 )
6456                 for (i = 0; i < MAX_MULTI_IE; i++)
6457                 {
6458                         if (parms[i][0] < 6) continue;
6459                         if (parms[i][2] == SSEXT_REQ) continue;
6460
6461                         if (appl)
6462                         {
6463                                 parms[i][0] = 0; /* kill it */
6464                                 sendf(appl, _MANUFACTURER_I,
6465                                       Id,
6466                                       0,
6467                                       "dwS",
6468                                       _DI_MANU_ID,
6469                                       _DI_SSEXT_CTRL,
6470                                       &parms[i][3]);
6471                         }
6472                         else if (plci->appl)
6473                         {
6474                                 parms[i][0] = 0; /* kill it */
6475                                 sendf(plci->appl, _MANUFACTURER_I,
6476                                       Id,
6477                                       0,
6478                                       "dwS",
6479                                       _DI_MANU_ID,
6480                                       _DI_SSEXT_CTRL,
6481                                       &parms[i][3]);
6482                         }
6483                 }
6484 };
6485
6486 static void nl_ind(PLCI *plci)
6487 {
6488         byte ch;
6489         word ncci;
6490         dword Id;
6491         DIVA_CAPI_ADAPTER *a;
6492         word NCCIcode;
6493         APPL *APPLptr;
6494         word count;
6495         word Num;
6496         word i, ncpi_state;
6497         byte len, ncci_state;
6498         word msg;
6499         word info = 0;
6500         word fax_feature_bits;
6501         byte fax_send_edata_ack;
6502         static byte v120_header_buffer[2 + 3];
6503         static word fax_info[] = {
6504                 0,                     /* T30_SUCCESS                        */
6505                 _FAX_NO_CONNECTION,    /* T30_ERR_NO_DIS_RECEIVED            */
6506                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_TIMEOUT_NO_RESPONSE        */
6507                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_RESPONSE          */
6508                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_TOO_MANY_REPEATS           */
6509                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_UNEXPECTED_MESSAGE         */
6510                 _FAX_REMOTE_ABORT,     /* T30_ERR_UNEXPECTED_DCN             */
6511                 _FAX_LOCAL_ABORT,      /* T30_ERR_DTC_UNSUPPORTED            */
6512                 _FAX_TRAINING_ERROR,   /* T30_ERR_ALL_RATES_FAILED           */
6513                 _FAX_TRAINING_ERROR,   /* T30_ERR_TOO_MANY_TRAINS            */
6514                 _FAX_PARAMETER_ERROR,  /* T30_ERR_RECEIVE_CORRUPTED          */
6515                 _FAX_REMOTE_ABORT,     /* T30_ERR_UNEXPECTED_DISC            */
6516                 _FAX_LOCAL_ABORT,      /* T30_ERR_APPLICATION_DISC           */
6517                 _FAX_REMOTE_REJECT,    /* T30_ERR_INCOMPATIBLE_DIS           */
6518                 _FAX_LOCAL_ABORT,      /* T30_ERR_INCOMPATIBLE_DCS           */
6519                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_TIMEOUT_NO_COMMAND         */
6520                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_COMMAND           */
6521                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_TIMEOUT_COMMAND_TOO_LONG   */
6522                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_TIMEOUT_RESPONSE_TOO_LONG  */
6523                 _FAX_NO_CONNECTION,    /* T30_ERR_NOT_IDENTIFIED             */
6524                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_SUPERVISORY_TIMEOUT        */
6525                 _FAX_PARAMETER_ERROR,  /* T30_ERR_TOO_LONG_SCAN_LINE         */
6526                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_PAGE_AFTER_MPS    */
6527                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_PAGE_AFTER_CFR    */
6528                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_DCS_AFTER_FTT     */
6529                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_DCS_AFTER_EOM     */
6530                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_DCS_AFTER_MPS     */
6531                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_DCN_AFTER_MCF     */
6532                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_DCN_AFTER_RTN     */
6533                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_CFR               */
6534                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_MCF_AFTER_EOP     */
6535                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_MCF_AFTER_EOM     */
6536                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_RETRY_NO_MCF_AFTER_MPS     */
6537                 0x331d,                /* T30_ERR_SUB_SEP_UNSUPPORTED        */
6538                 0x331e,                /* T30_ERR_PWD_UNSUPPORTED            */
6539                 0x331f,                /* T30_ERR_SUB_SEP_PWD_UNSUPPORTED    */
6540                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_INVALID_COMMAND_FRAME      */
6541                 _FAX_PARAMETER_ERROR,  /* T30_ERR_UNSUPPORTED_PAGE_CODING    */
6542                 _FAX_PARAMETER_ERROR,  /* T30_ERR_INVALID_PAGE_CODING        */
6543                 _FAX_REMOTE_REJECT,    /* T30_ERR_INCOMPATIBLE_PAGE_CONFIG   */
6544                 _FAX_LOCAL_ABORT,      /* T30_ERR_TIMEOUT_FROM_APPLICATION   */
6545                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_V34FAX_NO_REACTION_ON_MARK */
6546                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_V34FAX_TRAINING_TIMEOUT    */
6547                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_V34FAX_UNEXPECTED_V21      */
6548                 _FAX_PROTOCOL_ERROR,   /* T30_ERR_V34FAX_PRIMARY_CTS_ON      */
6549                 _FAX_LOCAL_ABORT,      /* T30_ERR_V34FAX_TURNAROUND_POLLING  */
6550                 _FAX_LOCAL_ABORT       /* T30_ERR_V34FAX_V8_INCOMPATIBILITY  */
6551         };
6552
6553         byte dtmf_code_buffer[CAPIDTMF_RECV_DIGIT_BUFFER_SIZE + 1];
6554
6555
6556         static word rtp_info[] = {
6557                 GOOD,                  /* RTP_SUCCESS                       */
6558                 0x3600                 /* RTP_ERR_SSRC_OR_PAYLOAD_CHANGE    */
6559         };
6560
6561         static dword udata_forwarding_table[0x100 / sizeof(dword)] =
6562                 {
6563                         0x0020301e, 0x00000000, 0x00000000, 0x00000000,
6564                         0x00000000, 0x00000000, 0x00000000, 0x00000000
6565                 };
6566
6567         ch = plci->NL.IndCh;
6568         a = plci->adapter;
6569         ncci = a->ch_ncci[ch];
6570         Id = (((dword)(ncci ? ncci : ch)) << 16) | (((word) plci->Id) << 8) | a->Id;
6571         if (plci->tel) Id |= EXT_CONTROLLER;
6572         APPLptr = plci->appl;
6573         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",
6574                         plci->NL.Id, Id, plci->Id, plci->tel, plci->State, ch, plci->channels, plci->NL.Ind & 0x0f));
6575
6576         /* in the case if no connect_active_Ind was sent to the appl we wait for */
6577
6578         if (plci->nl_remove_id)
6579         {
6580                 plci->NL.RNR = 2; /* discard */
6581                 dbug(1, dprintf("NL discard while remove pending"));
6582                 return;
6583         }
6584         if ((plci->NL.Ind & 0x0f) == N_CONNECT)
6585         {
6586                 if (plci->State == INC_DIS_PENDING
6587                     || plci->State == OUTG_DIS_PENDING
6588                     || plci->State == IDLE)
6589                 {
6590                         plci->NL.RNR = 2; /* discard */
6591                         dbug(1, dprintf("discard n_connect"));
6592                         return;
6593                 }
6594                 if (plci->State < INC_ACT_PENDING)
6595                 {
6596                         plci->NL.RNR = 1; /* flow control */
6597                         channel_x_off(plci, ch, N_XON_CONNECT_IND);
6598                         return;
6599                 }
6600         }
6601
6602         if (!APPLptr)                         /* no application or invalid data */
6603         {                                    /* while reloading the DSP        */
6604                 dbug(1, dprintf("discard1"));
6605                 plci->NL.RNR = 2;
6606                 return;
6607         }
6608
6609         if (((plci->NL.Ind & 0x0f) == N_UDATA)
6610             && (((plci->B2_prot != B2_SDLC) && ((plci->B1_resource == 17) || (plci->B1_resource == 18)))
6611                 || (plci->B2_prot == 7)
6612                 || (plci->B3_prot == 7)))
6613         {
6614                 plci->ncpi_buffer[0] = 0;
6615
6616                 ncpi_state = plci->ncpi_state;
6617                 if (plci->NL.complete == 1)
6618                 {
6619                         byte *data = &plci->NL.RBuffer->P[0];
6620
6621                         if ((plci->NL.RBuffer->length >= 12)
6622                             && ((*data == DSP_UDATA_INDICATION_DCD_ON)
6623                                 || (*data == DSP_UDATA_INDICATION_CTS_ON)))
6624                         {
6625                                 word conn_opt, ncpi_opt = 0x00;
6626 /*      HexDump ("MDM N_UDATA:", plci->NL.RBuffer->length, data); */
6627
6628                                 if (*data == DSP_UDATA_INDICATION_DCD_ON)
6629                                         plci->ncpi_state |= NCPI_MDM_DCD_ON_RECEIVED;
6630                                 if (*data == DSP_UDATA_INDICATION_CTS_ON)
6631                                         plci->ncpi_state |= NCPI_MDM_CTS_ON_RECEIVED;
6632
6633                                 data++;    /* indication code */
6634                                 data += 2; /* timestamp */
6635                                 if ((*data == DSP_CONNECTED_NORM_V18) || (*data == DSP_CONNECTED_NORM_VOWN))
6636                                         ncpi_state &= ~(NCPI_MDM_DCD_ON_RECEIVED | NCPI_MDM_CTS_ON_RECEIVED);
6637                                 data++;    /* connected norm */
6638                                 conn_opt = GET_WORD(data);
6639                                 data += 2; /* connected options */
6640
6641                                 PUT_WORD(&(plci->ncpi_buffer[1]), (word)(GET_DWORD(data) & 0x0000FFFF));
6642
6643                                 if (conn_opt & DSP_CONNECTED_OPTION_MASK_V42)
6644                                 {
6645                                         ncpi_opt |= MDM_NCPI_ECM_V42;
6646                                 }
6647                                 else if (conn_opt & DSP_CONNECTED_OPTION_MASK_MNP)
6648                                 {
6649                                         ncpi_opt |= MDM_NCPI_ECM_MNP;
6650                                 }
6651                                 else
6652                                 {
6653                                         ncpi_opt |= MDM_NCPI_TRANSPARENT;
6654                                 }
6655                                 if (conn_opt & DSP_CONNECTED_OPTION_MASK_COMPRESSION)
6656                                 {
6657                                         ncpi_opt |= MDM_NCPI_COMPRESSED;
6658                                 }
6659                                 PUT_WORD(&(plci->ncpi_buffer[3]), ncpi_opt);
6660                                 plci->ncpi_buffer[0] = 4;
6661
6662                                 plci->ncpi_state |= NCPI_VALID_CONNECT_B3_IND | NCPI_VALID_CONNECT_B3_ACT | NCPI_VALID_DISC_B3_IND;
6663                         }
6664                 }
6665                 if (plci->B3_prot == 7)
6666                 {
6667                         if (((a->ncci_state[ncci] == INC_ACT_PENDING) || (a->ncci_state[ncci] == OUTG_CON_PENDING))
6668                             && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6669                             && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6670                         {
6671                                 a->ncci_state[ncci] = INC_ACT_PENDING;
6672                                 sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
6673                                 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6674                         }
6675                 }
6676
6677                 if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
6678                       & ((1L << PRIVATE_V18) | (1L << PRIVATE_VOWN)))
6679                     || !(ncpi_state & NCPI_MDM_DCD_ON_RECEIVED)
6680                     || !(ncpi_state & NCPI_MDM_CTS_ON_RECEIVED))
6681
6682                 {
6683                         plci->NL.RNR = 2;
6684                         return;
6685                 }
6686         }
6687
6688         if (plci->NL.complete == 2)
6689         {
6690                 if (((plci->NL.Ind & 0x0f) == N_UDATA)
6691                     && !(udata_forwarding_table[plci->RData[0].P[0] >> 5] & (1L << (plci->RData[0].P[0] & 0x1f))))
6692                 {
6693                         switch (plci->RData[0].P[0])
6694                         {
6695
6696                         case DTMF_UDATA_INDICATION_FAX_CALLING_TONE:
6697                                 if (plci->dtmf_rec_active & DTMF_LISTEN_ACTIVE_FLAG)
6698                                         sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", SELECTOR_DTMF, "\x01X");
6699                                 break;
6700                         case DTMF_UDATA_INDICATION_ANSWER_TONE:
6701                                 if (plci->dtmf_rec_active & DTMF_LISTEN_ACTIVE_FLAG)
6702                                         sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", SELECTOR_DTMF, "\x01Y");
6703                                 break;
6704                         case DTMF_UDATA_INDICATION_DIGITS_RECEIVED:
6705                                 dtmf_indication(Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6706                                 break;
6707                         case DTMF_UDATA_INDICATION_DIGITS_SENT:
6708                                 dtmf_confirmation(Id, plci);
6709                                 break;
6710
6711
6712                         case UDATA_INDICATION_MIXER_TAP_DATA:
6713                                 capidtmf_recv_process_block(&(plci->capidtmf_state), plci->RData[0].P + 1, (word)(plci->RData[0].PLength - 1));
6714                                 i = capidtmf_indication(&(plci->capidtmf_state), dtmf_code_buffer + 1);
6715                                 if (i != 0)
6716                                 {
6717                                         dtmf_code_buffer[0] = DTMF_UDATA_INDICATION_DIGITS_RECEIVED;
6718                                         dtmf_indication(Id, plci, dtmf_code_buffer, (word)(i + 1));
6719                                 }
6720                                 break;
6721
6722
6723                         case UDATA_INDICATION_MIXER_COEFS_SET:
6724                                 mixer_indication_coefs_set(Id, plci);
6725                                 break;
6726                         case UDATA_INDICATION_XCONNECT_FROM:
6727                                 mixer_indication_xconnect_from(Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6728                                 break;
6729                         case UDATA_INDICATION_XCONNECT_TO:
6730                                 mixer_indication_xconnect_to(Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6731                                 break;
6732
6733
6734                         case LEC_UDATA_INDICATION_DISABLE_DETECT:
6735                                 ec_indication(Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6736                                 break;
6737
6738
6739
6740                         default:
6741                                 break;
6742                         }
6743                 }
6744                 else
6745                 {
6746                         if ((plci->RData[0].PLength != 0)
6747                             && ((plci->B2_prot == B2_V120_ASYNC)
6748                                 || (plci->B2_prot == B2_V120_ASYNC_V42BIS)
6749                                 || (plci->B2_prot == B2_V120_BIT_TRANSPARENT)))
6750                         {
6751
6752                                 sendf(plci->appl, _DATA_B3_I, Id, 0,
6753                                       "dwww",
6754                                       plci->RData[1].P,
6755                                       (plci->NL.RNum < 2) ? 0 : plci->RData[1].PLength,
6756                                       plci->RNum,
6757                                       plci->RFlags);
6758
6759                         }
6760                         else
6761                         {
6762
6763                                 sendf(plci->appl, _DATA_B3_I, Id, 0,
6764                                       "dwww",
6765                                       plci->RData[0].P,
6766                                       plci->RData[0].PLength,
6767                                       plci->RNum,
6768                                       plci->RFlags);
6769
6770                         }
6771                 }
6772                 return;
6773         }
6774
6775         fax_feature_bits = 0;
6776         if ((plci->NL.Ind & 0x0f) == N_CONNECT ||
6777             (plci->NL.Ind & 0x0f) == N_CONNECT_ACK ||
6778             (plci->NL.Ind & 0x0f) == N_DISC ||
6779             (plci->NL.Ind & 0x0f) == N_EDATA ||
6780             (plci->NL.Ind & 0x0f) == N_DISC_ACK)
6781         {
6782                 info = 0;
6783                 plci->ncpi_buffer[0] = 0;
6784                 switch (plci->B3_prot) {
6785                 case  0: /*XPARENT*/
6786                 case  1: /*T.90 NL*/
6787                         break;    /* no network control protocol info - jfr */
6788                 case  2: /*ISO8202*/
6789                 case  3: /*X25 DCE*/
6790                         for (i = 0; i < plci->NL.RLength; i++) plci->ncpi_buffer[4 + i] = plci->NL.RBuffer->P[i];
6791                         plci->ncpi_buffer[0] = (byte)(i + 3);
6792                         plci->ncpi_buffer[1] = (byte)(plci->NL.Ind & N_D_BIT ? 1 : 0);
6793                         plci->ncpi_buffer[2] = 0;
6794                         plci->ncpi_buffer[3] = 0;
6795                         break;
6796                 case  4: /*T.30 - FAX*/
6797                 case  5: /*T.30 - FAX*/
6798                         if (plci->NL.RLength >= sizeof(T30_INFO))
6799                         {
6800                                 dbug(1, dprintf("FaxStatus %04x", ((T30_INFO *)plci->NL.RBuffer->P)->code));
6801                                 len = 9;
6802                                 PUT_WORD(&(plci->ncpi_buffer[1]), ((T30_INFO *)plci->NL.RBuffer->P)->rate_div_2400 * 2400);
6803                                 fax_feature_bits = GET_WORD(&((T30_INFO *)plci->NL.RBuffer->P)->feature_bits_low);
6804                                 i = (((T30_INFO *)plci->NL.RBuffer->P)->resolution & T30_RESOLUTION_R8_0770_OR_200) ? 0x0001 : 0x0000;
6805                                 if (plci->B3_prot == 5)
6806                                 {
6807                                         if (!(fax_feature_bits & T30_FEATURE_BIT_ECM))
6808                                                 i |= 0x8000; /* This is not an ECM connection */
6809                                         if (fax_feature_bits & T30_FEATURE_BIT_T6_CODING)
6810                                                 i |= 0x4000; /* This is a connection with MMR compression */
6811                                         if (fax_feature_bits & T30_FEATURE_BIT_2D_CODING)
6812                                                 i |= 0x2000; /* This is a connection with MR compression */
6813                                         if (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS)
6814                                                 i |= 0x0004; /* More documents */
6815                                         if (fax_feature_bits & T30_FEATURE_BIT_POLLING)
6816                                                 i |= 0x0002; /* Fax-polling indication */
6817                                 }
6818                                 dbug(1, dprintf("FAX Options %04x %04x", fax_feature_bits, i));
6819                                 PUT_WORD(&(plci->ncpi_buffer[3]), i);
6820                                 PUT_WORD(&(plci->ncpi_buffer[5]), ((T30_INFO *)plci->NL.RBuffer->P)->data_format);
6821                                 plci->ncpi_buffer[7] = ((T30_INFO *)plci->NL.RBuffer->P)->pages_low;
6822                                 plci->ncpi_buffer[8] = ((T30_INFO *)plci->NL.RBuffer->P)->pages_high;
6823                                 plci->ncpi_buffer[len] = 0;
6824                                 if (((T30_INFO *)plci->NL.RBuffer->P)->station_id_len)
6825                                 {
6826                                         plci->ncpi_buffer[len] = 20;
6827                                         for (i = 0; i < T30_MAX_STATION_ID_LENGTH; i++)
6828                                                 plci->ncpi_buffer[++len] = ((T30_INFO *)plci->NL.RBuffer->P)->station_id[i];
6829                                 }
6830                                 if (((plci->NL.Ind & 0x0f) == N_DISC) || ((plci->NL.Ind & 0x0f) == N_DISC_ACK))
6831                                 {
6832                                         if (((T30_INFO *)plci->NL.RBuffer->P)->code < ARRAY_SIZE(fax_info))
6833                                                 info = fax_info[((T30_INFO *)plci->NL.RBuffer->P)->code];
6834                                         else
6835                                                 info = _FAX_PROTOCOL_ERROR;
6836                                 }
6837
6838                                 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id - 1])
6839                                     & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
6840                                 {
6841                                         i = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + ((T30_INFO *)plci->NL.RBuffer->P)->head_line_len;
6842                                         while (i < plci->NL.RBuffer->length)
6843                                                 plci->ncpi_buffer[++len] = plci->NL.RBuffer->P[i++];
6844                                 }
6845
6846                                 plci->ncpi_buffer[0] = len;
6847                                 fax_feature_bits = GET_WORD(&((T30_INFO *)plci->NL.RBuffer->P)->feature_bits_low);
6848                                 PUT_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->feature_bits_low, fax_feature_bits);
6849
6850                                 plci->ncpi_state |= NCPI_VALID_CONNECT_B3_IND;
6851                                 if (((plci->NL.Ind & 0x0f) == N_CONNECT_ACK)
6852                                     || (((plci->NL.Ind & 0x0f) == N_CONNECT)
6853                                         && (fax_feature_bits & T30_FEATURE_BIT_POLLING))
6854                                     || (((plci->NL.Ind & 0x0f) == N_EDATA)
6855                                         && ((((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_TRAIN_OK)
6856                                             || (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_DIS)
6857                                             || (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_DTC))))
6858                                 {
6859                                         plci->ncpi_state |= NCPI_VALID_CONNECT_B3_ACT;
6860                                 }
6861                                 if (((plci->NL.Ind & 0x0f) == N_DISC)
6862                                     || ((plci->NL.Ind & 0x0f) == N_DISC_ACK)
6863                                     || (((plci->NL.Ind & 0x0f) == N_EDATA)
6864                                         && (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_EOP_CAPI)))
6865                                 {
6866                                         plci->ncpi_state |= NCPI_VALID_CONNECT_B3_ACT | NCPI_VALID_DISC_B3_IND;
6867                                 }
6868                         }
6869                         break;
6870
6871                 case B3_RTP:
6872                         if (((plci->NL.Ind & 0x0f) == N_DISC) || ((plci->NL.Ind & 0x0f) == N_DISC_ACK))
6873                         {
6874                                 if (plci->NL.RLength != 0)
6875                                 {
6876                                         info = rtp_info[plci->NL.RBuffer->P[0]];
6877                                         plci->ncpi_buffer[0] = plci->NL.RLength - 1;
6878                                         for (i = 1; i < plci->NL.RLength; i++)
6879                                                 plci->ncpi_buffer[i] = plci->NL.RBuffer->P[i];
6880                                 }
6881                         }
6882                         break;
6883
6884                 }
6885                 plci->NL.RNR = 2;
6886         }
6887         switch (plci->NL.Ind & 0x0f) {
6888         case N_EDATA:
6889                 if ((plci->B3_prot == 4) || (plci->B3_prot == 5))
6890                 {
6891                         dbug(1, dprintf("EDATA ncci=0x%x state=%d code=%02x", ncci, a->ncci_state[ncci],
6892                                         ((T30_INFO *)plci->NL.RBuffer->P)->code));
6893                         fax_send_edata_ack = (((T30_INFO *)(plci->fax_connect_info_buffer))->operating_mode == T30_OPERATING_MODE_CAPI_NEG);
6894
6895                         if ((plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF)
6896                             && (plci->nsf_control_bits & (T30_NSF_CONTROL_BIT_NEGOTIATE_IND | T30_NSF_CONTROL_BIT_NEGOTIATE_RESP))
6897                             && (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_DIS)
6898                             && (a->ncci_state[ncci] == OUTG_CON_PENDING)
6899                             && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6900                             && !(plci->ncpi_state & NCPI_NEGOTIATE_B3_SENT))
6901                         {
6902                                 ((T30_INFO *)(plci->fax_connect_info_buffer))->code = ((T30_INFO *)plci->NL.RBuffer->P)->code;
6903                                 sendf(plci->appl, _MANUFACTURER_I, Id, 0, "dwbS", _DI_MANU_ID, _DI_NEGOTIATE_B3,
6904                                       (byte)(plci->ncpi_buffer[0] + 1), plci->ncpi_buffer);
6905                                 plci->ncpi_state |= NCPI_NEGOTIATE_B3_SENT;
6906                                 if (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP)
6907                                         fax_send_edata_ack = false;
6908                         }
6909
6910                         if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
6911                         {
6912                                 switch (((T30_INFO *)plci->NL.RBuffer->P)->code)
6913                                 {
6914                                 case EDATA_T30_DIS:
6915                                         if ((a->ncci_state[ncci] == OUTG_CON_PENDING)
6916                                             && !(GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low) & T30_CONTROL_BIT_REQUEST_POLLING)
6917                                             && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6918                                             && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6919                                         {
6920                                                 a->ncci_state[ncci] = INC_ACT_PENDING;
6921                                                 if (plci->B3_prot == 4)
6922                                                         sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
6923                                                 else
6924                                                         sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
6925                                                 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6926                                         }
6927                                         break;
6928
6929                                 case EDATA_T30_TRAIN_OK:
6930                                         if ((a->ncci_state[ncci] == INC_ACT_PENDING)
6931                                             && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6932                                             && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6933                                         {
6934                                                 if (plci->B3_prot == 4)
6935                                                         sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
6936                                                 else
6937                                                         sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
6938                                                 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6939                                         }
6940                                         break;
6941
6942                                 case EDATA_T30_EOP_CAPI:
6943                                         if (a->ncci_state[ncci] == CONNECTED)
6944                                         {
6945                                                 sendf(plci->appl, _DISCONNECT_B3_I, Id, 0, "wS", GOOD, plci->ncpi_buffer);
6946                                                 a->ncci_state[ncci] = INC_DIS_PENDING;
6947                                                 plci->ncpi_state = 0;
6948                                                 fax_send_edata_ack = false;
6949                                         }
6950                                         break;
6951                                 }
6952                         }
6953                         else
6954                         {
6955                                 switch (((T30_INFO *)plci->NL.RBuffer->P)->code)
6956                                 {
6957                                 case EDATA_T30_TRAIN_OK:
6958                                         if ((a->ncci_state[ncci] == INC_ACT_PENDING)
6959                                             && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6960                                             && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6961                                         {
6962                                                 if (plci->B3_prot == 4)
6963                                                         sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
6964                                                 else
6965                                                         sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
6966                                                 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6967                                         }
6968                                         break;
6969                                 }
6970                         }
6971                         if (fax_send_edata_ack)
6972                         {
6973                                 ((T30_INFO *)(plci->fax_connect_info_buffer))->code = ((T30_INFO *)plci->NL.RBuffer->P)->code;
6974                                 plci->fax_edata_ack_length = 1;
6975                                 start_internal_command(Id, plci, fax_edata_ack_command);
6976                         }
6977                 }
6978                 else
6979                 {
6980                         dbug(1, dprintf("EDATA ncci=0x%x state=%d", ncci, a->ncci_state[ncci]));
6981                 }
6982                 break;
6983         case N_CONNECT:
6984                 if (!a->ch_ncci[ch])
6985                 {
6986                         ncci = get_ncci(plci, ch, 0);
6987                         Id = (Id & 0xffff) | (((dword) ncci) << 16);
6988                 }
6989                 dbug(1, dprintf("N_CONNECT: ch=%d state=%d plci=%lx plci_Id=%lx plci_State=%d",
6990                                 ch, a->ncci_state[ncci], a->ncci_plci[ncci], plci->Id, plci->State));
6991
6992                 msg = _CONNECT_B3_I;
6993                 if (a->ncci_state[ncci] == IDLE)
6994                         plci->channels++;
6995                 else if (plci->B3_prot == 1)
6996                         msg = _CONNECT_B3_T90_ACTIVE_I;
6997
6998                 a->ncci_state[ncci] = INC_CON_PENDING;
6999                 if (plci->B3_prot == 4)
7000                         sendf(plci->appl, msg, Id, 0, "s", "");
7001                 else
7002                         sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer);
7003                 break;
7004         case N_CONNECT_ACK:
7005                 dbug(1, dprintf("N_connect_Ack"));
7006                 if (plci->internal_command_queue[0]
7007                     && ((plci->adjust_b_state == ADJUST_B_CONNECT_2)
7008                         || (plci->adjust_b_state == ADJUST_B_CONNECT_3)
7009                         || (plci->adjust_b_state == ADJUST_B_CONNECT_4)))
7010                 {
7011                         (*(plci->internal_command_queue[0]))(Id, plci, 0);
7012                         if (!plci->internal_command)
7013                                 next_internal_command(Id, plci);
7014                         break;
7015                 }
7016                 msg = _CONNECT_B3_ACTIVE_I;
7017                 if (plci->B3_prot == 1)
7018                 {
7019                         if (a->ncci_state[ncci] != OUTG_CON_PENDING)
7020                                 msg = _CONNECT_B3_T90_ACTIVE_I;
7021                         a->ncci_state[ncci] = INC_ACT_PENDING;
7022                         sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer);
7023                 }
7024                 else if ((plci->B3_prot == 4) || (plci->B3_prot == 5) || (plci->B3_prot == 7))
7025                 {
7026                         if ((a->ncci_state[ncci] == OUTG_CON_PENDING)
7027                             && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
7028                             && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
7029                         {
7030                                 a->ncci_state[ncci] = INC_ACT_PENDING;
7031                                 if (plci->B3_prot == 4)
7032                                         sendf(plci->appl, msg, Id, 0, "s", "");
7033                                 else
7034                                         sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer);
7035                                 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
7036                         }
7037                 }
7038                 else
7039                 {
7040                         a->ncci_state[ncci] = INC_ACT_PENDING;
7041                         sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer);
7042                 }
7043                 if (plci->adjust_b_restore)
7044                 {
7045                         plci->adjust_b_restore = false;
7046                         start_internal_command(Id, plci, adjust_b_restore);
7047                 }
7048                 break;
7049         case N_DISC:
7050         case N_DISC_ACK:
7051                 if (plci->internal_command_queue[0]
7052                     && ((plci->internal_command == FAX_DISCONNECT_COMMAND_1)
7053                         || (plci->internal_command == FAX_DISCONNECT_COMMAND_2)
7054                         || (plci->internal_command == FAX_DISCONNECT_COMMAND_3)))
7055                 {
7056                         (*(plci->internal_command_queue[0]))(Id, plci, 0);
7057                         if (!plci->internal_command)
7058                                 next_internal_command(Id, plci);
7059                 }
7060                 ncci_state = a->ncci_state[ncci];
7061                 ncci_remove(plci, ncci, false);
7062
7063                 /* with N_DISC or N_DISC_ACK the IDI frees the respective   */
7064                 /* channel, so we cannot store the state in ncci_state! The */
7065                 /* information which channel we received a N_DISC is thus   */
7066                 /* stored in the inc_dis_ncci_table buffer.                 */
7067                 for (i = 0; plci->inc_dis_ncci_table[i]; i++);
7068                 plci->inc_dis_ncci_table[i] = (byte) ncci;
7069
7070                 /* need a connect_b3_ind before a disconnect_b3_ind with FAX */
7071                 if (!plci->channels
7072                     && (plci->B1_resource == 16)
7073                     && (plci->State <= CONNECTED))
7074                 {
7075                         len = 9;
7076                         i = ((T30_INFO *)plci->fax_connect_info_buffer)->rate_div_2400 * 2400;
7077                         PUT_WORD(&plci->ncpi_buffer[1], i);
7078                         PUT_WORD(&plci->ncpi_buffer[3], 0);
7079                         i = ((T30_INFO *)plci->fax_connect_info_buffer)->data_format;
7080                         PUT_WORD(&plci->ncpi_buffer[5], i);
7081                         PUT_WORD(&plci->ncpi_buffer[7], 0);
7082                         plci->ncpi_buffer[len] = 0;
7083                         plci->ncpi_buffer[0] = len;
7084                         if (plci->B3_prot == 4)
7085                                 sendf(plci->appl, _CONNECT_B3_I, Id, 0, "s", "");
7086                         else
7087                         {
7088
7089                                 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id - 1])
7090                                     & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
7091                                 {
7092                                         plci->ncpi_buffer[++len] = 0;
7093                                         plci->ncpi_buffer[++len] = 0;
7094                                         plci->ncpi_buffer[++len] = 0;
7095                                         plci->ncpi_buffer[0] = len;
7096                                 }
7097
7098                                 sendf(plci->appl, _CONNECT_B3_I, Id, 0, "S", plci->ncpi_buffer);
7099                         }
7100                         sendf(plci->appl, _DISCONNECT_B3_I, Id, 0, "wS", info, plci->ncpi_buffer);
7101                         plci->ncpi_state = 0;
7102                         sig_req(plci, HANGUP, 0);
7103                         send_req(plci);
7104                         plci->State = OUTG_DIS_PENDING;
7105                         /* disc here */
7106                 }
7107                 else if ((a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
7108                          && ((plci->B3_prot == 4) || (plci->B3_prot == 5))
7109                          && ((ncci_state == INC_DIS_PENDING) || (ncci_state == IDLE)))
7110                 {
7111                         if (ncci_state == IDLE)
7112                         {
7113                                 if (plci->channels)
7114                                         plci->channels--;
7115                                 if ((plci->State == IDLE || plci->State == SUSPENDING) && !plci->channels) {
7116                                         if (plci->State == SUSPENDING) {
7117                                                 sendf(plci->appl,
7118                                                       _FACILITY_I,
7119                                                       Id & 0xffffL,
7120                                                       0,
7121                                                       "ws", (word)3, "\x03\x04\x00\x00");
7122                                                 sendf(plci->appl, _DISCONNECT_I, Id & 0xffffL, 0, "w", 0);
7123                                         }
7124                                         plci_remove(plci);
7125                                         plci->State = IDLE;
7126                                 }
7127                         }
7128                 }
7129                 else if (plci->channels)
7130                 {
7131                         sendf(plci->appl, _DISCONNECT_B3_I, Id, 0, "wS", info, plci->ncpi_buffer);
7132                         plci->ncpi_state = 0;
7133                         if ((ncci_state == OUTG_REJ_PENDING)
7134                             && ((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE)))
7135                         {
7136                                 sig_req(plci, HANGUP, 0);
7137                                 send_req(plci);
7138                                 plci->State = OUTG_DIS_PENDING;
7139                         }
7140                 }
7141                 break;
7142         case N_RESET:
7143                 a->ncci_state[ncci] = INC_RES_PENDING;
7144                 sendf(plci->appl, _RESET_B3_I, Id, 0, "S", plci->ncpi_buffer);
7145                 break;
7146         case N_RESET_ACK:
7147                 a->ncci_state[ncci] = CONNECTED;
7148                 sendf(plci->appl, _RESET_B3_I, Id, 0, "S", plci->ncpi_buffer);
7149                 break;
7150
7151         case N_UDATA:
7152                 if (!(udata_forwarding_table[plci->NL.RBuffer->P[0] >> 5] & (1L << (plci->NL.RBuffer->P[0] & 0x1f))))
7153                 {
7154                         plci->RData[0].P = plci->internal_ind_buffer + (-((int)(long)(plci->internal_ind_buffer)) & 3);
7155                         plci->RData[0].PLength = INTERNAL_IND_BUFFER_SIZE;
7156                         plci->NL.R = plci->RData;
7157                         plci->NL.RNum = 1;
7158                         return;
7159                 }
7160         case N_BDATA:
7161         case N_DATA:
7162                 if (((a->ncci_state[ncci] != CONNECTED) && (plci->B2_prot == 1)) /* transparent */
7163                     || (a->ncci_state[ncci] == IDLE)
7164                     || (a->ncci_state[ncci] == INC_DIS_PENDING))
7165                 {
7166                         plci->NL.RNR = 2;
7167                         break;
7168                 }
7169                 if ((a->ncci_state[ncci] != CONNECTED)
7170                     && (a->ncci_state[ncci] != OUTG_DIS_PENDING)
7171                     && (a->ncci_state[ncci] != OUTG_REJ_PENDING))
7172                 {
7173                         dbug(1, dprintf("flow control"));
7174                         plci->NL.RNR = 1; /* flow control  */
7175                         channel_x_off(plci, ch, 0);
7176                         break;
7177                 }
7178
7179                 NCCIcode = ncci | (((word)a->Id) << 8);
7180
7181                 /* count all buffers within the Application pool    */
7182                 /* belonging to the same NCCI. If this is below the */
7183                 /* number of buffers available per NCCI we accept   */
7184                 /* this packet, otherwise we reject it              */
7185                 count = 0;
7186                 Num = 0xffff;
7187                 for (i = 0; i < APPLptr->MaxBuffer; i++) {
7188                         if (NCCIcode == APPLptr->DataNCCI[i]) count++;
7189                         if (!APPLptr->DataNCCI[i] && Num == 0xffff) Num = i;
7190                 }
7191
7192                 if (count >= APPLptr->MaxNCCIData || Num == 0xffff)
7193                 {
7194                         dbug(3, dprintf("Flow-Control"));
7195                         plci->NL.RNR = 1;
7196                         if (++(APPLptr->NCCIDataFlowCtrlTimer) >=
7197                             (word)((a->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL) ? 40 : 2000))
7198                         {
7199                                 plci->NL.RNR = 2;
7200                                 dbug(3, dprintf("DiscardData"));
7201                         } else {
7202                                 channel_x_off(plci, ch, 0);
7203                         }
7204                         break;
7205                 }
7206                 else
7207                 {
7208                         APPLptr->NCCIDataFlowCtrlTimer = 0;
7209                 }
7210
7211                 plci->RData[0].P = ReceiveBufferGet(APPLptr, Num);
7212                 if (!plci->RData[0].P) {
7213                         plci->NL.RNR = 1;
7214                         channel_x_off(plci, ch, 0);
7215                         break;
7216                 }
7217
7218                 APPLptr->DataNCCI[Num] = NCCIcode;
7219                 APPLptr->DataFlags[Num] = (plci->Id << 8) | (plci->NL.Ind >> 4);
7220                 dbug(3, dprintf("Buffer(%d), Max = %d", Num, APPLptr->MaxBuffer));
7221
7222                 plci->RNum = Num;
7223                 plci->RFlags = plci->NL.Ind >> 4;
7224                 plci->RData[0].PLength = APPLptr->MaxDataLength;
7225                 plci->NL.R = plci->RData;
7226                 if ((plci->NL.RLength != 0)
7227                     && ((plci->B2_prot == B2_V120_ASYNC)
7228                         || (plci->B2_prot == B2_V120_ASYNC_V42BIS)
7229                         || (plci->B2_prot == B2_V120_BIT_TRANSPARENT)))
7230                 {
7231                         plci->RData[1].P = plci->RData[0].P;
7232                         plci->RData[1].PLength = plci->RData[0].PLength;
7233                         plci->RData[0].P = v120_header_buffer + (-((unsigned long)v120_header_buffer) & 3);
7234                         if ((plci->NL.RBuffer->P[0] & V120_HEADER_EXTEND_BIT) || (plci->NL.RLength == 1))
7235                                 plci->RData[0].PLength = 1;
7236                         else
7237                                 plci->RData[0].PLength = 2;
7238                         if (plci->NL.RBuffer->P[0] & V120_HEADER_BREAK_BIT)
7239                                 plci->RFlags |= 0x0010;
7240                         if (plci->NL.RBuffer->P[0] & (V120_HEADER_C1_BIT | V120_HEADER_C2_BIT))
7241                                 plci->RFlags |= 0x8000;
7242                         plci->NL.RNum = 2;
7243                 }
7244                 else
7245                 {
7246                         if ((plci->NL.Ind & 0x0f) == N_UDATA)
7247                                 plci->RFlags |= 0x0010;
7248
7249                         else if ((plci->B3_prot == B3_RTP) && ((plci->NL.Ind & 0x0f) == N_BDATA))
7250                                 plci->RFlags |= 0x0001;
7251
7252                         plci->NL.RNum = 1;
7253                 }
7254                 break;
7255         case N_DATA_ACK:
7256                 data_ack(plci, ch);
7257                 break;
7258         default:
7259                 plci->NL.RNR = 2;
7260                 break;
7261         }
7262 }
7263
7264 /*------------------------------------------------------------------*/
7265 /* find a free PLCI */
7266 /*------------------------------------------------------------------*/
7267
7268 static word get_plci(DIVA_CAPI_ADAPTER *a)
7269 {
7270         word i, j;
7271         PLCI *plci;
7272
7273         dump_plcis(a);
7274         for (i = 0; i < a->max_plci && a->plci[i].Id; i++);
7275         if (i == a->max_plci) {
7276                 dbug(1, dprintf("get_plci: out of PLCIs"));
7277                 return 0;
7278         }
7279         plci = &a->plci[i];
7280         plci->Id = (byte)(i + 1);
7281
7282         plci->Sig.Id = 0;
7283         plci->NL.Id = 0;
7284         plci->sig_req = 0;
7285         plci->nl_req = 0;
7286
7287         plci->appl = NULL;
7288         plci->relatedPTYPLCI = NULL;
7289         plci->State = IDLE;
7290         plci->SuppState = IDLE;
7291         plci->channels = 0;
7292         plci->tel = 0;
7293         plci->B1_resource = 0;
7294         plci->B2_prot = 0;
7295         plci->B3_prot = 0;
7296
7297         plci->command = 0;
7298         plci->m_command = 0;
7299         init_internal_command_queue(plci);
7300         plci->number = 0;
7301         plci->req_in_start = 0;
7302         plci->req_in = 0;
7303         plci->req_out = 0;
7304         plci->msg_in_write_pos = MSG_IN_QUEUE_SIZE;
7305         plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
7306         plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
7307
7308         plci->data_sent = false;
7309         plci->send_disc = 0;
7310         plci->sig_global_req = 0;
7311         plci->sig_remove_id = 0;
7312         plci->nl_global_req = 0;
7313         plci->nl_remove_id = 0;
7314         plci->adv_nl = 0;
7315         plci->manufacturer = false;
7316         plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
7317         plci->spoofed_msg = 0;
7318         plci->ptyState = 0;
7319         plci->cr_enquiry = false;
7320         plci->hangup_flow_ctrl_timer = 0;
7321
7322         plci->ncci_ring_list = 0;
7323         for (j = 0; j < MAX_CHANNELS_PER_PLCI; j++) plci->inc_dis_ncci_table[j] = 0;
7324         clear_c_ind_mask(plci);
7325         set_group_ind_mask(plci);
7326         plci->fax_connect_info_length = 0;
7327         plci->nsf_control_bits = 0;
7328         plci->ncpi_state = 0x00;
7329         plci->ncpi_buffer[0] = 0;
7330
7331         plci->requested_options_conn = 0;
7332         plci->requested_options = 0;
7333         plci->notifiedcall = 0;
7334         plci->vswitchstate = 0;
7335         plci->vsprot = 0;
7336         plci->vsprotdialect = 0;
7337         init_b1_config(plci);
7338         dbug(1, dprintf("get_plci(%x)", plci->Id));
7339         return i + 1;
7340 }
7341
7342 /*------------------------------------------------------------------*/
7343 /* put a parameter in the parameter buffer                          */
7344 /*------------------------------------------------------------------*/
7345
7346 static void add_p(PLCI *plci, byte code, byte *p)
7347 {
7348         word p_length;
7349
7350         p_length = 0;
7351         if (p) p_length = p[0];
7352         add_ie(plci, code, p, p_length);
7353 }
7354
7355 /*------------------------------------------------------------------*/
7356 /* put a structure in the parameter buffer                          */
7357 /*------------------------------------------------------------------*/
7358 static void add_s(PLCI *plci, byte code, API_PARSE *p)
7359 {
7360         if (p) add_ie(plci, code, p->info, (word)p->length);
7361 }
7362
7363 /*------------------------------------------------------------------*/
7364 /* put multiple structures in the parameter buffer                  */
7365 /*------------------------------------------------------------------*/
7366 static void add_ss(PLCI *plci, byte code, API_PARSE *p)
7367 {
7368         byte i;
7369
7370         if (p) {
7371                 dbug(1, dprintf("add_ss(%x,len=%d)", code, p->length));
7372                 for (i = 2; i < (byte)p->length; i += p->info[i] + 2) {
7373                         dbug(1, dprintf("add_ss_ie(%x,len=%d)", p->info[i - 1], p->info[i]));
7374                         add_ie(plci, p->info[i - 1], (byte *)&(p->info[i]), (word)p->info[i]);
7375                 }
7376         }
7377 }
7378
7379 /*------------------------------------------------------------------*/
7380 /* return the channel number sent by the application in a esc_chi   */
7381 /*------------------------------------------------------------------*/
7382 static byte getChannel(API_PARSE *p)
7383 {
7384         byte i;
7385
7386         if (p) {
7387                 for (i = 2; i < (byte)p->length; i += p->info[i] + 2) {
7388                         if (p->info[i] == 2) {
7389                                 if (p->info[i - 1] == ESC && p->info[i + 1] == CHI) return (p->info[i + 2]);
7390                         }
7391                 }
7392         }
7393         return 0;
7394 }
7395
7396
7397 /*------------------------------------------------------------------*/
7398 /* put an information element in the parameter buffer               */
7399 /*------------------------------------------------------------------*/
7400
7401 static void add_ie(PLCI *plci, byte code, byte *p, word p_length)
7402 {
7403         word i;
7404
7405         if (!(code & 0x80) && !p_length) return;
7406
7407         if (plci->req_in == plci->req_in_start) {
7408                 plci->req_in += 2;
7409         }
7410         else {
7411                 plci->req_in--;
7412         }
7413         plci->RBuffer[plci->req_in++] = code;
7414
7415         if (p) {
7416                 plci->RBuffer[plci->req_in++] = (byte)p_length;
7417                 for (i = 0; i < p_length; i++) plci->RBuffer[plci->req_in++] = p[1 + i];
7418         }
7419
7420         plci->RBuffer[plci->req_in++] = 0;
7421 }
7422
7423 /*------------------------------------------------------------------*/
7424 /* put a unstructured data into the buffer                          */
7425 /*------------------------------------------------------------------*/
7426
7427 static void add_d(PLCI *plci, word length, byte *p)
7428 {
7429         word i;
7430
7431         if (plci->req_in == plci->req_in_start) {
7432                 plci->req_in += 2;
7433         }
7434         else {
7435                 plci->req_in--;
7436         }
7437         for (i = 0; i < length; i++) plci->RBuffer[plci->req_in++] = p[i];
7438 }
7439
7440 /*------------------------------------------------------------------*/
7441 /* put parameters from the Additional Info parameter in the         */
7442 /* parameter buffer                                                 */
7443 /*------------------------------------------------------------------*/
7444
7445 static void add_ai(PLCI *plci, API_PARSE *ai)
7446 {
7447         word i;
7448         API_PARSE ai_parms[5];
7449
7450         for (i = 0; i < 5; i++) ai_parms[i].length = 0;
7451
7452         if (!ai->length)
7453                 return;
7454         if (api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms))
7455                 return;
7456
7457         add_s(plci, KEY, &ai_parms[1]);
7458         add_s(plci, UUI, &ai_parms[2]);
7459         add_ss(plci, FTY, &ai_parms[3]);
7460 }
7461
7462 /*------------------------------------------------------------------*/
7463 /* put parameter for b1 protocol in the parameter buffer            */
7464 /*------------------------------------------------------------------*/
7465
7466 static word add_b1(PLCI *plci, API_PARSE *bp, word b_channel_info,
7467                    word b1_facilities)
7468 {
7469         API_PARSE bp_parms[8];
7470         API_PARSE mdm_cfg[9];
7471         API_PARSE global_config[2];
7472         byte cai[256];
7473         byte resource[] = {5, 9, 13, 12, 16, 39, 9, 17, 17, 18};
7474         byte voice_cai[] = "\x06\x14\x00\x00\x00\x00\x08";
7475         word i;
7476
7477         API_PARSE mdm_cfg_v18[4];
7478         word j, n, w;
7479         dword d;
7480
7481
7482         for (i = 0; i < 8; i++) bp_parms[i].length = 0;
7483         for (i = 0; i < 2; i++) global_config[i].length = 0;
7484
7485         dbug(1, dprintf("add_b1"));
7486         api_save_msg(bp, "s", &plci->B_protocol);
7487
7488         if (b_channel_info == 2) {
7489                 plci->B1_resource = 0;
7490                 adjust_b1_facilities(plci, plci->B1_resource, b1_facilities);
7491                 add_p(plci, CAI, "\x01\x00");
7492                 dbug(1, dprintf("Cai=1,0 (no resource)"));
7493                 return 0;
7494         }
7495
7496         if (plci->tel == CODEC_PERMANENT) return 0;
7497         else if (plci->tel == CODEC) {
7498                 plci->B1_resource = 1;
7499                 adjust_b1_facilities(plci, plci->B1_resource, b1_facilities);
7500                 add_p(plci, CAI, "\x01\x01");
7501                 dbug(1, dprintf("Cai=1,1 (Codec)"));
7502                 return 0;
7503         }
7504         else if (plci->tel == ADV_VOICE) {
7505                 plci->B1_resource = add_b1_facilities(plci, 9, (word)(b1_facilities | B1_FACILITY_VOICE));
7506                 adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities | B1_FACILITY_VOICE));
7507                 voice_cai[1] = plci->B1_resource;
7508                 PUT_WORD(&voice_cai[5], plci->appl->MaxDataLength);
7509                 add_p(plci, CAI, voice_cai);
7510                 dbug(1, dprintf("Cai=1,0x%x (AdvVoice)", voice_cai[1]));
7511                 return 0;
7512         }
7513         plci->call_dir &= ~(CALL_DIR_ORIGINATE | CALL_DIR_ANSWER);
7514         if (plci->call_dir & CALL_DIR_OUT)
7515                 plci->call_dir |= CALL_DIR_ORIGINATE;
7516         else if (plci->call_dir & CALL_DIR_IN)
7517                 plci->call_dir |= CALL_DIR_ANSWER;
7518
7519         if (!bp->length) {
7520                 plci->B1_resource = 0x5;
7521                 adjust_b1_facilities(plci, plci->B1_resource, b1_facilities);
7522                 add_p(plci, CAI, "\x01\x05");
7523                 return 0;
7524         }
7525
7526         dbug(1, dprintf("b_prot_len=%d", (word)bp->length));
7527         if (bp->length > 256) return _WRONG_MESSAGE_FORMAT;
7528         if (api_parse(&bp->info[1], (word)bp->length, "wwwsssb", bp_parms))
7529         {
7530                 bp_parms[6].length = 0;
7531                 if (api_parse(&bp->info[1], (word)bp->length, "wwwsss", bp_parms))
7532                 {
7533                         dbug(1, dprintf("b-form.!"));
7534                         return _WRONG_MESSAGE_FORMAT;
7535                 }
7536         }
7537         else if (api_parse(&bp->info[1], (word)bp->length, "wwwssss", bp_parms))
7538         {
7539                 dbug(1, dprintf("b-form.!"));
7540                 return _WRONG_MESSAGE_FORMAT;
7541         }
7542
7543         if (bp_parms[6].length)
7544         {
7545                 if (api_parse(&bp_parms[6].info[1], (word)bp_parms[6].length, "w", global_config))
7546                 {
7547                         return _WRONG_MESSAGE_FORMAT;
7548                 }
7549                 switch (GET_WORD(global_config[0].info))
7550                 {
7551                 case 1:
7552                         plci->call_dir = (plci->call_dir & ~CALL_DIR_ANSWER) | CALL_DIR_ORIGINATE;
7553                         break;
7554                 case 2:
7555                         plci->call_dir = (plci->call_dir & ~CALL_DIR_ORIGINATE) | CALL_DIR_ANSWER;
7556                         break;
7557                 }
7558         }
7559         dbug(1, dprintf("call_dir=%04x", plci->call_dir));
7560
7561
7562         if ((GET_WORD(bp_parms[0].info) == B1_RTP)
7563             && (plci->adapter->man_profile.private_options & (1L << PRIVATE_RTP)))
7564         {
7565                 plci->B1_resource = add_b1_facilities(plci, 31, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7566                 adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7567                 cai[1] = plci->B1_resource;
7568                 cai[2] = 0;
7569                 cai[3] = 0;
7570                 cai[4] = 0;
7571                 PUT_WORD(&cai[5], plci->appl->MaxDataLength);
7572                 for (i = 0; i < bp_parms[3].length; i++)
7573                         cai[7 + i] = bp_parms[3].info[1 + i];
7574                 cai[0] = 6 + bp_parms[3].length;
7575                 add_p(plci, CAI, cai);
7576                 return 0;
7577         }
7578
7579
7580         if ((GET_WORD(bp_parms[0].info) == B1_PIAFS)
7581             && (plci->adapter->man_profile.private_options & (1L << PRIVATE_PIAFS)))
7582         {
7583                 plci->B1_resource = add_b1_facilities(plci, 35/* PIAFS HARDWARE FACILITY */, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7584                 adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7585                 cai[1] = plci->B1_resource;
7586                 cai[2] = 0;
7587                 cai[3] = 0;
7588                 cai[4] = 0;
7589                 PUT_WORD(&cai[5], plci->appl->MaxDataLength);
7590                 cai[0] = 6;
7591                 add_p(plci, CAI, cai);
7592                 return 0;
7593         }
7594
7595
7596         if ((GET_WORD(bp_parms[0].info) >= 32)
7597             || (!((1L << GET_WORD(bp_parms[0].info)) & plci->adapter->profile.B1_Protocols)
7598                 && ((GET_WORD(bp_parms[0].info) != 3)
7599                     || !((1L << B1_HDLC) & plci->adapter->profile.B1_Protocols)
7600                     || ((bp_parms[3].length != 0) && (GET_WORD(&bp_parms[3].info[1]) != 0) && (GET_WORD(&bp_parms[3].info[1]) != 56000)))))
7601         {
7602                 return _B1_NOT_SUPPORTED;
7603         }
7604         plci->B1_resource = add_b1_facilities(plci, resource[GET_WORD(bp_parms[0].info)],
7605                                               (word)(b1_facilities & ~B1_FACILITY_VOICE));
7606         adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7607         cai[0] = 6;
7608         cai[1] = plci->B1_resource;
7609         for (i = 2; i < sizeof(cai); i++) cai[i] = 0;
7610
7611         if ((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE)
7612             || (GET_WORD(bp_parms[0].info) == B1_MODEM_ASYNC)
7613             || (GET_WORD(bp_parms[0].info) == B1_MODEM_SYNC_HDLC))
7614         { /* B1 - modem */
7615                 for (i = 0; i < 7; i++) mdm_cfg[i].length = 0;
7616
7617                 if (bp_parms[3].length)
7618                 {
7619                         if (api_parse(&bp_parms[3].info[1], (word)bp_parms[3].length, "wwwwww", mdm_cfg))
7620                         {
7621                                 return (_WRONG_MESSAGE_FORMAT);
7622                         }
7623
7624                         cai[2] = 0; /* Bit rate for adaptation */
7625
7626                         dbug(1, dprintf("MDM Max Bit Rate:<%d>", GET_WORD(mdm_cfg[0].info)));
7627
7628                         PUT_WORD(&cai[13], 0);                          /* Min Tx speed */
7629                         PUT_WORD(&cai[15], GET_WORD(mdm_cfg[0].info)); /* Max Tx speed */
7630                         PUT_WORD(&cai[17], 0);                          /* Min Rx speed */
7631                         PUT_WORD(&cai[19], GET_WORD(mdm_cfg[0].info)); /* Max Rx speed */
7632
7633                         cai[3] = 0; /* Async framing parameters */
7634                         switch (GET_WORD(mdm_cfg[2].info))
7635                         {       /* Parity     */
7636                         case 1: /* odd parity */
7637                                 cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_ODD);
7638                                 dbug(1, dprintf("MDM: odd parity"));
7639                                 break;
7640
7641                         case 2: /* even parity */
7642                                 cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_EVEN);
7643                                 dbug(1, dprintf("MDM: even parity"));
7644                                 break;
7645
7646                         default:
7647                                 dbug(1, dprintf("MDM: no parity"));
7648                                 break;
7649                         }
7650
7651                         switch (GET_WORD(mdm_cfg[3].info))
7652                         {       /* stop bits   */
7653                         case 1: /* 2 stop bits */
7654                                 cai[3] |= DSP_CAI_ASYNC_TWO_STOP_BITS;
7655                                 dbug(1, dprintf("MDM: 2 stop bits"));
7656                                 break;
7657
7658                         default:
7659                                 dbug(1, dprintf("MDM: 1 stop bit"));
7660                                 break;
7661                         }
7662
7663                         switch (GET_WORD(mdm_cfg[1].info))
7664                         {     /* char length */
7665                         case 5:
7666                                 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_5;
7667                                 dbug(1, dprintf("MDM: 5 bits"));
7668                                 break;
7669
7670                         case 6:
7671                                 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_6;
7672                                 dbug(1, dprintf("MDM: 6 bits"));
7673                                 break;
7674
7675                         case 7:
7676                                 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_7;
7677                                 dbug(1, dprintf("MDM: 7 bits"));
7678                                 break;
7679
7680                         default:
7681                                 dbug(1, dprintf("MDM: 8 bits"));
7682                                 break;
7683                         }
7684
7685                         cai[7] = 0; /* Line taking options */
7686                         cai[8] = 0; /* Modulation negotiation options */
7687                         cai[9] = 0; /* Modulation options */
7688
7689                         if (((plci->call_dir & CALL_DIR_ORIGINATE) != 0) ^ ((plci->call_dir & CALL_DIR_OUT) != 0))
7690                         {
7691                                 cai[9] |= DSP_CAI_MODEM_REVERSE_DIRECTION;
7692                                 dbug(1, dprintf("MDM: Reverse direction"));
7693                         }
7694
7695                         if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_DISABLE_RETRAIN)
7696                         {
7697                                 cai[9] |= DSP_CAI_MODEM_DISABLE_RETRAIN;
7698                                 dbug(1, dprintf("MDM: Disable retrain"));
7699                         }
7700
7701                         if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_DISABLE_RING_TONE)
7702                         {
7703                                 cai[7] |= DSP_CAI_MODEM_DISABLE_CALLING_TONE | DSP_CAI_MODEM_DISABLE_ANSWER_TONE;
7704                                 dbug(1, dprintf("MDM: Disable ring tone"));
7705                         }
7706
7707                         if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_GUARD_1800)
7708                         {
7709                                 cai[8] |= DSP_CAI_MODEM_GUARD_TONE_1800HZ;
7710                                 dbug(1, dprintf("MDM: 1800 guard tone"));
7711                         }
7712                         else if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_GUARD_550)
7713                         {
7714                                 cai[8] |= DSP_CAI_MODEM_GUARD_TONE_550HZ;
7715                                 dbug(1, dprintf("MDM: 550 guard tone"));
7716                         }
7717
7718                         if ((GET_WORD(mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_V100)
7719                         {
7720                                 cai[8] |= DSP_CAI_MODEM_NEGOTIATE_V100;
7721                                 dbug(1, dprintf("MDM: V100"));
7722                         }
7723                         else if ((GET_WORD(mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_MOD_CLASS)
7724                         {
7725                                 cai[8] |= DSP_CAI_MODEM_NEGOTIATE_IN_CLASS;
7726                                 dbug(1, dprintf("MDM: IN CLASS"));
7727                         }
7728                         else if ((GET_WORD(mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_DISABLED)
7729                         {
7730                                 cai[8] |= DSP_CAI_MODEM_NEGOTIATE_DISABLED;
7731                                 dbug(1, dprintf("MDM: DISABLED"));
7732                         }
7733                         cai[0] = 20;
7734
7735                         if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_V18))
7736                             && (GET_WORD(mdm_cfg[5].info) & 0x8000)) /* Private V.18 enable */
7737                         {
7738                                 plci->requested_options |= 1L << PRIVATE_V18;
7739                         }
7740                         if (GET_WORD(mdm_cfg[5].info) & 0x4000) /* Private VOWN enable */
7741                                 plci->requested_options |= 1L << PRIVATE_VOWN;
7742
7743                         if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
7744                             & ((1L << PRIVATE_V18) | (1L << PRIVATE_VOWN)))
7745                         {
7746                                 if (!api_parse(&bp_parms[3].info[1], (word)bp_parms[3].length, "wwwwwws", mdm_cfg))
7747                                 {
7748                                         i = 27;
7749                                         if (mdm_cfg[6].length >= 4)
7750                                         {
7751                                                 d = GET_DWORD(&mdm_cfg[6].info[1]);
7752                                                 cai[7] |= (byte) d;          /* line taking options */
7753                                                 cai[9] |= (byte)(d >> 8);    /* modulation options */
7754                                                 cai[++i] = (byte)(d >> 16);  /* vown modulation options */
7755                                                 cai[++i] = (byte)(d >> 24);
7756                                                 if (mdm_cfg[6].length >= 8)
7757                                                 {
7758                                                         d = GET_DWORD(&mdm_cfg[6].info[5]);
7759                                                         cai[10] |= (byte) d;        /* disabled modulations mask */
7760                                                         cai[11] |= (byte)(d >> 8);
7761                                                         if (mdm_cfg[6].length >= 12)
7762                                                         {
7763                                                                 d = GET_DWORD(&mdm_cfg[6].info[9]);
7764                                                                 cai[12] = (byte) d;          /* enabled modulations mask */
7765                                                                 cai[++i] = (byte)(d >> 8);   /* vown enabled modulations */
7766                                                                 cai[++i] = (byte)(d >> 16);
7767                                                                 cai[++i] = (byte)(d >> 24);
7768                                                                 cai[++i] = 0;
7769                                                                 if (mdm_cfg[6].length >= 14)
7770                                                                 {
7771                                                                         w = GET_WORD(&mdm_cfg[6].info[13]);
7772                                                                         if (w != 0)
7773                                                                                 PUT_WORD(&cai[13], w);  /* min tx speed */
7774                                                                         if (mdm_cfg[6].length >= 16)
7775                                                                         {
7776                                                                                 w = GET_WORD(&mdm_cfg[6].info[15]);
7777                                                                                 if (w != 0)
7778                                                                                         PUT_WORD(&cai[15], w);  /* max tx speed */
7779                                                                                 if (mdm_cfg[6].length >= 18)
7780                                                                                 {
7781                                                                                         w = GET_WORD(&mdm_cfg[6].info[17]);
7782                                                                                         if (w != 0)
7783                                                                                                 PUT_WORD(&cai[17], w);  /* min rx speed */
7784                                                                                         if (mdm_cfg[6].length >= 20)
7785                                                                                         {
7786                                                                                                 w = GET_WORD(&mdm_cfg[6].info[19]);
7787                                                                                                 if (w != 0)
7788                                                                                                         PUT_WORD(&cai[19], w);  /* max rx speed */
7789                                                                                                 if (mdm_cfg[6].length >= 22)
7790                                                                                                 {
7791                                                                                                         w = GET_WORD(&mdm_cfg[6].info[21]);
7792                                                                                                         cai[23] = (byte)(-((short) w));  /* transmit level */
7793                                                                                                         if (mdm_cfg[6].length >= 24)
7794                                                                                                         {
7795                                                                                                                 w = GET_WORD(&mdm_cfg[6].info[23]);
7796                                                                                                                 cai[22] |= (byte) w;        /* info options mask */
7797                                                                                                                 cai[21] |= (byte)(w >> 8);  /* disabled symbol rates */
7798                                                                                                         }
7799                                                                                                 }
7800                                                                                         }
7801                                                                                 }
7802                                                                         }
7803                                                                 }
7804                                                         }
7805                                                 }
7806                                         }
7807                                         cai[27] = i - 27;
7808                                         i++;
7809                                         if (!api_parse(&bp_parms[3].info[1], (word)bp_parms[3].length, "wwwwwwss", mdm_cfg))
7810                                         {
7811                                                 if (!api_parse(&mdm_cfg[7].info[1], (word)mdm_cfg[7].length, "sss", mdm_cfg_v18))
7812                                                 {
7813                                                         for (n = 0; n < 3; n++)
7814                                                         {
7815                                                                 cai[i] = (byte)(mdm_cfg_v18[n].length);
7816                                                                 for (j = 1; j < ((word)(cai[i] + 1)); j++)
7817                                                                         cai[i + j] = mdm_cfg_v18[n].info[j];
7818                                                                 i += cai[i] + 1;
7819                                                         }
7820                                                 }
7821                                         }
7822                                         cai[0] = (byte)(i - 1);
7823                                 }
7824                         }
7825
7826                 }
7827         }
7828         if (GET_WORD(bp_parms[0].info) == 2 ||                         /* V.110 async */
7829             GET_WORD(bp_parms[0].info) == 3)                           /* V.110 sync */
7830         {
7831                 if (bp_parms[3].length) {
7832                         dbug(1, dprintf("V.110,%d", GET_WORD(&bp_parms[3].info[1])));
7833                         switch (GET_WORD(&bp_parms[3].info[1])) {                 /* Rate */
7834                         case 0:
7835                         case 56000:
7836                                 if (GET_WORD(bp_parms[0].info) == 3) {                  /* V.110 sync 56k */
7837                                         dbug(1, dprintf("56k sync HSCX"));
7838                                         cai[1] = 8;
7839                                         cai[2] = 0;
7840                                         cai[3] = 0;
7841                                 }
7842                                 else if (GET_WORD(bp_parms[0].info) == 2) {
7843                                         dbug(1, dprintf("56k async DSP"));
7844                                         cai[2] = 9;
7845                                 }
7846                                 break;
7847                         case 50:     cai[2] = 1;  break;
7848                         case 75:     cai[2] = 1;  break;
7849                         case 110:    cai[2] = 1;  break;
7850                         case 150:    cai[2] = 1;  break;
7851                         case 200:    cai[2] = 1;  break;
7852                         case 300:    cai[2] = 1;  break;
7853                         case 600:    cai[2] = 1;  break;
7854                         case 1200:   cai[2] = 2;  break;
7855                         case 2400:   cai[2] = 3;  break;
7856                         case 4800:   cai[2] = 4;  break;
7857                         case 7200:   cai[2] = 10; break;
7858                         case 9600:   cai[2] = 5;  break;
7859                         case 12000:  cai[2] = 13; break;
7860                         case 24000:  cai[2] = 0;  break;
7861                         case 14400:  cai[2] = 11; break;
7862                         case 19200:  cai[2] = 6;  break;
7863                         case 28800:  cai[2] = 12; break;
7864                         case 38400:  cai[2] = 7;  break;
7865                         case 48000:  cai[2] = 8;  break;
7866                         case 76:     cai[2] = 15; break;  /* 75/1200     */
7867                         case 1201:   cai[2] = 14; break;  /* 1200/75     */
7868                         case 56001:  cai[2] = 9;  break;  /* V.110 56000 */
7869
7870                         default:
7871                                 return _B1_PARM_NOT_SUPPORTED;
7872                         }
7873                         cai[3] = 0;
7874                         if (cai[1] == 13)                                        /* v.110 async */
7875                         {
7876                                 if (bp_parms[3].length >= 8)
7877                                 {
7878                                         switch (GET_WORD(&bp_parms[3].info[3]))
7879                                         {       /* char length */
7880                                         case 5:
7881                                                 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_5;
7882                                                 break;
7883                                         case 6:
7884                                                 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_6;
7885                                                 break;
7886                                         case 7:
7887                                                 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_7;
7888                                                 break;
7889                                         }
7890                                         switch (GET_WORD(&bp_parms[3].info[5]))
7891                                         {       /* Parity     */
7892                                         case 1: /* odd parity */
7893                                                 cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_ODD);
7894                                                 break;
7895                                         case 2: /* even parity */
7896                                                 cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_EVEN);
7897                                                 break;
7898                                         }
7899                                         switch (GET_WORD(&bp_parms[3].info[7]))
7900                                         {       /* stop bits   */
7901                                         case 1: /* 2 stop bits */
7902                                                 cai[3] |= DSP_CAI_ASYNC_TWO_STOP_BITS;
7903                                                 break;
7904                                         }
7905                                 }
7906                         }
7907                 }
7908                 else if (cai[1] == 8 || GET_WORD(bp_parms[0].info) == 3) {
7909                         dbug(1, dprintf("V.110 default 56k sync"));
7910                         cai[1] = 8;
7911                         cai[2] = 0;
7912                         cai[3] = 0;
7913                 }
7914                 else {
7915                         dbug(1, dprintf("V.110 default 9600 async"));
7916                         cai[2] = 5;
7917                 }
7918         }
7919         PUT_WORD(&cai[5], plci->appl->MaxDataLength);
7920         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]));
7921 /* HexDump ("CAI", sizeof(cai), &cai[0]); */
7922
7923         add_p(plci, CAI, cai);
7924         return 0;
7925 }
7926
7927 /*------------------------------------------------------------------*/
7928 /* put parameter for b2 and B3  protocol in the parameter buffer    */
7929 /*------------------------------------------------------------------*/
7930
7931 static word add_b23(PLCI *plci, API_PARSE *bp)
7932 {
7933         word i, fax_control_bits;
7934         byte pos, len;
7935         byte SAPI = 0x40;  /* default SAPI 16 for x.31 */
7936         API_PARSE bp_parms[8];
7937         API_PARSE *b1_config;
7938         API_PARSE *b2_config;
7939         API_PARSE b2_config_parms[8];
7940         API_PARSE *b3_config;
7941         API_PARSE b3_config_parms[6];
7942         API_PARSE global_config[2];
7943
7944         static byte llc[3] = {2,0,0};
7945         static byte dlc[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
7946         static byte nlc[256];
7947         static byte lli[12] = {1,1};
7948
7949         const byte llc2_out[] = {1,2,4,6,2,0,0,0, X75_V42BIS,V120_L2,V120_V42BIS,V120_L2,6};
7950         const byte llc2_in[]  = {1,3,4,6,3,0,0,0, X75_V42BIS,V120_L2,V120_V42BIS,V120_L2,6};
7951
7952         const byte llc3[] = {4,3,2,2,6,6,0};
7953         const byte header[] = {0,2,3,3,0,0,0};
7954
7955         for (i = 0; i < 8; i++) bp_parms[i].length = 0;
7956         for (i = 0; i < 6; i++) b2_config_parms[i].length = 0;
7957         for (i = 0; i < 5; i++) b3_config_parms[i].length = 0;
7958
7959         lli[0] = 1;
7960         lli[1] = 1;
7961         if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL)
7962                 lli[1] |= 2;
7963         if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL)
7964                 lli[1] |= 4;
7965
7966         if ((lli[1] & 0x02) && (diva_xdi_extended_features & DIVA_CAPI_USE_CMA)) {
7967                 lli[1] |= 0x10;
7968                 if (plci->rx_dma_descriptor <= 0) {
7969                         plci->rx_dma_descriptor = diva_get_dma_descriptor(plci, &plci->rx_dma_magic);
7970                         if (plci->rx_dma_descriptor >= 0)
7971                                 plci->rx_dma_descriptor++;
7972                 }
7973                 if (plci->rx_dma_descriptor > 0) {
7974                         lli[0] = 6;
7975                         lli[1] |= 0x40;
7976                         lli[2] = (byte)(plci->rx_dma_descriptor - 1);
7977                         lli[3] = (byte)plci->rx_dma_magic;
7978                         lli[4] = (byte)(plci->rx_dma_magic >>  8);
7979                         lli[5] = (byte)(plci->rx_dma_magic >> 16);
7980                         lli[6] = (byte)(plci->rx_dma_magic >> 24);
7981                 }
7982         }
7983
7984         if (DIVA_CAPI_SUPPORTS_NO_CANCEL(plci->adapter)) {
7985                 lli[1] |= 0x20;
7986         }
7987
7988         dbug(1, dprintf("add_b23"));
7989         api_save_msg(bp, "s", &plci->B_protocol);
7990
7991         if (!bp->length && plci->tel)
7992         {
7993                 plci->adv_nl = true;
7994                 dbug(1, dprintf("Default adv.Nl"));
7995                 add_p(plci, LLI, lli);
7996                 plci->B2_prot = 1 /*XPARENT*/;
7997                 plci->B3_prot = 0 /*XPARENT*/;
7998                 llc[1] = 2;
7999                 llc[2] = 4;
8000                 add_p(plci, LLC, llc);
8001                 dlc[0] = 2;
8002                 PUT_WORD(&dlc[1], plci->appl->MaxDataLength);
8003                 add_p(plci, DLC, dlc);
8004                 return 0;
8005         }
8006
8007         if (!bp->length) /*default*/
8008         {
8009                 dbug(1, dprintf("ret default"));
8010                 add_p(plci, LLI, lli);
8011                 plci->B2_prot = 0 /*X.75   */;
8012                 plci->B3_prot = 0 /*XPARENT*/;
8013                 llc[1] = 1;
8014                 llc[2] = 4;
8015                 add_p(plci, LLC, llc);
8016                 dlc[0] = 2;
8017                 PUT_WORD(&dlc[1], plci->appl->MaxDataLength);
8018                 add_p(plci, DLC, dlc);
8019                 return 0;
8020         }
8021         dbug(1, dprintf("b_prot_len=%d", (word)bp->length));
8022         if ((word)bp->length > 256)    return _WRONG_MESSAGE_FORMAT;
8023
8024         if (api_parse(&bp->info[1], (word)bp->length, "wwwsssb", bp_parms))
8025         {
8026                 bp_parms[6].length = 0;
8027                 if (api_parse(&bp->info[1], (word)bp->length, "wwwsss", bp_parms))
8028                 {
8029                         dbug(1, dprintf("b-form.!"));
8030                         return _WRONG_MESSAGE_FORMAT;
8031                 }
8032         }
8033         else if (api_parse(&bp->info[1], (word)bp->length, "wwwssss", bp_parms))
8034         {
8035                 dbug(1, dprintf("b-form.!"));
8036                 return _WRONG_MESSAGE_FORMAT;
8037         }
8038
8039         if (plci->tel == ADV_VOICE) /* transparent B on advanced voice */
8040         {
8041                 if (GET_WORD(bp_parms[1].info) != 1
8042                     || GET_WORD(bp_parms[2].info) != 0) return _B2_NOT_SUPPORTED;
8043                 plci->adv_nl = true;
8044         }
8045         else if (plci->tel) return _B2_NOT_SUPPORTED;
8046
8047
8048         if ((GET_WORD(bp_parms[1].info) == B2_RTP)
8049             && (GET_WORD(bp_parms[2].info) == B3_RTP)
8050             && (plci->adapter->man_profile.private_options & (1L << PRIVATE_RTP)))
8051         {
8052                 add_p(plci, LLI, lli);
8053                 plci->B2_prot = (byte) GET_WORD(bp_parms[1].info);
8054                 plci->B3_prot = (byte) GET_WORD(bp_parms[2].info);
8055                 llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ? 14 : 13;
8056                 llc[2] = 4;
8057                 add_p(plci, LLC, llc);
8058                 dlc[0] = 2;
8059                 PUT_WORD(&dlc[1], plci->appl->MaxDataLength);
8060                 dlc[3] = 3; /* Addr A */
8061                 dlc[4] = 1; /* Addr B */
8062                 dlc[5] = 7; /* modulo mode */
8063                 dlc[6] = 7; /* window size */
8064                 dlc[7] = 0; /* XID len Lo  */
8065                 dlc[8] = 0; /* XID len Hi  */
8066                 for (i = 0; i < bp_parms[4].length; i++)
8067                         dlc[9 + i] = bp_parms[4].info[1 + i];
8068                 dlc[0] = (byte)(8 + bp_parms[4].length);
8069                 add_p(plci, DLC, dlc);
8070                 for (i = 0; i < bp_parms[5].length; i++)
8071                         nlc[1 + i] = bp_parms[5].info[1 + i];
8072                 nlc[0] = (byte)(bp_parms[5].length);
8073                 add_p(plci, NLC, nlc);
8074                 return 0;
8075         }
8076
8077
8078
8079         if ((GET_WORD(bp_parms[1].info) >= 32)
8080             || (!((1L << GET_WORD(bp_parms[1].info)) & plci->adapter->profile.B2_Protocols)
8081                 && ((GET_WORD(bp_parms[1].info) != B2_PIAFS)
8082                     || !(plci->adapter->man_profile.private_options & (1L << PRIVATE_PIAFS)))))
8083
8084         {
8085                 return _B2_NOT_SUPPORTED;
8086         }
8087         if ((GET_WORD(bp_parms[2].info) >= 32)
8088             || !((1L << GET_WORD(bp_parms[2].info)) & plci->adapter->profile.B3_Protocols))
8089         {
8090                 return _B3_NOT_SUPPORTED;
8091         }
8092         if ((GET_WORD(bp_parms[1].info) != B2_SDLC)
8093             && ((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE)
8094                 || (GET_WORD(bp_parms[0].info) == B1_MODEM_ASYNC)
8095                 || (GET_WORD(bp_parms[0].info) == B1_MODEM_SYNC_HDLC)))
8096         {
8097                 return (add_modem_b23(plci, bp_parms));
8098         }
8099
8100         add_p(plci, LLI, lli);
8101
8102         plci->B2_prot = (byte)GET_WORD(bp_parms[1].info);
8103         plci->B3_prot = (byte)GET_WORD(bp_parms[2].info);
8104         if (plci->B2_prot == 12) SAPI = 0; /* default SAPI D-channel */
8105
8106         if (bp_parms[6].length)
8107         {
8108                 if (api_parse(&bp_parms[6].info[1], (word)bp_parms[6].length, "w", global_config))
8109                 {
8110                         return _WRONG_MESSAGE_FORMAT;
8111                 }
8112                 switch (GET_WORD(global_config[0].info))
8113                 {
8114                 case 1:
8115                         plci->call_dir = (plci->call_dir & ~CALL_DIR_ANSWER) | CALL_DIR_ORIGINATE;
8116                         break;
8117                 case 2:
8118                         plci->call_dir = (plci->call_dir & ~CALL_DIR_ORIGINATE) | CALL_DIR_ANSWER;
8119                         break;
8120                 }
8121         }
8122         dbug(1, dprintf("call_dir=%04x", plci->call_dir));
8123
8124
8125         if (plci->B2_prot == B2_PIAFS)
8126                 llc[1] = PIAFS_CRC;
8127         else
8128 /* IMPLEMENT_PIAFS */
8129         {
8130                 llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ?
8131                         llc2_out[GET_WORD(bp_parms[1].info)] : llc2_in[GET_WORD(bp_parms[1].info)];
8132         }
8133         llc[2] = llc3[GET_WORD(bp_parms[2].info)];
8134
8135         add_p(plci, LLC, llc);
8136
8137         dlc[0] = 2;
8138         PUT_WORD(&dlc[1], plci->appl->MaxDataLength +
8139                  header[GET_WORD(bp_parms[2].info)]);
8140
8141         b1_config = &bp_parms[3];
8142         nlc[0] = 0;
8143         if (plci->B3_prot == 4
8144             || plci->B3_prot == 5)
8145         {
8146                 for (i = 0; i < sizeof(T30_INFO); i++) nlc[i] = 0;
8147                 nlc[0] = sizeof(T30_INFO);
8148                 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
8149                         ((T30_INFO *)&nlc[1])->operating_mode = T30_OPERATING_MODE_CAPI;
8150                 ((T30_INFO *)&nlc[1])->rate_div_2400 = 0xff;
8151                 if (b1_config->length >= 2)
8152                 {
8153                         ((T30_INFO *)&nlc[1])->rate_div_2400 = (byte)(GET_WORD(&b1_config->info[1]) / 2400);
8154                 }
8155         }
8156         b2_config = &bp_parms[4];
8157
8158
8159         if (llc[1] == PIAFS_CRC)
8160         {
8161                 if (plci->B3_prot != B3_TRANSPARENT)
8162                 {
8163                         return _B_STACK_NOT_SUPPORTED;
8164                 }
8165                 if (b2_config->length && api_parse(&b2_config->info[1], (word)b2_config->length, "bwww", b2_config_parms)) {
8166                         return _WRONG_MESSAGE_FORMAT;
8167                 }
8168                 PUT_WORD(&dlc[1], plci->appl->MaxDataLength);
8169                 dlc[3] = 0; /* Addr A */
8170                 dlc[4] = 0; /* Addr B */
8171                 dlc[5] = 0; /* modulo mode */
8172                 dlc[6] = 0; /* window size */
8173                 if (b2_config->length >= 7) {
8174                         dlc[7] = 7;
8175                         dlc[8] = 0;
8176                         dlc[9] = b2_config_parms[0].info[0]; /* PIAFS protocol Speed configuration */
8177                         dlc[10] = b2_config_parms[1].info[0]; /* V.42bis P0 */
8178                         dlc[11] = b2_config_parms[1].info[1]; /* V.42bis P0 */
8179                         dlc[12] = b2_config_parms[2].info[0]; /* V.42bis P1 */
8180                         dlc[13] = b2_config_parms[2].info[1]; /* V.42bis P1 */
8181                         dlc[14] = b2_config_parms[3].info[0]; /* V.42bis P2 */
8182                         dlc[15] = b2_config_parms[3].info[1]; /* V.42bis P2 */
8183                         dlc[0] = 15;
8184                         if (b2_config->length >= 8) { /* PIAFS control abilities */
8185                                 dlc[7] = 10;
8186                                 dlc[16] = 2; /* Length of PIAFS extension */
8187                                 dlc[17] = PIAFS_UDATA_ABILITIES; /* control (UDATA) ability */
8188                                 dlc[18] = b2_config_parms[4].info[0]; /* value */
8189                                 dlc[0] = 18;
8190                         }
8191                 }
8192                 else /* default values, 64K, variable, no compression */
8193                 {
8194                         dlc[7] = 7;
8195                         dlc[8] = 0;
8196                         dlc[9] = 0x03; /* PIAFS protocol Speed configuration */
8197                         dlc[10] = 0x03; /* V.42bis P0 */
8198                         dlc[11] = 0;    /* V.42bis P0 */
8199                         dlc[12] = 0;    /* V.42bis P1 */
8200                         dlc[13] = 0;    /* V.42bis P1 */
8201                         dlc[14] = 0;    /* V.42bis P2 */
8202                         dlc[15] = 0;    /* V.42bis P2 */
8203                         dlc[0] = 15;
8204                 }
8205                 add_p(plci, DLC, dlc);
8206         }
8207         else
8208
8209                 if ((llc[1] == V120_L2) || (llc[1] == V120_V42BIS))
8210                 {
8211                         if (plci->B3_prot != B3_TRANSPARENT)
8212                                 return _B_STACK_NOT_SUPPORTED;
8213
8214                         dlc[0] = 6;
8215                         PUT_WORD(&dlc[1], GET_WORD(&dlc[1]) + 2);
8216                         dlc[3] = 0x08;
8217                         dlc[4] = 0x01;
8218                         dlc[5] = 127;
8219                         dlc[6] = 7;
8220                         if (b2_config->length != 0)
8221                         {
8222                                 if ((llc[1] == V120_V42BIS) && api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbwww", b2_config_parms)) {
8223                                         return _WRONG_MESSAGE_FORMAT;
8224                                 }
8225                                 dlc[3] = (byte)((b2_config->info[2] << 3) | ((b2_config->info[1] >> 5) & 0x04));
8226                                 dlc[4] = (byte)((b2_config->info[1] << 1) | 0x01);
8227                                 if (b2_config->info[3] != 128)
8228                                 {
8229                                         dbug(1, dprintf("1D-dlc= %x %x %x %x %x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4]));
8230                                         return _B2_PARM_NOT_SUPPORTED;
8231                                 }
8232                                 dlc[5] = (byte)(b2_config->info[3] - 1);
8233                                 dlc[6] = b2_config->info[4];
8234                                 if (llc[1] == V120_V42BIS) {
8235                                         if (b2_config->length >= 10) {
8236                                                 dlc[7] = 6;
8237                                                 dlc[8] = 0;
8238                                                 dlc[9] = b2_config_parms[4].info[0];
8239                                                 dlc[10] = b2_config_parms[4].info[1];
8240                                                 dlc[11] = b2_config_parms[5].info[0];
8241                                                 dlc[12] = b2_config_parms[5].info[1];
8242                                                 dlc[13] = b2_config_parms[6].info[0];
8243                                                 dlc[14] = b2_config_parms[6].info[1];
8244                                                 dlc[0] = 14;
8245                                                 dbug(1, dprintf("b2_config_parms[4].info[0] [1]:  %x %x", b2_config_parms[4].info[0], b2_config_parms[4].info[1]));
8246                                                 dbug(1, dprintf("b2_config_parms[5].info[0] [1]:  %x %x", b2_config_parms[5].info[0], b2_config_parms[5].info[1]));
8247                                                 dbug(1, dprintf("b2_config_parms[6].info[0] [1]:  %x %x", b2_config_parms[6].info[0], b2_config_parms[6].info[1]));
8248                                         }
8249                                         else {
8250                                                 dlc[6] = 14;
8251                                         }
8252                                 }
8253                         }
8254                 }
8255                 else
8256                 {
8257                         if (b2_config->length)
8258                         {
8259                                 dbug(1, dprintf("B2-Config"));
8260                                 if (llc[1] == X75_V42BIS) {
8261                                         if (api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbwww", b2_config_parms))
8262                                         {
8263                                                 return _WRONG_MESSAGE_FORMAT;
8264                                         }
8265                                 }
8266                                 else {
8267                                         if (api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbs", b2_config_parms))
8268                                         {
8269                                                 return _WRONG_MESSAGE_FORMAT;
8270                                         }
8271                                 }
8272                                 /* if B2 Protocol is LAPD, b2_config structure is different */
8273                                 if (llc[1] == 6)
8274                                 {
8275                                         dlc[0] = 4;
8276                                         if (b2_config->length >= 1) dlc[2] = b2_config->info[1];      /* TEI */
8277                                         else dlc[2] = 0x01;
8278                                         if ((b2_config->length >= 2) && (plci->B2_prot == 12))
8279                                         {
8280                                                 SAPI = b2_config->info[2];    /* SAPI */
8281                                         }
8282                                         dlc[1] = SAPI;
8283                                         if ((b2_config->length >= 3) && (b2_config->info[3] == 128))
8284                                         {
8285                                                 dlc[3] = 127;      /* Mode */
8286                                         }
8287                                         else
8288                                         {
8289                                                 dlc[3] = 7;        /* Mode */
8290                                         }
8291
8292                                         if (b2_config->length >= 4) dlc[4] = b2_config->info[4];      /* Window */
8293                                         else dlc[4] = 1;
8294                                         dbug(1, dprintf("D-dlc[%d]=%x,%x,%x,%x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4]));
8295                                         if (b2_config->length > 5) return _B2_PARM_NOT_SUPPORTED;
8296                                 }
8297                                 else
8298                                 {
8299                                         dlc[0] = (byte)(b2_config_parms[4].length + 6);
8300                                         dlc[3] = b2_config->info[1];
8301                                         dlc[4] = b2_config->info[2];
8302                                         if (b2_config->info[3] != 8 && b2_config->info[3] != 128) {
8303                                                 dbug(1, dprintf("1D-dlc= %x %x %x %x %x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4]));
8304                                                 return _B2_PARM_NOT_SUPPORTED;
8305                                         }
8306
8307                                         dlc[5] = (byte)(b2_config->info[3] - 1);
8308                                         dlc[6] = b2_config->info[4];
8309                                         if (dlc[6] > dlc[5]) {
8310                                                 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]));
8311                                                 return _B2_PARM_NOT_SUPPORTED;
8312                                         }
8313
8314                                         if (llc[1] == X75_V42BIS) {
8315                                                 if (b2_config->length >= 10) {
8316                                                         dlc[7] = 6;
8317                                                         dlc[8] = 0;
8318                                                         dlc[9] = b2_config_parms[4].info[0];
8319                                                         dlc[10] = b2_config_parms[4].info[1];
8320                                                         dlc[11] = b2_config_parms[5].info[0];
8321                                                         dlc[12] = b2_config_parms[5].info[1];
8322                                                         dlc[13] = b2_config_parms[6].info[0];
8323                                                         dlc[14] = b2_config_parms[6].info[1];
8324                                                         dlc[0] = 14;
8325                                                         dbug(1, dprintf("b2_config_parms[4].info[0] [1]:  %x %x", b2_config_parms[4].info[0], b2_config_parms[4].info[1]));
8326                                                         dbug(1, dprintf("b2_config_parms[5].info[0] [1]:  %x %x", b2_config_parms[5].info[0], b2_config_parms[5].info[1]));
8327                                                         dbug(1, dprintf("b2_config_parms[6].info[0] [1]:  %x %x", b2_config_parms[6].info[0], b2_config_parms[6].info[1]));
8328                                                 }
8329                                                 else {
8330                                                         dlc[6] = 14;
8331                                                 }
8332
8333                                         }
8334                                         else {
8335                                                 PUT_WORD(&dlc[7], (word)b2_config_parms[4].length);
8336                                                 for (i = 0; i < b2_config_parms[4].length; i++)
8337                                                         dlc[11 + i] = b2_config_parms[4].info[1 + i];
8338                                         }
8339                                 }
8340                         }
8341                 }
8342         add_p(plci, DLC, dlc);
8343
8344         b3_config = &bp_parms[5];
8345         if (b3_config->length)
8346         {
8347                 if (plci->B3_prot == 4
8348                     || plci->B3_prot == 5)
8349                 {
8350                         if (api_parse(&b3_config->info[1], (word)b3_config->length, "wwss", b3_config_parms))
8351                         {
8352                                 return _WRONG_MESSAGE_FORMAT;
8353                         }
8354                         i = GET_WORD((byte *)(b3_config_parms[0].info));
8355                         ((T30_INFO *)&nlc[1])->resolution = (byte)(((i & 0x0001) ||
8356                                                                     ((plci->B3_prot == 4) && (((byte)(GET_WORD((byte *)b3_config_parms[1].info))) != 5))) ? T30_RESOLUTION_R8_0770_OR_200 : 0);
8357                         ((T30_INFO *)&nlc[1])->data_format = (byte)(GET_WORD((byte *)b3_config_parms[1].info));
8358                         fax_control_bits = T30_CONTROL_BIT_ALL_FEATURES;
8359                         if ((((T30_INFO *)&nlc[1])->rate_div_2400 != 0) && (((T30_INFO *)&nlc[1])->rate_div_2400 <= 6))
8360                                 fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_V34FAX;
8361                         if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
8362                         {
8363
8364                                 if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
8365                                     & (1L << PRIVATE_FAX_PAPER_FORMATS))
8366                                 {
8367                                         ((T30_INFO *)&nlc[1])->resolution |= T30_RESOLUTION_R8_1540 |
8368                                                 T30_RESOLUTION_R16_1540_OR_400 | T30_RESOLUTION_300_300 |
8369                                                 T30_RESOLUTION_INCH_BASED | T30_RESOLUTION_METRIC_BASED;
8370                                 }
8371
8372                                 ((T30_INFO *)&nlc[1])->recording_properties =
8373                                         T30_RECORDING_WIDTH_ISO_A3 |
8374                                         (T30_RECORDING_LENGTH_UNLIMITED << 2) |
8375                                         (T30_MIN_SCANLINE_TIME_00_00_00 << 4);
8376                         }
8377                         if (plci->B3_prot == 5)
8378                         {
8379                                 if (i & 0x0002) /* Accept incoming fax-polling requests */
8380                                         fax_control_bits |= T30_CONTROL_BIT_ACCEPT_POLLING;
8381                                 if (i & 0x2000) /* Do not use MR compression */
8382                                         fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_2D_CODING;
8383                                 if (i & 0x4000) /* Do not use MMR compression */
8384                                         fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_T6_CODING;
8385                                 if (i & 0x8000) /* Do not use ECM */
8386                                         fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_ECM;
8387                                 if (plci->fax_connect_info_length != 0)
8388                                 {
8389                                         ((T30_INFO *)&nlc[1])->resolution = ((T30_INFO *)plci->fax_connect_info_buffer)->resolution;
8390                                         ((T30_INFO *)&nlc[1])->data_format = ((T30_INFO *)plci->fax_connect_info_buffer)->data_format;
8391                                         ((T30_INFO *)&nlc[1])->recording_properties = ((T30_INFO *)plci->fax_connect_info_buffer)->recording_properties;
8392                                         fax_control_bits |= GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low) &
8393                                                 (T30_CONTROL_BIT_REQUEST_POLLING | T30_CONTROL_BIT_MORE_DOCUMENTS);
8394                                 }
8395                         }
8396                         /* copy station id to NLC */
8397                         for (i = 0; i < T30_MAX_STATION_ID_LENGTH; i++)
8398                         {
8399                                 if (i < b3_config_parms[2].length)
8400                                 {
8401                                         ((T30_INFO *)&nlc[1])->station_id[i] = ((byte *)b3_config_parms[2].info)[1 + i];
8402                                 }
8403                                 else
8404                                 {
8405                                         ((T30_INFO *)&nlc[1])->station_id[i] = ' ';
8406                                 }
8407                         }
8408                         ((T30_INFO *)&nlc[1])->station_id_len = T30_MAX_STATION_ID_LENGTH;
8409                         /* copy head line to NLC */
8410                         if (b3_config_parms[3].length)
8411                         {
8412
8413                                 pos = (byte)(fax_head_line_time(&(((T30_INFO *)&nlc[1])->station_id[T30_MAX_STATION_ID_LENGTH])));
8414                                 if (pos != 0)
8415                                 {
8416                                         if (CAPI_MAX_DATE_TIME_LENGTH + 2 + b3_config_parms[3].length > CAPI_MAX_HEAD_LINE_SPACE)
8417                                                 pos = 0;
8418                                         else
8419                                         {
8420                                                 nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
8421                                                 nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
8422                                                 len = (byte)b3_config_parms[2].length;
8423                                                 if (len > 20)
8424                                                         len = 20;
8425                                                 if (CAPI_MAX_DATE_TIME_LENGTH + 2 + len + 2 + b3_config_parms[3].length <= CAPI_MAX_HEAD_LINE_SPACE)
8426                                                 {
8427                                                         for (i = 0; i < len; i++)
8428                                                                 nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ((byte *)b3_config_parms[2].info)[1 + i];
8429                                                         nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
8430                                                         nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
8431                                                 }
8432                                         }
8433                                 }
8434
8435                                 len = (byte)b3_config_parms[3].length;
8436                                 if (len > CAPI_MAX_HEAD_LINE_SPACE - pos)
8437                                         len = (byte)(CAPI_MAX_HEAD_LINE_SPACE - pos);
8438                                 ((T30_INFO *)&nlc[1])->head_line_len = (byte)(pos + len);
8439                                 nlc[0] += (byte)(pos + len);
8440                                 for (i = 0; i < len; i++)
8441                                         nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] =  ((byte *)b3_config_parms[3].info)[1 + i];
8442                         } else
8443                                 ((T30_INFO *)&nlc[1])->head_line_len = 0;
8444
8445                         plci->nsf_control_bits = 0;
8446                         if (plci->B3_prot == 5)
8447                         {
8448                                 if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_FAX_SUB_SEP_PWD))
8449                                     && (GET_WORD((byte *)b3_config_parms[1].info) & 0x8000)) /* Private SUB/SEP/PWD enable */
8450                                 {
8451                                         plci->requested_options |= 1L << PRIVATE_FAX_SUB_SEP_PWD;
8452                                 }
8453                                 if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_FAX_NONSTANDARD))
8454                                     && (GET_WORD((byte *)b3_config_parms[1].info) & 0x4000)) /* Private non-standard facilities enable */
8455                                 {
8456                                         plci->requested_options |= 1L << PRIVATE_FAX_NONSTANDARD;
8457                                 }
8458                                 if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
8459                                     & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
8460                                 {
8461                                         if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
8462                                             & (1L << PRIVATE_FAX_SUB_SEP_PWD))
8463                                         {
8464                                                 fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_PASSWORD;
8465                                                 if (fax_control_bits & T30_CONTROL_BIT_ACCEPT_POLLING)
8466                                                         fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SEL_POLLING;
8467                                         }
8468                                         len = nlc[0];
8469                                         pos = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
8470                                         if (pos < plci->fax_connect_info_length)
8471                                         {
8472                                                 for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--)
8473                                                         nlc[++len] = plci->fax_connect_info_buffer[pos++];
8474                                         }
8475                                         else
8476                                                 nlc[++len] = 0;
8477                                         if (pos < plci->fax_connect_info_length)
8478                                         {
8479                                                 for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--)
8480                                                         nlc[++len] = plci->fax_connect_info_buffer[pos++];
8481                                         }
8482                                         else
8483                                                 nlc[++len] = 0;
8484                                         if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
8485                                             & (1L << PRIVATE_FAX_NONSTANDARD))
8486                                         {
8487                                                 if ((pos < plci->fax_connect_info_length) && (plci->fax_connect_info_buffer[pos] != 0))
8488                                                 {
8489                                                         if ((plci->fax_connect_info_buffer[pos] >= 3) && (plci->fax_connect_info_buffer[pos + 1] >= 2))
8490                                                                 plci->nsf_control_bits = GET_WORD(&plci->fax_connect_info_buffer[pos + 2]);
8491                                                         for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--)
8492                                                                 nlc[++len] = plci->fax_connect_info_buffer[pos++];
8493                                                 }
8494                                                 else
8495                                                 {
8496                                                         if (api_parse(&b3_config->info[1], (word)b3_config->length, "wwsss", b3_config_parms))
8497                                                         {
8498                                                                 dbug(1, dprintf("non-standard facilities info missing or wrong format"));
8499                                                                 nlc[++len] = 0;
8500                                                         }
8501                                                         else
8502                                                         {
8503                                                                 if ((b3_config_parms[4].length >= 3) && (b3_config_parms[4].info[1] >= 2))
8504                                                                         plci->nsf_control_bits = GET_WORD(&b3_config_parms[4].info[2]);
8505                                                                 nlc[++len] = (byte)(b3_config_parms[4].length);
8506                                                                 for (i = 0; i < b3_config_parms[4].length; i++)
8507                                                                         nlc[++len] = b3_config_parms[4].info[1 + i];
8508                                                         }
8509                                                 }
8510                                         }
8511                                         nlc[0] = len;
8512                                         if ((plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF)
8513                                             && (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP))
8514                                         {
8515                                                 ((T30_INFO *)&nlc[1])->operating_mode = T30_OPERATING_MODE_CAPI_NEG;
8516                                         }
8517                                 }
8518                         }
8519
8520                         PUT_WORD(&(((T30_INFO *)&nlc[1])->control_bits_low), fax_control_bits);
8521                         len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
8522                         for (i = 0; i < len; i++)
8523                                 plci->fax_connect_info_buffer[i] = nlc[1 + i];
8524                         ((T30_INFO *) plci->fax_connect_info_buffer)->head_line_len = 0;
8525                         i += ((T30_INFO *)&nlc[1])->head_line_len;
8526                         while (i < nlc[0])
8527                                 plci->fax_connect_info_buffer[len++] = nlc[++i];
8528                         plci->fax_connect_info_length = len;
8529                 }
8530                 else
8531                 {
8532                         nlc[0] = 14;
8533                         if (b3_config->length != 16)
8534                                 return _B3_PARM_NOT_SUPPORTED;
8535                         for (i = 0; i < 12; i++) nlc[1 + i] = b3_config->info[1 + i];
8536                         if (GET_WORD(&b3_config->info[13]) != 8 && GET_WORD(&b3_config->info[13]) != 128)
8537                                 return _B3_PARM_NOT_SUPPORTED;
8538                         nlc[13] = b3_config->info[13];
8539                         if (GET_WORD(&b3_config->info[15]) >= nlc[13])
8540                                 return _B3_PARM_NOT_SUPPORTED;
8541                         nlc[14] = b3_config->info[15];
8542                 }
8543         }
8544         else
8545         {
8546                 if (plci->B3_prot == 4
8547                     || plci->B3_prot == 5 /*T.30 - FAX*/) return _B3_PARM_NOT_SUPPORTED;
8548         }
8549         add_p(plci, NLC, nlc);
8550         return 0;
8551 }
8552
8553 /*----------------------------------------------------------------*/
8554 /*      make the same as add_b23, but only for the modem related  */
8555 /*      L2 and L3 B-Chan protocol.                                */
8556 /*                                                                */
8557 /*      Enabled L2 and L3 Configurations:                         */
8558 /*        If L1 == Modem all negotiation                          */
8559 /*          only L2 == Modem with full negotiation is allowed     */
8560 /*        If L1 == Modem async or sync                            */
8561 /*          only L2 == Transparent is allowed                     */
8562 /*        L3 == Modem or L3 == Transparent are allowed            */
8563 /*      B2 Configuration for modem:                               */
8564 /*          word : enable/disable compression, bitoptions         */
8565 /*      B3 Configuration for modem:                               */
8566 /*          empty                                                 */
8567 /*----------------------------------------------------------------*/
8568 static word add_modem_b23(PLCI *plci, API_PARSE *bp_parms)
8569 {
8570         static byte lli[12] = {1,1};
8571         static byte llc[3] = {2,0,0};
8572         static byte dlc[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
8573         API_PARSE mdm_config[2];
8574         word i;
8575         word b2_config = 0;
8576
8577         for (i = 0; i < 2; i++) mdm_config[i].length = 0;
8578         for (i = 0; i < sizeof(dlc); i++) dlc[i] = 0;
8579
8580         if (((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE)
8581              && (GET_WORD(bp_parms[1].info) != B2_MODEM_EC_COMPRESSION))
8582             || ((GET_WORD(bp_parms[0].info) != B1_MODEM_ALL_NEGOTIATE)
8583                 && (GET_WORD(bp_parms[1].info) != B2_TRANSPARENT)))
8584         {
8585                 return (_B_STACK_NOT_SUPPORTED);
8586         }
8587         if ((GET_WORD(bp_parms[2].info) != B3_MODEM)
8588             && (GET_WORD(bp_parms[2].info) != B3_TRANSPARENT))
8589         {
8590                 return (_B_STACK_NOT_SUPPORTED);
8591         }
8592
8593         plci->B2_prot = (byte) GET_WORD(bp_parms[1].info);
8594         plci->B3_prot = (byte) GET_WORD(bp_parms[2].info);
8595
8596         if ((GET_WORD(bp_parms[1].info) == B2_MODEM_EC_COMPRESSION) && bp_parms[4].length)
8597         {
8598                 if (api_parse(&bp_parms[4].info[1],
8599                               (word)bp_parms[4].length, "w",
8600                               mdm_config))
8601                 {
8602                         return (_WRONG_MESSAGE_FORMAT);
8603                 }
8604                 b2_config = GET_WORD(mdm_config[0].info);
8605         }
8606
8607         /* OK, L2 is modem */
8608
8609         lli[0] = 1;
8610         lli[1] = 1;
8611         if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL)
8612                 lli[1] |= 2;
8613         if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL)
8614                 lli[1] |= 4;
8615
8616         if ((lli[1] & 0x02) && (diva_xdi_extended_features & DIVA_CAPI_USE_CMA)) {
8617                 lli[1] |= 0x10;
8618                 if (plci->rx_dma_descriptor <= 0) {
8619                         plci->rx_dma_descriptor = diva_get_dma_descriptor(plci, &plci->rx_dma_magic);
8620                         if (plci->rx_dma_descriptor >= 0)
8621                                 plci->rx_dma_descriptor++;
8622                 }
8623                 if (plci->rx_dma_descriptor > 0) {
8624                         lli[1] |= 0x40;
8625                         lli[0] = 6;
8626                         lli[2] = (byte)(plci->rx_dma_descriptor - 1);
8627                         lli[3] = (byte)plci->rx_dma_magic;
8628                         lli[4] = (byte)(plci->rx_dma_magic >>  8);
8629                         lli[5] = (byte)(plci->rx_dma_magic >> 16);
8630                         lli[6] = (byte)(plci->rx_dma_magic >> 24);
8631                 }
8632         }
8633
8634         if (DIVA_CAPI_SUPPORTS_NO_CANCEL(plci->adapter)) {
8635                 lli[1] |= 0x20;
8636         }
8637
8638         llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ?
8639                 /*V42*/ 10 : /*V42_IN*/ 9;
8640         llc[2] = 4;                      /* pass L3 always transparent */
8641         add_p(plci, LLI, lli);
8642         add_p(plci, LLC, llc);
8643         i =  1;
8644         PUT_WORD(&dlc[i], plci->appl->MaxDataLength);
8645         i += 2;
8646         if (GET_WORD(bp_parms[1].info) == B2_MODEM_EC_COMPRESSION)
8647         {
8648                 if (bp_parms[4].length)
8649                 {
8650                         dbug(1, dprintf("MDM b2_config=%02x", b2_config));
8651                         dlc[i++] = 3; /* Addr A */
8652                         dlc[i++] = 1; /* Addr B */
8653                         dlc[i++] = 7; /* modulo mode */
8654                         dlc[i++] = 7; /* window size */
8655                         dlc[i++] = 0; /* XID len Lo  */
8656                         dlc[i++] = 0; /* XID len Hi  */
8657
8658                         if (b2_config & MDM_B2_DISABLE_V42bis)
8659                         {
8660                                 dlc[i] |= DLC_MODEMPROT_DISABLE_V42_V42BIS;
8661                         }
8662                         if (b2_config & MDM_B2_DISABLE_MNP)
8663                         {
8664                                 dlc[i] |= DLC_MODEMPROT_DISABLE_MNP_MNP5;
8665                         }
8666                         if (b2_config & MDM_B2_DISABLE_TRANS)
8667                         {
8668                                 dlc[i] |= DLC_MODEMPROT_REQUIRE_PROTOCOL;
8669                         }
8670                         if (b2_config & MDM_B2_DISABLE_V42)
8671                         {
8672                                 dlc[i] |= DLC_MODEMPROT_DISABLE_V42_DETECT;
8673                         }
8674                         if (b2_config & MDM_B2_DISABLE_COMP)
8675                         {
8676                                 dlc[i] |= DLC_MODEMPROT_DISABLE_COMPRESSION;
8677                         }
8678                         i++;
8679                 }
8680         }
8681         else
8682         {
8683                 dlc[i++] = 3; /* Addr A */
8684                 dlc[i++] = 1; /* Addr B */
8685                 dlc[i++] = 7; /* modulo mode */
8686                 dlc[i++] = 7; /* window size */
8687                 dlc[i++] = 0; /* XID len Lo  */
8688                 dlc[i++] = 0; /* XID len Hi  */
8689                 dlc[i++] = DLC_MODEMPROT_DISABLE_V42_V42BIS |
8690                         DLC_MODEMPROT_DISABLE_MNP_MNP5 |
8691                         DLC_MODEMPROT_DISABLE_V42_DETECT |
8692                         DLC_MODEMPROT_DISABLE_COMPRESSION;
8693         }
8694         dlc[0] = (byte)(i - 1);
8695 /* HexDump ("DLC", sizeof(dlc), &dlc[0]); */
8696         add_p(plci, DLC, dlc);
8697         return (0);
8698 }
8699
8700
8701 /*------------------------------------------------------------------*/
8702 /* send a request for the signaling entity                          */
8703 /*------------------------------------------------------------------*/
8704
8705 static void sig_req(PLCI *plci, byte req, byte Id)
8706 {
8707         if (!plci) return;
8708         if (plci->adapter->adapter_disabled) return;
8709         dbug(1, dprintf("sig_req(%x)", req));
8710         if (req == REMOVE)
8711                 plci->sig_remove_id = plci->Sig.Id;
8712         if (plci->req_in == plci->req_in_start) {
8713                 plci->req_in += 2;
8714                 plci->RBuffer[plci->req_in++] = 0;
8715         }
8716         PUT_WORD(&plci->RBuffer[plci->req_in_start], plci->req_in-plci->req_in_start - 2);
8717         plci->RBuffer[plci->req_in++] = Id;   /* sig/nl flag */
8718         plci->RBuffer[plci->req_in++] = req;  /* request */
8719         plci->RBuffer[plci->req_in++] = 0;    /* channel */
8720         plci->req_in_start = plci->req_in;
8721 }
8722
8723 /*------------------------------------------------------------------*/
8724 /* send a request for the network layer entity                      */
8725 /*------------------------------------------------------------------*/
8726
8727 static void nl_req_ncci(PLCI *plci, byte req, byte ncci)
8728 {
8729         if (!plci) return;
8730         if (plci->adapter->adapter_disabled) return;
8731         dbug(1, dprintf("nl_req %02x %02x %02x", plci->Id, req, ncci));
8732         if (req == REMOVE)
8733         {
8734                 plci->nl_remove_id = plci->NL.Id;
8735                 ncci_remove(plci, 0, (byte)(ncci != 0));
8736                 ncci = 0;
8737         }
8738         if (plci->req_in == plci->req_in_start) {
8739                 plci->req_in += 2;
8740                 plci->RBuffer[plci->req_in++] = 0;
8741         }
8742         PUT_WORD(&plci->RBuffer[plci->req_in_start], plci->req_in-plci->req_in_start - 2);
8743         plci->RBuffer[plci->req_in++] = 1;    /* sig/nl flag */
8744         plci->RBuffer[plci->req_in++] = req;  /* request */
8745         plci->RBuffer[plci->req_in++] = plci->adapter->ncci_ch[ncci];   /* channel */
8746         plci->req_in_start = plci->req_in;
8747 }
8748
8749 static void send_req(PLCI *plci)
8750 {
8751         ENTITY *e;
8752         word l;
8753 /*  word i; */
8754
8755         if (!plci) return;
8756         if (plci->adapter->adapter_disabled) return;
8757         channel_xmit_xon(plci);
8758
8759         /* if nothing to do, return */
8760         if (plci->req_in == plci->req_out) return;
8761         dbug(1, dprintf("send_req(in=%d,out=%d)", plci->req_in, plci->req_out));
8762
8763         if (plci->nl_req || plci->sig_req) return;
8764
8765         l = GET_WORD(&plci->RBuffer[plci->req_out]);
8766         plci->req_out += 2;
8767         plci->XData[0].P = &plci->RBuffer[plci->req_out];
8768         plci->req_out += l;
8769         if (plci->RBuffer[plci->req_out] == 1)
8770         {
8771                 e = &plci->NL;
8772                 plci->req_out++;
8773                 e->Req = plci->nl_req = plci->RBuffer[plci->req_out++];
8774                 e->ReqCh = plci->RBuffer[plci->req_out++];
8775                 if (!(e->Id & 0x1f))
8776                 {
8777                         e->Id = NL_ID;
8778                         plci->RBuffer[plci->req_out - 4] = CAI;
8779                         plci->RBuffer[plci->req_out - 3] = 1;
8780                         plci->RBuffer[plci->req_out - 2] = (plci->Sig.Id == 0xff) ? 0 : plci->Sig.Id;
8781                         plci->RBuffer[plci->req_out - 1] = 0;
8782                         l += 3;
8783                         plci->nl_global_req = plci->nl_req;
8784                 }
8785                 dbug(1, dprintf("%x:NLREQ(%x:%x:%x)", plci->adapter->Id, e->Id, e->Req, e->ReqCh));
8786         }
8787         else
8788         {
8789                 e = &plci->Sig;
8790                 if (plci->RBuffer[plci->req_out])
8791                         e->Id = plci->RBuffer[plci->req_out];
8792                 plci->req_out++;
8793                 e->Req = plci->sig_req = plci->RBuffer[plci->req_out++];
8794                 e->ReqCh = plci->RBuffer[plci->req_out++];
8795                 if (!(e->Id & 0x1f))
8796                         plci->sig_global_req = plci->sig_req;
8797                 dbug(1, dprintf("%x:SIGREQ(%x:%x:%x)", plci->adapter->Id, e->Id, e->Req, e->ReqCh));
8798         }
8799         plci->XData[0].PLength = l;
8800         e->X = plci->XData;
8801         plci->adapter->request(e);
8802         dbug(1, dprintf("send_ok"));
8803 }
8804
8805 static void send_data(PLCI *plci)
8806 {
8807         DIVA_CAPI_ADAPTER *a;
8808         DATA_B3_DESC *data;
8809         NCCI   *ncci_ptr;
8810         word ncci;
8811
8812         if (!plci->nl_req && plci->ncci_ring_list)
8813         {
8814                 a = plci->adapter;
8815                 ncci = plci->ncci_ring_list;
8816                 do
8817                 {
8818                         ncci = a->ncci_next[ncci];
8819                         ncci_ptr = &(a->ncci[ncci]);
8820                         if (!(a->ncci_ch[ncci]
8821                               && (a->ch_flow_control[a->ncci_ch[ncci]] & N_OK_FC_PENDING)))
8822                         {
8823                                 if (ncci_ptr->data_pending)
8824                                 {
8825                                         if ((a->ncci_state[ncci] == CONNECTED)
8826                                             || (a->ncci_state[ncci] == INC_ACT_PENDING)
8827                                             || (plci->send_disc == ncci))
8828                                         {
8829                                                 data = &(ncci_ptr->DBuffer[ncci_ptr->data_out]);
8830                                                 if ((plci->B2_prot == B2_V120_ASYNC)
8831                                                     || (plci->B2_prot == B2_V120_ASYNC_V42BIS)
8832                                                     || (plci->B2_prot == B2_V120_BIT_TRANSPARENT))
8833                                                 {
8834                                                         plci->NData[1].P = TransmitBufferGet(plci->appl, data->P);
8835                                                         plci->NData[1].PLength = data->Length;
8836                                                         if (data->Flags & 0x10)
8837                                                                 plci->NData[0].P = v120_break_header;
8838                                                         else
8839                                                                 plci->NData[0].P = v120_default_header;
8840                                                         plci->NData[0].PLength = 1;
8841                                                         plci->NL.XNum = 2;
8842                                                         plci->NL.Req = plci->nl_req = (byte)((data->Flags & 0x07) << 4 | N_DATA);
8843                                                 }
8844                                                 else
8845                                                 {
8846                                                         plci->NData[0].P = TransmitBufferGet(plci->appl, data->P);
8847                                                         plci->NData[0].PLength = data->Length;
8848                                                         if (data->Flags & 0x10)
8849                                                                 plci->NL.Req = plci->nl_req = (byte)N_UDATA;
8850
8851                                                         else if ((plci->B3_prot == B3_RTP) && (data->Flags & 0x01))
8852                                                                 plci->NL.Req = plci->nl_req = (byte)N_BDATA;
8853
8854                                                         else
8855                                                                 plci->NL.Req = plci->nl_req = (byte)((data->Flags & 0x07) << 4 | N_DATA);
8856                                                 }
8857                                                 plci->NL.X = plci->NData;
8858                                                 plci->NL.ReqCh = a->ncci_ch[ncci];
8859                                                 dbug(1, dprintf("%x:DREQ(%x:%x)", a->Id, plci->NL.Id, plci->NL.Req));
8860                                                 plci->data_sent = true;
8861                                                 plci->data_sent_ptr = data->P;
8862                                                 a->request(&plci->NL);
8863                                         }
8864                                         else {
8865                                                 cleanup_ncci_data(plci, ncci);
8866                                         }
8867                                 }
8868                                 else if (plci->send_disc == ncci)
8869                                 {
8870                                         /* dprintf("N_DISC"); */
8871                                         plci->NData[0].PLength = 0;
8872                                         plci->NL.ReqCh = a->ncci_ch[ncci];
8873                                         plci->NL.Req = plci->nl_req = N_DISC;
8874                                         a->request(&plci->NL);
8875                                         plci->command = _DISCONNECT_B3_R;
8876                                         plci->send_disc = 0;
8877                                 }
8878                         }
8879                 } while (!plci->nl_req && (ncci != plci->ncci_ring_list));
8880                 plci->ncci_ring_list = ncci;
8881         }
8882 }
8883
8884 static void listen_check(DIVA_CAPI_ADAPTER *a)
8885 {
8886         word i, j;
8887         PLCI *plci;
8888         byte activnotifiedcalls = 0;
8889
8890         dbug(1, dprintf("listen_check(%d,%d)", a->listen_active, a->max_listen));
8891         if (!remove_started && !a->adapter_disabled)
8892         {
8893                 for (i = 0; i < a->max_plci; i++)
8894                 {
8895                         plci = &(a->plci[i]);
8896                         if (plci->notifiedcall) activnotifiedcalls++;
8897                 }
8898                 dbug(1, dprintf("listen_check(%d)", activnotifiedcalls));
8899
8900                 for (i = a->listen_active; i < ((word)(a->max_listen + activnotifiedcalls)); i++) {
8901                         if ((j = get_plci(a))) {
8902                                 a->listen_active++;
8903                                 plci = &a->plci[j - 1];
8904                                 plci->State = LISTENING;
8905
8906                                 add_p(plci, OAD, "\x01\xfd");
8907
8908                                 add_p(plci, KEY, "\x04\x43\x41\x32\x30");
8909
8910                                 add_p(plci, CAI, "\x01\xc0");
8911                                 add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
8912                                 add_p(plci, LLI, "\x01\xc4");                  /* support Dummy CR FAC + MWI + SpoofNotify */
8913                                 add_p(plci, SHIFT | 6, NULL);
8914                                 add_p(plci, SIN, "\x02\x00\x00");
8915                                 plci->internal_command = LISTEN_SIG_ASSIGN_PEND;     /* do indicate_req if OK  */
8916                                 sig_req(plci, ASSIGN, DSIG_ID);
8917                                 send_req(plci);
8918                         }
8919                 }
8920         }
8921 }
8922
8923 /*------------------------------------------------------------------*/
8924 /* functions for all parameters sent in INDs                        */
8925 /*------------------------------------------------------------------*/
8926
8927 static void IndParse(PLCI *plci, word *parms_id, byte **parms, byte multiIEsize)
8928 {
8929         word ploc;            /* points to current location within packet */
8930         byte w;
8931         byte wlen;
8932         byte codeset, lock;
8933         byte *in;
8934         word i;
8935         word code;
8936         word mIEindex = 0;
8937         ploc = 0;
8938         codeset = 0;
8939         lock = 0;
8940
8941         in = plci->Sig.RBuffer->P;
8942         for (i = 0; i < parms_id[0]; i++)   /* multiIE parms_id contains just the 1st */
8943         {                            /* element but parms array is larger      */
8944                 parms[i] = (byte *)"";
8945         }
8946         for (i = 0; i < multiIEsize; i++)
8947         {
8948                 parms[i] = (byte *)"";
8949         }
8950
8951         while (ploc < plci->Sig.RBuffer->length - 1) {
8952
8953                 /* read information element id and length                   */
8954                 w = in[ploc];
8955
8956                 if (w & 0x80) {
8957 /*    w &=0xf0; removed, cannot detect congestion levels */
8958 /*    upper 4 bit masked with w==SHIFT now               */
8959                         wlen = 0;
8960                 }
8961                 else {
8962                         wlen = (byte)(in[ploc + 1] + 1);
8963                 }
8964                 /* check if length valid (not exceeding end of packet)      */
8965                 if ((ploc + wlen) > 270) return;
8966                 if (lock & 0x80) lock &= 0x7f;
8967                 else codeset = lock;
8968
8969                 if ((w & 0xf0) == SHIFT) {
8970                         codeset = in[ploc];
8971                         if (!(codeset & 0x08)) lock = (byte)(codeset & 7);
8972                         codeset &= 7;
8973                         lock |= 0x80;
8974                 }
8975                 else {
8976                         if (w == ESC && wlen >= 3) code = in[ploc + 2] | 0x800;
8977                         else code = w;
8978                         code |= (codeset << 8);
8979
8980                         for (i = 1; i < parms_id[0] + 1 && parms_id[i] != code; i++);
8981
8982                         if (i < parms_id[0] + 1) {
8983                                 if (!multiIEsize) { /* with multiIEs use next field index,          */
8984                                         mIEindex = i - 1;    /* with normal IEs use same index like parms_id */
8985                                 }
8986
8987                                 parms[mIEindex] = &in[ploc + 1];
8988                                 dbug(1, dprintf("mIE[%d]=0x%x", *parms[mIEindex], in[ploc]));
8989                                 if (parms_id[i] == OAD
8990                                     || parms_id[i] == CONN_NR
8991                                     || parms_id[i] == CAD) {
8992                                         if (in[ploc + 2] & 0x80) {
8993                                                 in[ploc + 0] = (byte)(in[ploc + 1] + 1);
8994                                                 in[ploc + 1] = (byte)(in[ploc + 2] & 0x7f);
8995                                                 in[ploc + 2] = 0x80;
8996                                                 parms[mIEindex] = &in[ploc];
8997                                         }
8998                                 }
8999                                 mIEindex++;       /* effects multiIEs only */
9000                         }
9001                 }
9002
9003                 ploc += (wlen + 1);
9004         }
9005         return;
9006 }
9007
9008 /*------------------------------------------------------------------*/
9009 /* try to match a cip from received BC and HLC                      */
9010 /*------------------------------------------------------------------*/
9011
9012 static byte ie_compare(byte *ie1, byte *ie2)
9013 {
9014         word i;
9015         if (!ie1 || !ie2) return false;
9016         if (!ie1[0]) return false;
9017         for (i = 0; i < (word)(ie1[0] + 1); i++) if (ie1[i] != ie2[i]) return false;
9018         return true;
9019 }
9020
9021 static word find_cip(DIVA_CAPI_ADAPTER *a, byte *bc, byte *hlc)
9022 {
9023         word i;
9024         word j;
9025
9026         for (i = 9; i && !ie_compare(bc, cip_bc[i][a->u_law]); i--);
9027
9028         for (j = 16; j < 29 &&
9029                      (!ie_compare(bc, cip_bc[j][a->u_law]) || !ie_compare(hlc, cip_hlc[j])); j++);
9030         if (j == 29) return i;
9031         return j;
9032 }
9033
9034
9035 static byte AddInfo(byte **add_i,
9036                     byte **fty_i,
9037                     byte *esc_chi,
9038                     byte *facility)
9039 {
9040         byte i;
9041         byte j;
9042         byte k;
9043         byte flen;
9044         byte len = 0;
9045         /* facility is a nested structure */
9046         /* FTY can be more than once      */
9047
9048         if (esc_chi[0] && !(esc_chi[esc_chi[0]] & 0x7f))
9049         {
9050                 add_i[0] = (byte *)"\x02\x02\x00"; /* use neither b nor d channel */
9051         }
9052
9053         else
9054         {
9055                 add_i[0] = (byte *)"";
9056         }
9057         if (!fty_i[0][0])
9058         {
9059                 add_i[3] = (byte *)"";
9060         }
9061         else
9062         {    /* facility array found  */
9063                 for (i = 0, j = 1; i < MAX_MULTI_IE && fty_i[i][0]; i++)
9064                 {
9065                         dbug(1, dprintf("AddIFac[%d]", fty_i[i][0]));
9066                         len += fty_i[i][0];
9067                         len += 2;
9068                         flen = fty_i[i][0];
9069                         facility[j++] = 0x1c; /* copy fac IE */
9070                         for (k = 0; k <= flen; k++, j++)
9071                         {
9072                                 facility[j] = fty_i[i][k];
9073 /*      dbug(1, dprintf("%x ",facility[j])); */
9074                         }
9075                 }
9076                 facility[0] = len;
9077                 add_i[3] = facility;
9078         }
9079 /*  dbug(1, dprintf("FacArrLen=%d ",len)); */
9080         len = add_i[0][0] + add_i[1][0] + add_i[2][0] + add_i[3][0];
9081         len += 4;                          /* calculate length of all */
9082         return (len);
9083 }
9084
9085 /*------------------------------------------------------------------*/
9086 /* voice and codec features                                         */
9087 /*------------------------------------------------------------------*/
9088
9089 static void SetVoiceChannel(PLCI *plci, byte *chi, DIVA_CAPI_ADAPTER *a)
9090 {
9091         byte voice_chi[] = "\x02\x18\x01";
9092         byte channel;
9093
9094         channel = chi[chi[0]] & 0x3;
9095         dbug(1, dprintf("ExtDevON(Ch=0x%x)", channel));
9096         voice_chi[2] = (channel) ? channel : 1;
9097         add_p(plci, FTY, "\x02\x01\x07");             /* B On, default on 1 */
9098         add_p(plci, ESC, voice_chi);                  /* Channel */
9099         sig_req(plci, TEL_CTRL, 0);
9100         send_req(plci);
9101         if (a->AdvSignalPLCI)
9102         {
9103                 adv_voice_write_coefs(a->AdvSignalPLCI, ADV_VOICE_WRITE_ACTIVATION);
9104         }
9105 }
9106
9107 static void VoiceChannelOff(PLCI *plci)
9108 {
9109         dbug(1, dprintf("ExtDevOFF"));
9110         add_p(plci, FTY, "\x02\x01\x08");             /* B Off */
9111         sig_req(plci, TEL_CTRL, 0);
9112         send_req(plci);
9113         if (plci->adapter->AdvSignalPLCI)
9114         {
9115                 adv_voice_clear_config(plci->adapter->AdvSignalPLCI);
9116         }
9117 }
9118
9119
9120 static word AdvCodecSupport(DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl,
9121                             byte hook_listen)
9122 {
9123         word j;
9124         PLCI *splci;
9125
9126         /* check if hardware supports handset with hook states (adv.codec) */
9127         /* or if just a on board codec is supported                        */
9128         /* the advanced codec plci is just for internal use                */
9129
9130         /* diva Pro with on-board codec:                                   */
9131         if (a->profile.Global_Options & HANDSET)
9132         {
9133                 /* new call, but hook states are already signalled */
9134                 if (a->AdvCodecFLAG)
9135                 {
9136                         if (a->AdvSignalAppl != appl || a->AdvSignalPLCI)
9137                         {
9138                                 dbug(1, dprintf("AdvSigPlci=0x%x", a->AdvSignalPLCI));
9139                                 return 0x2001; /* codec in use by another application */
9140                         }
9141                         if (plci != NULL)
9142                         {
9143                                 a->AdvSignalPLCI = plci;
9144                                 plci->tel = ADV_VOICE;
9145                         }
9146                         return 0;                      /* adv codec still used */
9147                 }
9148                 if ((j = get_plci(a)))
9149                 {
9150                         splci = &a->plci[j - 1];
9151                         splci->tel = CODEC_PERMANENT;
9152                         /* hook_listen indicates if a facility_req with handset/hook support */
9153                         /* was sent. Otherwise if just a call on an external device was made */
9154                         /* the codec will be used but the hook info will be discarded (just  */
9155                         /* the external controller is in use                                 */
9156                         if (hook_listen) splci->State = ADVANCED_VOICE_SIG;
9157                         else
9158                         {
9159                                 splci->State = ADVANCED_VOICE_NOSIG;
9160                                 if (plci)
9161                                 {
9162                                         plci->spoofed_msg = SPOOFING_REQUIRED;
9163                                 }
9164                                 /* indicate D-ch connect if  */
9165                         }                                        /* codec is connected OK     */
9166                         if (plci != NULL)
9167                         {
9168                                 a->AdvSignalPLCI = plci;
9169                                 plci->tel = ADV_VOICE;
9170                         }
9171                         a->AdvSignalAppl = appl;
9172                         a->AdvCodecFLAG = true;
9173                         a->AdvCodecPLCI = splci;
9174                         add_p(splci, CAI, "\x01\x15");
9175                         add_p(splci, LLI, "\x01\x00");
9176                         add_p(splci, ESC, "\x02\x18\x00");
9177                         add_p(splci, UID, "\x06\x43\x61\x70\x69\x32\x30");
9178                         splci->internal_command = PERM_COD_ASSIGN;
9179                         dbug(1, dprintf("Codec Assign"));
9180                         sig_req(splci, ASSIGN, DSIG_ID);
9181                         send_req(splci);
9182                 }
9183                 else
9184                 {
9185                         return 0x2001; /* wrong state, no more plcis */
9186                 }
9187         }
9188         else if (a->profile.Global_Options & ON_BOARD_CODEC)
9189         {
9190                 if (hook_listen) return 0x300B;               /* Facility not supported */
9191                 /* no hook with SCOM      */
9192                 if (plci != NULL) plci->tel = CODEC;
9193                 dbug(1, dprintf("S/SCOM codec"));
9194                 /* first time we use the scom-s codec we must shut down the internal   */
9195                 /* handset application of the card. This can be done by an assign with */
9196                 /* a cai with the 0x80 bit set. Assign return code is 'out of resource'*/
9197                 if (!a->scom_appl_disable) {
9198                         if ((j = get_plci(a))) {
9199                                 splci = &a->plci[j - 1];
9200                                 add_p(splci, CAI, "\x01\x80");
9201                                 add_p(splci, UID, "\x06\x43\x61\x70\x69\x32\x30");
9202                                 sig_req(splci, ASSIGN, 0xC0);  /* 0xc0 is the TEL_ID */
9203                                 send_req(splci);
9204                                 a->scom_appl_disable = true;
9205                         }
9206                         else{
9207                                 return 0x2001; /* wrong state, no more plcis */
9208                         }
9209                 }
9210         }
9211         else return 0x300B;               /* Facility not supported */
9212
9213         return 0;
9214 }
9215
9216
9217 static void CodecIdCheck(DIVA_CAPI_ADAPTER *a, PLCI *plci)
9218 {
9219
9220         dbug(1, dprintf("CodecIdCheck"));
9221
9222         if (a->AdvSignalPLCI == plci)
9223         {
9224                 dbug(1, dprintf("PLCI owns codec"));
9225                 VoiceChannelOff(a->AdvCodecPLCI);
9226                 if (a->AdvCodecPLCI->State == ADVANCED_VOICE_NOSIG)
9227                 {
9228                         dbug(1, dprintf("remove temp codec PLCI"));
9229                         plci_remove(a->AdvCodecPLCI);
9230                         a->AdvCodecFLAG  = 0;
9231                         a->AdvCodecPLCI  = NULL;
9232                         a->AdvSignalAppl = NULL;
9233                 }
9234                 a->AdvSignalPLCI = NULL;
9235         }
9236 }
9237
9238 /* -------------------------------------------------------------------
9239    Ask for physical address of card on PCI bus
9240    ------------------------------------------------------------------- */
9241 static void diva_ask_for_xdi_sdram_bar(DIVA_CAPI_ADAPTER *a,
9242                                        IDI_SYNC_REQ *preq) {
9243         a->sdram_bar = 0;
9244         if (diva_xdi_extended_features & DIVA_CAPI_XDI_PROVIDES_SDRAM_BAR) {
9245                 ENTITY *e = (ENTITY *)preq;
9246
9247                 e->user[0] = a->Id - 1;
9248                 preq->xdi_sdram_bar.info.bar    = 0;
9249                 preq->xdi_sdram_bar.Req         = 0;
9250                 preq->xdi_sdram_bar.Rc           = IDI_SYNC_REQ_XDI_GET_ADAPTER_SDRAM_BAR;
9251
9252                 (*(a->request))(e);
9253
9254                 a->sdram_bar = preq->xdi_sdram_bar.info.bar;
9255                 dbug(3, dprintf("A(%d) SDRAM BAR = %08x", a->Id, a->sdram_bar));
9256         }
9257 }
9258
9259 /* -------------------------------------------------------------------
9260    Ask XDI about extended features
9261    ------------------------------------------------------------------- */
9262 static void diva_get_extended_adapter_features(DIVA_CAPI_ADAPTER *a) {
9263         IDI_SYNC_REQ *preq;
9264         char buffer[((sizeof(preq->xdi_extended_features) + 4) > sizeof(ENTITY)) ? (sizeof(preq->xdi_extended_features) + 4) : sizeof(ENTITY)];
9265
9266         char features[4];
9267         preq = (IDI_SYNC_REQ *)&buffer[0];
9268
9269         if (!diva_xdi_extended_features) {
9270                 ENTITY *e = (ENTITY *)preq;
9271                 diva_xdi_extended_features |= 0x80000000;
9272
9273                 e->user[0] = a->Id - 1;
9274                 preq->xdi_extended_features.Req = 0;
9275                 preq->xdi_extended_features.Rc  = IDI_SYNC_REQ_XDI_GET_EXTENDED_FEATURES;
9276                 preq->xdi_extended_features.info.buffer_length_in_bytes = sizeof(features);
9277                 preq->xdi_extended_features.info.features = &features[0];
9278
9279                 (*(a->request))(e);
9280
9281                 if (features[0] & DIVA_XDI_EXTENDED_FEATURES_VALID) {
9282                         /*
9283                           Check features located in the byte '0'
9284                         */
9285                         if (features[0] & DIVA_XDI_EXTENDED_FEATURE_CMA) {
9286                                 diva_xdi_extended_features |= DIVA_CAPI_USE_CMA;
9287                         }
9288                         if (features[0] & DIVA_XDI_EXTENDED_FEATURE_RX_DMA) {
9289                                 diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_RX_DMA;
9290                                 dbug(1, dprintf("XDI provides RxDMA"));
9291                         }
9292                         if (features[0] & DIVA_XDI_EXTENDED_FEATURE_SDRAM_BAR) {
9293                                 diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_SDRAM_BAR;
9294                         }
9295                         if (features[0] & DIVA_XDI_EXTENDED_FEATURE_NO_CANCEL_RC) {
9296                                 diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_NO_CANCEL;
9297                                 dbug(3, dprintf("XDI provides NO_CANCEL_RC feature"));
9298                         }
9299
9300                 }
9301         }
9302
9303         diva_ask_for_xdi_sdram_bar(a, preq);
9304 }
9305
9306 /*------------------------------------------------------------------*/
9307 /* automatic law                                                    */
9308 /*------------------------------------------------------------------*/
9309 /* called from OS specific part after init time to get the Law              */
9310 /* a-law (Euro) and u-law (us,japan) use different BCs in the Setup message */
9311 void AutomaticLaw(DIVA_CAPI_ADAPTER *a)
9312 {
9313         word j;
9314         PLCI *splci;
9315
9316         if (a->automatic_law) {
9317                 return;
9318         }
9319         if ((j = get_plci(a))) {
9320                 diva_get_extended_adapter_features(a);
9321                 splci = &a->plci[j - 1];
9322                 a->automatic_lawPLCI = splci;
9323                 a->automatic_law = 1;
9324                 add_p(splci, CAI, "\x01\x80");
9325                 add_p(splci, UID, "\x06\x43\x61\x70\x69\x32\x30");
9326                 splci->internal_command = USELAW_REQ;
9327                 splci->command = 0;
9328                 splci->number = 0;
9329                 sig_req(splci, ASSIGN, DSIG_ID);
9330                 send_req(splci);
9331         }
9332 }
9333
9334 /* called from OS specific part if an application sends an Capi20Release */
9335 word CapiRelease(word Id)
9336 {
9337         word i, j, appls_found;
9338         PLCI *plci;
9339         APPL   *this;
9340         DIVA_CAPI_ADAPTER *a;
9341
9342         if (!Id)
9343         {
9344                 dbug(0, dprintf("A: CapiRelease(Id==0)"));
9345                 return (_WRONG_APPL_ID);
9346         }
9347
9348         this = &application[Id - 1];               /* get application pointer */
9349
9350         for (i = 0, appls_found = 0; i < max_appl; i++)
9351         {
9352                 if (application[i].Id)       /* an application has been found        */
9353                 {
9354                         appls_found++;
9355                 }
9356         }
9357
9358         for (i = 0; i < max_adapter; i++)             /* scan all adapters...    */
9359         {
9360                 a = &adapter[i];
9361                 if (a->request)
9362                 {
9363                         a->Info_Mask[Id - 1] = 0;
9364                         a->CIP_Mask[Id - 1] = 0;
9365                         a->Notification_Mask[Id - 1] = 0;
9366                         a->codec_listen[Id - 1] = NULL;
9367                         a->requested_options_table[Id - 1] = 0;
9368                         for (j = 0; j < a->max_plci; j++)           /* and all PLCIs connected */
9369                         {                                      /* with this application   */
9370                                 plci = &a->plci[j];
9371                                 if (plci->Id)                         /* if plci owns no application */
9372                                 {                                    /* it may be not jet connected */
9373                                         if (plci->State == INC_CON_PENDING
9374                                             || plci->State == INC_CON_ALERT)
9375                                         {
9376                                                 if (test_c_ind_mask_bit(plci, (word)(Id - 1)))
9377                                                 {
9378                                                         clear_c_ind_mask_bit(plci, (word)(Id - 1));
9379                                                         if (c_ind_mask_empty(plci))
9380                                                         {
9381                                                                 sig_req(plci, HANGUP, 0);
9382                                                                 send_req(plci);
9383                                                                 plci->State = OUTG_DIS_PENDING;
9384                                                         }
9385                                                 }
9386                                         }
9387                                         if (test_c_ind_mask_bit(plci, (word)(Id - 1)))
9388                                         {
9389                                                 clear_c_ind_mask_bit(plci, (word)(Id - 1));
9390                                                 if (c_ind_mask_empty(plci))
9391                                                 {
9392                                                         if (!plci->appl)
9393                                                         {
9394                                                                 plci_remove(plci);
9395                                                                 plci->State = IDLE;
9396                                                         }
9397                                                 }
9398                                         }
9399                                         if (plci->appl == this)
9400                                         {
9401                                                 plci->appl = NULL;
9402                                                 plci_remove(plci);
9403                                                 plci->State = IDLE;
9404                                         }
9405                                 }
9406                         }
9407                         listen_check(a);
9408
9409                         if (a->flag_dynamic_l1_down)
9410                         {
9411                                 if (appls_found == 1)            /* last application does a capi release */
9412                                 {
9413                                         if ((j = get_plci(a)))
9414                                         {
9415                                                 plci = &a->plci[j - 1];
9416                                                 plci->command = 0;
9417                                                 add_p(plci, OAD, "\x01\xfd");
9418                                                 add_p(plci, CAI, "\x01\x80");
9419                                                 add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
9420                                                 add_p(plci, SHIFT | 6, NULL);
9421                                                 add_p(plci, SIN, "\x02\x00\x00");
9422                                                 plci->internal_command = REM_L1_SIG_ASSIGN_PEND;
9423                                                 sig_req(plci, ASSIGN, DSIG_ID);
9424                                                 add_p(plci, FTY, "\x02\xff\x06"); /* l1 down */
9425                                                 sig_req(plci, SIG_CTRL, 0);
9426                                                 send_req(plci);
9427                                         }
9428                                 }
9429                         }
9430                         if (a->AdvSignalAppl == this)
9431                         {
9432                                 this->NullCREnable = false;
9433                                 if (a->AdvCodecPLCI)
9434                                 {
9435                                         plci_remove(a->AdvCodecPLCI);
9436                                         a->AdvCodecPLCI->tel = 0;
9437                                         a->AdvCodecPLCI->adv_nl = 0;
9438                                 }
9439                                 a->AdvSignalAppl = NULL;
9440                                 a->AdvSignalPLCI = NULL;
9441                                 a->AdvCodecFLAG = 0;
9442                                 a->AdvCodecPLCI = NULL;
9443                         }
9444                 }
9445         }
9446
9447         this->Id = 0;
9448
9449         return GOOD;
9450 }
9451
9452 static word plci_remove_check(PLCI *plci)
9453 {
9454         if (!plci) return true;
9455         if (!plci->NL.Id && c_ind_mask_empty(plci))
9456         {
9457                 if (plci->Sig.Id == 0xff)
9458                         plci->Sig.Id = 0;
9459                 if (!plci->Sig.Id)
9460                 {
9461                         dbug(1, dprintf("plci_remove_complete(%x)", plci->Id));
9462                         dbug(1, dprintf("tel=0x%x,Sig=0x%x", plci->tel, plci->Sig.Id));
9463                         if (plci->Id)
9464                         {
9465                                 CodecIdCheck(plci->adapter, plci);
9466                                 clear_b1_config(plci);
9467                                 ncci_remove(plci, 0, false);
9468                                 plci_free_msg_in_queue(plci);
9469                                 channel_flow_control_remove(plci);
9470                                 plci->Id = 0;
9471                                 plci->State = IDLE;
9472                                 plci->channels = 0;
9473                                 plci->appl = NULL;
9474                                 plci->notifiedcall = 0;
9475                         }
9476                         listen_check(plci->adapter);
9477                         return true;
9478                 }
9479         }
9480         return false;
9481 }
9482
9483
9484 /*------------------------------------------------------------------*/
9485
9486 static byte plci_nl_busy(PLCI *plci)
9487 {
9488         /* only applicable for non-multiplexed protocols */
9489         return (plci->nl_req
9490                 || (plci->ncci_ring_list
9491                     && plci->adapter->ncci_ch[plci->ncci_ring_list]
9492                     && (plci->adapter->ch_flow_control[plci->adapter->ncci_ch[plci->ncci_ring_list]] & N_OK_FC_PENDING)));
9493 }
9494
9495
9496 /*------------------------------------------------------------------*/
9497 /* DTMF facilities                                                  */
9498 /*------------------------------------------------------------------*/
9499
9500
9501 static struct
9502 {
9503         byte send_mask;
9504         byte listen_mask;
9505         byte character;
9506         byte code;
9507 } dtmf_digit_map[] =
9508 {
9509         { 0x01, 0x01, 0x23, DTMF_DIGIT_TONE_CODE_HASHMARK },
9510         { 0x01, 0x01, 0x2a, DTMF_DIGIT_TONE_CODE_STAR },
9511         { 0x01, 0x01, 0x30, DTMF_DIGIT_TONE_CODE_0 },
9512         { 0x01, 0x01, 0x31, DTMF_DIGIT_TONE_CODE_1 },
9513         { 0x01, 0x01, 0x32, DTMF_DIGIT_TONE_CODE_2 },
9514         { 0x01, 0x01, 0x33, DTMF_DIGIT_TONE_CODE_3 },
9515         { 0x01, 0x01, 0x34, DTMF_DIGIT_TONE_CODE_4 },
9516         { 0x01, 0x01, 0x35, DTMF_DIGIT_TONE_CODE_5 },
9517         { 0x01, 0x01, 0x36, DTMF_DIGIT_TONE_CODE_6 },
9518         { 0x01, 0x01, 0x37, DTMF_DIGIT_TONE_CODE_7 },
9519         { 0x01, 0x01, 0x38, DTMF_DIGIT_TONE_CODE_8 },
9520         { 0x01, 0x01, 0x39, DTMF_DIGIT_TONE_CODE_9 },
9521         { 0x01, 0x01, 0x41, DTMF_DIGIT_TONE_CODE_A },
9522         { 0x01, 0x01, 0x42, DTMF_DIGIT_TONE_CODE_B },
9523         { 0x01, 0x01, 0x43, DTMF_DIGIT_TONE_CODE_C },
9524         { 0x01, 0x01, 0x44, DTMF_DIGIT_TONE_CODE_D },
9525         { 0x01, 0x00, 0x61, DTMF_DIGIT_TONE_CODE_A },
9526         { 0x01, 0x00, 0x62, DTMF_DIGIT_TONE_CODE_B },
9527         { 0x01, 0x00, 0x63, DTMF_DIGIT_TONE_CODE_C },
9528         { 0x01, 0x00, 0x64, DTMF_DIGIT_TONE_CODE_D },
9529
9530         { 0x04, 0x04, 0x80, DTMF_SIGNAL_NO_TONE },
9531         { 0x00, 0x04, 0x81, DTMF_SIGNAL_UNIDENTIFIED_TONE },
9532         { 0x04, 0x04, 0x82, DTMF_SIGNAL_DIAL_TONE },
9533         { 0x04, 0x04, 0x83, DTMF_SIGNAL_PABX_INTERNAL_DIAL_TONE },
9534         { 0x04, 0x04, 0x84, DTMF_SIGNAL_SPECIAL_DIAL_TONE },
9535         { 0x04, 0x04, 0x85, DTMF_SIGNAL_SECOND_DIAL_TONE },
9536         { 0x04, 0x04, 0x86, DTMF_SIGNAL_RINGING_TONE },
9537         { 0x04, 0x04, 0x87, DTMF_SIGNAL_SPECIAL_RINGING_TONE },
9538         { 0x04, 0x04, 0x88, DTMF_SIGNAL_BUSY_TONE },
9539         { 0x04, 0x04, 0x89, DTMF_SIGNAL_CONGESTION_TONE },
9540         { 0x04, 0x04, 0x8a, DTMF_SIGNAL_SPECIAL_INFORMATION_TONE },
9541         { 0x04, 0x04, 0x8b, DTMF_SIGNAL_COMFORT_TONE },
9542         { 0x04, 0x04, 0x8c, DTMF_SIGNAL_HOLD_TONE },
9543         { 0x04, 0x04, 0x8d, DTMF_SIGNAL_RECORD_TONE },
9544         { 0x04, 0x04, 0x8e, DTMF_SIGNAL_CALLER_WAITING_TONE },
9545         { 0x04, 0x04, 0x8f, DTMF_SIGNAL_CALL_WAITING_TONE },
9546         { 0x04, 0x04, 0x90, DTMF_SIGNAL_PAY_TONE },
9547         { 0x04, 0x04, 0x91, DTMF_SIGNAL_POSITIVE_INDICATION_TONE },
9548         { 0x04, 0x04, 0x92, DTMF_SIGNAL_NEGATIVE_INDICATION_TONE },
9549         { 0x04, 0x04, 0x93, DTMF_SIGNAL_WARNING_TONE },
9550         { 0x04, 0x04, 0x94, DTMF_SIGNAL_INTRUSION_TONE },
9551         { 0x04, 0x04, 0x95, DTMF_SIGNAL_CALLING_CARD_SERVICE_TONE },
9552         { 0x04, 0x04, 0x96, DTMF_SIGNAL_PAYPHONE_RECOGNITION_TONE },
9553         { 0x04, 0x04, 0x97, DTMF_SIGNAL_CPE_ALERTING_SIGNAL },
9554         { 0x04, 0x04, 0x98, DTMF_SIGNAL_OFF_HOOK_WARNING_TONE },
9555         { 0x04, 0x04, 0xbf, DTMF_SIGNAL_INTERCEPT_TONE },
9556         { 0x04, 0x04, 0xc0, DTMF_SIGNAL_MODEM_CALLING_TONE },
9557         { 0x04, 0x04, 0xc1, DTMF_SIGNAL_FAX_CALLING_TONE },
9558         { 0x04, 0x04, 0xc2, DTMF_SIGNAL_ANSWER_TONE },
9559         { 0x04, 0x04, 0xc3, DTMF_SIGNAL_REVERSED_ANSWER_TONE },
9560         { 0x04, 0x04, 0xc4, DTMF_SIGNAL_ANSAM_TONE },
9561         { 0x04, 0x04, 0xc5, DTMF_SIGNAL_REVERSED_ANSAM_TONE },
9562         { 0x04, 0x04, 0xc6, DTMF_SIGNAL_BELL103_ANSWER_TONE },
9563         { 0x04, 0x04, 0xc7, DTMF_SIGNAL_FAX_FLAGS },
9564         { 0x04, 0x04, 0xc8, DTMF_SIGNAL_G2_FAX_GROUP_ID },
9565         { 0x00, 0x04, 0xc9, DTMF_SIGNAL_HUMAN_SPEECH },
9566         { 0x04, 0x04, 0xca, DTMF_SIGNAL_ANSWERING_MACHINE_390 },
9567         { 0x02, 0x02, 0xf1, DTMF_MF_DIGIT_TONE_CODE_1 },
9568         { 0x02, 0x02, 0xf2, DTMF_MF_DIGIT_TONE_CODE_2 },
9569         { 0x02, 0x02, 0xf3, DTMF_MF_DIGIT_TONE_CODE_3 },
9570         { 0x02, 0x02, 0xf4, DTMF_MF_DIGIT_TONE_CODE_4 },
9571         { 0x02, 0x02, 0xf5, DTMF_MF_DIGIT_TONE_CODE_5 },
9572         { 0x02, 0x02, 0xf6, DTMF_MF_DIGIT_TONE_CODE_6 },
9573         { 0x02, 0x02, 0xf7, DTMF_MF_DIGIT_TONE_CODE_7 },
9574         { 0x02, 0x02, 0xf8, DTMF_MF_DIGIT_TONE_CODE_8 },
9575         { 0x02, 0x02, 0xf9, DTMF_MF_DIGIT_TONE_CODE_9 },
9576         { 0x02, 0x02, 0xfa, DTMF_MF_DIGIT_TONE_CODE_0 },
9577         { 0x02, 0x02, 0xfb, DTMF_MF_DIGIT_TONE_CODE_K1 },
9578         { 0x02, 0x02, 0xfc, DTMF_MF_DIGIT_TONE_CODE_K2 },
9579         { 0x02, 0x02, 0xfd, DTMF_MF_DIGIT_TONE_CODE_KP },
9580         { 0x02, 0x02, 0xfe, DTMF_MF_DIGIT_TONE_CODE_S1 },
9581         { 0x02, 0x02, 0xff, DTMF_MF_DIGIT_TONE_CODE_ST },
9582
9583 };
9584
9585 #define DTMF_DIGIT_MAP_ENTRIES ARRAY_SIZE(dtmf_digit_map)
9586
9587
9588 static void dtmf_enable_receiver(PLCI *plci, byte enable_mask)
9589 {
9590         word min_digit_duration, min_gap_duration;
9591
9592         dbug(1, dprintf("[%06lx] %s,%d: dtmf_enable_receiver %02x",
9593                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
9594                         (char *)(FILE_), __LINE__, enable_mask));
9595
9596         if (enable_mask != 0)
9597         {
9598                 min_digit_duration = (plci->dtmf_rec_pulse_ms == 0) ? 40 : plci->dtmf_rec_pulse_ms;
9599                 min_gap_duration = (plci->dtmf_rec_pause_ms == 0) ? 40 : plci->dtmf_rec_pause_ms;
9600                 plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_ENABLE_RECEIVER;
9601                 PUT_WORD(&plci->internal_req_buffer[1], min_digit_duration);
9602                 PUT_WORD(&plci->internal_req_buffer[3], min_gap_duration);
9603                 plci->NData[0].PLength = 5;
9604
9605                 PUT_WORD(&plci->internal_req_buffer[5], INTERNAL_IND_BUFFER_SIZE);
9606                 plci->NData[0].PLength += 2;
9607                 capidtmf_recv_enable(&(plci->capidtmf_state), min_digit_duration, min_gap_duration);
9608
9609         }
9610         else
9611         {
9612                 plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_DISABLE_RECEIVER;
9613                 plci->NData[0].PLength = 1;
9614
9615                 capidtmf_recv_disable(&(plci->capidtmf_state));
9616
9617         }
9618         plci->NData[0].P = plci->internal_req_buffer;
9619         plci->NL.X = plci->NData;
9620         plci->NL.ReqCh = 0;
9621         plci->NL.Req = plci->nl_req = (byte) N_UDATA;
9622         plci->adapter->request(&plci->NL);
9623 }
9624
9625
9626 static void dtmf_send_digits(PLCI *plci, byte *digit_buffer, word digit_count)
9627 {
9628         word w, i;
9629
9630         dbug(1, dprintf("[%06lx] %s,%d: dtmf_send_digits %d",
9631                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
9632                         (char *)(FILE_), __LINE__, digit_count));
9633
9634         plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_SEND_DIGITS;
9635         w = (plci->dtmf_send_pulse_ms == 0) ? 40 : plci->dtmf_send_pulse_ms;
9636         PUT_WORD(&plci->internal_req_buffer[1], w);
9637         w = (plci->dtmf_send_pause_ms == 0) ? 40 : plci->dtmf_send_pause_ms;
9638         PUT_WORD(&plci->internal_req_buffer[3], w);
9639         for (i = 0; i < digit_count; i++)
9640         {
9641                 w = 0;
9642                 while ((w < DTMF_DIGIT_MAP_ENTRIES)
9643                        && (digit_buffer[i] != dtmf_digit_map[w].character))
9644                 {
9645                         w++;
9646                 }
9647                 plci->internal_req_buffer[5 + i] = (w < DTMF_DIGIT_MAP_ENTRIES) ?
9648                         dtmf_digit_map[w].code : DTMF_DIGIT_TONE_CODE_STAR;
9649         }
9650         plci->NData[0].PLength = 5 + digit_count;
9651         plci->NData[0].P = plci->internal_req_buffer;
9652         plci->NL.X = plci->NData;
9653         plci->NL.ReqCh = 0;
9654         plci->NL.Req = plci->nl_req = (byte) N_UDATA;
9655         plci->adapter->request(&plci->NL);
9656 }
9657
9658
9659 static void dtmf_rec_clear_config(PLCI *plci)
9660 {
9661
9662         dbug(1, dprintf("[%06lx] %s,%d: dtmf_rec_clear_config",
9663                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
9664                         (char *)(FILE_), __LINE__));
9665
9666         plci->dtmf_rec_active = 0;
9667         plci->dtmf_rec_pulse_ms = 0;
9668         plci->dtmf_rec_pause_ms = 0;
9669
9670         capidtmf_init(&(plci->capidtmf_state), plci->adapter->u_law);
9671
9672 }
9673
9674
9675 static void dtmf_send_clear_config(PLCI *plci)
9676 {
9677
9678         dbug(1, dprintf("[%06lx] %s,%d: dtmf_send_clear_config",
9679                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
9680                         (char *)(FILE_), __LINE__));
9681
9682         plci->dtmf_send_requests = 0;
9683         plci->dtmf_send_pulse_ms = 0;
9684         plci->dtmf_send_pause_ms = 0;
9685 }
9686
9687
9688 static void dtmf_prepare_switch(dword Id, PLCI *plci)
9689 {
9690
9691         dbug(1, dprintf("[%06lx] %s,%d: dtmf_prepare_switch",
9692                         UnMapId(Id), (char *)(FILE_), __LINE__));
9693
9694         while (plci->dtmf_send_requests != 0)
9695                 dtmf_confirmation(Id, plci);
9696 }
9697
9698
9699 static word dtmf_save_config(dword Id, PLCI *plci, byte Rc)
9700 {
9701
9702         dbug(1, dprintf("[%06lx] %s,%d: dtmf_save_config %02x %d",
9703                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
9704
9705         return (GOOD);
9706 }
9707
9708
9709 static word dtmf_restore_config(dword Id, PLCI *plci, byte Rc)
9710 {
9711         word Info;
9712
9713         dbug(1, dprintf("[%06lx] %s,%d: dtmf_restore_config %02x %d",
9714                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
9715
9716         Info = GOOD;
9717         if (plci->B1_facilities & B1_FACILITY_DTMFR)
9718         {
9719                 switch (plci->adjust_b_state)
9720                 {
9721                 case ADJUST_B_RESTORE_DTMF_1:
9722                         plci->internal_command = plci->adjust_b_command;
9723                         if (plci_nl_busy(plci))
9724                         {
9725                                 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
9726                                 break;
9727                         }
9728                         dtmf_enable_receiver(plci, plci->dtmf_rec_active);
9729                         plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_2;
9730                         break;
9731                 case ADJUST_B_RESTORE_DTMF_2:
9732                         if ((Rc != OK) && (Rc != OK_FC))
9733                         {
9734                                 dbug(1, dprintf("[%06lx] %s,%d: Reenable DTMF receiver failed %02x",
9735                                                 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
9736                                 Info = _WRONG_STATE;
9737                                 break;
9738                         }
9739                         break;
9740                 }
9741         }
9742         return (Info);
9743 }
9744
9745
9746 static void dtmf_command(dword Id, PLCI *plci, byte Rc)
9747 {
9748         word internal_command, Info;
9749         byte mask;
9750         byte result[4];
9751
9752         dbug(1, dprintf("[%06lx] %s,%d: dtmf_command %02x %04x %04x %d %d %d %d",
9753                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command,
9754                         plci->dtmf_cmd, plci->dtmf_rec_pulse_ms, plci->dtmf_rec_pause_ms,
9755                         plci->dtmf_send_pulse_ms, plci->dtmf_send_pause_ms));
9756
9757         Info = GOOD;
9758         result[0] = 2;
9759         PUT_WORD(&result[1], DTMF_SUCCESS);
9760         internal_command = plci->internal_command;
9761         plci->internal_command = 0;
9762         mask = 0x01;
9763         switch (plci->dtmf_cmd)
9764         {
9765
9766         case DTMF_LISTEN_TONE_START:
9767                 mask <<= 1;
9768         case DTMF_LISTEN_MF_START:
9769                 mask <<= 1;
9770
9771         case DTMF_LISTEN_START:
9772                 switch (internal_command)
9773                 {
9774                 default:
9775                         adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities |
9776                                                                   B1_FACILITY_DTMFR), DTMF_COMMAND_1);
9777                 case DTMF_COMMAND_1:
9778                         if (adjust_b_process(Id, plci, Rc) != GOOD)
9779                         {
9780                                 dbug(1, dprintf("[%06lx] %s,%d: Load DTMF failed",
9781                                                 UnMapId(Id), (char *)(FILE_), __LINE__));
9782                                 Info = _FACILITY_NOT_SUPPORTED;
9783                                 break;
9784                         }
9785                         if (plci->internal_command)
9786                                 return;
9787                 case DTMF_COMMAND_2:
9788                         if (plci_nl_busy(plci))
9789                         {
9790                                 plci->internal_command = DTMF_COMMAND_2;
9791                                 return;
9792                         }
9793                         plci->internal_command = DTMF_COMMAND_3;
9794                         dtmf_enable_receiver(plci, (byte)(plci->dtmf_rec_active | mask));
9795                         return;
9796                 case DTMF_COMMAND_3:
9797                         if ((Rc != OK) && (Rc != OK_FC))
9798                         {
9799                                 dbug(1, dprintf("[%06lx] %s,%d: Enable DTMF receiver failed %02x",
9800                                                 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
9801                                 Info = _FACILITY_NOT_SUPPORTED;
9802                                 break;
9803                         }
9804
9805                         plci->tone_last_indication_code = DTMF_SIGNAL_NO_TONE;
9806
9807                         plci->dtmf_rec_active |= mask;
9808                         break;
9809                 }
9810                 break;
9811
9812
9813         case DTMF_LISTEN_TONE_STOP:
9814                 mask <<= 1;
9815         case DTMF_LISTEN_MF_STOP:
9816                 mask <<= 1;
9817
9818         case DTMF_LISTEN_STOP:
9819                 switch (internal_command)
9820                 {
9821                 default:
9822                         plci->dtmf_rec_active &= ~mask;
9823                         if (plci->dtmf_rec_active)
9824                                 break;
9825 /*
9826   case DTMF_COMMAND_1:
9827   if (plci->dtmf_rec_active)
9828   {
9829   if (plci_nl_busy (plci))
9830   {
9831   plci->internal_command = DTMF_COMMAND_1;
9832   return;
9833   }
9834   plci->dtmf_rec_active &= ~mask;
9835   plci->internal_command = DTMF_COMMAND_2;
9836   dtmf_enable_receiver (plci, false);
9837   return;
9838   }
9839   Rc = OK;
9840   case DTMF_COMMAND_2:
9841   if ((Rc != OK) && (Rc != OK_FC))
9842   {
9843   dbug (1, dprintf("[%06lx] %s,%d: Disable DTMF receiver failed %02x",
9844   UnMapId (Id), (char far *)(FILE_), __LINE__, Rc));
9845   Info = _FACILITY_NOT_SUPPORTED;
9846   break;
9847   }
9848 */
9849                         adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities &
9850                                                                   ~(B1_FACILITY_DTMFX | B1_FACILITY_DTMFR)), DTMF_COMMAND_3);
9851                 case DTMF_COMMAND_3:
9852                         if (adjust_b_process(Id, plci, Rc) != GOOD)
9853                         {
9854                                 dbug(1, dprintf("[%06lx] %s,%d: Unload DTMF failed",
9855                                                 UnMapId(Id), (char *)(FILE_), __LINE__));
9856                                 Info = _FACILITY_NOT_SUPPORTED;
9857                                 break;
9858                         }
9859                         if (plci->internal_command)
9860                                 return;
9861                         break;
9862                 }
9863                 break;
9864
9865
9866         case DTMF_SEND_TONE:
9867                 mask <<= 1;
9868         case DTMF_SEND_MF:
9869                 mask <<= 1;
9870
9871         case DTMF_DIGITS_SEND:
9872                 switch (internal_command)
9873                 {
9874                 default:
9875                         adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities |
9876                                                                   ((plci->dtmf_parameter_length != 0) ? B1_FACILITY_DTMFX | B1_FACILITY_DTMFR : B1_FACILITY_DTMFX)),
9877                                            DTMF_COMMAND_1);
9878                 case DTMF_COMMAND_1:
9879                         if (adjust_b_process(Id, plci, Rc) != GOOD)
9880                         {
9881                                 dbug(1, dprintf("[%06lx] %s,%d: Load DTMF failed",
9882                                                 UnMapId(Id), (char *)(FILE_), __LINE__));
9883                                 Info = _FACILITY_NOT_SUPPORTED;
9884                                 break;
9885                         }
9886                         if (plci->internal_command)
9887                                 return;
9888                 case DTMF_COMMAND_2:
9889                         if (plci_nl_busy(plci))
9890                         {
9891                                 plci->internal_command = DTMF_COMMAND_2;
9892                                 return;
9893                         }
9894                         plci->dtmf_msg_number_queue[(plci->dtmf_send_requests)++] = plci->number;
9895                         plci->internal_command = DTMF_COMMAND_3;
9896                         dtmf_send_digits(plci, &plci->saved_msg.parms[3].info[1], plci->saved_msg.parms[3].length);
9897                         return;
9898                 case DTMF_COMMAND_3:
9899                         if ((Rc != OK) && (Rc != OK_FC))
9900                         {
9901                                 dbug(1, dprintf("[%06lx] %s,%d: Send DTMF digits failed %02x",
9902                                                 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
9903                                 if (plci->dtmf_send_requests != 0)
9904                                         (plci->dtmf_send_requests)--;
9905                                 Info = _FACILITY_NOT_SUPPORTED;
9906                                 break;
9907                         }
9908                         return;
9909                 }
9910                 break;
9911         }
9912         sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->number,
9913               "wws", Info, SELECTOR_DTMF, result);
9914 }
9915
9916
9917 static byte dtmf_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL   *appl, API_PARSE *msg)
9918 {
9919         word Info;
9920         word i, j;
9921         byte mask;
9922         API_PARSE dtmf_parms[5];
9923         byte result[40];
9924
9925         dbug(1, dprintf("[%06lx] %s,%d: dtmf_request",
9926                         UnMapId(Id), (char *)(FILE_), __LINE__));
9927
9928         Info = GOOD;
9929         result[0] = 2;
9930         PUT_WORD(&result[1], DTMF_SUCCESS);
9931         if (!(a->profile.Global_Options & GL_DTMF_SUPPORTED))
9932         {
9933                 dbug(1, dprintf("[%06lx] %s,%d: Facility not supported",
9934                                 UnMapId(Id), (char *)(FILE_), __LINE__));
9935                 Info = _FACILITY_NOT_SUPPORTED;
9936         }
9937         else if (api_parse(&msg[1].info[1], msg[1].length, "w", dtmf_parms))
9938         {
9939                 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
9940                                 UnMapId(Id), (char *)(FILE_), __LINE__));
9941                 Info = _WRONG_MESSAGE_FORMAT;
9942         }
9943
9944         else if ((GET_WORD(dtmf_parms[0].info) == DTMF_GET_SUPPORTED_DETECT_CODES)
9945                  || (GET_WORD(dtmf_parms[0].info) == DTMF_GET_SUPPORTED_SEND_CODES))
9946         {
9947                 if (!((a->requested_options_table[appl->Id - 1])
9948                       & (1L << PRIVATE_DTMF_TONE)))
9949                 {
9950                         dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x",
9951                                         UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(dtmf_parms[0].info)));
9952                         PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST);
9953                 }
9954                 else
9955                 {
9956                         for (i = 0; i < 32; i++)
9957                                 result[4 + i] = 0;
9958                         if (GET_WORD(dtmf_parms[0].info) == DTMF_GET_SUPPORTED_DETECT_CODES)
9959                         {
9960                                 for (i = 0; i < DTMF_DIGIT_MAP_ENTRIES; i++)
9961                                 {
9962                                         if (dtmf_digit_map[i].listen_mask != 0)
9963                                                 result[4 + (dtmf_digit_map[i].character >> 3)] |= (1 << (dtmf_digit_map[i].character & 0x7));
9964                                 }
9965                         }
9966                         else
9967                         {
9968                                 for (i = 0; i < DTMF_DIGIT_MAP_ENTRIES; i++)
9969                                 {
9970                                         if (dtmf_digit_map[i].send_mask != 0)
9971                                                 result[4 + (dtmf_digit_map[i].character >> 3)] |= (1 << (dtmf_digit_map[i].character & 0x7));
9972                                 }
9973                         }
9974                         result[0] = 3 + 32;
9975                         result[3] = 32;
9976                 }
9977         }
9978
9979         else if (plci == NULL)
9980         {
9981                 dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI",
9982                                 UnMapId(Id), (char *)(FILE_), __LINE__));
9983                 Info = _WRONG_IDENTIFIER;
9984         }
9985         else
9986         {
9987                 if (!plci->State
9988                     || !plci->NL.Id || plci->nl_remove_id)
9989                 {
9990                         dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
9991                                         UnMapId(Id), (char *)(FILE_), __LINE__));
9992                         Info = _WRONG_STATE;
9993                 }
9994                 else
9995                 {
9996                         plci->command = 0;
9997                         plci->dtmf_cmd = GET_WORD(dtmf_parms[0].info);
9998                         mask = 0x01;
9999                         switch (plci->dtmf_cmd)
10000                         {
10001
10002                         case DTMF_LISTEN_TONE_START:
10003                         case DTMF_LISTEN_TONE_STOP:
10004                                 mask <<= 1;
10005                         case DTMF_LISTEN_MF_START:
10006                         case DTMF_LISTEN_MF_STOP:
10007                                 mask <<= 1;
10008                                 if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[appl->Id - 1])
10009                                       & (1L << PRIVATE_DTMF_TONE)))
10010                                 {
10011                                         dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x",
10012                                                         UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(dtmf_parms[0].info)));
10013                                         PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST);
10014                                         break;
10015                                 }
10016
10017                         case DTMF_LISTEN_START:
10018                         case DTMF_LISTEN_STOP:
10019                                 if (!(a->manufacturer_features & MANUFACTURER_FEATURE_HARDDTMF)
10020                                     && !(a->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE))
10021                                 {
10022                                         dbug(1, dprintf("[%06lx] %s,%d: Facility not supported",
10023                                                         UnMapId(Id), (char *)(FILE_), __LINE__));
10024                                         Info = _FACILITY_NOT_SUPPORTED;
10025                                         break;
10026                                 }
10027                                 if (mask & DTMF_LISTEN_ACTIVE_FLAG)
10028                                 {
10029                                         if (api_parse(&msg[1].info[1], msg[1].length, "wwws", dtmf_parms))
10030                                         {
10031                                                 plci->dtmf_rec_pulse_ms = 0;
10032                                                 plci->dtmf_rec_pause_ms = 0;
10033                                         }
10034                                         else
10035                                         {
10036                                                 plci->dtmf_rec_pulse_ms = GET_WORD(dtmf_parms[1].info);
10037                                                 plci->dtmf_rec_pause_ms = GET_WORD(dtmf_parms[2].info);
10038                                         }
10039                                 }
10040                                 start_internal_command(Id, plci, dtmf_command);
10041                                 return (false);
10042
10043
10044                         case DTMF_SEND_TONE:
10045                                 mask <<= 1;
10046                         case DTMF_SEND_MF:
10047                                 mask <<= 1;
10048                                 if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[appl->Id - 1])
10049                                       & (1L << PRIVATE_DTMF_TONE)))
10050                                 {
10051                                         dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x",
10052                                                         UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(dtmf_parms[0].info)));
10053                                         PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST);
10054                                         break;
10055                                 }
10056
10057                         case DTMF_DIGITS_SEND:
10058                                 if (api_parse(&msg[1].info[1], msg[1].length, "wwws", dtmf_parms))
10059                                 {
10060                                         dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
10061                                                         UnMapId(Id), (char *)(FILE_), __LINE__));
10062                                         Info = _WRONG_MESSAGE_FORMAT;
10063                                         break;
10064                                 }
10065                                 if (mask & DTMF_LISTEN_ACTIVE_FLAG)
10066                                 {
10067                                         plci->dtmf_send_pulse_ms = GET_WORD(dtmf_parms[1].info);
10068                                         plci->dtmf_send_pause_ms = GET_WORD(dtmf_parms[2].info);
10069                                 }
10070                                 i = 0;
10071                                 j = 0;
10072                                 while ((i < dtmf_parms[3].length) && (j < DTMF_DIGIT_MAP_ENTRIES))
10073                                 {
10074                                         j = 0;
10075                                         while ((j < DTMF_DIGIT_MAP_ENTRIES)
10076                                                && ((dtmf_parms[3].info[i + 1] != dtmf_digit_map[j].character)
10077                                                    || ((dtmf_digit_map[j].send_mask & mask) == 0)))
10078                                         {
10079                                                 j++;
10080                                         }
10081                                         i++;
10082                                 }
10083                                 if (j == DTMF_DIGIT_MAP_ENTRIES)
10084                                 {
10085                                         dbug(1, dprintf("[%06lx] %s,%d: Incorrect DTMF digit %02x",
10086                                                         UnMapId(Id), (char *)(FILE_), __LINE__, dtmf_parms[3].info[i]));
10087                                         PUT_WORD(&result[1], DTMF_INCORRECT_DIGIT);
10088                                         break;
10089                                 }
10090                                 if (plci->dtmf_send_requests >= ARRAY_SIZE(plci->dtmf_msg_number_queue))
10091                                 {
10092                                         dbug(1, dprintf("[%06lx] %s,%d: DTMF request overrun",
10093                                                         UnMapId(Id), (char *)(FILE_), __LINE__));
10094                                         Info = _WRONG_STATE;
10095                                         break;
10096                                 }
10097                                 api_save_msg(dtmf_parms, "wwws", &plci->saved_msg);
10098                                 start_internal_command(Id, plci, dtmf_command);
10099                                 return (false);
10100
10101                         default:
10102                                 dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x",
10103                                                 UnMapId(Id), (char *)(FILE_), __LINE__, plci->dtmf_cmd));
10104                                 PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST);
10105                         }
10106                 }
10107         }
10108         sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
10109               "wws", Info, SELECTOR_DTMF, result);
10110         return (false);
10111 }
10112
10113
10114 static void dtmf_confirmation(dword Id, PLCI *plci)
10115 {
10116         word i;
10117         byte result[4];
10118
10119         dbug(1, dprintf("[%06lx] %s,%d: dtmf_confirmation",
10120                         UnMapId(Id), (char *)(FILE_), __LINE__));
10121
10122         result[0] = 2;
10123         PUT_WORD(&result[1], DTMF_SUCCESS);
10124         if (plci->dtmf_send_requests != 0)
10125         {
10126                 sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->dtmf_msg_number_queue[0],
10127                       "wws", GOOD, SELECTOR_DTMF, result);
10128                 (plci->dtmf_send_requests)--;
10129                 for (i = 0; i < plci->dtmf_send_requests; i++)
10130                         plci->dtmf_msg_number_queue[i] = plci->dtmf_msg_number_queue[i + 1];
10131         }
10132 }
10133
10134
10135 static void dtmf_indication(dword Id, PLCI *plci, byte *msg, word length)
10136 {
10137         word i, j, n;
10138
10139         dbug(1, dprintf("[%06lx] %s,%d: dtmf_indication",
10140                         UnMapId(Id), (char *)(FILE_), __LINE__));
10141
10142         n = 0;
10143         for (i = 1; i < length; i++)
10144         {
10145                 j = 0;
10146                 while ((j < DTMF_DIGIT_MAP_ENTRIES)
10147                        && ((msg[i] != dtmf_digit_map[j].code)
10148                            || ((dtmf_digit_map[j].listen_mask & plci->dtmf_rec_active) == 0)))
10149                 {
10150                         j++;
10151                 }
10152                 if (j < DTMF_DIGIT_MAP_ENTRIES)
10153                 {
10154
10155                         if ((dtmf_digit_map[j].listen_mask & DTMF_TONE_LISTEN_ACTIVE_FLAG)
10156                             && (plci->tone_last_indication_code == DTMF_SIGNAL_NO_TONE)
10157                             && (dtmf_digit_map[j].character != DTMF_SIGNAL_UNIDENTIFIED_TONE))
10158                         {
10159                                 if (n + 1 == i)
10160                                 {
10161                                         for (i = length; i > n + 1; i--)
10162                                                 msg[i] = msg[i - 1];
10163                                         length++;
10164                                         i++;
10165                                 }
10166                                 msg[++n] = DTMF_SIGNAL_UNIDENTIFIED_TONE;
10167                         }
10168                         plci->tone_last_indication_code = dtmf_digit_map[j].character;
10169
10170                         msg[++n] = dtmf_digit_map[j].character;
10171                 }
10172         }
10173         if (n != 0)
10174         {
10175                 msg[0] = (byte) n;
10176                 sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "wS", SELECTOR_DTMF, msg);
10177         }
10178 }
10179
10180
10181 /*------------------------------------------------------------------*/
10182 /* DTMF parameters                                                  */
10183 /*------------------------------------------------------------------*/
10184
10185 static void dtmf_parameter_write(PLCI *plci)
10186 {
10187         word i;
10188         byte parameter_buffer[DTMF_PARAMETER_BUFFER_SIZE + 2];
10189
10190         dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_write",
10191                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10192                         (char *)(FILE_), __LINE__));
10193
10194         parameter_buffer[0] = plci->dtmf_parameter_length + 1;
10195         parameter_buffer[1] = DSP_CTRL_SET_DTMF_PARAMETERS;
10196         for (i = 0; i < plci->dtmf_parameter_length; i++)
10197                 parameter_buffer[2 + i] = plci->dtmf_parameter_buffer[i];
10198         add_p(plci, FTY, parameter_buffer);
10199         sig_req(plci, TEL_CTRL, 0);
10200         send_req(plci);
10201 }
10202
10203
10204 static void dtmf_parameter_clear_config(PLCI *plci)
10205 {
10206
10207         dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_clear_config",
10208                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10209                         (char *)(FILE_), __LINE__));
10210
10211         plci->dtmf_parameter_length = 0;
10212 }
10213
10214
10215 static void dtmf_parameter_prepare_switch(dword Id, PLCI *plci)
10216 {
10217
10218         dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_prepare_switch",
10219                         UnMapId(Id), (char *)(FILE_), __LINE__));
10220
10221 }
10222
10223
10224 static word dtmf_parameter_save_config(dword Id, PLCI *plci, byte Rc)
10225 {
10226
10227         dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_save_config %02x %d",
10228                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
10229
10230         return (GOOD);
10231 }
10232
10233
10234 static word dtmf_parameter_restore_config(dword Id, PLCI *plci, byte Rc)
10235 {
10236         word Info;
10237
10238         dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_restore_config %02x %d",
10239                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
10240
10241         Info = GOOD;
10242         if ((plci->B1_facilities & B1_FACILITY_DTMFR)
10243             && (plci->dtmf_parameter_length != 0))
10244         {
10245                 switch (plci->adjust_b_state)
10246                 {
10247                 case ADJUST_B_RESTORE_DTMF_PARAMETER_1:
10248                         plci->internal_command = plci->adjust_b_command;
10249                         if (plci->sig_req)
10250                         {
10251                                 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_1;
10252                                 break;
10253                         }
10254                         dtmf_parameter_write(plci);
10255                         plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_2;
10256                         break;
10257                 case ADJUST_B_RESTORE_DTMF_PARAMETER_2:
10258                         if ((Rc != OK) && (Rc != OK_FC))
10259                         {
10260                                 dbug(1, dprintf("[%06lx] %s,%d: Restore DTMF parameters failed %02x",
10261                                                 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
10262                                 Info = _WRONG_STATE;
10263                                 break;
10264                         }
10265                         break;
10266                 }
10267         }
10268         return (Info);
10269 }
10270
10271
10272 /*------------------------------------------------------------------*/
10273 /* Line interconnect facilities                                     */
10274 /*------------------------------------------------------------------*/
10275
10276
10277 LI_CONFIG   *li_config_table;
10278 word li_total_channels;
10279
10280
10281 /*------------------------------------------------------------------*/
10282 /* translate a CHI information element to a channel number          */
10283 /* returns 0xff - any channel                                       */
10284 /*         0xfe - chi wrong coding                                  */
10285 /*         0xfd - D-channel                                         */
10286 /*         0x00 - no channel                                        */
10287 /*         else channel number / PRI: timeslot                      */
10288 /* if channels is provided we accept more than one channel.         */
10289 /*------------------------------------------------------------------*/
10290
10291 static byte chi_to_channel(byte *chi, dword *pchannelmap)
10292 {
10293         int p;
10294         int i;
10295         dword map;
10296         byte excl;
10297         byte ofs;
10298         byte ch;
10299
10300         if (pchannelmap) *pchannelmap = 0;
10301         if (!chi[0]) return 0xff;
10302         excl = 0;
10303
10304         if (chi[1] & 0x20) {
10305                 if (chi[0] == 1 && chi[1] == 0xac) return 0xfd; /* exclusive d-channel */
10306                 for (i = 1; i < chi[0] && !(chi[i] & 0x80); i++);
10307                 if (i == chi[0] || !(chi[i] & 0x80)) return 0xfe;
10308                 if ((chi[1] | 0xc8) != 0xe9) return 0xfe;
10309                 if (chi[1] & 0x08) excl = 0x40;
10310
10311                 /* int. id present */
10312                 if (chi[1] & 0x40) {
10313                         p = i + 1;
10314                         for (i = p; i < chi[0] && !(chi[i] & 0x80); i++);
10315                         if (i == chi[0] || !(chi[i] & 0x80)) return 0xfe;
10316                 }
10317
10318                 /* coding standard, Number/Map, Channel Type */
10319                 p = i + 1;
10320                 for (i = p; i < chi[0] && !(chi[i] & 0x80); i++);
10321                 if (i == chi[0] || !(chi[i] & 0x80)) return 0xfe;
10322                 if ((chi[p] | 0xd0) != 0xd3) return 0xfe;
10323
10324                 /* Number/Map */
10325                 if (chi[p] & 0x10) {
10326
10327                         /* map */
10328                         if ((chi[0] - p) == 4) ofs = 0;
10329                         else if ((chi[0] - p) == 3) ofs = 1;
10330                         else return 0xfe;
10331                         ch = 0;
10332                         map = 0;
10333                         for (i = 0; i < 4 && p < chi[0]; i++) {
10334                                 p++;
10335                                 ch += 8;
10336                                 map <<= 8;
10337                                 if (chi[p]) {
10338                                         for (ch = 0; !(chi[p] & (1 << ch)); ch++);
10339                                         map |= chi[p];
10340                                 }
10341                         }
10342                         ch += ofs;
10343                         map <<= ofs;
10344                 }
10345                 else {
10346
10347                         /* number */
10348                         p = i + 1;
10349                         ch = chi[p] & 0x3f;
10350                         if (pchannelmap) {
10351                                 if ((byte)(chi[0] - p) > 30) return 0xfe;
10352                                 map = 0;
10353                                 for (i = p; i <= chi[0]; i++) {
10354                                         if ((chi[i] & 0x7f) > 31) return 0xfe;
10355                                         map |= (1L << (chi[i] & 0x7f));
10356                                 }
10357                         }
10358                         else {
10359                                 if (p != chi[0]) return 0xfe;
10360                                 if (ch > 31) return 0xfe;
10361                                 map = (1L << ch);
10362                         }
10363                         if (chi[p] & 0x40) return 0xfe;
10364                 }
10365                 if (pchannelmap) *pchannelmap = map;
10366                 else if (map != ((dword)(1L << ch))) return 0xfe;
10367                 return (byte)(excl | ch);
10368         }
10369         else {  /* not PRI */
10370                 for (i = 1; i < chi[0] && !(chi[i] & 0x80); i++);
10371                 if (i != chi[0] || !(chi[i] & 0x80)) return 0xfe;
10372                 if (chi[1] & 0x08) excl = 0x40;
10373
10374                 switch (chi[1] | 0x98) {
10375                 case 0x98: return 0;
10376                 case 0x99:
10377                         if (pchannelmap) *pchannelmap = 2;
10378                         return excl | 1;
10379                 case 0x9a:
10380                         if (pchannelmap) *pchannelmap = 4;
10381                         return excl | 2;
10382                 case 0x9b: return 0xff;
10383                 case 0x9c: return 0xfd; /* d-ch */
10384                 default: return 0xfe;
10385                 }
10386         }
10387 }
10388
10389
10390 static void mixer_set_bchannel_id_esc(PLCI *plci, byte bchannel_id)
10391 {
10392         DIVA_CAPI_ADAPTER *a;
10393         PLCI *splci;
10394         byte old_id;
10395
10396         a = plci->adapter;
10397         old_id = plci->li_bchannel_id;
10398         if (a->li_pri)
10399         {
10400                 if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10401                         li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10402                 plci->li_bchannel_id = (bchannel_id & 0x1f) + 1;
10403                 if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10404                         li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10405         }
10406         else
10407         {
10408                 if (((bchannel_id & 0x03) == 1) || ((bchannel_id & 0x03) == 2))
10409                 {
10410                         if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10411                                 li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10412                         plci->li_bchannel_id = bchannel_id & 0x03;
10413                         if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI != plci) && (a->AdvSignalPLCI->tel == ADV_VOICE))
10414                         {
10415                                 splci = a->AdvSignalPLCI;
10416                                 if (li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci == NULL)
10417                                 {
10418                                         if ((splci->li_bchannel_id != 0)
10419                                             && (li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci == splci))
10420                                         {
10421                                                 li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci = NULL;
10422                                         }
10423                                         splci->li_bchannel_id = 3 - plci->li_bchannel_id;
10424                                         li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci = splci;
10425                                         dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id_esc %d",
10426                                                         (dword)((splci->Id << 8) | UnMapController(splci->adapter->Id)),
10427                                                         (char *)(FILE_), __LINE__, splci->li_bchannel_id));
10428                                 }
10429                         }
10430                         if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10431                                 li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10432                 }
10433         }
10434         if ((old_id == 0) && (plci->li_bchannel_id != 0)
10435             && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
10436         {
10437                 mixer_clear_config(plci);
10438         }
10439         dbug(1, dprintf("[%06lx] %s,%d: mixer_set_bchannel_id_esc %d %d",
10440                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10441                         (char *)(FILE_), __LINE__, bchannel_id, plci->li_bchannel_id));
10442 }
10443
10444
10445 static void mixer_set_bchannel_id(PLCI *plci, byte *chi)
10446 {
10447         DIVA_CAPI_ADAPTER *a;
10448         PLCI *splci;
10449         byte ch, old_id;
10450
10451         a = plci->adapter;
10452         old_id = plci->li_bchannel_id;
10453         ch = chi_to_channel(chi, NULL);
10454         if (!(ch & 0x80))
10455         {
10456                 if (a->li_pri)
10457                 {
10458                         if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10459                                 li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10460                         plci->li_bchannel_id = (ch & 0x1f) + 1;
10461                         if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10462                                 li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10463                 }
10464                 else
10465                 {
10466                         if (((ch & 0x1f) == 1) || ((ch & 0x1f) == 2))
10467                         {
10468                                 if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10469                                         li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10470                                 plci->li_bchannel_id = ch & 0x1f;
10471                                 if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI != plci) && (a->AdvSignalPLCI->tel == ADV_VOICE))
10472                                 {
10473                                         splci = a->AdvSignalPLCI;
10474                                         if (li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci == NULL)
10475                                         {
10476                                                 if ((splci->li_bchannel_id != 0)
10477                                                     && (li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci == splci))
10478                                                 {
10479                                                         li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci = NULL;
10480                                                 }
10481                                                 splci->li_bchannel_id = 3 - plci->li_bchannel_id;
10482                                                 li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci = splci;
10483                                                 dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id %d",
10484                                                                 (dword)((splci->Id << 8) | UnMapController(splci->adapter->Id)),
10485                                                                 (char *)(FILE_), __LINE__, splci->li_bchannel_id));
10486                                         }
10487                                 }
10488                                 if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10489                                         li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10490                         }
10491                 }
10492         }
10493         if ((old_id == 0) && (plci->li_bchannel_id != 0)
10494             && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
10495         {
10496                 mixer_clear_config(plci);
10497         }
10498         dbug(1, dprintf("[%06lx] %s,%d: mixer_set_bchannel_id %02x %d",
10499                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10500                         (char *)(FILE_), __LINE__, ch, plci->li_bchannel_id));
10501 }
10502
10503
10504 #define MIXER_MAX_DUMP_CHANNELS 34
10505
10506 static void mixer_calculate_coefs(DIVA_CAPI_ADAPTER *a)
10507 {
10508         word n, i, j;
10509         char *p;
10510         char hex_line[2 * MIXER_MAX_DUMP_CHANNELS + MIXER_MAX_DUMP_CHANNELS / 8 + 4];
10511
10512         dbug(1, dprintf("[%06lx] %s,%d: mixer_calculate_coefs",
10513                         (dword)(UnMapController(a->Id)), (char *)(FILE_), __LINE__));
10514
10515         for (i = 0; i < li_total_channels; i++)
10516         {
10517                 li_config_table[i].channel &= LI_CHANNEL_ADDRESSES_SET;
10518                 if (li_config_table[i].chflags != 0)
10519                         li_config_table[i].channel |= LI_CHANNEL_INVOLVED;
10520                 else
10521                 {
10522                         for (j = 0; j < li_total_channels; j++)
10523                         {
10524                                 if (((li_config_table[i].flag_table[j]) != 0)
10525                                     || ((li_config_table[j].flag_table[i]) != 0))
10526                                 {
10527                                         li_config_table[i].channel |= LI_CHANNEL_INVOLVED;
10528                                 }
10529                                 if (((li_config_table[i].flag_table[j] & LI_FLAG_CONFERENCE) != 0)
10530                                     || ((li_config_table[j].flag_table[i] & LI_FLAG_CONFERENCE) != 0))
10531                                 {
10532                                         li_config_table[i].channel |= LI_CHANNEL_CONFERENCE;
10533                                 }
10534                         }
10535                 }
10536         }
10537         for (i = 0; i < li_total_channels; i++)
10538         {
10539                 for (j = 0; j < li_total_channels; j++)
10540                 {
10541                         li_config_table[i].coef_table[j] &= ~(LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC);
10542                         if (li_config_table[i].flag_table[j] & LI_FLAG_CONFERENCE)
10543                                 li_config_table[i].coef_table[j] |= LI_COEF_CH_CH;
10544                 }
10545         }
10546         for (n = 0; n < li_total_channels; n++)
10547         {
10548                 if (li_config_table[n].channel & LI_CHANNEL_CONFERENCE)
10549                 {
10550                         for (i = 0; i < li_total_channels; i++)
10551                         {
10552                                 if (li_config_table[i].channel & LI_CHANNEL_CONFERENCE)
10553                                 {
10554                                         for (j = 0; j < li_total_channels; j++)
10555                                         {
10556                                                 li_config_table[i].coef_table[j] |=
10557                                                         li_config_table[i].coef_table[n] & li_config_table[n].coef_table[j];
10558                                         }
10559                                 }
10560                         }
10561                 }
10562         }
10563         for (i = 0; i < li_total_channels; i++)
10564         {
10565                 if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10566                 {
10567                         li_config_table[i].coef_table[i] &= ~LI_COEF_CH_CH;
10568                         for (j = 0; j < li_total_channels; j++)
10569                         {
10570                                 if (li_config_table[i].coef_table[j] & LI_COEF_CH_CH)
10571                                         li_config_table[i].flag_table[j] |= LI_FLAG_CONFERENCE;
10572                         }
10573                         if (li_config_table[i].flag_table[i] & LI_FLAG_CONFERENCE)
10574                                 li_config_table[i].coef_table[i] |= LI_COEF_CH_CH;
10575                 }
10576         }
10577         for (i = 0; i < li_total_channels; i++)
10578         {
10579                 if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10580                 {
10581                         for (j = 0; j < li_total_channels; j++)
10582                         {
10583                                 if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
10584                                         li_config_table[i].coef_table[j] |= LI_COEF_CH_CH;
10585                                 if (li_config_table[i].flag_table[j] & LI_FLAG_MONITOR)
10586                                         li_config_table[i].coef_table[j] |= LI_COEF_CH_PC;
10587                                 if (li_config_table[i].flag_table[j] & LI_FLAG_MIX)
10588                                         li_config_table[i].coef_table[j] |= LI_COEF_PC_CH;
10589                                 if (li_config_table[i].flag_table[j] & LI_FLAG_PCCONNECT)
10590                                         li_config_table[i].coef_table[j] |= LI_COEF_PC_PC;
10591                         }
10592                         if (li_config_table[i].chflags & LI_CHFLAG_MONITOR)
10593                         {
10594                                 for (j = 0; j < li_total_channels; j++)
10595                                 {
10596                                         if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
10597                                         {
10598                                                 li_config_table[i].coef_table[j] |= LI_COEF_CH_PC;
10599                                                 if (li_config_table[j].chflags & LI_CHFLAG_MIX)
10600                                                         li_config_table[i].coef_table[j] |= LI_COEF_PC_CH | LI_COEF_PC_PC;
10601                                         }
10602                                 }
10603                         }
10604                         if (li_config_table[i].chflags & LI_CHFLAG_MIX)
10605                         {
10606                                 for (j = 0; j < li_total_channels; j++)
10607                                 {
10608                                         if (li_config_table[j].flag_table[i] & LI_FLAG_INTERCONNECT)
10609                                                 li_config_table[j].coef_table[i] |= LI_COEF_PC_CH;
10610                                 }
10611                         }
10612                         if (li_config_table[i].chflags & LI_CHFLAG_LOOP)
10613                         {
10614                                 for (j = 0; j < li_total_channels; j++)
10615                                 {
10616                                         if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
10617                                         {
10618                                                 for (n = 0; n < li_total_channels; n++)
10619                                                 {
10620                                                         if (li_config_table[n].flag_table[i] & LI_FLAG_INTERCONNECT)
10621                                                         {
10622                                                                 li_config_table[n].coef_table[j] |= LI_COEF_CH_CH;
10623                                                                 if (li_config_table[j].chflags & LI_CHFLAG_MIX)
10624                                                                 {
10625                                                                         li_config_table[n].coef_table[j] |= LI_COEF_PC_CH;
10626                                                                         if (li_config_table[n].chflags & LI_CHFLAG_MONITOR)
10627                                                                                 li_config_table[n].coef_table[j] |= LI_COEF_CH_PC | LI_COEF_PC_PC;
10628                                                                 }
10629                                                                 else if (li_config_table[n].chflags & LI_CHFLAG_MONITOR)
10630                                                                         li_config_table[n].coef_table[j] |= LI_COEF_CH_PC;
10631                                                         }
10632                                                 }
10633                                         }
10634                                 }
10635                         }
10636                 }
10637         }
10638         for (i = 0; i < li_total_channels; i++)
10639         {
10640                 if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10641                 {
10642                         if (li_config_table[i].chflags & (LI_CHFLAG_MONITOR | LI_CHFLAG_MIX | LI_CHFLAG_LOOP))
10643                                 li_config_table[i].channel |= LI_CHANNEL_ACTIVE;
10644                         if (li_config_table[i].chflags & LI_CHFLAG_MONITOR)
10645                                 li_config_table[i].channel |= LI_CHANNEL_RX_DATA;
10646                         if (li_config_table[i].chflags & LI_CHFLAG_MIX)
10647                                 li_config_table[i].channel |= LI_CHANNEL_TX_DATA;
10648                         for (j = 0; j < li_total_channels; j++)
10649                         {
10650                                 if ((li_config_table[i].flag_table[j] &
10651                                      (LI_FLAG_INTERCONNECT | LI_FLAG_PCCONNECT | LI_FLAG_CONFERENCE | LI_FLAG_MONITOR))
10652                                     || (li_config_table[j].flag_table[i] &
10653                                         (LI_FLAG_INTERCONNECT | LI_FLAG_PCCONNECT | LI_FLAG_CONFERENCE | LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX)))
10654                                 {
10655                                         li_config_table[i].channel |= LI_CHANNEL_ACTIVE;
10656                                 }
10657                                 if (li_config_table[i].flag_table[j] & (LI_FLAG_PCCONNECT | LI_FLAG_MONITOR))
10658                                         li_config_table[i].channel |= LI_CHANNEL_RX_DATA;
10659                                 if (li_config_table[j].flag_table[i] & (LI_FLAG_PCCONNECT | LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX))
10660                                         li_config_table[i].channel |= LI_CHANNEL_TX_DATA;
10661                         }
10662                         if (!(li_config_table[i].channel & LI_CHANNEL_ACTIVE))
10663                         {
10664                                 li_config_table[i].coef_table[i] |= LI_COEF_PC_CH | LI_COEF_CH_PC;
10665                                 li_config_table[i].channel |= LI_CHANNEL_TX_DATA | LI_CHANNEL_RX_DATA;
10666                         }
10667                 }
10668         }
10669         for (i = 0; i < li_total_channels; i++)
10670         {
10671                 if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10672                 {
10673                         j = 0;
10674                         while ((j < li_total_channels) && !(li_config_table[i].flag_table[j] & LI_FLAG_ANNOUNCEMENT))
10675                                 j++;
10676                         if (j < li_total_channels)
10677                         {
10678                                 for (j = 0; j < li_total_channels; j++)
10679                                 {
10680                                         li_config_table[i].coef_table[j] &= ~(LI_COEF_CH_CH | LI_COEF_PC_CH);
10681                                         if (li_config_table[i].flag_table[j] & LI_FLAG_ANNOUNCEMENT)
10682                                                 li_config_table[i].coef_table[j] |= LI_COEF_PC_CH;
10683                                 }
10684                         }
10685                 }
10686         }
10687         n = li_total_channels;
10688         if (n > MIXER_MAX_DUMP_CHANNELS)
10689                 n = MIXER_MAX_DUMP_CHANNELS;
10690
10691         p = hex_line;
10692         for (j = 0; j < n; j++)
10693         {
10694                 if ((j & 0x7) == 0)
10695                         *(p++) = ' ';
10696                 p = hex_byte_pack(p, li_config_table[j].curchnl);
10697         }
10698         *p = '\0';
10699         dbug(1, dprintf("[%06lx] CURRENT %s",
10700                         (dword)(UnMapController(a->Id)), (char *)hex_line));
10701         p = hex_line;
10702         for (j = 0; j < n; j++)
10703         {
10704                 if ((j & 0x7) == 0)
10705                         *(p++) = ' ';
10706                 p = hex_byte_pack(p, li_config_table[j].channel);
10707         }
10708         *p = '\0';
10709         dbug(1, dprintf("[%06lx] CHANNEL %s",
10710                         (dword)(UnMapController(a->Id)), (char *)hex_line));
10711         p = hex_line;
10712         for (j = 0; j < n; j++)
10713         {
10714                 if ((j & 0x7) == 0)
10715                         *(p++) = ' ';
10716                 p = hex_byte_pack(p, li_config_table[j].chflags);
10717         }
10718         *p = '\0';
10719         dbug(1, dprintf("[%06lx] CHFLAG  %s",
10720                         (dword)(UnMapController(a->Id)), (char *)hex_line));
10721         for (i = 0; i < n; i++)
10722         {
10723                 p = hex_line;
10724                 for (j = 0; j < n; j++)
10725                 {
10726                         if ((j & 0x7) == 0)
10727                                 *(p++) = ' ';
10728                         p = hex_byte_pack(p, li_config_table[i].flag_table[j]);
10729                 }
10730                 *p = '\0';
10731                 dbug(1, dprintf("[%06lx] FLAG[%02x]%s",
10732                                 (dword)(UnMapController(a->Id)), i, (char *)hex_line));
10733         }
10734         for (i = 0; i < n; i++)
10735         {
10736                 p = hex_line;
10737                 for (j = 0; j < n; j++)
10738                 {
10739                         if ((j & 0x7) == 0)
10740                                 *(p++) = ' ';
10741                         p = hex_byte_pack(p, li_config_table[i].coef_table[j]);
10742                 }
10743                 *p = '\0';
10744                 dbug(1, dprintf("[%06lx] COEF[%02x]%s",
10745                                 (dword)(UnMapController(a->Id)), i, (char *)hex_line));
10746         }
10747 }
10748
10749
10750 static struct
10751 {
10752         byte mask;
10753         byte line_flags;
10754 } mixer_write_prog_pri[] =
10755 {
10756         { LI_COEF_CH_CH, 0 },
10757         { LI_COEF_CH_PC, MIXER_COEF_LINE_TO_PC_FLAG },
10758         { LI_COEF_PC_CH, MIXER_COEF_LINE_FROM_PC_FLAG },
10759         { LI_COEF_PC_PC, MIXER_COEF_LINE_TO_PC_FLAG | MIXER_COEF_LINE_FROM_PC_FLAG }
10760 };
10761
10762 static struct
10763 {
10764         byte from_ch;
10765         byte to_ch;
10766         byte mask;
10767         byte xconnect_override;
10768 } mixer_write_prog_bri[] =
10769 {
10770         { 0, 0, LI_COEF_CH_CH, 0x01 },  /* B      to B      */
10771         { 1, 0, LI_COEF_CH_CH, 0x01 },  /* Alt B  to B      */
10772         { 0, 0, LI_COEF_PC_CH, 0x80 },  /* PC     to B      */
10773         { 1, 0, LI_COEF_PC_CH, 0x01 },  /* Alt PC to B      */
10774         { 2, 0, LI_COEF_CH_CH, 0x00 },  /* IC     to B      */
10775         { 3, 0, LI_COEF_CH_CH, 0x00 },  /* Alt IC to B      */
10776         { 0, 0, LI_COEF_CH_PC, 0x80 },  /* B      to PC     */
10777         { 1, 0, LI_COEF_CH_PC, 0x01 },  /* Alt B  to PC     */
10778         { 0, 0, LI_COEF_PC_PC, 0x01 },  /* PC     to PC     */
10779         { 1, 0, LI_COEF_PC_PC, 0x01 },  /* Alt PC to PC     */
10780         { 2, 0, LI_COEF_CH_PC, 0x00 },  /* IC     to PC     */
10781         { 3, 0, LI_COEF_CH_PC, 0x00 },  /* Alt IC to PC     */
10782         { 0, 2, LI_COEF_CH_CH, 0x00 },  /* B      to IC     */
10783         { 1, 2, LI_COEF_CH_CH, 0x00 },  /* Alt B  to IC     */
10784         { 0, 2, LI_COEF_PC_CH, 0x00 },  /* PC     to IC     */
10785         { 1, 2, LI_COEF_PC_CH, 0x00 },  /* Alt PC to IC     */
10786         { 2, 2, LI_COEF_CH_CH, 0x00 },  /* IC     to IC     */
10787         { 3, 2, LI_COEF_CH_CH, 0x00 },  /* Alt IC to IC     */
10788         { 1, 1, LI_COEF_CH_CH, 0x01 },  /* Alt B  to Alt B  */
10789         { 0, 1, LI_COEF_CH_CH, 0x01 },  /* B      to Alt B  */
10790         { 1, 1, LI_COEF_PC_CH, 0x80 },  /* Alt PC to Alt B  */
10791         { 0, 1, LI_COEF_PC_CH, 0x01 },  /* PC     to Alt B  */
10792         { 3, 1, LI_COEF_CH_CH, 0x00 },  /* Alt IC to Alt B  */
10793         { 2, 1, LI_COEF_CH_CH, 0x00 },  /* IC     to Alt B  */
10794         { 1, 1, LI_COEF_CH_PC, 0x80 },  /* Alt B  to Alt PC */
10795         { 0, 1, LI_COEF_CH_PC, 0x01 },  /* B      to Alt PC */
10796         { 1, 1, LI_COEF_PC_PC, 0x01 },  /* Alt PC to Alt PC */
10797         { 0, 1, LI_COEF_PC_PC, 0x01 },  /* PC     to Alt PC */
10798         { 3, 1, LI_COEF_CH_PC, 0x00 },  /* Alt IC to Alt PC */
10799         { 2, 1, LI_COEF_CH_PC, 0x00 },  /* IC     to Alt PC */
10800         { 1, 3, LI_COEF_CH_CH, 0x00 },  /* Alt B  to Alt IC */
10801         { 0, 3, LI_COEF_CH_CH, 0x00 },  /* B      to Alt IC */
10802         { 1, 3, LI_COEF_PC_CH, 0x00 },  /* Alt PC to Alt IC */
10803         { 0, 3, LI_COEF_PC_CH, 0x00 },  /* PC     to Alt IC */
10804         { 3, 3, LI_COEF_CH_CH, 0x00 },  /* Alt IC to Alt IC */
10805         { 2, 3, LI_COEF_CH_CH, 0x00 }   /* IC     to Alt IC */
10806 };
10807
10808 static byte mixer_swapped_index_bri[] =
10809 {
10810         18,  /* B      to B      */
10811         19,  /* Alt B  to B      */
10812         20,  /* PC     to B      */
10813         21,  /* Alt PC to B      */
10814         22,  /* IC     to B      */
10815         23,  /* Alt IC to B      */
10816         24,  /* B      to PC     */
10817         25,  /* Alt B  to PC     */
10818         26,  /* PC     to PC     */
10819         27,  /* Alt PC to PC     */
10820         28,  /* IC     to PC     */
10821         29,  /* Alt IC to PC     */
10822         30,  /* B      to IC     */
10823         31,  /* Alt B  to IC     */
10824         32,  /* PC     to IC     */
10825         33,  /* Alt PC to IC     */
10826         34,  /* IC     to IC     */
10827         35,  /* Alt IC to IC     */
10828         0,   /* Alt B  to Alt B  */
10829         1,   /* B      to Alt B  */
10830         2,   /* Alt PC to Alt B  */
10831         3,   /* PC     to Alt B  */
10832         4,   /* Alt IC to Alt B  */
10833         5,   /* IC     to Alt B  */
10834         6,   /* Alt B  to Alt PC */
10835         7,   /* B      to Alt PC */
10836         8,   /* Alt PC to Alt PC */
10837         9,   /* PC     to Alt PC */
10838         10,  /* Alt IC to Alt PC */
10839         11,  /* IC     to Alt PC */
10840         12,  /* Alt B  to Alt IC */
10841         13,  /* B      to Alt IC */
10842         14,  /* Alt PC to Alt IC */
10843         15,  /* PC     to Alt IC */
10844         16,  /* Alt IC to Alt IC */
10845         17   /* IC     to Alt IC */
10846 };
10847
10848 static struct
10849 {
10850         byte mask;
10851         byte from_pc;
10852         byte to_pc;
10853 } xconnect_write_prog[] =
10854 {
10855         { LI_COEF_CH_CH, false, false },
10856         { LI_COEF_CH_PC, false, true },
10857         { LI_COEF_PC_CH, true, false },
10858         { LI_COEF_PC_PC, true, true }
10859 };
10860
10861
10862 static void xconnect_query_addresses(PLCI *plci)
10863 {
10864         DIVA_CAPI_ADAPTER *a;
10865         word w, ch;
10866         byte *p;
10867
10868         dbug(1, dprintf("[%06lx] %s,%d: xconnect_query_addresses",
10869                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10870                         (char *)(FILE_), __LINE__));
10871
10872         a = plci->adapter;
10873         if (a->li_pri && ((plci->li_bchannel_id == 0)
10874                           || (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci)))
10875         {
10876                 dbug(1, dprintf("[%06x] %s,%d: Channel id wiped out",
10877                                 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10878                                 (char *)(FILE_), __LINE__));
10879                 return;
10880         }
10881         p = plci->internal_req_buffer;
10882         ch = (a->li_pri) ? plci->li_bchannel_id - 1 : 0;
10883         *(p++) = UDATA_REQUEST_XCONNECT_FROM;
10884         w = ch;
10885         *(p++) = (byte) w;
10886         *(p++) = (byte)(w >> 8);
10887         w = ch | XCONNECT_CHANNEL_PORT_PC;
10888         *(p++) = (byte) w;
10889         *(p++) = (byte)(w >> 8);
10890         plci->NData[0].P = plci->internal_req_buffer;
10891         plci->NData[0].PLength = p - plci->internal_req_buffer;
10892         plci->NL.X = plci->NData;
10893         plci->NL.ReqCh = 0;
10894         plci->NL.Req = plci->nl_req = (byte) N_UDATA;
10895         plci->adapter->request(&plci->NL);
10896 }
10897
10898
10899 static void xconnect_write_coefs(PLCI *plci, word internal_command)
10900 {
10901
10902         dbug(1, dprintf("[%06lx] %s,%d: xconnect_write_coefs %04x",
10903                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10904                         (char *)(FILE_), __LINE__, internal_command));
10905
10906         plci->li_write_command = internal_command;
10907         plci->li_write_channel = 0;
10908 }
10909
10910
10911 static byte xconnect_write_coefs_process(dword Id, PLCI *plci, byte Rc)
10912 {
10913         DIVA_CAPI_ADAPTER *a;
10914         word w, n, i, j, r, s, to_ch;
10915         dword d;
10916         byte *p;
10917         struct xconnect_transfer_address_s   *transfer_address;
10918         byte ch_map[MIXER_CHANNELS_BRI];
10919
10920         dbug(1, dprintf("[%06x] %s,%d: xconnect_write_coefs_process %02x %d",
10921                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->li_write_channel));
10922
10923         a = plci->adapter;
10924         if ((plci->li_bchannel_id == 0)
10925             || (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci))
10926         {
10927                 dbug(1, dprintf("[%06x] %s,%d: Channel id wiped out",
10928                                 UnMapId(Id), (char *)(FILE_), __LINE__));
10929                 return (true);
10930         }
10931         i = a->li_base + (plci->li_bchannel_id - 1);
10932         j = plci->li_write_channel;
10933         p = plci->internal_req_buffer;
10934         if (j != 0)
10935         {
10936                 if ((Rc != OK) && (Rc != OK_FC))
10937                 {
10938                         dbug(1, dprintf("[%06lx] %s,%d: LI write coefs failed %02x",
10939                                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
10940                         return (false);
10941                 }
10942         }
10943         if (li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
10944         {
10945                 r = 0;
10946                 s = 0;
10947                 if (j < li_total_channels)
10948                 {
10949                         if (li_config_table[i].channel & LI_CHANNEL_ADDRESSES_SET)
10950                         {
10951                                 s = ((li_config_table[i].send_b.card_address.low | li_config_table[i].send_b.card_address.high) ?
10952                                      (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_PC | LI_COEF_PC_PC)) &
10953                                         ((li_config_table[i].send_pc.card_address.low | li_config_table[i].send_pc.card_address.high) ?
10954                                          (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_PC_CH));
10955                         }
10956                         r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
10957                         while ((j < li_total_channels)
10958                                && ((r == 0)
10959                                    || (!(li_config_table[j].channel & LI_CHANNEL_ADDRESSES_SET))
10960                                    || (!li_config_table[j].adapter->li_pri
10961                                        && (j >= li_config_table[j].adapter->li_base + MIXER_BCHANNELS_BRI))
10962                                    || (((li_config_table[j].send_b.card_address.low != li_config_table[i].send_b.card_address.low)
10963                                         || (li_config_table[j].send_b.card_address.high != li_config_table[i].send_b.card_address.high))
10964                                        && (!(a->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)
10965                                            || !(li_config_table[j].adapter->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)))
10966                                    || ((li_config_table[j].adapter->li_base != a->li_base)
10967                                        && !(r & s &
10968                                             ((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ?
10969                                              (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) &
10970                                             ((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ?
10971                                              (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC))))))
10972                         {
10973                                 j++;
10974                                 if (j < li_total_channels)
10975                                         r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
10976                         }
10977                 }
10978                 if (j < li_total_channels)
10979                 {
10980                         plci->internal_command = plci->li_write_command;
10981                         if (plci_nl_busy(plci))
10982                                 return (true);
10983                         to_ch = (a->li_pri) ? plci->li_bchannel_id - 1 : 0;
10984                         *(p++) = UDATA_REQUEST_XCONNECT_TO;
10985                         do
10986                         {
10987                                 if (li_config_table[j].adapter->li_base != a->li_base)
10988                                 {
10989                                         r &= s &
10990                                                 ((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ?
10991                                                  (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) &
10992                                                 ((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ?
10993                                                  (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC));
10994                                 }
10995                                 n = 0;
10996                                 do
10997                                 {
10998                                         if (r & xconnect_write_prog[n].mask)
10999                                         {
11000                                                 if (xconnect_write_prog[n].from_pc)
11001                                                         transfer_address = &(li_config_table[j].send_pc);
11002                                                 else
11003                                                         transfer_address = &(li_config_table[j].send_b);
11004                                                 d = transfer_address->card_address.low;
11005                                                 *(p++) = (byte) d;
11006                                                 *(p++) = (byte)(d >> 8);
11007                                                 *(p++) = (byte)(d >> 16);
11008                                                 *(p++) = (byte)(d >> 24);
11009                                                 d = transfer_address->card_address.high;
11010                                                 *(p++) = (byte) d;
11011                                                 *(p++) = (byte)(d >> 8);
11012                                                 *(p++) = (byte)(d >> 16);
11013                                                 *(p++) = (byte)(d >> 24);
11014                                                 d = transfer_address->offset;
11015                                                 *(p++) = (byte) d;
11016                                                 *(p++) = (byte)(d >> 8);
11017                                                 *(p++) = (byte)(d >> 16);
11018                                                 *(p++) = (byte)(d >> 24);
11019                                                 w = xconnect_write_prog[n].to_pc ? to_ch | XCONNECT_CHANNEL_PORT_PC : to_ch;
11020                                                 *(p++) = (byte) w;
11021                                                 *(p++) = (byte)(w >> 8);
11022                                                 w = ((li_config_table[i].coef_table[j] & xconnect_write_prog[n].mask) == 0) ? 0x01 :
11023                                                         (li_config_table[i].adapter->u_law ?
11024                                                          (li_config_table[j].adapter->u_law ? 0x80 : 0x86) :
11025                                                          (li_config_table[j].adapter->u_law ? 0x7a : 0x80));
11026                                                 *(p++) = (byte) w;
11027                                                 *(p++) = (byte) 0;
11028                                                 li_config_table[i].coef_table[j] ^= xconnect_write_prog[n].mask << 4;
11029                                         }
11030                                         n++;
11031                                 } while ((n < ARRAY_SIZE(xconnect_write_prog))
11032                                          && ((p - plci->internal_req_buffer) + 16 < INTERNAL_REQ_BUFFER_SIZE));
11033                                 if (n == ARRAY_SIZE(xconnect_write_prog))
11034                                 {
11035                                         do
11036                                         {
11037                                                 j++;
11038                                                 if (j < li_total_channels)
11039                                                         r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
11040                                         } while ((j < li_total_channels)
11041                                                  && ((r == 0)
11042                                                      || (!(li_config_table[j].channel & LI_CHANNEL_ADDRESSES_SET))
11043                                                      || (!li_config_table[j].adapter->li_pri
11044                                                          && (j >= li_config_table[j].adapter->li_base + MIXER_BCHANNELS_BRI))
11045                                                      || (((li_config_table[j].send_b.card_address.low != li_config_table[i].send_b.card_address.low)
11046                                                           || (li_config_table[j].send_b.card_address.high != li_config_table[i].send_b.card_address.high))
11047                                                          && (!(a->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)
11048                                                              || !(li_config_table[j].adapter->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)))
11049                                                      || ((li_config_table[j].adapter->li_base != a->li_base)
11050                                                          && !(r & s &
11051                                                               ((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ?
11052                                                                (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) &
11053                                                               ((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ?
11054                                                                (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC))))));
11055                                 }
11056                         } while ((j < li_total_channels)
11057                                  && ((p - plci->internal_req_buffer) + 16 < INTERNAL_REQ_BUFFER_SIZE));
11058                 }
11059                 else if (j == li_total_channels)
11060                 {
11061                         plci->internal_command = plci->li_write_command;
11062                         if (plci_nl_busy(plci))
11063                                 return (true);
11064                         if (a->li_pri)
11065                         {
11066                                 *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_PRI_SYNC;
11067                                 w = 0;
11068                                 if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
11069                                         w |= MIXER_FEATURE_ENABLE_TX_DATA;
11070                                 if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
11071                                         w |= MIXER_FEATURE_ENABLE_RX_DATA;
11072                                 *(p++) = (byte) w;
11073                                 *(p++) = (byte)(w >> 8);
11074                         }
11075                         else
11076                         {
11077                                 *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_BRI;
11078                                 w = 0;
11079                                 if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI)
11080                                     && (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length))
11081                                 {
11082                                         w = GET_WORD(a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE);
11083                                 }
11084                                 if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
11085                                         w |= MIXER_FEATURE_ENABLE_TX_DATA;
11086                                 if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
11087                                         w |= MIXER_FEATURE_ENABLE_RX_DATA;
11088                                 *(p++) = (byte) w;
11089                                 *(p++) = (byte)(w >> 8);
11090                                 for (j = 0; j < sizeof(ch_map); j += 2)
11091                                 {
11092                                         if (plci->li_bchannel_id == 2)
11093                                         {
11094                                                 ch_map[j] = (byte)(j + 1);
11095                                                 ch_map[j + 1] = (byte) j;
11096                                         }
11097                                         else
11098                                         {
11099                                                 ch_map[j] = (byte) j;
11100                                                 ch_map[j + 1] = (byte)(j + 1);
11101                                         }
11102                                 }
11103                                 for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++)
11104                                 {
11105                                         i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch];
11106                                         j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch];
11107                                         if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED)
11108                                         {
11109                                                 *p = (mixer_write_prog_bri[n].xconnect_override != 0) ?
11110                                                         mixer_write_prog_bri[n].xconnect_override :
11111                                                         ((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01);
11112                                                 if ((i >= a->li_base + MIXER_BCHANNELS_BRI) || (j >= a->li_base + MIXER_BCHANNELS_BRI))
11113                                                 {
11114                                                         w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
11115                                                         li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4;
11116                                                 }
11117                                         }
11118                                         else
11119                                         {
11120                                                 *p = 0x00;
11121                                                 if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI->tel == ADV_VOICE))
11122                                                 {
11123                                                         w = (plci == a->AdvSignalPLCI) ? n : mixer_swapped_index_bri[n];
11124                                                         if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w < a->adv_voice_coef_length)
11125                                                                 *p = a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w];
11126                                                 }
11127                                         }
11128                                         p++;
11129                                 }
11130                         }
11131                         j = li_total_channels + 1;
11132                 }
11133         }
11134         else
11135         {
11136                 if (j <= li_total_channels)
11137                 {
11138                         plci->internal_command = plci->li_write_command;
11139                         if (plci_nl_busy(plci))
11140                                 return (true);
11141                         if (j < a->li_base)
11142                                 j = a->li_base;
11143                         if (a->li_pri)
11144                         {
11145                                 *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_PRI_SYNC;
11146                                 w = 0;
11147                                 if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
11148                                         w |= MIXER_FEATURE_ENABLE_TX_DATA;
11149                                 if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
11150                                         w |= MIXER_FEATURE_ENABLE_RX_DATA;
11151                                 *(p++) = (byte) w;
11152                                 *(p++) = (byte)(w >> 8);
11153                                 for (n = 0; n < ARRAY_SIZE(mixer_write_prog_pri); n++)
11154                                 {
11155                                         *(p++) = (byte)((plci->li_bchannel_id - 1) | mixer_write_prog_pri[n].line_flags);
11156                                         for (j = a->li_base; j < a->li_base + MIXER_CHANNELS_PRI; j++)
11157                                         {
11158                                                 w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
11159                                                 if (w & mixer_write_prog_pri[n].mask)
11160                                                 {
11161                                                         *(p++) = (li_config_table[i].coef_table[j] & mixer_write_prog_pri[n].mask) ? 0x80 : 0x01;
11162                                                         li_config_table[i].coef_table[j] ^= mixer_write_prog_pri[n].mask << 4;
11163                                                 }
11164                                                 else
11165                                                         *(p++) = 0x00;
11166                                         }
11167                                         *(p++) = (byte)((plci->li_bchannel_id - 1) | MIXER_COEF_LINE_ROW_FLAG | mixer_write_prog_pri[n].line_flags);
11168                                         for (j = a->li_base; j < a->li_base + MIXER_CHANNELS_PRI; j++)
11169                                         {
11170                                                 w = ((li_config_table[j].coef_table[i] & 0xf) ^ (li_config_table[j].coef_table[i] >> 4));
11171                                                 if (w & mixer_write_prog_pri[n].mask)
11172                                                 {
11173                                                         *(p++) = (li_config_table[j].coef_table[i] & mixer_write_prog_pri[n].mask) ? 0x80 : 0x01;
11174                                                         li_config_table[j].coef_table[i] ^= mixer_write_prog_pri[n].mask << 4;
11175                                                 }
11176                                                 else
11177                                                         *(p++) = 0x00;
11178                                         }
11179                                 }
11180                         }
11181                         else
11182                         {
11183                                 *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_BRI;
11184                                 w = 0;
11185                                 if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI)
11186                                     && (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length))
11187                                 {
11188                                         w = GET_WORD(a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE);
11189                                 }
11190                                 if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
11191                                         w |= MIXER_FEATURE_ENABLE_TX_DATA;
11192                                 if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
11193                                         w |= MIXER_FEATURE_ENABLE_RX_DATA;
11194                                 *(p++) = (byte) w;
11195                                 *(p++) = (byte)(w >> 8);
11196                                 for (j = 0; j < sizeof(ch_map); j += 2)
11197                                 {
11198                                         if (plci->li_bchannel_id == 2)
11199                                         {
11200                                                 ch_map[j] = (byte)(j + 1);
11201                                                 ch_map[j + 1] = (byte) j;
11202                                         }
11203                                         else
11204                                         {
11205                                                 ch_map[j] = (byte) j;
11206                                                 ch_map[j + 1] = (byte)(j + 1);
11207                                         }
11208                                 }
11209                                 for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++)
11210                                 {
11211                                         i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch];
11212                                         j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch];
11213                                         if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED)
11214                                         {
11215                                                 *p = ((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01);
11216                                                 w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
11217                                                 li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4;
11218                                         }
11219                                         else
11220                                         {
11221                                                 *p = 0x00;
11222                                                 if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI->tel == ADV_VOICE))
11223                                                 {
11224                                                         w = (plci == a->AdvSignalPLCI) ? n : mixer_swapped_index_bri[n];
11225                                                         if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w < a->adv_voice_coef_length)
11226                                                                 *p = a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w];
11227                                                 }
11228                                         }
11229                                         p++;
11230                                 }
11231                         }
11232                         j = li_total_channels + 1;
11233                 }
11234         }
11235         plci->li_write_channel = j;
11236         if (p != plci->internal_req_buffer)
11237         {
11238                 plci->NData[0].P = plci->internal_req_buffer;
11239                 plci->NData[0].PLength = p - plci->internal_req_buffer;
11240                 plci->NL.X = plci->NData;
11241                 plci->NL.ReqCh = 0;
11242                 plci->NL.Req = plci->nl_req = (byte) N_UDATA;
11243                 plci->adapter->request(&plci->NL);
11244         }
11245         return (true);
11246 }
11247
11248
11249 static void mixer_notify_update(PLCI *plci, byte others)
11250 {
11251         DIVA_CAPI_ADAPTER *a;
11252         word i, w;
11253         PLCI *notify_plci;
11254         byte msg[sizeof(CAPI_MSG_HEADER) + 6];
11255
11256         dbug(1, dprintf("[%06lx] %s,%d: mixer_notify_update %d",
11257                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
11258                         (char *)(FILE_), __LINE__, others));
11259
11260         a = plci->adapter;
11261         if (a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED)
11262         {
11263                 if (others)
11264                         plci->li_notify_update = true;
11265                 i = 0;
11266                 do
11267                 {
11268                         notify_plci = NULL;
11269                         if (others)
11270                         {
11271                                 while ((i < li_total_channels) && (li_config_table[i].plci == NULL))
11272                                         i++;
11273                                 if (i < li_total_channels)
11274                                         notify_plci = li_config_table[i++].plci;
11275                         }
11276                         else
11277                         {
11278                                 if ((plci->li_bchannel_id != 0)
11279                                     && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11280                                 {
11281                                         notify_plci = plci;
11282                                 }
11283                         }
11284                         if ((notify_plci != NULL)
11285                             && !notify_plci->li_notify_update
11286                             && (notify_plci->appl != NULL)
11287                             && (notify_plci->State)
11288                             && notify_plci->NL.Id && !notify_plci->nl_remove_id)
11289                         {
11290                                 notify_plci->li_notify_update = true;
11291                                 ((CAPI_MSG *) msg)->header.length = 18;
11292                                 ((CAPI_MSG *) msg)->header.appl_id = notify_plci->appl->Id;
11293                                 ((CAPI_MSG *) msg)->header.command = _FACILITY_R;
11294                                 ((CAPI_MSG *) msg)->header.number = 0;
11295                                 ((CAPI_MSG *) msg)->header.controller = notify_plci->adapter->Id;
11296                                 ((CAPI_MSG *) msg)->header.plci = notify_plci->Id;
11297                                 ((CAPI_MSG *) msg)->header.ncci = 0;
11298                                 ((CAPI_MSG *) msg)->info.facility_req.Selector = SELECTOR_LINE_INTERCONNECT;
11299                                 ((CAPI_MSG *) msg)->info.facility_req.structs[0] = 3;
11300                                 PUT_WORD(&(((CAPI_MSG *) msg)->info.facility_req.structs[1]), LI_REQ_SILENT_UPDATE);
11301                                 ((CAPI_MSG *) msg)->info.facility_req.structs[3] = 0;
11302                                 w = api_put(notify_plci->appl, (CAPI_MSG *) msg);
11303                                 if (w != _QUEUE_FULL)
11304                                 {
11305                                         if (w != 0)
11306                                         {
11307                                                 dbug(1, dprintf("[%06lx] %s,%d: Interconnect notify failed %06x %d",
11308                                                                 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
11309                                                                 (char *)(FILE_), __LINE__,
11310                                                                 (dword)((notify_plci->Id << 8) | UnMapController(notify_plci->adapter->Id)), w));
11311                                         }
11312                                         notify_plci->li_notify_update = false;
11313                                 }
11314                         }
11315                 } while (others && (notify_plci != NULL));
11316                 if (others)
11317                         plci->li_notify_update = false;
11318         }
11319 }
11320
11321
11322 static void mixer_clear_config(PLCI *plci)
11323 {
11324         DIVA_CAPI_ADAPTER *a;
11325         word i, j;
11326
11327         dbug(1, dprintf("[%06lx] %s,%d: mixer_clear_config",
11328                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
11329                         (char *)(FILE_), __LINE__));
11330
11331         plci->li_notify_update = false;
11332         plci->li_plci_b_write_pos = 0;
11333         plci->li_plci_b_read_pos = 0;
11334         plci->li_plci_b_req_pos = 0;
11335         a = plci->adapter;
11336         if ((plci->li_bchannel_id != 0)
11337             && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11338         {
11339                 i = a->li_base + (plci->li_bchannel_id - 1);
11340                 li_config_table[i].curchnl = 0;
11341                 li_config_table[i].channel = 0;
11342                 li_config_table[i].chflags = 0;
11343                 for (j = 0; j < li_total_channels; j++)
11344                 {
11345                         li_config_table[j].flag_table[i] = 0;
11346                         li_config_table[i].flag_table[j] = 0;
11347                         li_config_table[i].coef_table[j] = 0;
11348                         li_config_table[j].coef_table[i] = 0;
11349                 }
11350                 if (!a->li_pri)
11351                 {
11352                         li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET;
11353                         if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
11354                         {
11355                                 i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
11356                                 li_config_table[i].curchnl = 0;
11357                                 li_config_table[i].channel = 0;
11358                                 li_config_table[i].chflags = 0;
11359                                 for (j = 0; j < li_total_channels; j++)
11360                                 {
11361                                         li_config_table[i].flag_table[j] = 0;
11362                                         li_config_table[j].flag_table[i] = 0;
11363                                         li_config_table[i].coef_table[j] = 0;
11364                                         li_config_table[j].coef_table[i] = 0;
11365                                 }
11366                                 if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
11367                                 {
11368                                         i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
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                                 }
11380                         }
11381                 }
11382         }
11383 }
11384
11385
11386 static void mixer_prepare_switch(dword Id, PLCI *plci)
11387 {
11388
11389         dbug(1, dprintf("[%06lx] %s,%d: mixer_prepare_switch",
11390                         UnMapId(Id), (char *)(FILE_), __LINE__));
11391
11392         do
11393         {
11394                 mixer_indication_coefs_set(Id, plci);
11395         } while (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos);
11396 }
11397
11398
11399 static word mixer_save_config(dword Id, PLCI *plci, byte Rc)
11400 {
11401         DIVA_CAPI_ADAPTER *a;
11402         word i, j;
11403
11404         dbug(1, dprintf("[%06lx] %s,%d: mixer_save_config %02x %d",
11405                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
11406
11407         a = plci->adapter;
11408         if ((plci->li_bchannel_id != 0)
11409             && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11410         {
11411                 i = a->li_base + (plci->li_bchannel_id - 1);
11412                 for (j = 0; j < li_total_channels; j++)
11413                 {
11414                         li_config_table[i].coef_table[j] &= 0xf;
11415                         li_config_table[j].coef_table[i] &= 0xf;
11416                 }
11417                 if (!a->li_pri)
11418                         li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET;
11419         }
11420         return (GOOD);
11421 }
11422
11423
11424 static word mixer_restore_config(dword Id, PLCI *plci, byte Rc)
11425 {
11426         DIVA_CAPI_ADAPTER *a;
11427         word Info;
11428
11429         dbug(1, dprintf("[%06lx] %s,%d: mixer_restore_config %02x %d",
11430                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
11431
11432         Info = GOOD;
11433         a = plci->adapter;
11434         if ((plci->B1_facilities & B1_FACILITY_MIXER)
11435             && (plci->li_bchannel_id != 0)
11436             && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11437         {
11438                 switch (plci->adjust_b_state)
11439                 {
11440                 case ADJUST_B_RESTORE_MIXER_1:
11441                         if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
11442                         {
11443                                 plci->internal_command = plci->adjust_b_command;
11444                                 if (plci_nl_busy(plci))
11445                                 {
11446                                         plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_1;
11447                                         break;
11448                                 }
11449                                 xconnect_query_addresses(plci);
11450                                 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_2;
11451                                 break;
11452                         }
11453                         plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5;
11454                         Rc = OK;
11455                 case ADJUST_B_RESTORE_MIXER_2:
11456                 case ADJUST_B_RESTORE_MIXER_3:
11457                 case ADJUST_B_RESTORE_MIXER_4:
11458                         if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0))
11459                         {
11460                                 dbug(1, dprintf("[%06lx] %s,%d: Adjust B query addresses failed %02x",
11461                                                 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
11462                                 Info = _WRONG_STATE;
11463                                 break;
11464                         }
11465                         if (Rc == OK)
11466                         {
11467                                 if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2)
11468                                         plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_3;
11469                                 else if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_4)
11470                                         plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5;
11471                         }
11472                         else if (Rc == 0)
11473                         {
11474                                 if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2)
11475                                         plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_4;
11476                                 else if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_3)
11477                                         plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5;
11478                         }
11479                         if (plci->adjust_b_state != ADJUST_B_RESTORE_MIXER_5)
11480                         {
11481                                 plci->internal_command = plci->adjust_b_command;
11482                                 break;
11483                         }
11484                 case ADJUST_B_RESTORE_MIXER_5:
11485                         xconnect_write_coefs(plci, plci->adjust_b_command);
11486                         plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_6;
11487                         Rc = OK;
11488                 case ADJUST_B_RESTORE_MIXER_6:
11489                         if (!xconnect_write_coefs_process(Id, plci, Rc))
11490                         {
11491                                 dbug(1, dprintf("[%06lx] %s,%d: Write mixer coefs failed",
11492                                                 UnMapId(Id), (char *)(FILE_), __LINE__));
11493                                 Info = _FACILITY_NOT_SUPPORTED;
11494                                 break;
11495                         }
11496                         if (plci->internal_command)
11497                                 break;
11498                         plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_7;
11499                 case ADJUST_B_RESTORE_MIXER_7:
11500                         break;
11501                 }
11502         }
11503         return (Info);
11504 }
11505
11506
11507 static void mixer_command(dword Id, PLCI *plci, byte Rc)
11508 {
11509         DIVA_CAPI_ADAPTER *a;
11510         word i, internal_command;
11511
11512         dbug(1, dprintf("[%06lx] %s,%d: mixer_command %02x %04x %04x",
11513                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command,
11514                         plci->li_cmd));
11515
11516         a = plci->adapter;
11517         internal_command = plci->internal_command;
11518         plci->internal_command = 0;
11519         switch (plci->li_cmd)
11520         {
11521         case LI_REQ_CONNECT:
11522         case LI_REQ_DISCONNECT:
11523         case LI_REQ_SILENT_UPDATE:
11524                 switch (internal_command)
11525                 {
11526                 default:
11527                         if (plci->li_channel_bits & LI_CHANNEL_INVOLVED)
11528                         {
11529                                 adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities |
11530                                                                           B1_FACILITY_MIXER), MIXER_COMMAND_1);
11531                         }
11532                 case MIXER_COMMAND_1:
11533                         if (plci->li_channel_bits & LI_CHANNEL_INVOLVED)
11534                         {
11535                                 if (adjust_b_process(Id, plci, Rc) != GOOD)
11536                                 {
11537                                         dbug(1, dprintf("[%06lx] %s,%d: Load mixer failed",
11538                                                         UnMapId(Id), (char *)(FILE_), __LINE__));
11539                                         break;
11540                                 }
11541                                 if (plci->internal_command)
11542                                         return;
11543                         }
11544                         plci->li_plci_b_req_pos = plci->li_plci_b_write_pos;
11545                         if ((plci->li_channel_bits & LI_CHANNEL_INVOLVED)
11546                             || ((get_b1_facilities(plci, plci->B1_resource) & B1_FACILITY_MIXER)
11547                                 && (add_b1_facilities(plci, plci->B1_resource, (word)(plci->B1_facilities &
11548                                                                                       ~B1_FACILITY_MIXER)) == plci->B1_resource)))
11549                         {
11550                                 xconnect_write_coefs(plci, MIXER_COMMAND_2);
11551                         }
11552                         else
11553                         {
11554                                 do
11555                                 {
11556                                         mixer_indication_coefs_set(Id, plci);
11557                                 } while (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos);
11558                         }
11559                 case MIXER_COMMAND_2:
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                                 if (!xconnect_write_coefs_process(Id, plci, Rc))
11566                                 {
11567                                         dbug(1, dprintf("[%06lx] %s,%d: Write mixer coefs failed",
11568                                                         UnMapId(Id), (char *)(FILE_), __LINE__));
11569                                         if (plci->li_plci_b_write_pos != plci->li_plci_b_req_pos)
11570                                         {
11571                                                 do
11572                                                 {
11573                                                         plci->li_plci_b_write_pos = (plci->li_plci_b_write_pos == 0) ?
11574                                                                 LI_PLCI_B_QUEUE_ENTRIES - 1 : plci->li_plci_b_write_pos - 1;
11575                                                         i = (plci->li_plci_b_write_pos == 0) ?
11576                                                                 LI_PLCI_B_QUEUE_ENTRIES - 1 : plci->li_plci_b_write_pos - 1;
11577                                                 } while ((plci->li_plci_b_write_pos != plci->li_plci_b_req_pos)
11578                                                          && !(plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG));
11579                                         }
11580                                         break;
11581                                 }
11582                                 if (plci->internal_command)
11583                                         return;
11584                         }
11585                         if (!(plci->li_channel_bits & LI_CHANNEL_INVOLVED))
11586                         {
11587                                 adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities &
11588                                                                           ~B1_FACILITY_MIXER), MIXER_COMMAND_3);
11589                         }
11590                 case MIXER_COMMAND_3:
11591                         if (!(plci->li_channel_bits & LI_CHANNEL_INVOLVED))
11592                         {
11593                                 if (adjust_b_process(Id, plci, Rc) != GOOD)
11594                                 {
11595                                         dbug(1, dprintf("[%06lx] %s,%d: Unload mixer failed",
11596                                                         UnMapId(Id), (char *)(FILE_), __LINE__));
11597                                         break;
11598                                 }
11599                                 if (plci->internal_command)
11600                                         return;
11601                         }
11602                         break;
11603                 }
11604                 break;
11605         }
11606         if ((plci->li_bchannel_id == 0)
11607             || (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci))
11608         {
11609                 dbug(1, dprintf("[%06x] %s,%d: Channel id wiped out %d",
11610                                 UnMapId(Id), (char *)(FILE_), __LINE__, (int)(plci->li_bchannel_id)));
11611         }
11612         else
11613         {
11614                 i = a->li_base + (plci->li_bchannel_id - 1);
11615                 li_config_table[i].curchnl = plci->li_channel_bits;
11616                 if (!a->li_pri && (plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
11617                 {
11618                         i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
11619                         li_config_table[i].curchnl = plci->li_channel_bits;
11620                         if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
11621                         {
11622                                 i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
11623                                 li_config_table[i].curchnl = plci->li_channel_bits;
11624                         }
11625                 }
11626         }
11627 }
11628
11629
11630 static void li_update_connect(dword Id, DIVA_CAPI_ADAPTER *a, PLCI *plci,
11631                               dword plci_b_id, byte connect, dword li_flags)
11632 {
11633         word i, ch_a, ch_a_v, ch_a_s, ch_b, ch_b_v, ch_b_s;
11634         PLCI *plci_b;
11635         DIVA_CAPI_ADAPTER *a_b;
11636
11637         a_b = &(adapter[MapController((byte)(plci_b_id & 0x7f)) - 1]);
11638         plci_b = &(a_b->plci[((plci_b_id >> 8) & 0xff) - 1]);
11639         ch_a = a->li_base + (plci->li_bchannel_id - 1);
11640         if (!a->li_pri && (plci->tel == ADV_VOICE)
11641             && (plci == a->AdvSignalPLCI) && (Id & EXT_CONTROLLER))
11642         {
11643                 ch_a_v = ch_a + MIXER_IC_CHANNEL_BASE;
11644                 ch_a_s = (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11645                         a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id) : ch_a_v;
11646         }
11647         else
11648         {
11649                 ch_a_v = ch_a;
11650                 ch_a_s = ch_a;
11651         }
11652         ch_b = a_b->li_base + (plci_b->li_bchannel_id - 1);
11653         if (!a_b->li_pri && (plci_b->tel == ADV_VOICE)
11654             && (plci_b == a_b->AdvSignalPLCI) && (plci_b_id & EXT_CONTROLLER))
11655         {
11656                 ch_b_v = ch_b + MIXER_IC_CHANNEL_BASE;
11657                 ch_b_s = (a_b->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11658                         a_b->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci_b->li_bchannel_id) : ch_b_v;
11659         }
11660         else
11661         {
11662                 ch_b_v = ch_b;
11663                 ch_b_s = ch_b;
11664         }
11665         if (connect)
11666         {
11667                 li_config_table[ch_a].flag_table[ch_a_v] &= ~LI_FLAG_MONITOR;
11668                 li_config_table[ch_a].flag_table[ch_a_s] &= ~LI_FLAG_MONITOR;
11669                 li_config_table[ch_a_v].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11670                 li_config_table[ch_a_s].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11671         }
11672         li_config_table[ch_a].flag_table[ch_b_v] &= ~LI_FLAG_MONITOR;
11673         li_config_table[ch_a].flag_table[ch_b_s] &= ~LI_FLAG_MONITOR;
11674         li_config_table[ch_b_v].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11675         li_config_table[ch_b_s].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11676         if (ch_a_v == ch_b_v)
11677         {
11678                 li_config_table[ch_a_v].flag_table[ch_b_v] &= ~LI_FLAG_CONFERENCE;
11679                 li_config_table[ch_a_s].flag_table[ch_b_s] &= ~LI_FLAG_CONFERENCE;
11680         }
11681         else
11682         {
11683                 if (li_config_table[ch_a_v].flag_table[ch_b_v] & LI_FLAG_CONFERENCE)
11684                 {
11685                         for (i = 0; i < li_total_channels; i++)
11686                         {
11687                                 if (i != ch_a_v)
11688                                         li_config_table[ch_a_v].flag_table[i] &= ~LI_FLAG_CONFERENCE;
11689                         }
11690                 }
11691                 if (li_config_table[ch_a_s].flag_table[ch_b_v] & LI_FLAG_CONFERENCE)
11692                 {
11693                         for (i = 0; i < li_total_channels; i++)
11694                         {
11695                                 if (i != ch_a_s)
11696                                         li_config_table[ch_a_s].flag_table[i] &= ~LI_FLAG_CONFERENCE;
11697                         }
11698                 }
11699                 if (li_config_table[ch_b_v].flag_table[ch_a_v] & LI_FLAG_CONFERENCE)
11700                 {
11701                         for (i = 0; i < li_total_channels; i++)
11702                         {
11703                                 if (i != ch_a_v)
11704                                         li_config_table[i].flag_table[ch_a_v] &= ~LI_FLAG_CONFERENCE;
11705                         }
11706                 }
11707                 if (li_config_table[ch_b_v].flag_table[ch_a_s] & LI_FLAG_CONFERENCE)
11708                 {
11709                         for (i = 0; i < li_total_channels; i++)
11710                         {
11711                                 if (i != ch_a_s)
11712                                         li_config_table[i].flag_table[ch_a_s] &= ~LI_FLAG_CONFERENCE;
11713                         }
11714                 }
11715         }
11716         if (li_flags & LI_FLAG_CONFERENCE_A_B)
11717         {
11718                 li_config_table[ch_b_v].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11719                 li_config_table[ch_b_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11720                 li_config_table[ch_b_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11721                 li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11722         }
11723         if (li_flags & LI_FLAG_CONFERENCE_B_A)
11724         {
11725                 li_config_table[ch_a_v].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11726                 li_config_table[ch_a_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11727                 li_config_table[ch_a_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11728                 li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11729         }
11730         if (li_flags & LI_FLAG_MONITOR_A)
11731         {
11732                 li_config_table[ch_a].flag_table[ch_a_v] |= LI_FLAG_MONITOR;
11733                 li_config_table[ch_a].flag_table[ch_a_s] |= LI_FLAG_MONITOR;
11734         }
11735         if (li_flags & LI_FLAG_MONITOR_B)
11736         {
11737                 li_config_table[ch_a].flag_table[ch_b_v] |= LI_FLAG_MONITOR;
11738                 li_config_table[ch_a].flag_table[ch_b_s] |= LI_FLAG_MONITOR;
11739         }
11740         if (li_flags & LI_FLAG_ANNOUNCEMENT_A)
11741         {
11742                 li_config_table[ch_a_v].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11743                 li_config_table[ch_a_s].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11744         }
11745         if (li_flags & LI_FLAG_ANNOUNCEMENT_B)
11746         {
11747                 li_config_table[ch_b_v].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11748                 li_config_table[ch_b_s].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11749         }
11750         if (li_flags & LI_FLAG_MIX_A)
11751         {
11752                 li_config_table[ch_a_v].flag_table[ch_a] |= LI_FLAG_MIX;
11753                 li_config_table[ch_a_s].flag_table[ch_a] |= LI_FLAG_MIX;
11754         }
11755         if (li_flags & LI_FLAG_MIX_B)
11756         {
11757                 li_config_table[ch_b_v].flag_table[ch_a] |= LI_FLAG_MIX;
11758                 li_config_table[ch_b_s].flag_table[ch_a] |= LI_FLAG_MIX;
11759         }
11760         if (ch_a_v != ch_a_s)
11761         {
11762                 li_config_table[ch_a_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11763                 li_config_table[ch_a_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11764         }
11765         if (ch_b_v != ch_b_s)
11766         {
11767                 li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11768                 li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11769         }
11770 }
11771
11772
11773 static void li2_update_connect(dword Id, DIVA_CAPI_ADAPTER *a, PLCI *plci,
11774                                dword plci_b_id, byte connect, dword li_flags)
11775 {
11776         word ch_a, ch_a_v, ch_a_s, ch_b, ch_b_v, ch_b_s;
11777         PLCI *plci_b;
11778         DIVA_CAPI_ADAPTER *a_b;
11779
11780         a_b = &(adapter[MapController((byte)(plci_b_id & 0x7f)) - 1]);
11781         plci_b = &(a_b->plci[((plci_b_id >> 8) & 0xff) - 1]);
11782         ch_a = a->li_base + (plci->li_bchannel_id - 1);
11783         if (!a->li_pri && (plci->tel == ADV_VOICE)
11784             && (plci == a->AdvSignalPLCI) && (Id & EXT_CONTROLLER))
11785         {
11786                 ch_a_v = ch_a + MIXER_IC_CHANNEL_BASE;
11787                 ch_a_s = (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11788                         a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id) : ch_a_v;
11789         }
11790         else
11791         {
11792                 ch_a_v = ch_a;
11793                 ch_a_s = ch_a;
11794         }
11795         ch_b = a_b->li_base + (plci_b->li_bchannel_id - 1);
11796         if (!a_b->li_pri && (plci_b->tel == ADV_VOICE)
11797             && (plci_b == a_b->AdvSignalPLCI) && (plci_b_id & EXT_CONTROLLER))
11798         {
11799                 ch_b_v = ch_b + MIXER_IC_CHANNEL_BASE;
11800                 ch_b_s = (a_b->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11801                         a_b->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci_b->li_bchannel_id) : ch_b_v;
11802         }
11803         else
11804         {
11805                 ch_b_v = ch_b;
11806                 ch_b_s = ch_b;
11807         }
11808         if (connect)
11809         {
11810                 li_config_table[ch_b].flag_table[ch_b_v] &= ~LI_FLAG_MONITOR;
11811                 li_config_table[ch_b].flag_table[ch_b_s] &= ~LI_FLAG_MONITOR;
11812                 li_config_table[ch_b_v].flag_table[ch_b] &= ~LI_FLAG_MIX;
11813                 li_config_table[ch_b_s].flag_table[ch_b] &= ~LI_FLAG_MIX;
11814                 li_config_table[ch_b].flag_table[ch_b] &= ~LI_FLAG_PCCONNECT;
11815                 li_config_table[ch_b].chflags &= ~(LI_CHFLAG_MONITOR | LI_CHFLAG_MIX | LI_CHFLAG_LOOP);
11816         }
11817         li_config_table[ch_b_v].flag_table[ch_a_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11818         li_config_table[ch_b_s].flag_table[ch_a_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11819         li_config_table[ch_b_v].flag_table[ch_a_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11820         li_config_table[ch_b_s].flag_table[ch_a_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11821         li_config_table[ch_a_v].flag_table[ch_b_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11822         li_config_table[ch_a_v].flag_table[ch_b_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11823         li_config_table[ch_a_s].flag_table[ch_b_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11824         li_config_table[ch_a_s].flag_table[ch_b_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11825         if (li_flags & LI2_FLAG_INTERCONNECT_A_B)
11826         {
11827                 li_config_table[ch_b_v].flag_table[ch_a_v] |= LI_FLAG_INTERCONNECT;
11828                 li_config_table[ch_b_s].flag_table[ch_a_v] |= LI_FLAG_INTERCONNECT;
11829                 li_config_table[ch_b_v].flag_table[ch_a_s] |= LI_FLAG_INTERCONNECT;
11830                 li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_INTERCONNECT;
11831         }
11832         if (li_flags & LI2_FLAG_INTERCONNECT_B_A)
11833         {
11834                 li_config_table[ch_a_v].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11835                 li_config_table[ch_a_v].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11836                 li_config_table[ch_a_s].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11837                 li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11838         }
11839         if (li_flags & LI2_FLAG_MONITOR_B)
11840         {
11841                 li_config_table[ch_b].flag_table[ch_b_v] |= LI_FLAG_MONITOR;
11842                 li_config_table[ch_b].flag_table[ch_b_s] |= LI_FLAG_MONITOR;
11843         }
11844         if (li_flags & LI2_FLAG_MIX_B)
11845         {
11846                 li_config_table[ch_b_v].flag_table[ch_b] |= LI_FLAG_MIX;
11847                 li_config_table[ch_b_s].flag_table[ch_b] |= LI_FLAG_MIX;
11848         }
11849         if (li_flags & LI2_FLAG_MONITOR_X)
11850                 li_config_table[ch_b].chflags |= LI_CHFLAG_MONITOR;
11851         if (li_flags & LI2_FLAG_MIX_X)
11852                 li_config_table[ch_b].chflags |= LI_CHFLAG_MIX;
11853         if (li_flags & LI2_FLAG_LOOP_B)
11854         {
11855                 li_config_table[ch_b_v].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11856                 li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11857                 li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11858                 li_config_table[ch_b_s].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11859         }
11860         if (li_flags & LI2_FLAG_LOOP_PC)
11861                 li_config_table[ch_b].flag_table[ch_b] |= LI_FLAG_PCCONNECT;
11862         if (li_flags & LI2_FLAG_LOOP_X)
11863                 li_config_table[ch_b].chflags |= LI_CHFLAG_LOOP;
11864         if (li_flags & LI2_FLAG_PCCONNECT_A_B)
11865                 li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_PCCONNECT;
11866         if (li_flags & LI2_FLAG_PCCONNECT_B_A)
11867                 li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_PCCONNECT;
11868         if (ch_a_v != ch_a_s)
11869         {
11870                 li_config_table[ch_a_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11871                 li_config_table[ch_a_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11872         }
11873         if (ch_b_v != ch_b_s)
11874         {
11875                 li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11876                 li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11877         }
11878 }
11879
11880
11881 static word li_check_main_plci(dword Id, PLCI *plci)
11882 {
11883         if (plci == NULL)
11884         {
11885                 dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI",
11886                                 UnMapId(Id), (char *)(FILE_), __LINE__));
11887                 return (_WRONG_IDENTIFIER);
11888         }
11889         if (!plci->State
11890             || !plci->NL.Id || plci->nl_remove_id
11891             || (plci->li_bchannel_id == 0))
11892         {
11893                 dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
11894                                 UnMapId(Id), (char *)(FILE_), __LINE__));
11895                 return (_WRONG_STATE);
11896         }
11897         li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci = plci;
11898         return (GOOD);
11899 }
11900
11901
11902 static PLCI *li_check_plci_b(dword Id, PLCI *plci,
11903                              dword plci_b_id, word plci_b_write_pos, byte *p_result)
11904 {
11905         byte ctlr_b;
11906         PLCI *plci_b;
11907
11908         if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
11909              LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2)
11910         {
11911                 dbug(1, dprintf("[%06lx] %s,%d: LI request overrun",
11912                                 UnMapId(Id), (char *)(FILE_), __LINE__));
11913                 PUT_WORD(p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE);
11914                 return (NULL);
11915         }
11916         ctlr_b = 0;
11917         if ((plci_b_id & 0x7f) != 0)
11918         {
11919                 ctlr_b = MapController((byte)(plci_b_id & 0x7f));
11920                 if ((ctlr_b > max_adapter) || ((ctlr_b != 0) && (adapter[ctlr_b - 1].request == NULL)))
11921                         ctlr_b = 0;
11922         }
11923         if ((ctlr_b == 0)
11924             || (((plci_b_id >> 8) & 0xff) == 0)
11925             || (((plci_b_id >> 8) & 0xff) > adapter[ctlr_b - 1].max_plci))
11926         {
11927                 dbug(1, dprintf("[%06lx] %s,%d: LI invalid second PLCI %08lx",
11928                                 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
11929                 PUT_WORD(p_result, _WRONG_IDENTIFIER);
11930                 return (NULL);
11931         }
11932         plci_b = &(adapter[ctlr_b - 1].plci[((plci_b_id >> 8) & 0xff) - 1]);
11933         if (!plci_b->State
11934             || !plci_b->NL.Id || plci_b->nl_remove_id
11935             || (plci_b->li_bchannel_id == 0))
11936         {
11937                 dbug(1, dprintf("[%06lx] %s,%d: LI peer in wrong state %08lx",
11938                                 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
11939                 PUT_WORD(p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE);
11940                 return (NULL);
11941         }
11942         li_config_table[plci_b->adapter->li_base + (plci_b->li_bchannel_id - 1)].plci = plci_b;
11943         if (((byte)(plci_b_id & ~EXT_CONTROLLER)) !=
11944             ((byte)(UnMapController(plci->adapter->Id) & ~EXT_CONTROLLER))
11945             && (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
11946                 || !(plci_b->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)))
11947         {
11948                 dbug(1, dprintf("[%06lx] %s,%d: LI not on same ctrl %08lx",
11949                                 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
11950                 PUT_WORD(p_result, _WRONG_IDENTIFIER);
11951                 return (NULL);
11952         }
11953         if (!(get_b1_facilities(plci_b, add_b1_facilities(plci_b, plci_b->B1_resource,
11954                                                           (word)(plci_b->B1_facilities | B1_FACILITY_MIXER))) & B1_FACILITY_MIXER))
11955         {
11956                 dbug(1, dprintf("[%06lx] %s,%d: Interconnect peer cannot mix %d",
11957                                 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b->B1_resource));
11958                 PUT_WORD(p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE);
11959                 return (NULL);
11960         }
11961         return (plci_b);
11962 }
11963
11964
11965 static PLCI *li2_check_plci_b(dword Id, PLCI *plci,
11966                               dword plci_b_id, word plci_b_write_pos, byte *p_result)
11967 {
11968         byte ctlr_b;
11969         PLCI *plci_b;
11970
11971         if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
11972              LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2)
11973         {
11974                 dbug(1, dprintf("[%06lx] %s,%d: LI request overrun",
11975                                 UnMapId(Id), (char *)(FILE_), __LINE__));
11976                 PUT_WORD(p_result, _WRONG_STATE);
11977                 return (NULL);
11978         }
11979         ctlr_b = 0;
11980         if ((plci_b_id & 0x7f) != 0)
11981         {
11982                 ctlr_b = MapController((byte)(plci_b_id & 0x7f));
11983                 if ((ctlr_b > max_adapter) || ((ctlr_b != 0) && (adapter[ctlr_b - 1].request == NULL)))
11984                         ctlr_b = 0;
11985         }
11986         if ((ctlr_b == 0)
11987             || (((plci_b_id >> 8) & 0xff) == 0)
11988             || (((plci_b_id >> 8) & 0xff) > adapter[ctlr_b - 1].max_plci))
11989         {
11990                 dbug(1, dprintf("[%06lx] %s,%d: LI invalid second PLCI %08lx",
11991                                 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
11992                 PUT_WORD(p_result, _WRONG_IDENTIFIER);
11993                 return (NULL);
11994         }
11995         plci_b = &(adapter[ctlr_b - 1].plci[((plci_b_id >> 8) & 0xff) - 1]);
11996         if (!plci_b->State
11997             || !plci_b->NL.Id || plci_b->nl_remove_id
11998             || (plci_b->li_bchannel_id == 0)
11999             || (li_config_table[plci_b->adapter->li_base + (plci_b->li_bchannel_id - 1)].plci != plci_b))
12000         {
12001                 dbug(1, dprintf("[%06lx] %s,%d: LI peer in wrong state %08lx",
12002                                 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
12003                 PUT_WORD(p_result, _WRONG_STATE);
12004                 return (NULL);
12005         }
12006         if (((byte)(plci_b_id & ~EXT_CONTROLLER)) !=
12007             ((byte)(UnMapController(plci->adapter->Id) & ~EXT_CONTROLLER))
12008             && (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12009                 || !(plci_b->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)))
12010         {
12011                 dbug(1, dprintf("[%06lx] %s,%d: LI not on same ctrl %08lx",
12012                                 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
12013                 PUT_WORD(p_result, _WRONG_IDENTIFIER);
12014                 return (NULL);
12015         }
12016         if (!(get_b1_facilities(plci_b, add_b1_facilities(plci_b, plci_b->B1_resource,
12017                                                           (word)(plci_b->B1_facilities | B1_FACILITY_MIXER))) & B1_FACILITY_MIXER))
12018         {
12019                 dbug(1, dprintf("[%06lx] %s,%d: Interconnect peer cannot mix %d",
12020                                 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b->B1_resource));
12021                 PUT_WORD(p_result, _WRONG_STATE);
12022                 return (NULL);
12023         }
12024         return (plci_b);
12025 }
12026
12027
12028 static byte mixer_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL   *appl, API_PARSE *msg)
12029 {
12030         word Info;
12031         word i;
12032         dword d, li_flags, plci_b_id;
12033         PLCI *plci_b;
12034         API_PARSE li_parms[3];
12035         API_PARSE li_req_parms[3];
12036         API_PARSE li_participant_struct[2];
12037         API_PARSE li_participant_parms[3];
12038         word participant_parms_pos;
12039         byte result_buffer[32];
12040         byte *result;
12041         word result_pos;
12042         word plci_b_write_pos;
12043
12044         dbug(1, dprintf("[%06lx] %s,%d: mixer_request",
12045                         UnMapId(Id), (char *)(FILE_), __LINE__));
12046
12047         Info = GOOD;
12048         result = result_buffer;
12049         result_buffer[0] = 0;
12050         if (!(a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED))
12051         {
12052                 dbug(1, dprintf("[%06lx] %s,%d: Facility not supported",
12053                                 UnMapId(Id), (char *)(FILE_), __LINE__));
12054                 Info = _FACILITY_NOT_SUPPORTED;
12055         }
12056         else if (api_parse(&msg[1].info[1], msg[1].length, "ws", li_parms))
12057         {
12058                 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12059                                 UnMapId(Id), (char *)(FILE_), __LINE__));
12060                 Info = _WRONG_MESSAGE_FORMAT;
12061         }
12062         else
12063         {
12064                 result_buffer[0] = 3;
12065                 PUT_WORD(&result_buffer[1], GET_WORD(li_parms[0].info));
12066                 result_buffer[3] = 0;
12067                 switch (GET_WORD(li_parms[0].info))
12068                 {
12069                 case LI_GET_SUPPORTED_SERVICES:
12070                         if (appl->appl_flags & APPL_FLAG_OLD_LI_SPEC)
12071                         {
12072                                 result_buffer[0] = 17;
12073                                 result_buffer[3] = 14;
12074                                 PUT_WORD(&result_buffer[4], GOOD);
12075                                 d = 0;
12076                                 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_CH)
12077                                         d |= LI_CONFERENCING_SUPPORTED;
12078                                 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_PC)
12079                                         d |= LI_MONITORING_SUPPORTED;
12080                                 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_CH)
12081                                         d |= LI_ANNOUNCEMENTS_SUPPORTED | LI_MIXING_SUPPORTED;
12082                                 if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12083                                         d |= LI_CROSS_CONTROLLER_SUPPORTED;
12084                                 PUT_DWORD(&result_buffer[6], d);
12085                                 if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12086                                 {
12087                                         d = 0;
12088                                         for (i = 0; i < li_total_channels; i++)
12089                                         {
12090                                                 if ((li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12091                                                     && (li_config_table[i].adapter->li_pri
12092                                                         || (i < li_config_table[i].adapter->li_base + MIXER_BCHANNELS_BRI)))
12093                                                 {
12094                                                         d++;
12095                                                 }
12096                                         }
12097                                 }
12098                                 else
12099                                 {
12100                                         d = a->li_pri ? a->li_channels : MIXER_BCHANNELS_BRI;
12101                                 }
12102                                 PUT_DWORD(&result_buffer[10], d / 2);
12103                                 PUT_DWORD(&result_buffer[14], d);
12104                         }
12105                         else
12106                         {
12107                                 result_buffer[0] = 25;
12108                                 result_buffer[3] = 22;
12109                                 PUT_WORD(&result_buffer[4], GOOD);
12110                                 d = LI2_ASYMMETRIC_SUPPORTED | LI2_B_LOOPING_SUPPORTED | LI2_X_LOOPING_SUPPORTED;
12111                                 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_PC)
12112                                         d |= LI2_MONITORING_SUPPORTED | LI2_REMOTE_MONITORING_SUPPORTED;
12113                                 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_CH)
12114                                         d |= LI2_MIXING_SUPPORTED | LI2_REMOTE_MIXING_SUPPORTED;
12115                                 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_PC)
12116                                         d |= LI2_PC_LOOPING_SUPPORTED;
12117                                 if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12118                                         d |= LI2_CROSS_CONTROLLER_SUPPORTED;
12119                                 PUT_DWORD(&result_buffer[6], d);
12120                                 d = a->li_pri ? a->li_channels : MIXER_BCHANNELS_BRI;
12121                                 PUT_DWORD(&result_buffer[10], d / 2);
12122                                 PUT_DWORD(&result_buffer[14], d - 1);
12123                                 if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12124                                 {
12125                                         d = 0;
12126                                         for (i = 0; i < li_total_channels; i++)
12127                                         {
12128                                                 if ((li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12129                                                     && (li_config_table[i].adapter->li_pri
12130                                                         || (i < li_config_table[i].adapter->li_base + MIXER_BCHANNELS_BRI)))
12131                                                 {
12132                                                         d++;
12133                                                 }
12134                                         }
12135                                 }
12136                                 PUT_DWORD(&result_buffer[18], d / 2);
12137                                 PUT_DWORD(&result_buffer[22], d - 1);
12138                         }
12139                         break;
12140
12141                 case LI_REQ_CONNECT:
12142                         if (li_parms[1].length == 8)
12143                         {
12144                                 appl->appl_flags |= APPL_FLAG_OLD_LI_SPEC;
12145                                 if (api_parse(&li_parms[1].info[1], li_parms[1].length, "dd", li_req_parms))
12146                                 {
12147                                         dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12148                                                         UnMapId(Id), (char *)(FILE_), __LINE__));
12149                                         Info = _WRONG_MESSAGE_FORMAT;
12150                                         break;
12151                                 }
12152                                 plci_b_id = GET_DWORD(li_req_parms[0].info) & 0xffff;
12153                                 li_flags = GET_DWORD(li_req_parms[1].info);
12154                                 Info = li_check_main_plci(Id, plci);
12155                                 result_buffer[0] = 9;
12156                                 result_buffer[3] = 6;
12157                                 PUT_DWORD(&result_buffer[4], plci_b_id);
12158                                 PUT_WORD(&result_buffer[8], GOOD);
12159                                 if (Info != GOOD)
12160                                         break;
12161                                 result = plci->saved_msg.info;
12162                                 for (i = 0; i <= result_buffer[0]; i++)
12163                                         result[i] = result_buffer[i];
12164                                 plci_b_write_pos = plci->li_plci_b_write_pos;
12165                                 plci_b = li_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[8]);
12166                                 if (plci_b == NULL)
12167                                         break;
12168                                 li_update_connect(Id, a, plci, plci_b_id, true, li_flags);
12169                                 plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_LAST_FLAG;
12170                                 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12171                                 plci->li_plci_b_write_pos = plci_b_write_pos;
12172                         }
12173                         else
12174                         {
12175                                 appl->appl_flags &= ~APPL_FLAG_OLD_LI_SPEC;
12176                                 if (api_parse(&li_parms[1].info[1], li_parms[1].length, "ds", li_req_parms))
12177                                 {
12178                                         dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12179                                                         UnMapId(Id), (char *)(FILE_), __LINE__));
12180                                         Info = _WRONG_MESSAGE_FORMAT;
12181                                         break;
12182                                 }
12183                                 li_flags = GET_DWORD(li_req_parms[0].info) & ~(LI2_FLAG_INTERCONNECT_A_B | LI2_FLAG_INTERCONNECT_B_A);
12184                                 Info = li_check_main_plci(Id, plci);
12185                                 result_buffer[0] = 7;
12186                                 result_buffer[3] = 4;
12187                                 PUT_WORD(&result_buffer[4], Info);
12188                                 result_buffer[6] = 0;
12189                                 if (Info != GOOD)
12190                                         break;
12191                                 result = plci->saved_msg.info;
12192                                 for (i = 0; i <= result_buffer[0]; i++)
12193                                         result[i] = result_buffer[i];
12194                                 plci_b_write_pos = plci->li_plci_b_write_pos;
12195                                 participant_parms_pos = 0;
12196                                 result_pos = 7;
12197                                 li2_update_connect(Id, a, plci, UnMapId(Id), true, li_flags);
12198                                 while (participant_parms_pos < li_req_parms[1].length)
12199                                 {
12200                                         result[result_pos] = 6;
12201                                         result_pos += 7;
12202                                         PUT_DWORD(&result[result_pos - 6], 0);
12203                                         PUT_WORD(&result[result_pos - 2], GOOD);
12204                                         if (api_parse(&li_req_parms[1].info[1 + participant_parms_pos],
12205                                                       (word)(li_parms[1].length - participant_parms_pos), "s", li_participant_struct))
12206                                         {
12207                                                 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12208                                                                 UnMapId(Id), (char *)(FILE_), __LINE__));
12209                                                 PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12210                                                 break;
12211                                         }
12212                                         if (api_parse(&li_participant_struct[0].info[1],
12213                                                       li_participant_struct[0].length, "dd", li_participant_parms))
12214                                         {
12215                                                 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12216                                                                 UnMapId(Id), (char *)(FILE_), __LINE__));
12217                                                 PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12218                                                 break;
12219                                         }
12220                                         plci_b_id = GET_DWORD(li_participant_parms[0].info) & 0xffff;
12221                                         li_flags = GET_DWORD(li_participant_parms[1].info);
12222                                         PUT_DWORD(&result[result_pos - 6], plci_b_id);
12223                                         if (sizeof(result) - result_pos < 7)
12224                                         {
12225                                                 dbug(1, dprintf("[%06lx] %s,%d: LI result overrun",
12226                                                                 UnMapId(Id), (char *)(FILE_), __LINE__));
12227                                                 PUT_WORD(&result[result_pos - 2], _WRONG_STATE);
12228                                                 break;
12229                                         }
12230                                         plci_b = li2_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[result_pos - 2]);
12231                                         if (plci_b != NULL)
12232                                         {
12233                                                 li2_update_connect(Id, a, plci, plci_b_id, true, li_flags);
12234                                                 plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id |
12235                                                         ((li_flags & (LI2_FLAG_INTERCONNECT_A_B | LI2_FLAG_INTERCONNECT_B_A |
12236                                                                       LI2_FLAG_PCCONNECT_A_B | LI2_FLAG_PCCONNECT_B_A)) ? 0 : LI_PLCI_B_DISC_FLAG);
12237                                                 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12238                                         }
12239                                         participant_parms_pos = (word)((&li_participant_struct[0].info[1 + li_participant_struct[0].length]) -
12240                                                                        (&li_req_parms[1].info[1]));
12241                                 }
12242                                 result[0] = (byte)(result_pos - 1);
12243                                 result[3] = (byte)(result_pos - 4);
12244                                 result[6] = (byte)(result_pos - 7);
12245                                 i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES - 1 : plci_b_write_pos - 1;
12246                                 if ((plci_b_write_pos == plci->li_plci_b_read_pos)
12247                                     || (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG))
12248                                 {
12249                                         plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_FLAG | LI_PLCI_B_LAST_FLAG;
12250                                         plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12251                                 }
12252                                 else
12253                                         plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG;
12254                                 plci->li_plci_b_write_pos = plci_b_write_pos;
12255                         }
12256                         mixer_calculate_coefs(a);
12257                         plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel;
12258                         mixer_notify_update(plci, true);
12259                         sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
12260                               "wwS", Info, SELECTOR_LINE_INTERCONNECT, result);
12261                         plci->command = 0;
12262                         plci->li_cmd = GET_WORD(li_parms[0].info);
12263                         start_internal_command(Id, plci, mixer_command);
12264                         return (false);
12265
12266                 case LI_REQ_DISCONNECT:
12267                         if (li_parms[1].length == 4)
12268                         {
12269                                 appl->appl_flags |= APPL_FLAG_OLD_LI_SPEC;
12270                                 if (api_parse(&li_parms[1].info[1], li_parms[1].length, "d", li_req_parms))
12271                                 {
12272                                         dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12273                                                         UnMapId(Id), (char *)(FILE_), __LINE__));
12274                                         Info = _WRONG_MESSAGE_FORMAT;
12275                                         break;
12276                                 }
12277                                 plci_b_id = GET_DWORD(li_req_parms[0].info) & 0xffff;
12278                                 Info = li_check_main_plci(Id, plci);
12279                                 result_buffer[0] = 9;
12280                                 result_buffer[3] = 6;
12281                                 PUT_DWORD(&result_buffer[4], GET_DWORD(li_req_parms[0].info));
12282                                 PUT_WORD(&result_buffer[8], GOOD);
12283                                 if (Info != GOOD)
12284                                         break;
12285                                 result = plci->saved_msg.info;
12286                                 for (i = 0; i <= result_buffer[0]; i++)
12287                                         result[i] = result_buffer[i];
12288                                 plci_b_write_pos = plci->li_plci_b_write_pos;
12289                                 plci_b = li_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[8]);
12290                                 if (plci_b == NULL)
12291                                         break;
12292                                 li_update_connect(Id, a, plci, plci_b_id, false, 0);
12293                                 plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG | LI_PLCI_B_LAST_FLAG;
12294                                 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12295                                 plci->li_plci_b_write_pos = plci_b_write_pos;
12296                         }
12297                         else
12298                         {
12299                                 appl->appl_flags &= ~APPL_FLAG_OLD_LI_SPEC;
12300                                 if (api_parse(&li_parms[1].info[1], li_parms[1].length, "s", li_req_parms))
12301                                 {
12302                                         dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12303                                                         UnMapId(Id), (char *)(FILE_), __LINE__));
12304                                         Info = _WRONG_MESSAGE_FORMAT;
12305                                         break;
12306                                 }
12307                                 Info = li_check_main_plci(Id, plci);
12308                                 result_buffer[0] = 7;
12309                                 result_buffer[3] = 4;
12310                                 PUT_WORD(&result_buffer[4], Info);
12311                                 result_buffer[6] = 0;
12312                                 if (Info != GOOD)
12313                                         break;
12314                                 result = plci->saved_msg.info;
12315                                 for (i = 0; i <= result_buffer[0]; i++)
12316                                         result[i] = result_buffer[i];
12317                                 plci_b_write_pos = plci->li_plci_b_write_pos;
12318                                 participant_parms_pos = 0;
12319                                 result_pos = 7;
12320                                 while (participant_parms_pos < li_req_parms[0].length)
12321                                 {
12322                                         result[result_pos] = 6;
12323                                         result_pos += 7;
12324                                         PUT_DWORD(&result[result_pos - 6], 0);
12325                                         PUT_WORD(&result[result_pos - 2], GOOD);
12326                                         if (api_parse(&li_req_parms[0].info[1 + participant_parms_pos],
12327                                                       (word)(li_parms[1].length - participant_parms_pos), "s", li_participant_struct))
12328                                         {
12329                                                 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12330                                                                 UnMapId(Id), (char *)(FILE_), __LINE__));
12331                                                 PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12332                                                 break;
12333                                         }
12334                                         if (api_parse(&li_participant_struct[0].info[1],
12335                                                       li_participant_struct[0].length, "d", li_participant_parms))
12336                                         {
12337                                                 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12338                                                                 UnMapId(Id), (char *)(FILE_), __LINE__));
12339                                                 PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12340                                                 break;
12341                                         }
12342                                         plci_b_id = GET_DWORD(li_participant_parms[0].info) & 0xffff;
12343                                         PUT_DWORD(&result[result_pos - 6], plci_b_id);
12344                                         if (sizeof(result) - result_pos < 7)
12345                                         {
12346                                                 dbug(1, dprintf("[%06lx] %s,%d: LI result overrun",
12347                                                                 UnMapId(Id), (char *)(FILE_), __LINE__));
12348                                                 PUT_WORD(&result[result_pos - 2], _WRONG_STATE);
12349                                                 break;
12350                                         }
12351                                         plci_b = li2_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[result_pos - 2]);
12352                                         if (plci_b != NULL)
12353                                         {
12354                                                 li2_update_connect(Id, a, plci, plci_b_id, false, 0);
12355                                                 plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG;
12356                                                 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12357                                         }
12358                                         participant_parms_pos = (word)((&li_participant_struct[0].info[1 + li_participant_struct[0].length]) -
12359                                                                        (&li_req_parms[0].info[1]));
12360                                 }
12361                                 result[0] = (byte)(result_pos - 1);
12362                                 result[3] = (byte)(result_pos - 4);
12363                                 result[6] = (byte)(result_pos - 7);
12364                                 i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES - 1 : plci_b_write_pos - 1;
12365                                 if ((plci_b_write_pos == plci->li_plci_b_read_pos)
12366                                     || (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG))
12367                                 {
12368                                         plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_FLAG | LI_PLCI_B_LAST_FLAG;
12369                                         plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12370                                 }
12371                                 else
12372                                         plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG;
12373                                 plci->li_plci_b_write_pos = plci_b_write_pos;
12374                         }
12375                         mixer_calculate_coefs(a);
12376                         plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel;
12377                         mixer_notify_update(plci, true);
12378                         sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
12379                               "wwS", Info, SELECTOR_LINE_INTERCONNECT, result);
12380                         plci->command = 0;
12381                         plci->li_cmd = GET_WORD(li_parms[0].info);
12382                         start_internal_command(Id, plci, mixer_command);
12383                         return (false);
12384
12385                 case LI_REQ_SILENT_UPDATE:
12386                         if (!plci || !plci->State
12387                             || !plci->NL.Id || plci->nl_remove_id
12388                             || (plci->li_bchannel_id == 0)
12389                             || (li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci != plci))
12390                         {
12391                                 dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
12392                                                 UnMapId(Id), (char *)(FILE_), __LINE__));
12393                                 return (false);
12394                         }
12395                         plci_b_write_pos = plci->li_plci_b_write_pos;
12396                         if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
12397                              LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2)
12398                         {
12399                                 dbug(1, dprintf("[%06lx] %s,%d: LI request overrun",
12400                                                 UnMapId(Id), (char *)(FILE_), __LINE__));
12401                                 return (false);
12402                         }
12403                         i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES - 1 : plci_b_write_pos - 1;
12404                         if ((plci_b_write_pos == plci->li_plci_b_read_pos)
12405                             || (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG))
12406                         {
12407                                 plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_FLAG | LI_PLCI_B_LAST_FLAG;
12408                                 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12409                         }
12410                         else
12411                                 plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG;
12412                         plci->li_plci_b_write_pos = plci_b_write_pos;
12413                         plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel;
12414                         plci->command = 0;
12415                         plci->li_cmd = GET_WORD(li_parms[0].info);
12416                         start_internal_command(Id, plci, mixer_command);
12417                         return (false);
12418
12419                 default:
12420                         dbug(1, dprintf("[%06lx] %s,%d: LI unknown request %04x",
12421                                         UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(li_parms[0].info)));
12422                         Info = _FACILITY_NOT_SUPPORTED;
12423                 }
12424         }
12425         sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
12426               "wwS", Info, SELECTOR_LINE_INTERCONNECT, result);
12427         return (false);
12428 }
12429
12430
12431 static void mixer_indication_coefs_set(dword Id, PLCI *plci)
12432 {
12433         dword d;
12434         byte result[12];
12435
12436         dbug(1, dprintf("[%06lx] %s,%d: mixer_indication_coefs_set",
12437                         UnMapId(Id), (char *)(FILE_), __LINE__));
12438
12439         if (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos)
12440         {
12441                 do
12442                 {
12443                         d = plci->li_plci_b_queue[plci->li_plci_b_read_pos];
12444                         if (!(d & LI_PLCI_B_SKIP_FLAG))
12445                         {
12446                                 if (plci->appl->appl_flags & APPL_FLAG_OLD_LI_SPEC)
12447                                 {
12448                                         if (d & LI_PLCI_B_DISC_FLAG)
12449                                         {
12450                                                 result[0] = 5;
12451                                                 PUT_WORD(&result[1], LI_IND_DISCONNECT);
12452                                                 result[3] = 2;
12453                                                 PUT_WORD(&result[4], _LI_USER_INITIATED);
12454                                         }
12455                                         else
12456                                         {
12457                                                 result[0] = 7;
12458                                                 PUT_WORD(&result[1], LI_IND_CONNECT_ACTIVE);
12459                                                 result[3] = 4;
12460                                                 PUT_DWORD(&result[4], d & ~LI_PLCI_B_FLAG_MASK);
12461                                         }
12462                                 }
12463                                 else
12464                                 {
12465                                         if (d & LI_PLCI_B_DISC_FLAG)
12466                                         {
12467                                                 result[0] = 9;
12468                                                 PUT_WORD(&result[1], LI_IND_DISCONNECT);
12469                                                 result[3] = 6;
12470                                                 PUT_DWORD(&result[4], d & ~LI_PLCI_B_FLAG_MASK);
12471                                                 PUT_WORD(&result[8], _LI_USER_INITIATED);
12472                                         }
12473                                         else
12474                                         {
12475                                                 result[0] = 7;
12476                                                 PUT_WORD(&result[1], LI_IND_CONNECT_ACTIVE);
12477                                                 result[3] = 4;
12478                                                 PUT_DWORD(&result[4], d & ~LI_PLCI_B_FLAG_MASK);
12479                                         }
12480                                 }
12481                                 sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0,
12482                                       "ws", SELECTOR_LINE_INTERCONNECT, result);
12483                         }
12484                         plci->li_plci_b_read_pos = (plci->li_plci_b_read_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ?
12485                                 0 : plci->li_plci_b_read_pos + 1;
12486                 } while (!(d & LI_PLCI_B_LAST_FLAG) && (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos));
12487         }
12488 }
12489
12490
12491 static void mixer_indication_xconnect_from(dword Id, PLCI *plci, byte *msg, word length)
12492 {
12493         word i, j, ch;
12494         struct xconnect_transfer_address_s s,   *p;
12495         DIVA_CAPI_ADAPTER *a;
12496
12497         dbug(1, dprintf("[%06lx] %s,%d: mixer_indication_xconnect_from %d",
12498                         UnMapId(Id), (char *)(FILE_), __LINE__, (int)length));
12499
12500         a = plci->adapter;
12501         i = 1;
12502         for (i = 1; i < length; i += 16)
12503         {
12504                 s.card_address.low = msg[i] | (msg[i + 1] << 8) | (((dword)(msg[i + 2])) << 16) | (((dword)(msg[i + 3])) << 24);
12505                 s.card_address.high = msg[i + 4] | (msg[i + 5] << 8) | (((dword)(msg[i + 6])) << 16) | (((dword)(msg[i + 7])) << 24);
12506                 s.offset = msg[i + 8] | (msg[i + 9] << 8) | (((dword)(msg[i + 10])) << 16) | (((dword)(msg[i + 11])) << 24);
12507                 ch = msg[i + 12] | (msg[i + 13] << 8);
12508                 j = ch & XCONNECT_CHANNEL_NUMBER_MASK;
12509                 if (!a->li_pri && (plci->li_bchannel_id == 2))
12510                         j = 1 - j;
12511                 j += a->li_base;
12512                 if (ch & XCONNECT_CHANNEL_PORT_PC)
12513                         p = &(li_config_table[j].send_pc);
12514                 else
12515                         p = &(li_config_table[j].send_b);
12516                 p->card_address.low = s.card_address.low;
12517                 p->card_address.high = s.card_address.high;
12518                 p->offset = s.offset;
12519                 li_config_table[j].channel |= LI_CHANNEL_ADDRESSES_SET;
12520         }
12521         if (plci->internal_command_queue[0]
12522             && ((plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2)
12523                 || (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_3)
12524                 || (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_4)))
12525         {
12526                 (*(plci->internal_command_queue[0]))(Id, plci, 0);
12527                 if (!plci->internal_command)
12528                         next_internal_command(Id, plci);
12529         }
12530         mixer_notify_update(plci, true);
12531 }
12532
12533
12534 static void mixer_indication_xconnect_to(dword Id, PLCI *plci, byte *msg, word length)
12535 {
12536
12537         dbug(1, dprintf("[%06lx] %s,%d: mixer_indication_xconnect_to %d",
12538                         UnMapId(Id), (char *)(FILE_), __LINE__, (int) length));
12539
12540 }
12541
12542
12543 static byte mixer_notify_source_removed(PLCI *plci, dword plci_b_id)
12544 {
12545         word plci_b_write_pos;
12546
12547         plci_b_write_pos = plci->li_plci_b_write_pos;
12548         if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
12549              LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 1)
12550         {
12551                 dbug(1, dprintf("[%06lx] %s,%d: LI request overrun",
12552                                 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
12553                                 (char *)(FILE_), __LINE__));
12554                 return (false);
12555         }
12556         plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG;
12557         plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12558         plci->li_plci_b_write_pos = plci_b_write_pos;
12559         return (true);
12560 }
12561
12562
12563 static void mixer_remove(PLCI *plci)
12564 {
12565         DIVA_CAPI_ADAPTER *a;
12566         PLCI *notify_plci;
12567         dword plci_b_id;
12568         word i, j;
12569
12570         dbug(1, dprintf("[%06lx] %s,%d: mixer_remove",
12571                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
12572                         (char *)(FILE_), __LINE__));
12573
12574         a = plci->adapter;
12575         plci_b_id = (plci->Id << 8) | UnMapController(plci->adapter->Id);
12576         if (a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED)
12577         {
12578                 if ((plci->li_bchannel_id != 0)
12579                     && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
12580                 {
12581                         i = a->li_base + (plci->li_bchannel_id - 1);
12582                         if ((li_config_table[i].curchnl | li_config_table[i].channel) & LI_CHANNEL_INVOLVED)
12583                         {
12584                                 for (j = 0; j < li_total_channels; j++)
12585                                 {
12586                                         if ((li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
12587                                             || (li_config_table[j].flag_table[i] & LI_FLAG_INTERCONNECT))
12588                                         {
12589                                                 notify_plci = li_config_table[j].plci;
12590                                                 if ((notify_plci != NULL)
12591                                                     && (notify_plci != plci)
12592                                                     && (notify_plci->appl != NULL)
12593                                                     && !(notify_plci->appl->appl_flags & APPL_FLAG_OLD_LI_SPEC)
12594                                                     && (notify_plci->State)
12595                                                     && notify_plci->NL.Id && !notify_plci->nl_remove_id)
12596                                                 {
12597                                                         mixer_notify_source_removed(notify_plci, plci_b_id);
12598                                                 }
12599                                         }
12600                                 }
12601                                 mixer_clear_config(plci);
12602                                 mixer_calculate_coefs(a);
12603                                 mixer_notify_update(plci, true);
12604                         }
12605                         li_config_table[i].plci = NULL;
12606                         plci->li_bchannel_id = 0;
12607                 }
12608         }
12609 }
12610
12611
12612 /*------------------------------------------------------------------*/
12613 /* Echo canceller facilities                                        */
12614 /*------------------------------------------------------------------*/
12615
12616
12617 static void ec_write_parameters(PLCI *plci)
12618 {
12619         word w;
12620         byte parameter_buffer[6];
12621
12622         dbug(1, dprintf("[%06lx] %s,%d: ec_write_parameters",
12623                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
12624                         (char *)(FILE_), __LINE__));
12625
12626         parameter_buffer[0] = 5;
12627         parameter_buffer[1] = DSP_CTRL_SET_LEC_PARAMETERS;
12628         PUT_WORD(&parameter_buffer[2], plci->ec_idi_options);
12629         plci->ec_idi_options &= ~LEC_RESET_COEFFICIENTS;
12630         w = (plci->ec_tail_length == 0) ? 128 : plci->ec_tail_length;
12631         PUT_WORD(&parameter_buffer[4], w);
12632         add_p(plci, FTY, parameter_buffer);
12633         sig_req(plci, TEL_CTRL, 0);
12634         send_req(plci);
12635 }
12636
12637
12638 static void ec_clear_config(PLCI *plci)
12639 {
12640
12641         dbug(1, dprintf("[%06lx] %s,%d: ec_clear_config",
12642                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
12643                         (char *)(FILE_), __LINE__));
12644
12645         plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER |
12646                 LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING;
12647         plci->ec_tail_length = 0;
12648 }
12649
12650
12651 static void ec_prepare_switch(dword Id, PLCI *plci)
12652 {
12653
12654         dbug(1, dprintf("[%06lx] %s,%d: ec_prepare_switch",
12655                         UnMapId(Id), (char *)(FILE_), __LINE__));
12656
12657 }
12658
12659
12660 static word ec_save_config(dword Id, PLCI *plci, byte Rc)
12661 {
12662
12663         dbug(1, dprintf("[%06lx] %s,%d: ec_save_config %02x %d",
12664                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
12665
12666         return (GOOD);
12667 }
12668
12669
12670 static word ec_restore_config(dword Id, PLCI *plci, byte Rc)
12671 {
12672         word Info;
12673
12674         dbug(1, dprintf("[%06lx] %s,%d: ec_restore_config %02x %d",
12675                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
12676
12677         Info = GOOD;
12678         if (plci->B1_facilities & B1_FACILITY_EC)
12679         {
12680                 switch (plci->adjust_b_state)
12681                 {
12682                 case ADJUST_B_RESTORE_EC_1:
12683                         plci->internal_command = plci->adjust_b_command;
12684                         if (plci->sig_req)
12685                         {
12686                                 plci->adjust_b_state = ADJUST_B_RESTORE_EC_1;
12687                                 break;
12688                         }
12689                         ec_write_parameters(plci);
12690                         plci->adjust_b_state = ADJUST_B_RESTORE_EC_2;
12691                         break;
12692                 case ADJUST_B_RESTORE_EC_2:
12693                         if ((Rc != OK) && (Rc != OK_FC))
12694                         {
12695                                 dbug(1, dprintf("[%06lx] %s,%d: Restore EC failed %02x",
12696                                                 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
12697                                 Info = _WRONG_STATE;
12698                                 break;
12699                         }
12700                         break;
12701                 }
12702         }
12703         return (Info);
12704 }
12705
12706
12707 static void ec_command(dword Id, PLCI *plci, byte Rc)
12708 {
12709         word internal_command, Info;
12710         byte result[8];
12711
12712         dbug(1, dprintf("[%06lx] %s,%d: ec_command %02x %04x %04x %04x %d",
12713                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command,
12714                         plci->ec_cmd, plci->ec_idi_options, plci->ec_tail_length));
12715
12716         Info = GOOD;
12717         if (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC)
12718         {
12719                 result[0] = 2;
12720                 PUT_WORD(&result[1], EC_SUCCESS);
12721         }
12722         else
12723         {
12724                 result[0] = 5;
12725                 PUT_WORD(&result[1], plci->ec_cmd);
12726                 result[3] = 2;
12727                 PUT_WORD(&result[4], GOOD);
12728         }
12729         internal_command = plci->internal_command;
12730         plci->internal_command = 0;
12731         switch (plci->ec_cmd)
12732         {
12733         case EC_ENABLE_OPERATION:
12734         case EC_FREEZE_COEFFICIENTS:
12735         case EC_RESUME_COEFFICIENT_UPDATE:
12736         case EC_RESET_COEFFICIENTS:
12737                 switch (internal_command)
12738                 {
12739                 default:
12740                         adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities |
12741                                                                   B1_FACILITY_EC), EC_COMMAND_1);
12742                 case EC_COMMAND_1:
12743                         if (adjust_b_process(Id, plci, Rc) != GOOD)
12744                         {
12745                                 dbug(1, dprintf("[%06lx] %s,%d: Load EC failed",
12746                                                 UnMapId(Id), (char *)(FILE_), __LINE__));
12747                                 Info = _FACILITY_NOT_SUPPORTED;
12748                                 break;
12749                         }
12750                         if (plci->internal_command)
12751                                 return;
12752                 case EC_COMMAND_2:
12753                         if (plci->sig_req)
12754                         {
12755                                 plci->internal_command = EC_COMMAND_2;
12756                                 return;
12757                         }
12758                         plci->internal_command = EC_COMMAND_3;
12759                         ec_write_parameters(plci);
12760                         return;
12761                 case EC_COMMAND_3:
12762                         if ((Rc != OK) && (Rc != OK_FC))
12763                         {
12764                                 dbug(1, dprintf("[%06lx] %s,%d: Enable EC failed %02x",
12765                                                 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
12766                                 Info = _FACILITY_NOT_SUPPORTED;
12767                                 break;
12768                         }
12769                         break;
12770                 }
12771                 break;
12772
12773         case EC_DISABLE_OPERATION:
12774                 switch (internal_command)
12775                 {
12776                 default:
12777                 case EC_COMMAND_1:
12778                         if (plci->B1_facilities & B1_FACILITY_EC)
12779                         {
12780                                 if (plci->sig_req)
12781                                 {
12782                                         plci->internal_command = EC_COMMAND_1;
12783                                         return;
12784                                 }
12785                                 plci->internal_command = EC_COMMAND_2;
12786                                 ec_write_parameters(plci);
12787                                 return;
12788                         }
12789                         Rc = OK;
12790                 case EC_COMMAND_2:
12791                         if ((Rc != OK) && (Rc != OK_FC))
12792                         {
12793                                 dbug(1, dprintf("[%06lx] %s,%d: Disable EC failed %02x",
12794                                                 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
12795                                 Info = _FACILITY_NOT_SUPPORTED;
12796                                 break;
12797                         }
12798                         adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities &
12799                                                                   ~B1_FACILITY_EC), EC_COMMAND_3);
12800                 case EC_COMMAND_3:
12801                         if (adjust_b_process(Id, plci, Rc) != GOOD)
12802                         {
12803                                 dbug(1, dprintf("[%06lx] %s,%d: Unload EC failed",
12804                                                 UnMapId(Id), (char *)(FILE_), __LINE__));
12805                                 Info = _FACILITY_NOT_SUPPORTED;
12806                                 break;
12807                         }
12808                         if (plci->internal_command)
12809                                 return;
12810                         break;
12811                 }
12812                 break;
12813         }
12814         sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->number,
12815               "wws", Info, (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ?
12816               PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result);
12817 }
12818
12819
12820 static byte ec_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL   *appl, API_PARSE *msg)
12821 {
12822         word Info;
12823         word opt;
12824         API_PARSE ec_parms[3];
12825         byte result[16];
12826
12827         dbug(1, dprintf("[%06lx] %s,%d: ec_request",
12828                         UnMapId(Id), (char *)(FILE_), __LINE__));
12829
12830         Info = GOOD;
12831         result[0] = 0;
12832         if (!(a->man_profile.private_options & (1L << PRIVATE_ECHO_CANCELLER)))
12833         {
12834                 dbug(1, dprintf("[%06lx] %s,%d: Facility not supported",
12835                                 UnMapId(Id), (char *)(FILE_), __LINE__));
12836                 Info = _FACILITY_NOT_SUPPORTED;
12837         }
12838         else
12839         {
12840                 if (appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC)
12841                 {
12842                         if (api_parse(&msg[1].info[1], msg[1].length, "w", ec_parms))
12843                         {
12844                                 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12845                                                 UnMapId(Id), (char *)(FILE_), __LINE__));
12846                                 Info = _WRONG_MESSAGE_FORMAT;
12847                         }
12848                         else
12849                         {
12850                                 if (plci == NULL)
12851                                 {
12852                                         dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI",
12853                                                         UnMapId(Id), (char *)(FILE_), __LINE__));
12854                                         Info = _WRONG_IDENTIFIER;
12855                                 }
12856                                 else if (!plci->State || !plci->NL.Id || plci->nl_remove_id)
12857                                 {
12858                                         dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
12859                                                         UnMapId(Id), (char *)(FILE_), __LINE__));
12860                                         Info = _WRONG_STATE;
12861                                 }
12862                                 else
12863                                 {
12864                                         plci->command = 0;
12865                                         plci->ec_cmd = GET_WORD(ec_parms[0].info);
12866                                         plci->ec_idi_options &= ~(LEC_MANUAL_DISABLE | LEC_RESET_COEFFICIENTS);
12867                                         result[0] = 2;
12868                                         PUT_WORD(&result[1], EC_SUCCESS);
12869                                         if (msg[1].length >= 4)
12870                                         {
12871                                                 opt = GET_WORD(&ec_parms[0].info[2]);
12872                                                 plci->ec_idi_options &= ~(LEC_ENABLE_NONLINEAR_PROCESSING |
12873                                                                           LEC_ENABLE_2100HZ_DETECTOR | LEC_REQUIRE_2100HZ_REVERSALS);
12874                                                 if (!(opt & EC_DISABLE_NON_LINEAR_PROCESSING))
12875                                                         plci->ec_idi_options |= LEC_ENABLE_NONLINEAR_PROCESSING;
12876                                                 if (opt & EC_DETECT_DISABLE_TONE)
12877                                                         plci->ec_idi_options |= LEC_ENABLE_2100HZ_DETECTOR;
12878                                                 if (!(opt & EC_DO_NOT_REQUIRE_REVERSALS))
12879                                                         plci->ec_idi_options |= LEC_REQUIRE_2100HZ_REVERSALS;
12880                                                 if (msg[1].length >= 6)
12881                                                 {
12882                                                         plci->ec_tail_length = GET_WORD(&ec_parms[0].info[4]);
12883                                                 }
12884                                         }
12885                                         switch (plci->ec_cmd)
12886                                         {
12887                                         case EC_ENABLE_OPERATION:
12888                                                 plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS;
12889                                                 start_internal_command(Id, plci, ec_command);
12890                                                 return (false);
12891
12892                                         case EC_DISABLE_OPERATION:
12893                                                 plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER |
12894                                                         LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING |
12895                                                         LEC_RESET_COEFFICIENTS;
12896                                                 start_internal_command(Id, plci, ec_command);
12897                                                 return (false);
12898
12899                                         case EC_FREEZE_COEFFICIENTS:
12900                                                 plci->ec_idi_options |= LEC_FREEZE_COEFFICIENTS;
12901                                                 start_internal_command(Id, plci, ec_command);
12902                                                 return (false);
12903
12904                                         case EC_RESUME_COEFFICIENT_UPDATE:
12905                                                 plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS;
12906                                                 start_internal_command(Id, plci, ec_command);
12907                                                 return (false);
12908
12909                                         case EC_RESET_COEFFICIENTS:
12910                                                 plci->ec_idi_options |= LEC_RESET_COEFFICIENTS;
12911                                                 start_internal_command(Id, plci, ec_command);
12912                                                 return (false);
12913
12914                                         default:
12915                                                 dbug(1, dprintf("[%06lx] %s,%d: EC unknown request %04x",
12916                                                                 UnMapId(Id), (char *)(FILE_), __LINE__, plci->ec_cmd));
12917                                                 PUT_WORD(&result[1], EC_UNSUPPORTED_OPERATION);
12918                                         }
12919                                 }
12920                         }
12921                 }
12922                 else
12923                 {
12924                         if (api_parse(&msg[1].info[1], msg[1].length, "ws", ec_parms))
12925                         {
12926                                 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12927                                                 UnMapId(Id), (char *)(FILE_), __LINE__));
12928                                 Info = _WRONG_MESSAGE_FORMAT;
12929                         }
12930                         else
12931                         {
12932                                 if (GET_WORD(ec_parms[0].info) == EC_GET_SUPPORTED_SERVICES)
12933                                 {
12934                                         result[0] = 11;
12935                                         PUT_WORD(&result[1], EC_GET_SUPPORTED_SERVICES);
12936                                         result[3] = 8;
12937                                         PUT_WORD(&result[4], GOOD);
12938                                         PUT_WORD(&result[6], 0x0007);
12939                                         PUT_WORD(&result[8], LEC_MAX_SUPPORTED_TAIL_LENGTH);
12940                                         PUT_WORD(&result[10], 0);
12941                                 }
12942                                 else if (plci == NULL)
12943                                 {
12944                                         dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI",
12945                                                         UnMapId(Id), (char *)(FILE_), __LINE__));
12946                                         Info = _WRONG_IDENTIFIER;
12947                                 }
12948                                 else if (!plci->State || !plci->NL.Id || plci->nl_remove_id)
12949                                 {
12950                                         dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
12951                                                         UnMapId(Id), (char *)(FILE_), __LINE__));
12952                                         Info = _WRONG_STATE;
12953                                 }
12954                                 else
12955                                 {
12956                                         plci->command = 0;
12957                                         plci->ec_cmd = GET_WORD(ec_parms[0].info);
12958                                         plci->ec_idi_options &= ~(LEC_MANUAL_DISABLE | LEC_RESET_COEFFICIENTS);
12959                                         result[0] = 5;
12960                                         PUT_WORD(&result[1], plci->ec_cmd);
12961                                         result[3] = 2;
12962                                         PUT_WORD(&result[4], GOOD);
12963                                         plci->ec_idi_options &= ~(LEC_ENABLE_NONLINEAR_PROCESSING |
12964                                                                   LEC_ENABLE_2100HZ_DETECTOR | LEC_REQUIRE_2100HZ_REVERSALS);
12965                                         plci->ec_tail_length = 0;
12966                                         if (ec_parms[1].length >= 2)
12967                                         {
12968                                                 opt = GET_WORD(&ec_parms[1].info[1]);
12969                                                 if (opt & EC_ENABLE_NON_LINEAR_PROCESSING)
12970                                                         plci->ec_idi_options |= LEC_ENABLE_NONLINEAR_PROCESSING;
12971                                                 if (opt & EC_DETECT_DISABLE_TONE)
12972                                                         plci->ec_idi_options |= LEC_ENABLE_2100HZ_DETECTOR;
12973                                                 if (!(opt & EC_DO_NOT_REQUIRE_REVERSALS))
12974                                                         plci->ec_idi_options |= LEC_REQUIRE_2100HZ_REVERSALS;
12975                                                 if (ec_parms[1].length >= 4)
12976                                                 {
12977                                                         plci->ec_tail_length = GET_WORD(&ec_parms[1].info[3]);
12978                                                 }
12979                                         }
12980                                         switch (plci->ec_cmd)
12981                                         {
12982                                         case EC_ENABLE_OPERATION:
12983                                                 plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS;
12984                                                 start_internal_command(Id, plci, ec_command);
12985                                                 return (false);
12986
12987                                         case EC_DISABLE_OPERATION:
12988                                                 plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER |
12989                                                         LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING |
12990                                                         LEC_RESET_COEFFICIENTS;
12991                                                 start_internal_command(Id, plci, ec_command);
12992                                                 return (false);
12993
12994                                         default:
12995                                                 dbug(1, dprintf("[%06lx] %s,%d: EC unknown request %04x",
12996                                                                 UnMapId(Id), (char *)(FILE_), __LINE__, plci->ec_cmd));
12997                                                 PUT_WORD(&result[4], _FACILITY_SPECIFIC_FUNCTION_NOT_SUPP);
12998                                         }
12999                                 }
13000                         }
13001                 }
13002         }
13003         sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
13004               "wws", Info, (appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ?
13005               PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result);
13006         return (false);
13007 }
13008
13009
13010 static void ec_indication(dword Id, PLCI *plci, byte *msg, word length)
13011 {
13012         byte result[8];
13013
13014         dbug(1, dprintf("[%06lx] %s,%d: ec_indication",
13015                         UnMapId(Id), (char *)(FILE_), __LINE__));
13016
13017         if (!(plci->ec_idi_options & LEC_MANUAL_DISABLE))
13018         {
13019                 if (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC)
13020                 {
13021                         result[0] = 2;
13022                         PUT_WORD(&result[1], 0);
13023                         switch (msg[1])
13024                         {
13025                         case LEC_DISABLE_TYPE_CONTIGNUOUS_2100HZ:
13026                                 PUT_WORD(&result[1], EC_BYPASS_DUE_TO_CONTINUOUS_2100HZ);
13027                                 break;
13028                         case LEC_DISABLE_TYPE_REVERSED_2100HZ:
13029                                 PUT_WORD(&result[1], EC_BYPASS_DUE_TO_REVERSED_2100HZ);
13030                                 break;
13031                         case LEC_DISABLE_RELEASED:
13032                                 PUT_WORD(&result[1], EC_BYPASS_RELEASED);
13033                                 break;
13034                         }
13035                 }
13036                 else
13037                 {
13038                         result[0] = 5;
13039                         PUT_WORD(&result[1], EC_BYPASS_INDICATION);
13040                         result[3] = 2;
13041                         PUT_WORD(&result[4], 0);
13042                         switch (msg[1])
13043                         {
13044                         case LEC_DISABLE_TYPE_CONTIGNUOUS_2100HZ:
13045                                 PUT_WORD(&result[4], EC_BYPASS_DUE_TO_CONTINUOUS_2100HZ);
13046                                 break;
13047                         case LEC_DISABLE_TYPE_REVERSED_2100HZ:
13048                                 PUT_WORD(&result[4], EC_BYPASS_DUE_TO_REVERSED_2100HZ);
13049                                 break;
13050                         case LEC_DISABLE_RELEASED:
13051                                 PUT_WORD(&result[4], EC_BYPASS_RELEASED);
13052                                 break;
13053                         }
13054                 }
13055                 sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ?
13056                       PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result);
13057         }
13058 }
13059
13060
13061
13062 /*------------------------------------------------------------------*/
13063 /* Advanced voice                                                   */
13064 /*------------------------------------------------------------------*/
13065
13066 static void adv_voice_write_coefs(PLCI *plci, word write_command)
13067 {
13068         DIVA_CAPI_ADAPTER *a;
13069         word i;
13070         byte *p;
13071
13072         word w, n, j, k;
13073         byte ch_map[MIXER_CHANNELS_BRI];
13074
13075         byte coef_buffer[ADV_VOICE_COEF_BUFFER_SIZE + 2];
13076
13077         dbug(1, dprintf("[%06lx] %s,%d: adv_voice_write_coefs %d",
13078                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13079                         (char *)(FILE_), __LINE__, write_command));
13080
13081         a = plci->adapter;
13082         p = coef_buffer + 1;
13083         *(p++) = DSP_CTRL_OLD_SET_MIXER_COEFFICIENTS;
13084         i = 0;
13085         while (i + sizeof(word) <= a->adv_voice_coef_length)
13086         {
13087                 PUT_WORD(p, GET_WORD(a->adv_voice_coef_buffer + i));
13088                 p += 2;
13089                 i += 2;
13090         }
13091         while (i < ADV_VOICE_OLD_COEF_COUNT * sizeof(word))
13092         {
13093                 PUT_WORD(p, 0x8000);
13094                 p += 2;
13095                 i += 2;
13096         }
13097
13098         if (!a->li_pri && (plci->li_bchannel_id == 0))
13099         {
13100                 if ((li_config_table[a->li_base].plci == NULL) && (li_config_table[a->li_base + 1].plci != NULL))
13101                 {
13102                         plci->li_bchannel_id = 1;
13103                         li_config_table[a->li_base].plci = plci;
13104                         dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id %d",
13105                                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13106                                         (char *)(FILE_), __LINE__, plci->li_bchannel_id));
13107                 }
13108                 else if ((li_config_table[a->li_base].plci != NULL) && (li_config_table[a->li_base + 1].plci == NULL))
13109                 {
13110                         plci->li_bchannel_id = 2;
13111                         li_config_table[a->li_base + 1].plci = plci;
13112                         dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id %d",
13113                                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13114                                         (char *)(FILE_), __LINE__, plci->li_bchannel_id));
13115                 }
13116         }
13117         if (!a->li_pri && (plci->li_bchannel_id != 0)
13118             && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
13119         {
13120                 i = a->li_base + (plci->li_bchannel_id - 1);
13121                 switch (write_command)
13122                 {
13123                 case ADV_VOICE_WRITE_ACTIVATION:
13124                         j = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
13125                         k = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
13126                         if (!(plci->B1_facilities & B1_FACILITY_MIXER))
13127                         {
13128                                 li_config_table[j].flag_table[i] |= LI_FLAG_CONFERENCE | LI_FLAG_MIX;
13129                                 li_config_table[i].flag_table[j] |= LI_FLAG_CONFERENCE | LI_FLAG_MONITOR;
13130                         }
13131                         if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13132                         {
13133                                 li_config_table[k].flag_table[i] |= LI_FLAG_CONFERENCE | LI_FLAG_MIX;
13134                                 li_config_table[i].flag_table[k] |= LI_FLAG_CONFERENCE | LI_FLAG_MONITOR;
13135                                 li_config_table[k].flag_table[j] |= LI_FLAG_CONFERENCE;
13136                                 li_config_table[j].flag_table[k] |= LI_FLAG_CONFERENCE;
13137                         }
13138                         mixer_calculate_coefs(a);
13139                         li_config_table[i].curchnl = li_config_table[i].channel;
13140                         li_config_table[j].curchnl = li_config_table[j].channel;
13141                         if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13142                                 li_config_table[k].curchnl = li_config_table[k].channel;
13143                         break;
13144
13145                 case ADV_VOICE_WRITE_DEACTIVATION:
13146                         for (j = 0; j < li_total_channels; j++)
13147                         {
13148                                 li_config_table[i].flag_table[j] = 0;
13149                                 li_config_table[j].flag_table[i] = 0;
13150                         }
13151                         k = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
13152                         for (j = 0; j < li_total_channels; j++)
13153                         {
13154                                 li_config_table[k].flag_table[j] = 0;
13155                                 li_config_table[j].flag_table[k] = 0;
13156                         }
13157                         if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13158                         {
13159                                 k = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
13160                                 for (j = 0; j < li_total_channels; j++)
13161                                 {
13162                                         li_config_table[k].flag_table[j] = 0;
13163                                         li_config_table[j].flag_table[k] = 0;
13164                                 }
13165                         }
13166                         mixer_calculate_coefs(a);
13167                         break;
13168                 }
13169                 if (plci->B1_facilities & B1_FACILITY_MIXER)
13170                 {
13171                         w = 0;
13172                         if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length)
13173                                 w = GET_WORD(a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE);
13174                         if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
13175                                 w |= MIXER_FEATURE_ENABLE_TX_DATA;
13176                         if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
13177                                 w |= MIXER_FEATURE_ENABLE_RX_DATA;
13178                         *(p++) = (byte) w;
13179                         *(p++) = (byte)(w >> 8);
13180                         for (j = 0; j < sizeof(ch_map); j += 2)
13181                         {
13182                                 ch_map[j] = (byte)(j + (plci->li_bchannel_id - 1));
13183                                 ch_map[j + 1] = (byte)(j + (2 - plci->li_bchannel_id));
13184                         }
13185                         for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++)
13186                         {
13187                                 i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch];
13188                                 j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch];
13189                                 if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED)
13190                                 {
13191                                         *(p++) = ((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01);
13192                                         w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
13193                                         li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4;
13194                                 }
13195                                 else
13196                                 {
13197                                         *(p++) = (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + n < a->adv_voice_coef_length) ?
13198                                                 a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + n] : 0x00;
13199                                 }
13200                         }
13201                 }
13202                 else
13203                 {
13204                         for (i = ADV_VOICE_NEW_COEF_BASE; i < a->adv_voice_coef_length; i++)
13205                                 *(p++) = a->adv_voice_coef_buffer[i];
13206                 }
13207         }
13208         else
13209
13210         {
13211                 for (i = ADV_VOICE_NEW_COEF_BASE; i < a->adv_voice_coef_length; i++)
13212                         *(p++) = a->adv_voice_coef_buffer[i];
13213         }
13214         coef_buffer[0] = (p - coef_buffer) - 1;
13215         add_p(plci, FTY, coef_buffer);
13216         sig_req(plci, TEL_CTRL, 0);
13217         send_req(plci);
13218 }
13219
13220
13221 static void adv_voice_clear_config(PLCI *plci)
13222 {
13223         DIVA_CAPI_ADAPTER *a;
13224
13225         word i, j;
13226
13227
13228         dbug(1, dprintf("[%06lx] %s,%d: adv_voice_clear_config",
13229                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13230                         (char *)(FILE_), __LINE__));
13231
13232         a = plci->adapter;
13233         if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
13234         {
13235                 a->adv_voice_coef_length = 0;
13236
13237                 if (!a->li_pri && (plci->li_bchannel_id != 0)
13238                     && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
13239                 {
13240                         i = a->li_base + (plci->li_bchannel_id - 1);
13241                         li_config_table[i].curchnl = 0;
13242                         li_config_table[i].channel = 0;
13243                         li_config_table[i].chflags = 0;
13244                         for (j = 0; j < li_total_channels; j++)
13245                         {
13246                                 li_config_table[i].flag_table[j] = 0;
13247                                 li_config_table[j].flag_table[i] = 0;
13248                                 li_config_table[i].coef_table[j] = 0;
13249                                 li_config_table[j].coef_table[i] = 0;
13250                         }
13251                         li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET;
13252                         i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
13253                         li_config_table[i].curchnl = 0;
13254                         li_config_table[i].channel = 0;
13255                         li_config_table[i].chflags = 0;
13256                         for (j = 0; j < li_total_channels; j++)
13257                         {
13258                                 li_config_table[i].flag_table[j] = 0;
13259                                 li_config_table[j].flag_table[i] = 0;
13260                                 li_config_table[i].coef_table[j] = 0;
13261                                 li_config_table[j].coef_table[i] = 0;
13262                         }
13263                         if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13264                         {
13265                                 i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
13266                                 li_config_table[i].curchnl = 0;
13267                                 li_config_table[i].channel = 0;
13268                                 li_config_table[i].chflags = 0;
13269                                 for (j = 0; j < li_total_channels; j++)
13270                                 {
13271                                         li_config_table[i].flag_table[j] = 0;
13272                                         li_config_table[j].flag_table[i] = 0;
13273                                         li_config_table[i].coef_table[j] = 0;
13274                                         li_config_table[j].coef_table[i] = 0;
13275                                 }
13276                         }
13277                 }
13278
13279         }
13280 }
13281
13282
13283 static void adv_voice_prepare_switch(dword Id, PLCI *plci)
13284 {
13285
13286         dbug(1, dprintf("[%06lx] %s,%d: adv_voice_prepare_switch",
13287                         UnMapId(Id), (char *)(FILE_), __LINE__));
13288
13289 }
13290
13291
13292 static word adv_voice_save_config(dword Id, PLCI *plci, byte Rc)
13293 {
13294
13295         dbug(1, dprintf("[%06lx] %s,%d: adv_voice_save_config %02x %d",
13296                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
13297
13298         return (GOOD);
13299 }
13300
13301
13302 static word adv_voice_restore_config(dword Id, PLCI *plci, byte Rc)
13303 {
13304         DIVA_CAPI_ADAPTER *a;
13305         word Info;
13306
13307         dbug(1, dprintf("[%06lx] %s,%d: adv_voice_restore_config %02x %d",
13308                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
13309
13310         Info = GOOD;
13311         a = plci->adapter;
13312         if ((plci->B1_facilities & B1_FACILITY_VOICE)
13313             && (plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
13314         {
13315                 switch (plci->adjust_b_state)
13316                 {
13317                 case ADJUST_B_RESTORE_VOICE_1:
13318                         plci->internal_command = plci->adjust_b_command;
13319                         if (plci->sig_req)
13320                         {
13321                                 plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_1;
13322                                 break;
13323                         }
13324                         adv_voice_write_coefs(plci, ADV_VOICE_WRITE_UPDATE);
13325                         plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_2;
13326                         break;
13327                 case ADJUST_B_RESTORE_VOICE_2:
13328                         if ((Rc != OK) && (Rc != OK_FC))
13329                         {
13330                                 dbug(1, dprintf("[%06lx] %s,%d: Restore voice config failed %02x",
13331                                                 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
13332                                 Info = _WRONG_STATE;
13333                                 break;
13334                         }
13335                         break;
13336                 }
13337         }
13338         return (Info);
13339 }
13340
13341
13342
13343
13344 /*------------------------------------------------------------------*/
13345 /* B1 resource switching                                            */
13346 /*------------------------------------------------------------------*/
13347
13348 static byte b1_facilities_table[] =
13349 {
13350         0x00,  /* 0  No bchannel resources      */
13351         0x00,  /* 1  Codec (automatic law)      */
13352         0x00,  /* 2  Codec (A-law)              */
13353         0x00,  /* 3  Codec (y-law)              */
13354         0x00,  /* 4  HDLC for X.21              */
13355         0x00,  /* 5  HDLC                       */
13356         0x00,  /* 6  External Device 0          */
13357         0x00,  /* 7  External Device 1          */
13358         0x00,  /* 8  HDLC 56k                   */
13359         0x00,  /* 9  Transparent                */
13360         0x00,  /* 10 Loopback to network        */
13361         0x00,  /* 11 Test pattern to net        */
13362         0x00,  /* 12 Rate adaptation sync       */
13363         0x00,  /* 13 Rate adaptation async      */
13364         0x00,  /* 14 R-Interface                */
13365         0x00,  /* 15 HDLC 128k leased line      */
13366         0x00,  /* 16 FAX                        */
13367         0x00,  /* 17 Modem async                */
13368         0x00,  /* 18 Modem sync HDLC            */
13369         0x00,  /* 19 V.110 async HDLC           */
13370         0x12,  /* 20 Adv voice (Trans,mixer)    */
13371         0x00,  /* 21 Codec connected to IC      */
13372         0x0c,  /* 22 Trans,DTMF                 */
13373         0x1e,  /* 23 Trans,DTMF+mixer           */
13374         0x1f,  /* 24 Trans,DTMF+mixer+local     */
13375         0x13,  /* 25 Trans,mixer+local          */
13376         0x12,  /* 26 HDLC,mixer                 */
13377         0x12,  /* 27 HDLC 56k,mixer             */
13378         0x2c,  /* 28 Trans,LEC+DTMF             */
13379         0x3e,  /* 29 Trans,LEC+DTMF+mixer       */
13380         0x3f,  /* 30 Trans,LEC+DTMF+mixer+local */
13381         0x2c,  /* 31 RTP,LEC+DTMF               */
13382         0x3e,  /* 32 RTP,LEC+DTMF+mixer         */
13383         0x3f,  /* 33 RTP,LEC+DTMF+mixer+local   */
13384         0x00,  /* 34 Signaling task             */
13385         0x00,  /* 35 PIAFS                      */
13386         0x0c,  /* 36 Trans,DTMF+TONE            */
13387         0x1e,  /* 37 Trans,DTMF+TONE+mixer      */
13388         0x1f   /* 38 Trans,DTMF+TONE+mixer+local*/
13389 };
13390
13391
13392 static word get_b1_facilities(PLCI *plci, byte b1_resource)
13393 {
13394         word b1_facilities;
13395
13396         b1_facilities = b1_facilities_table[b1_resource];
13397         if ((b1_resource == 9) || (b1_resource == 20) || (b1_resource == 25))
13398         {
13399
13400                 if (!(((plci->requested_options_conn | plci->requested_options) & (1L << PRIVATE_DTMF_TONE))
13401                       || (plci->appl && (plci->adapter->requested_options_table[plci->appl->Id - 1] & (1L << PRIVATE_DTMF_TONE)))))
13402
13403                 {
13404                         if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_SEND)
13405                                 b1_facilities |= B1_FACILITY_DTMFX;
13406                         if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE)
13407                                 b1_facilities |= B1_FACILITY_DTMFR;
13408                 }
13409         }
13410         if ((b1_resource == 17) || (b1_resource == 18))
13411         {
13412                 if (plci->adapter->manufacturer_features & (MANUFACTURER_FEATURE_V18 | MANUFACTURER_FEATURE_VOWN))
13413                         b1_facilities |= B1_FACILITY_DTMFX | B1_FACILITY_DTMFR;
13414         }
13415 /*
13416   dbug (1, dprintf("[%06lx] %s,%d: get_b1_facilities %d %04x",
13417   (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13418   (char far *)(FILE_), __LINE__, b1_resource, b1_facilites));
13419 */
13420         return (b1_facilities);
13421 }
13422
13423
13424 static byte add_b1_facilities(PLCI *plci, byte b1_resource, word b1_facilities)
13425 {
13426         byte b;
13427
13428         switch (b1_resource)
13429         {
13430         case 5:
13431         case 26:
13432                 if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13433                         b = 26;
13434                 else
13435                         b = 5;
13436                 break;
13437
13438         case 8:
13439         case 27:
13440                 if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13441                         b = 27;
13442                 else
13443                         b = 8;
13444                 break;
13445
13446         case 9:
13447         case 20:
13448         case 22:
13449         case 23:
13450         case 24:
13451         case 25:
13452         case 28:
13453         case 29:
13454         case 30:
13455         case 36:
13456         case 37:
13457         case 38:
13458                 if (b1_facilities & B1_FACILITY_EC)
13459                 {
13460                         if (b1_facilities & B1_FACILITY_LOCAL)
13461                                 b = 30;
13462                         else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13463                                 b = 29;
13464                         else
13465                                 b = 28;
13466                 }
13467
13468                 else if ((b1_facilities & (B1_FACILITY_DTMFX | B1_FACILITY_DTMFR | B1_FACILITY_MIXER))
13469                          && (((plci->requested_options_conn | plci->requested_options) & (1L << PRIVATE_DTMF_TONE))
13470                              || (plci->appl && (plci->adapter->requested_options_table[plci->appl->Id - 1] & (1L << PRIVATE_DTMF_TONE)))))
13471                 {
13472                         if (b1_facilities & B1_FACILITY_LOCAL)
13473                                 b = 38;
13474                         else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13475                                 b = 37;
13476                         else
13477                                 b = 36;
13478                 }
13479
13480                 else if (((plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_HARDDTMF)
13481                           && !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE))
13482                          || ((b1_facilities & B1_FACILITY_DTMFR)
13483                              && ((b1_facilities & B1_FACILITY_MIXER)
13484                                  || !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE)))
13485                          || ((b1_facilities & B1_FACILITY_DTMFX)
13486                              && ((b1_facilities & B1_FACILITY_MIXER)
13487                                  || !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_SEND))))
13488                 {
13489                         if (b1_facilities & B1_FACILITY_LOCAL)
13490                                 b = 24;
13491                         else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13492                                 b = 23;
13493                         else
13494                                 b = 22;
13495                 }
13496                 else
13497                 {
13498                         if (b1_facilities & B1_FACILITY_LOCAL)
13499                                 b = 25;
13500                         else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13501                                 b = 20;
13502                         else
13503                                 b = 9;
13504                 }
13505                 break;
13506
13507         case 31:
13508         case 32:
13509         case 33:
13510                 if (b1_facilities & B1_FACILITY_LOCAL)
13511                         b = 33;
13512                 else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13513                         b = 32;
13514                 else
13515                         b = 31;
13516                 break;
13517
13518         default:
13519                 b = b1_resource;
13520         }
13521         dbug(1, dprintf("[%06lx] %s,%d: add_b1_facilities %d %04x %d %04x",
13522                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13523                         (char *)(FILE_), __LINE__,
13524                         b1_resource, b1_facilities, b, get_b1_facilities(plci, b)));
13525         return (b);
13526 }
13527
13528
13529 static void adjust_b1_facilities(PLCI *plci, byte new_b1_resource, word new_b1_facilities)
13530 {
13531         word removed_facilities;
13532
13533         dbug(1, dprintf("[%06lx] %s,%d: adjust_b1_facilities %d %04x %04x",
13534                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13535                         (char *)(FILE_), __LINE__, new_b1_resource, new_b1_facilities,
13536                         new_b1_facilities & get_b1_facilities(plci, new_b1_resource)));
13537
13538         new_b1_facilities &= get_b1_facilities(plci, new_b1_resource);
13539         removed_facilities = plci->B1_facilities & ~new_b1_facilities;
13540
13541         if (removed_facilities & B1_FACILITY_EC)
13542                 ec_clear_config(plci);
13543
13544
13545         if (removed_facilities & B1_FACILITY_DTMFR)
13546         {
13547                 dtmf_rec_clear_config(plci);
13548                 dtmf_parameter_clear_config(plci);
13549         }
13550         if (removed_facilities & B1_FACILITY_DTMFX)
13551                 dtmf_send_clear_config(plci);
13552
13553
13554         if (removed_facilities & B1_FACILITY_MIXER)
13555                 mixer_clear_config(plci);
13556
13557         if (removed_facilities & B1_FACILITY_VOICE)
13558                 adv_voice_clear_config(plci);
13559         plci->B1_facilities = new_b1_facilities;
13560 }
13561
13562
13563 static void adjust_b_clear(PLCI *plci)
13564 {
13565
13566         dbug(1, dprintf("[%06lx] %s,%d: adjust_b_clear",
13567                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13568                         (char *)(FILE_), __LINE__));
13569
13570         plci->adjust_b_restore = false;
13571 }
13572
13573
13574 static word adjust_b_process(dword Id, PLCI *plci, byte Rc)
13575 {
13576         word Info;
13577         byte b1_resource;
13578         NCCI *ncci_ptr;
13579         API_PARSE bp[2];
13580
13581         dbug(1, dprintf("[%06lx] %s,%d: adjust_b_process %02x %d",
13582                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
13583
13584         Info = GOOD;
13585         switch (plci->adjust_b_state)
13586         {
13587         case ADJUST_B_START:
13588                 if ((plci->adjust_b_parms_msg == NULL)
13589                     && (plci->adjust_b_mode & ADJUST_B_MODE_SWITCH_L1)
13590                     && ((plci->adjust_b_mode & ~(ADJUST_B_MODE_SAVE | ADJUST_B_MODE_SWITCH_L1 |
13591                                                  ADJUST_B_MODE_NO_RESOURCE | ADJUST_B_MODE_RESTORE)) == 0))
13592                 {
13593                         b1_resource = (plci->adjust_b_mode == ADJUST_B_MODE_NO_RESOURCE) ?
13594                                 0 : add_b1_facilities(plci, plci->B1_resource, plci->adjust_b_facilities);
13595                         if (b1_resource == plci->B1_resource)
13596                         {
13597                                 adjust_b1_facilities(plci, b1_resource, plci->adjust_b_facilities);
13598                                 break;
13599                         }
13600                         if (plci->adjust_b_facilities & ~get_b1_facilities(plci, b1_resource))
13601                         {
13602                                 dbug(1, dprintf("[%06lx] %s,%d: Adjust B nonsupported facilities %d %d %04x",
13603                                                 UnMapId(Id), (char *)(FILE_), __LINE__,
13604                                                 plci->B1_resource, b1_resource, plci->adjust_b_facilities));
13605                                 Info = _WRONG_STATE;
13606                                 break;
13607                         }
13608                 }
13609                 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13610                 {
13611
13612                         mixer_prepare_switch(Id, plci);
13613
13614
13615                         dtmf_prepare_switch(Id, plci);
13616                         dtmf_parameter_prepare_switch(Id, plci);
13617
13618
13619                         ec_prepare_switch(Id, plci);
13620
13621                         adv_voice_prepare_switch(Id, plci);
13622                 }
13623                 plci->adjust_b_state = ADJUST_B_SAVE_MIXER_1;
13624                 Rc = OK;
13625         case ADJUST_B_SAVE_MIXER_1:
13626                 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13627                 {
13628
13629                         Info = mixer_save_config(Id, plci, Rc);
13630                         if ((Info != GOOD) || plci->internal_command)
13631                                 break;
13632
13633                 }
13634                 plci->adjust_b_state = ADJUST_B_SAVE_DTMF_1;
13635                 Rc = OK;
13636         case ADJUST_B_SAVE_DTMF_1:
13637                 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13638                 {
13639
13640                         Info = dtmf_save_config(Id, plci, Rc);
13641                         if ((Info != GOOD) || plci->internal_command)
13642                                 break;
13643
13644                 }
13645                 plci->adjust_b_state = ADJUST_B_REMOVE_L23_1;
13646         case ADJUST_B_REMOVE_L23_1:
13647                 if ((plci->adjust_b_mode & ADJUST_B_MODE_REMOVE_L23)
13648                     && plci->NL.Id && !plci->nl_remove_id)
13649                 {
13650                         plci->internal_command = plci->adjust_b_command;
13651                         if (plci->adjust_b_ncci != 0)
13652                         {
13653                                 ncci_ptr = &(plci->adapter->ncci[plci->adjust_b_ncci]);
13654                                 while (ncci_ptr->data_pending)
13655                                 {
13656                                         plci->data_sent_ptr = ncci_ptr->DBuffer[ncci_ptr->data_out].P;
13657                                         data_rc(plci, plci->adapter->ncci_ch[plci->adjust_b_ncci]);
13658                                 }
13659                                 while (ncci_ptr->data_ack_pending)
13660                                         data_ack(plci, plci->adapter->ncci_ch[plci->adjust_b_ncci]);
13661                         }
13662                         nl_req_ncci(plci, REMOVE,
13663                                     (byte)((plci->adjust_b_mode & ADJUST_B_MODE_CONNECT) ? plci->adjust_b_ncci : 0));
13664                         send_req(plci);
13665                         plci->adjust_b_state = ADJUST_B_REMOVE_L23_2;
13666                         break;
13667                 }
13668                 plci->adjust_b_state = ADJUST_B_REMOVE_L23_2;
13669                 Rc = OK;
13670         case ADJUST_B_REMOVE_L23_2:
13671                 if ((Rc != OK) && (Rc != OK_FC))
13672                 {
13673                         dbug(1, dprintf("[%06lx] %s,%d: Adjust B remove failed %02x",
13674                                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
13675                         Info = _WRONG_STATE;
13676                         break;
13677                 }
13678                 if (plci->adjust_b_mode & ADJUST_B_MODE_REMOVE_L23)
13679                 {
13680                         if (plci_nl_busy(plci))
13681                         {
13682                                 plci->internal_command = plci->adjust_b_command;
13683                                 break;
13684                         }
13685                 }
13686                 plci->adjust_b_state = ADJUST_B_SAVE_EC_1;
13687                 Rc = OK;
13688         case ADJUST_B_SAVE_EC_1:
13689                 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13690                 {
13691
13692                         Info = ec_save_config(Id, plci, Rc);
13693                         if ((Info != GOOD) || plci->internal_command)
13694                                 break;
13695
13696                 }
13697                 plci->adjust_b_state = ADJUST_B_SAVE_DTMF_PARAMETER_1;
13698                 Rc = OK;
13699         case ADJUST_B_SAVE_DTMF_PARAMETER_1:
13700                 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13701                 {
13702
13703                         Info = dtmf_parameter_save_config(Id, plci, Rc);
13704                         if ((Info != GOOD) || plci->internal_command)
13705                                 break;
13706
13707                 }
13708                 plci->adjust_b_state = ADJUST_B_SAVE_VOICE_1;
13709                 Rc = OK;
13710         case ADJUST_B_SAVE_VOICE_1:
13711                 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13712                 {
13713                         Info = adv_voice_save_config(Id, plci, Rc);
13714                         if ((Info != GOOD) || plci->internal_command)
13715                                 break;
13716                 }
13717                 plci->adjust_b_state = ADJUST_B_SWITCH_L1_1;
13718         case ADJUST_B_SWITCH_L1_1:
13719                 if (plci->adjust_b_mode & ADJUST_B_MODE_SWITCH_L1)
13720                 {
13721                         if (plci->sig_req)
13722                         {
13723                                 plci->internal_command = plci->adjust_b_command;
13724                                 break;
13725                         }
13726                         if (plci->adjust_b_parms_msg != NULL)
13727                                 api_load_msg(plci->adjust_b_parms_msg, bp);
13728                         else
13729                                 api_load_msg(&plci->B_protocol, bp);
13730                         Info = add_b1(plci, bp,
13731                                       (word)((plci->adjust_b_mode & ADJUST_B_MODE_NO_RESOURCE) ? 2 : 0),
13732                                       plci->adjust_b_facilities);
13733                         if (Info != GOOD)
13734                         {
13735                                 dbug(1, dprintf("[%06lx] %s,%d: Adjust B invalid L1 parameters %d %04x",
13736                                                 UnMapId(Id), (char *)(FILE_), __LINE__,
13737                                                 plci->B1_resource, plci->adjust_b_facilities));
13738                                 break;
13739                         }
13740                         plci->internal_command = plci->adjust_b_command;
13741                         sig_req(plci, RESOURCES, 0);
13742                         send_req(plci);
13743                         plci->adjust_b_state = ADJUST_B_SWITCH_L1_2;
13744                         break;
13745                 }
13746                 plci->adjust_b_state = ADJUST_B_SWITCH_L1_2;
13747                 Rc = OK;
13748         case ADJUST_B_SWITCH_L1_2:
13749                 if ((Rc != OK) && (Rc != OK_FC))
13750                 {
13751                         dbug(1, dprintf("[%06lx] %s,%d: Adjust B switch failed %02x %d %04x",
13752                                         UnMapId(Id), (char *)(FILE_), __LINE__,
13753                                         Rc, plci->B1_resource, plci->adjust_b_facilities));
13754                         Info = _WRONG_STATE;
13755                         break;
13756                 }
13757                 plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_1;
13758                 Rc = OK;
13759         case ADJUST_B_RESTORE_VOICE_1:
13760         case ADJUST_B_RESTORE_VOICE_2:
13761                 if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13762                 {
13763                         Info = adv_voice_restore_config(Id, plci, Rc);
13764                         if ((Info != GOOD) || plci->internal_command)
13765                                 break;
13766                 }
13767                 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_1;
13768                 Rc = OK;
13769         case ADJUST_B_RESTORE_DTMF_PARAMETER_1:
13770         case ADJUST_B_RESTORE_DTMF_PARAMETER_2:
13771                 if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13772                 {
13773
13774                         Info = dtmf_parameter_restore_config(Id, plci, Rc);
13775                         if ((Info != GOOD) || plci->internal_command)
13776                                 break;
13777
13778                 }
13779                 plci->adjust_b_state = ADJUST_B_RESTORE_EC_1;
13780                 Rc = OK;
13781         case ADJUST_B_RESTORE_EC_1:
13782         case ADJUST_B_RESTORE_EC_2:
13783                 if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13784                 {
13785
13786                         Info = ec_restore_config(Id, plci, Rc);
13787                         if ((Info != GOOD) || plci->internal_command)
13788                                 break;
13789
13790                 }
13791                 plci->adjust_b_state = ADJUST_B_ASSIGN_L23_1;
13792         case ADJUST_B_ASSIGN_L23_1:
13793                 if (plci->adjust_b_mode & ADJUST_B_MODE_ASSIGN_L23)
13794                 {
13795                         if (plci_nl_busy(plci))
13796                         {
13797                                 plci->internal_command = plci->adjust_b_command;
13798                                 break;
13799                         }
13800                         if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT)
13801                                 plci->call_dir |= CALL_DIR_FORCE_OUTG_NL;
13802                         if (plci->adjust_b_parms_msg != NULL)
13803                                 api_load_msg(plci->adjust_b_parms_msg, bp);
13804                         else
13805                                 api_load_msg(&plci->B_protocol, bp);
13806                         Info = add_b23(plci, bp);
13807                         if (Info != GOOD)
13808                         {
13809                                 dbug(1, dprintf("[%06lx] %s,%d: Adjust B invalid L23 parameters %04x",
13810                                                 UnMapId(Id), (char *)(FILE_), __LINE__, Info));
13811                                 break;
13812                         }
13813                         plci->internal_command = plci->adjust_b_command;
13814                         nl_req_ncci(plci, ASSIGN, 0);
13815                         send_req(plci);
13816                         plci->adjust_b_state = ADJUST_B_ASSIGN_L23_2;
13817                         break;
13818                 }
13819                 plci->adjust_b_state = ADJUST_B_ASSIGN_L23_2;
13820                 Rc = ASSIGN_OK;
13821         case ADJUST_B_ASSIGN_L23_2:
13822                 if ((Rc != OK) && (Rc != OK_FC) && (Rc != ASSIGN_OK))
13823                 {
13824                         dbug(1, dprintf("[%06lx] %s,%d: Adjust B assign failed %02x",
13825                                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
13826                         Info = _WRONG_STATE;
13827                         break;
13828                 }
13829                 if (plci->adjust_b_mode & ADJUST_B_MODE_ASSIGN_L23)
13830                 {
13831                         if (Rc != ASSIGN_OK)
13832                         {
13833                                 plci->internal_command = plci->adjust_b_command;
13834                                 break;
13835                         }
13836                 }
13837                 if (plci->adjust_b_mode & ADJUST_B_MODE_USER_CONNECT)
13838                 {
13839                         plci->adjust_b_restore = true;
13840                         break;
13841                 }
13842                 plci->adjust_b_state = ADJUST_B_CONNECT_1;
13843         case ADJUST_B_CONNECT_1:
13844                 if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT)
13845                 {
13846                         plci->internal_command = plci->adjust_b_command;
13847                         if (plci_nl_busy(plci))
13848                                 break;
13849                         nl_req_ncci(plci, N_CONNECT, 0);
13850                         send_req(plci);
13851                         plci->adjust_b_state = ADJUST_B_CONNECT_2;
13852                         break;
13853                 }
13854                 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
13855                 Rc = OK;
13856         case ADJUST_B_CONNECT_2:
13857         case ADJUST_B_CONNECT_3:
13858         case ADJUST_B_CONNECT_4:
13859                 if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0))
13860                 {
13861                         dbug(1, dprintf("[%06lx] %s,%d: Adjust B connect failed %02x",
13862                                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
13863                         Info = _WRONG_STATE;
13864                         break;
13865                 }
13866                 if (Rc == OK)
13867                 {
13868                         if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT)
13869                         {
13870                                 get_ncci(plci, (byte)(Id >> 16), plci->adjust_b_ncci);
13871                                 Id = (Id & 0xffff) | (((dword)(plci->adjust_b_ncci)) << 16);
13872                         }
13873                         if (plci->adjust_b_state == ADJUST_B_CONNECT_2)
13874                                 plci->adjust_b_state = ADJUST_B_CONNECT_3;
13875                         else if (plci->adjust_b_state == ADJUST_B_CONNECT_4)
13876                                 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
13877                 }
13878                 else if (Rc == 0)
13879                 {
13880                         if (plci->adjust_b_state == ADJUST_B_CONNECT_2)
13881                                 plci->adjust_b_state = ADJUST_B_CONNECT_4;
13882                         else if (plci->adjust_b_state == ADJUST_B_CONNECT_3)
13883                                 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
13884                 }
13885                 if (plci->adjust_b_state != ADJUST_B_RESTORE_DTMF_1)
13886                 {
13887                         plci->internal_command = plci->adjust_b_command;
13888                         break;
13889                 }
13890                 Rc = OK;
13891         case ADJUST_B_RESTORE_DTMF_1:
13892         case ADJUST_B_RESTORE_DTMF_2:
13893                 if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13894                 {
13895
13896                         Info = dtmf_restore_config(Id, plci, Rc);
13897                         if ((Info != GOOD) || plci->internal_command)
13898                                 break;
13899
13900                 }
13901                 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_1;
13902                 Rc = OK;
13903         case ADJUST_B_RESTORE_MIXER_1:
13904         case ADJUST_B_RESTORE_MIXER_2:
13905         case ADJUST_B_RESTORE_MIXER_3:
13906         case ADJUST_B_RESTORE_MIXER_4:
13907         case ADJUST_B_RESTORE_MIXER_5:
13908         case ADJUST_B_RESTORE_MIXER_6:
13909         case ADJUST_B_RESTORE_MIXER_7:
13910                 if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13911                 {
13912
13913                         Info = mixer_restore_config(Id, plci, Rc);
13914                         if ((Info != GOOD) || plci->internal_command)
13915                                 break;
13916
13917                 }
13918                 plci->adjust_b_state = ADJUST_B_END;
13919         case ADJUST_B_END:
13920                 break;
13921         }
13922         return (Info);
13923 }
13924
13925
13926 static void adjust_b1_resource(dword Id, PLCI *plci, API_SAVE   *bp_msg, word b1_facilities, word internal_command)
13927 {
13928
13929         dbug(1, dprintf("[%06lx] %s,%d: adjust_b1_resource %d %04x",
13930                         UnMapId(Id), (char *)(FILE_), __LINE__,
13931                         plci->B1_resource, b1_facilities));
13932
13933         plci->adjust_b_parms_msg = bp_msg;
13934         plci->adjust_b_facilities = b1_facilities;
13935         plci->adjust_b_command = internal_command;
13936         plci->adjust_b_ncci = (word)(Id >> 16);
13937         if ((bp_msg == NULL) && (plci->B1_resource == 0))
13938                 plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_NO_RESOURCE | ADJUST_B_MODE_SWITCH_L1;
13939         else
13940                 plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_SWITCH_L1 | ADJUST_B_MODE_RESTORE;
13941         plci->adjust_b_state = ADJUST_B_START;
13942         dbug(1, dprintf("[%06lx] %s,%d: Adjust B1 resource %d %04x...",
13943                         UnMapId(Id), (char *)(FILE_), __LINE__,
13944                         plci->B1_resource, b1_facilities));
13945 }
13946
13947
13948 static void adjust_b_restore(dword Id, PLCI *plci, byte Rc)
13949 {
13950         word internal_command;
13951
13952         dbug(1, dprintf("[%06lx] %s,%d: adjust_b_restore %02x %04x",
13953                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
13954
13955         internal_command = plci->internal_command;
13956         plci->internal_command = 0;
13957         switch (internal_command)
13958         {
13959         default:
13960                 plci->command = 0;
13961                 if (plci->req_in != 0)
13962                 {
13963                         plci->internal_command = ADJUST_B_RESTORE_1;
13964                         break;
13965                 }
13966                 Rc = OK;
13967         case ADJUST_B_RESTORE_1:
13968                 if ((Rc != OK) && (Rc != OK_FC))
13969                 {
13970                         dbug(1, dprintf("[%06lx] %s,%d: Adjust B enqueued failed %02x",
13971                                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
13972                 }
13973                 plci->adjust_b_parms_msg = NULL;
13974                 plci->adjust_b_facilities = plci->B1_facilities;
13975                 plci->adjust_b_command = ADJUST_B_RESTORE_2;
13976                 plci->adjust_b_ncci = (word)(Id >> 16);
13977                 plci->adjust_b_mode = ADJUST_B_MODE_RESTORE;
13978                 plci->adjust_b_state = ADJUST_B_START;
13979                 dbug(1, dprintf("[%06lx] %s,%d: Adjust B restore...",
13980                                 UnMapId(Id), (char *)(FILE_), __LINE__));
13981         case ADJUST_B_RESTORE_2:
13982                 if (adjust_b_process(Id, plci, Rc) != GOOD)
13983                 {
13984                         dbug(1, dprintf("[%06lx] %s,%d: Adjust B restore failed",
13985                                         UnMapId(Id), (char *)(FILE_), __LINE__));
13986                 }
13987                 if (plci->internal_command)
13988                         break;
13989                 break;
13990         }
13991 }
13992
13993
13994 static void reset_b3_command(dword Id, PLCI *plci, byte Rc)
13995 {
13996         word Info;
13997         word internal_command;
13998
13999         dbug(1, dprintf("[%06lx] %s,%d: reset_b3_command %02x %04x",
14000                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14001
14002         Info = GOOD;
14003         internal_command = plci->internal_command;
14004         plci->internal_command = 0;
14005         switch (internal_command)
14006         {
14007         default:
14008                 plci->command = 0;
14009                 plci->adjust_b_parms_msg = NULL;
14010                 plci->adjust_b_facilities = plci->B1_facilities;
14011                 plci->adjust_b_command = RESET_B3_COMMAND_1;
14012                 plci->adjust_b_ncci = (word)(Id >> 16);
14013                 plci->adjust_b_mode = ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_CONNECT;
14014                 plci->adjust_b_state = ADJUST_B_START;
14015                 dbug(1, dprintf("[%06lx] %s,%d: Reset B3...",
14016                                 UnMapId(Id), (char *)(FILE_), __LINE__));
14017         case RESET_B3_COMMAND_1:
14018                 Info = adjust_b_process(Id, plci, Rc);
14019                 if (Info != GOOD)
14020                 {
14021                         dbug(1, dprintf("[%06lx] %s,%d: Reset failed",
14022                                         UnMapId(Id), (char *)(FILE_), __LINE__));
14023                         break;
14024                 }
14025                 if (plci->internal_command)
14026                         return;
14027                 break;
14028         }
14029 /*  sendf (plci->appl, _RESET_B3_R | CONFIRM, Id, plci->number, "w", Info);*/
14030         sendf(plci->appl, _RESET_B3_I, Id, 0, "s", "");
14031 }
14032
14033
14034 static void select_b_command(dword Id, PLCI *plci, byte Rc)
14035 {
14036         word Info;
14037         word internal_command;
14038         byte esc_chi[3];
14039
14040         dbug(1, dprintf("[%06lx] %s,%d: select_b_command %02x %04x",
14041                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14042
14043         Info = GOOD;
14044         internal_command = plci->internal_command;
14045         plci->internal_command = 0;
14046         switch (internal_command)
14047         {
14048         default:
14049                 plci->command = 0;
14050                 plci->adjust_b_parms_msg = &plci->saved_msg;
14051                 if ((plci->tel == ADV_VOICE) && (plci == plci->adapter->AdvSignalPLCI))
14052                         plci->adjust_b_facilities = plci->B1_facilities | B1_FACILITY_VOICE;
14053                 else
14054                         plci->adjust_b_facilities = plci->B1_facilities & ~B1_FACILITY_VOICE;
14055                 plci->adjust_b_command = SELECT_B_COMMAND_1;
14056                 plci->adjust_b_ncci = (word)(Id >> 16);
14057                 if (plci->saved_msg.parms[0].length == 0)
14058                 {
14059                         plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_SWITCH_L1 |
14060                                 ADJUST_B_MODE_NO_RESOURCE;
14061                 }
14062                 else
14063                 {
14064                         plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_SWITCH_L1 |
14065                                 ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_USER_CONNECT | ADJUST_B_MODE_RESTORE;
14066                 }
14067                 plci->adjust_b_state = ADJUST_B_START;
14068                 dbug(1, dprintf("[%06lx] %s,%d: Select B protocol...",
14069                                 UnMapId(Id), (char *)(FILE_), __LINE__));
14070         case SELECT_B_COMMAND_1:
14071                 Info = adjust_b_process(Id, plci, Rc);
14072                 if (Info != GOOD)
14073                 {
14074                         dbug(1, dprintf("[%06lx] %s,%d: Select B protocol failed",
14075                                         UnMapId(Id), (char *)(FILE_), __LINE__));
14076                         break;
14077                 }
14078                 if (plci->internal_command)
14079                         return;
14080                 if (plci->tel == ADV_VOICE)
14081                 {
14082                         esc_chi[0] = 0x02;
14083                         esc_chi[1] = 0x18;
14084                         esc_chi[2] = plci->b_channel;
14085                         SetVoiceChannel(plci->adapter->AdvCodecPLCI, esc_chi, plci->adapter);
14086                 }
14087                 break;
14088         }
14089         sendf(plci->appl, _SELECT_B_REQ | CONFIRM, Id, plci->number, "w", Info);
14090 }
14091
14092
14093 static void fax_connect_ack_command(dword Id, PLCI *plci, byte Rc)
14094 {
14095         word internal_command;
14096
14097         dbug(1, dprintf("[%06lx] %s,%d: fax_connect_ack_command %02x %04x",
14098                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14099
14100         internal_command = plci->internal_command;
14101         plci->internal_command = 0;
14102         switch (internal_command)
14103         {
14104         default:
14105                 plci->command = 0;
14106         case FAX_CONNECT_ACK_COMMAND_1:
14107                 if (plci_nl_busy(plci))
14108                 {
14109                         plci->internal_command = FAX_CONNECT_ACK_COMMAND_1;
14110                         return;
14111                 }
14112                 plci->internal_command = FAX_CONNECT_ACK_COMMAND_2;
14113                 plci->NData[0].P = plci->fax_connect_info_buffer;
14114                 plci->NData[0].PLength = plci->fax_connect_info_length;
14115                 plci->NL.X = plci->NData;
14116                 plci->NL.ReqCh = 0;
14117                 plci->NL.Req = plci->nl_req = (byte) N_CONNECT_ACK;
14118                 plci->adapter->request(&plci->NL);
14119                 return;
14120         case FAX_CONNECT_ACK_COMMAND_2:
14121                 if ((Rc != OK) && (Rc != OK_FC))
14122                 {
14123                         dbug(1, dprintf("[%06lx] %s,%d: FAX issue CONNECT ACK failed %02x",
14124                                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14125                         break;
14126                 }
14127         }
14128         if ((plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
14129             && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
14130         {
14131                 if (plci->B3_prot == 4)
14132                         sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
14133                 else
14134                         sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
14135                 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
14136         }
14137 }
14138
14139
14140 static void fax_edata_ack_command(dword Id, PLCI *plci, byte Rc)
14141 {
14142         word internal_command;
14143
14144         dbug(1, dprintf("[%06lx] %s,%d: fax_edata_ack_command %02x %04x",
14145                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14146
14147         internal_command = plci->internal_command;
14148         plci->internal_command = 0;
14149         switch (internal_command)
14150         {
14151         default:
14152                 plci->command = 0;
14153         case FAX_EDATA_ACK_COMMAND_1:
14154                 if (plci_nl_busy(plci))
14155                 {
14156                         plci->internal_command = FAX_EDATA_ACK_COMMAND_1;
14157                         return;
14158                 }
14159                 plci->internal_command = FAX_EDATA_ACK_COMMAND_2;
14160                 plci->NData[0].P = plci->fax_connect_info_buffer;
14161                 plci->NData[0].PLength = plci->fax_edata_ack_length;
14162                 plci->NL.X = plci->NData;
14163                 plci->NL.ReqCh = 0;
14164                 plci->NL.Req = plci->nl_req = (byte) N_EDATA;
14165                 plci->adapter->request(&plci->NL);
14166                 return;
14167         case FAX_EDATA_ACK_COMMAND_2:
14168                 if ((Rc != OK) && (Rc != OK_FC))
14169                 {
14170                         dbug(1, dprintf("[%06lx] %s,%d: FAX issue EDATA ACK failed %02x",
14171                                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14172                         break;
14173                 }
14174         }
14175 }
14176
14177
14178 static void fax_connect_info_command(dword Id, PLCI *plci, byte Rc)
14179 {
14180         word Info;
14181         word internal_command;
14182
14183         dbug(1, dprintf("[%06lx] %s,%d: fax_connect_info_command %02x %04x",
14184                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14185
14186         Info = GOOD;
14187         internal_command = plci->internal_command;
14188         plci->internal_command = 0;
14189         switch (internal_command)
14190         {
14191         default:
14192                 plci->command = 0;
14193         case FAX_CONNECT_INFO_COMMAND_1:
14194                 if (plci_nl_busy(plci))
14195                 {
14196                         plci->internal_command = FAX_CONNECT_INFO_COMMAND_1;
14197                         return;
14198                 }
14199                 plci->internal_command = FAX_CONNECT_INFO_COMMAND_2;
14200                 plci->NData[0].P = plci->fax_connect_info_buffer;
14201                 plci->NData[0].PLength = plci->fax_connect_info_length;
14202                 plci->NL.X = plci->NData;
14203                 plci->NL.ReqCh = 0;
14204                 plci->NL.Req = plci->nl_req = (byte) N_EDATA;
14205                 plci->adapter->request(&plci->NL);
14206                 return;
14207         case FAX_CONNECT_INFO_COMMAND_2:
14208                 if ((Rc != OK) && (Rc != OK_FC))
14209                 {
14210                         dbug(1, dprintf("[%06lx] %s,%d: FAX setting connect info failed %02x",
14211                                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14212                         Info = _WRONG_STATE;
14213                         break;
14214                 }
14215                 if (plci_nl_busy(plci))
14216                 {
14217                         plci->internal_command = FAX_CONNECT_INFO_COMMAND_2;
14218                         return;
14219                 }
14220                 plci->command = _CONNECT_B3_R;
14221                 nl_req_ncci(plci, N_CONNECT, 0);
14222                 send_req(plci);
14223                 return;
14224         }
14225         sendf(plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info);
14226 }
14227
14228
14229 static void fax_adjust_b23_command(dword Id, PLCI *plci, byte Rc)
14230 {
14231         word Info;
14232         word internal_command;
14233
14234         dbug(1, dprintf("[%06lx] %s,%d: fax_adjust_b23_command %02x %04x",
14235                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14236
14237         Info = GOOD;
14238         internal_command = plci->internal_command;
14239         plci->internal_command = 0;
14240         switch (internal_command)
14241         {
14242         default:
14243                 plci->command = 0;
14244                 plci->adjust_b_parms_msg = NULL;
14245                 plci->adjust_b_facilities = plci->B1_facilities;
14246                 plci->adjust_b_command = FAX_ADJUST_B23_COMMAND_1;
14247                 plci->adjust_b_ncci = (word)(Id >> 16);
14248                 plci->adjust_b_mode = ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_ASSIGN_L23;
14249                 plci->adjust_b_state = ADJUST_B_START;
14250                 dbug(1, dprintf("[%06lx] %s,%d: FAX adjust B23...",
14251                                 UnMapId(Id), (char *)(FILE_), __LINE__));
14252         case FAX_ADJUST_B23_COMMAND_1:
14253                 Info = adjust_b_process(Id, plci, Rc);
14254                 if (Info != GOOD)
14255                 {
14256                         dbug(1, dprintf("[%06lx] %s,%d: FAX adjust failed",
14257                                         UnMapId(Id), (char *)(FILE_), __LINE__));
14258                         break;
14259                 }
14260                 if (plci->internal_command)
14261                         return;
14262         case FAX_ADJUST_B23_COMMAND_2:
14263                 if (plci_nl_busy(plci))
14264                 {
14265                         plci->internal_command = FAX_ADJUST_B23_COMMAND_2;
14266                         return;
14267                 }
14268                 plci->command = _CONNECT_B3_R;
14269                 nl_req_ncci(plci, N_CONNECT, 0);
14270                 send_req(plci);
14271                 return;
14272         }
14273         sendf(plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info);
14274 }
14275
14276
14277 static void fax_disconnect_command(dword Id, PLCI *plci, byte Rc)
14278 {
14279         word internal_command;
14280
14281         dbug(1, dprintf("[%06lx] %s,%d: fax_disconnect_command %02x %04x",
14282                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14283
14284         internal_command = plci->internal_command;
14285         plci->internal_command = 0;
14286         switch (internal_command)
14287         {
14288         default:
14289                 plci->command = 0;
14290                 plci->internal_command = FAX_DISCONNECT_COMMAND_1;
14291                 return;
14292         case FAX_DISCONNECT_COMMAND_1:
14293         case FAX_DISCONNECT_COMMAND_2:
14294         case FAX_DISCONNECT_COMMAND_3:
14295                 if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0))
14296                 {
14297                         dbug(1, dprintf("[%06lx] %s,%d: FAX disconnect EDATA failed %02x",
14298                                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14299                         break;
14300                 }
14301                 if (Rc == OK)
14302                 {
14303                         if ((internal_command == FAX_DISCONNECT_COMMAND_1)
14304                             || (internal_command == FAX_DISCONNECT_COMMAND_2))
14305                         {
14306                                 plci->internal_command = FAX_DISCONNECT_COMMAND_2;
14307                         }
14308                 }
14309                 else if (Rc == 0)
14310                 {
14311                         if (internal_command == FAX_DISCONNECT_COMMAND_1)
14312                                 plci->internal_command = FAX_DISCONNECT_COMMAND_3;
14313                 }
14314                 return;
14315         }
14316 }
14317
14318
14319
14320 static void rtp_connect_b3_req_command(dword Id, PLCI *plci, byte Rc)
14321 {
14322         word Info;
14323         word internal_command;
14324
14325         dbug(1, dprintf("[%06lx] %s,%d: rtp_connect_b3_req_command %02x %04x",
14326                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14327
14328         Info = GOOD;
14329         internal_command = plci->internal_command;
14330         plci->internal_command = 0;
14331         switch (internal_command)
14332         {
14333         default:
14334                 plci->command = 0;
14335         case RTP_CONNECT_B3_REQ_COMMAND_1:
14336                 if (plci_nl_busy(plci))
14337                 {
14338                         plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_1;
14339                         return;
14340                 }
14341                 plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_2;
14342                 nl_req_ncci(plci, N_CONNECT, 0);
14343                 send_req(plci);
14344                 return;
14345         case RTP_CONNECT_B3_REQ_COMMAND_2:
14346                 if ((Rc != OK) && (Rc != OK_FC))
14347                 {
14348                         dbug(1, dprintf("[%06lx] %s,%d: RTP setting connect info failed %02x",
14349                                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14350                         Info = _WRONG_STATE;
14351                         break;
14352                 }
14353                 if (plci_nl_busy(plci))
14354                 {
14355                         plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_2;
14356                         return;
14357                 }
14358                 plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_3;
14359                 plci->NData[0].PLength = plci->internal_req_buffer[0];
14360                 plci->NData[0].P = plci->internal_req_buffer + 1;
14361                 plci->NL.X = plci->NData;
14362                 plci->NL.ReqCh = 0;
14363                 plci->NL.Req = plci->nl_req = (byte) N_UDATA;
14364                 plci->adapter->request(&plci->NL);
14365                 break;
14366         case RTP_CONNECT_B3_REQ_COMMAND_3:
14367                 return;
14368         }
14369         sendf(plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info);
14370 }
14371
14372
14373 static void rtp_connect_b3_res_command(dword Id, PLCI *plci, byte Rc)
14374 {
14375         word internal_command;
14376
14377         dbug(1, dprintf("[%06lx] %s,%d: rtp_connect_b3_res_command %02x %04x",
14378                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14379
14380         internal_command = plci->internal_command;
14381         plci->internal_command = 0;
14382         switch (internal_command)
14383         {
14384         default:
14385                 plci->command = 0;
14386         case RTP_CONNECT_B3_RES_COMMAND_1:
14387                 if (plci_nl_busy(plci))
14388                 {
14389                         plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_1;
14390                         return;
14391                 }
14392                 plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_2;
14393                 nl_req_ncci(plci, N_CONNECT_ACK, (byte)(Id >> 16));
14394                 send_req(plci);
14395                 return;
14396         case RTP_CONNECT_B3_RES_COMMAND_2:
14397                 if ((Rc != OK) && (Rc != OK_FC))
14398                 {
14399                         dbug(1, dprintf("[%06lx] %s,%d: RTP setting connect resp info failed %02x",
14400                                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14401                         break;
14402                 }
14403                 if (plci_nl_busy(plci))
14404                 {
14405                         plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_2;
14406                         return;
14407                 }
14408                 sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
14409                 plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_3;
14410                 plci->NData[0].PLength = plci->internal_req_buffer[0];
14411                 plci->NData[0].P = plci->internal_req_buffer + 1;
14412                 plci->NL.X = plci->NData;
14413                 plci->NL.ReqCh = 0;
14414                 plci->NL.Req = plci->nl_req = (byte) N_UDATA;
14415                 plci->adapter->request(&plci->NL);
14416                 return;
14417         case RTP_CONNECT_B3_RES_COMMAND_3:
14418                 return;
14419         }
14420 }
14421
14422
14423
14424 static void hold_save_command(dword Id, PLCI *plci, byte Rc)
14425 {
14426         byte SS_Ind[] = "\x05\x02\x00\x02\x00\x00"; /* Hold_Ind struct*/
14427         word Info;
14428         word internal_command;
14429
14430         dbug(1, dprintf("[%06lx] %s,%d: hold_save_command %02x %04x",
14431                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14432
14433         Info = GOOD;
14434         internal_command = plci->internal_command;
14435         plci->internal_command = 0;
14436         switch (internal_command)
14437         {
14438         default:
14439                 if (!plci->NL.Id)
14440                         break;
14441                 plci->command = 0;
14442                 plci->adjust_b_parms_msg = NULL;
14443                 plci->adjust_b_facilities = plci->B1_facilities;
14444                 plci->adjust_b_command = HOLD_SAVE_COMMAND_1;
14445                 plci->adjust_b_ncci = (word)(Id >> 16);
14446                 plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23;
14447                 plci->adjust_b_state = ADJUST_B_START;
14448                 dbug(1, dprintf("[%06lx] %s,%d: HOLD save...",
14449                                 UnMapId(Id), (char *)(FILE_), __LINE__));
14450         case HOLD_SAVE_COMMAND_1:
14451                 Info = adjust_b_process(Id, plci, Rc);
14452                 if (Info != GOOD)
14453                 {
14454                         dbug(1, dprintf("[%06lx] %s,%d: HOLD save failed",
14455                                         UnMapId(Id), (char *)(FILE_), __LINE__));
14456                         break;
14457                 }
14458                 if (plci->internal_command)
14459                         return;
14460         }
14461         sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", 3, SS_Ind);
14462 }
14463
14464
14465 static void retrieve_restore_command(dword Id, PLCI *plci, byte Rc)
14466 {
14467         byte SS_Ind[] = "\x05\x03\x00\x02\x00\x00"; /* Retrieve_Ind struct*/
14468         word Info;
14469         word internal_command;
14470
14471         dbug(1, dprintf("[%06lx] %s,%d: retrieve_restore_command %02x %04x",
14472                         UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14473
14474         Info = GOOD;
14475         internal_command = plci->internal_command;
14476         plci->internal_command = 0;
14477         switch (internal_command)
14478         {
14479         default:
14480                 plci->command = 0;
14481                 plci->adjust_b_parms_msg = NULL;
14482                 plci->adjust_b_facilities = plci->B1_facilities;
14483                 plci->adjust_b_command = RETRIEVE_RESTORE_COMMAND_1;
14484                 plci->adjust_b_ncci = (word)(Id >> 16);
14485                 plci->adjust_b_mode = ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_USER_CONNECT | ADJUST_B_MODE_RESTORE;
14486                 plci->adjust_b_state = ADJUST_B_START;
14487                 dbug(1, dprintf("[%06lx] %s,%d: RETRIEVE restore...",
14488                                 UnMapId(Id), (char *)(FILE_), __LINE__));
14489         case RETRIEVE_RESTORE_COMMAND_1:
14490                 Info = adjust_b_process(Id, plci, Rc);
14491                 if (Info != GOOD)
14492                 {
14493                         dbug(1, dprintf("[%06lx] %s,%d: RETRIEVE restore failed",
14494                                         UnMapId(Id), (char *)(FILE_), __LINE__));
14495                         break;
14496                 }
14497                 if (plci->internal_command)
14498                         return;
14499         }
14500         sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", 3, SS_Ind);
14501 }
14502
14503
14504 static void init_b1_config(PLCI *plci)
14505 {
14506
14507         dbug(1, dprintf("[%06lx] %s,%d: init_b1_config",
14508                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
14509                         (char *)(FILE_), __LINE__));
14510
14511         plci->B1_resource = 0;
14512         plci->B1_facilities = 0;
14513
14514         plci->li_bchannel_id = 0;
14515         mixer_clear_config(plci);
14516
14517
14518         ec_clear_config(plci);
14519
14520
14521         dtmf_rec_clear_config(plci);
14522         dtmf_send_clear_config(plci);
14523         dtmf_parameter_clear_config(plci);
14524
14525         adv_voice_clear_config(plci);
14526         adjust_b_clear(plci);
14527 }
14528
14529
14530 static void clear_b1_config(PLCI *plci)
14531 {
14532
14533         dbug(1, dprintf("[%06lx] %s,%d: clear_b1_config",
14534                         (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
14535                         (char *)(FILE_), __LINE__));
14536
14537         adv_voice_clear_config(plci);
14538         adjust_b_clear(plci);
14539
14540         ec_clear_config(plci);
14541
14542
14543         dtmf_rec_clear_config(plci);
14544         dtmf_send_clear_config(plci);
14545         dtmf_parameter_clear_config(plci);
14546
14547
14548         if ((plci->li_bchannel_id != 0)
14549             && (li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci == plci))
14550         {
14551                 mixer_clear_config(plci);
14552                 li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci = NULL;
14553                 plci->li_bchannel_id = 0;
14554         }
14555
14556         plci->B1_resource = 0;
14557         plci->B1_facilities = 0;
14558 }
14559
14560
14561 /* -----------------------------------------------------------------
14562    XON protocol local helpers
14563    ----------------------------------------------------------------- */
14564 static void channel_flow_control_remove(PLCI *plci) {
14565         DIVA_CAPI_ADAPTER *a = plci->adapter;
14566         word i;
14567         for (i = 1; i < MAX_NL_CHANNEL + 1; i++) {
14568                 if (a->ch_flow_plci[i] == plci->Id) {
14569                         a->ch_flow_plci[i] = 0;
14570                         a->ch_flow_control[i] = 0;
14571                 }
14572         }
14573 }
14574
14575 static void channel_x_on(PLCI *plci, byte ch) {
14576         DIVA_CAPI_ADAPTER *a = plci->adapter;
14577         if (a->ch_flow_control[ch] & N_XON_SENT) {
14578                 a->ch_flow_control[ch] &= ~N_XON_SENT;
14579         }
14580 }
14581
14582 static void channel_x_off(PLCI *plci, byte ch, byte flag) {
14583         DIVA_CAPI_ADAPTER *a = plci->adapter;
14584         if ((a->ch_flow_control[ch] & N_RX_FLOW_CONTROL_MASK) == 0) {
14585                 a->ch_flow_control[ch] |= (N_CH_XOFF | flag);
14586                 a->ch_flow_plci[ch] = plci->Id;
14587                 a->ch_flow_control_pending++;
14588         }
14589 }
14590
14591 static void channel_request_xon(PLCI *plci, byte ch) {
14592         DIVA_CAPI_ADAPTER *a = plci->adapter;
14593
14594         if (a->ch_flow_control[ch] & N_CH_XOFF) {
14595                 a->ch_flow_control[ch] |= N_XON_REQ;
14596                 a->ch_flow_control[ch] &= ~N_CH_XOFF;
14597                 a->ch_flow_control[ch] &= ~N_XON_CONNECT_IND;
14598         }
14599 }
14600
14601 static void channel_xmit_extended_xon(PLCI *plci) {
14602         DIVA_CAPI_ADAPTER *a;
14603         int max_ch = ARRAY_SIZE(a->ch_flow_control);
14604         int i, one_requested = 0;
14605
14606         if ((!plci) || (!plci->Id) || ((a = plci->adapter) == NULL)) {
14607                 return;
14608         }
14609
14610         for (i = 0; i < max_ch; i++) {
14611                 if ((a->ch_flow_control[i] & N_CH_XOFF) &&
14612                     (a->ch_flow_control[i] & N_XON_CONNECT_IND) &&
14613                     (plci->Id == a->ch_flow_plci[i])) {
14614                         channel_request_xon(plci, (byte)i);
14615                         one_requested = 1;
14616                 }
14617         }
14618
14619         if (one_requested) {
14620                 channel_xmit_xon(plci);
14621         }
14622 }
14623
14624 /*
14625   Try to xmit next X_ON
14626 */
14627 static int find_channel_with_pending_x_on(DIVA_CAPI_ADAPTER *a, PLCI *plci) {
14628         int max_ch = ARRAY_SIZE(a->ch_flow_control);
14629         int i;
14630
14631         if (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL)) {
14632                 return (0);
14633         }
14634
14635         if (a->last_flow_control_ch >= max_ch) {
14636                 a->last_flow_control_ch = 1;
14637         }
14638         for (i = a->last_flow_control_ch; i < max_ch; i++) {
14639                 if ((a->ch_flow_control[i] & N_XON_REQ) &&
14640                     (plci->Id == a->ch_flow_plci[i])) {
14641                         a->last_flow_control_ch = i + 1;
14642                         return (i);
14643                 }
14644         }
14645
14646         for (i = 1; i < a->last_flow_control_ch; i++) {
14647                 if ((a->ch_flow_control[i] & N_XON_REQ) &&
14648                     (plci->Id == a->ch_flow_plci[i])) {
14649                         a->last_flow_control_ch = i + 1;
14650                         return (i);
14651                 }
14652         }
14653
14654         return (0);
14655 }
14656
14657 static void channel_xmit_xon(PLCI *plci) {
14658         DIVA_CAPI_ADAPTER *a = plci->adapter;
14659         byte ch;
14660
14661         if (plci->nl_req || !plci->NL.Id || plci->nl_remove_id) {
14662                 return;
14663         }
14664         if ((ch = (byte)find_channel_with_pending_x_on(a, plci)) == 0) {
14665                 return;
14666         }
14667         a->ch_flow_control[ch] &= ~N_XON_REQ;
14668         a->ch_flow_control[ch] |= N_XON_SENT;
14669
14670         plci->NL.Req = plci->nl_req = (byte)N_XON;
14671         plci->NL.ReqCh         = ch;
14672         plci->NL.X             = plci->NData;
14673         plci->NL.XNum          = 1;
14674         plci->NData[0].P       = &plci->RBuffer[0];
14675         plci->NData[0].PLength = 0;
14676
14677         plci->adapter->request(&plci->NL);
14678 }
14679
14680 static int channel_can_xon(PLCI *plci, byte ch) {
14681         APPL *APPLptr;
14682         DIVA_CAPI_ADAPTER *a;
14683         word NCCIcode;
14684         dword count;
14685         word Num;
14686         word i;
14687
14688         APPLptr = plci->appl;
14689         a = plci->adapter;
14690
14691         if (!APPLptr)
14692                 return (0);
14693
14694         NCCIcode = a->ch_ncci[ch] | (((word) a->Id) << 8);
14695
14696         /* count all buffers within the Application pool    */
14697         /* belonging to the same NCCI. XON if a first is    */
14698         /* used.                                            */
14699         count = 0;
14700         Num = 0xffff;
14701         for (i = 0; i < APPLptr->MaxBuffer; i++) {
14702                 if (NCCIcode == APPLptr->DataNCCI[i]) count++;
14703                 if (!APPLptr->DataNCCI[i] && Num == 0xffff) Num = i;
14704         }
14705         if ((count > 2) || (Num == 0xffff)) {
14706                 return (0);
14707         }
14708         return (1);
14709 }
14710
14711
14712 /*------------------------------------------------------------------*/
14713
14714 static word CPN_filter_ok(byte *cpn, DIVA_CAPI_ADAPTER *a, word offset)
14715 {
14716         return 1;
14717 }
14718
14719
14720
14721 /**********************************************************************************/
14722 /* function groups the listening applications according to the CIP mask and the   */
14723 /* Info_Mask. Each group gets just one Connect_Ind. Some application manufacturer */
14724 /* are not multi-instance capable, so they start e.g. 30 applications what causes */
14725 /* big problems on application level (one call, 30 Connect_Ind, ect). The         */
14726 /* function must be enabled by setting "a->group_optimization_enabled" from the   */
14727 /* OS specific part (per adapter).                                                */
14728 /**********************************************************************************/
14729 static void group_optimization(DIVA_CAPI_ADAPTER *a, PLCI *plci)
14730 {
14731         word i, j, k, busy, group_found;
14732         dword info_mask_group[MAX_CIP_TYPES];
14733         dword cip_mask_group[MAX_CIP_TYPES];
14734         word appl_number_group_type[MAX_APPL];
14735         PLCI *auxplci;
14736
14737         set_group_ind_mask(plci); /* all APPLs within this inc. call are allowed to dial in */
14738
14739         if (!a->group_optimization_enabled)
14740         {
14741                 dbug(1, dprintf("No group optimization"));
14742                 return;
14743         }
14744
14745         dbug(1, dprintf("Group optimization = 0x%x...", a->group_optimization_enabled));
14746
14747         for (i = 0; i < MAX_CIP_TYPES; i++)
14748         {
14749                 info_mask_group[i] = 0;
14750                 cip_mask_group[i] = 0;
14751         }
14752         for (i = 0; i < MAX_APPL; i++)
14753         {
14754                 appl_number_group_type[i] = 0;
14755         }
14756         for (i = 0; i < max_appl; i++) /* check if any multi instance capable application is present */
14757         {  /* group_optimization set to 1 means not to optimize multi-instance capable applications (default) */
14758                 if (application[i].Id && (application[i].MaxNCCI) > 1 && (a->CIP_Mask[i]) && (a->group_optimization_enabled == 1))
14759                 {
14760                         dbug(1, dprintf("Multi-Instance capable, no optimization required"));
14761                         return; /* allow good application unfiltered access */
14762                 }
14763         }
14764         for (i = 0; i < max_appl; i++) /* Build CIP Groups */
14765         {
14766                 if (application[i].Id && a->CIP_Mask[i])
14767                 {
14768                         for (k = 0, busy = false; k < a->max_plci; k++)
14769                         {
14770                                 if (a->plci[k].Id)
14771                                 {
14772                                         auxplci = &a->plci[k];
14773                                         if (auxplci->appl == &application[i]) /* application has a busy PLCI */
14774                                         {
14775                                                 busy = true;
14776                                                 dbug(1, dprintf("Appl 0x%x is busy", i + 1));
14777                                         }
14778                                         else if (test_c_ind_mask_bit(auxplci, i)) /* application has an incoming call pending */
14779                                         {
14780                                                 busy = true;
14781                                                 dbug(1, dprintf("Appl 0x%x has inc. call pending", i + 1));
14782                                         }
14783                                 }
14784                         }
14785
14786                         for (j = 0, group_found = 0; j <= (MAX_CIP_TYPES) && !busy && !group_found; j++)     /* build groups with free applications only */
14787                         {
14788                                 if (j == MAX_CIP_TYPES)       /* all groups are in use but group still not found */
14789                                 {                           /* the MAX_CIP_TYPES group enables all calls because of field overflow */
14790                                         appl_number_group_type[i] = MAX_CIP_TYPES;
14791                                         group_found = true;
14792                                         dbug(1, dprintf("Field overflow appl 0x%x", i + 1));
14793                                 }
14794                                 else if ((info_mask_group[j] == a->CIP_Mask[i]) && (cip_mask_group[j] == a->Info_Mask[i]))
14795                                 {                                      /* is group already present ?                  */
14796                                         appl_number_group_type[i] = j | 0x80;  /* store the group number for each application */
14797                                         group_found = true;
14798                                         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]));
14799                                 }
14800                                 else if (!info_mask_group[j])
14801                                 {                                      /* establish a new group                       */
14802                                         appl_number_group_type[i] = j | 0x80;  /* store the group number for each application */
14803                                         info_mask_group[j] = a->CIP_Mask[i]; /* store the new CIP mask for the new group    */
14804                                         cip_mask_group[j] = a->Info_Mask[i]; /* store the new Info_Mask for this new group  */
14805                                         group_found = true;
14806                                         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]));
14807                                 }
14808                         }
14809                 }
14810         }
14811
14812         for (i = 0; i < max_appl; i++) /* Build group_optimization_mask_table */
14813         {
14814                 if (appl_number_group_type[i]) /* application is free, has listens and is member of a group */
14815                 {
14816                         if (appl_number_group_type[i] == MAX_CIP_TYPES)
14817                         {
14818                                 dbug(1, dprintf("OverflowGroup 0x%x, valid appl = 0x%x, call enabled", appl_number_group_type[i], i + 1));
14819                         }
14820                         else
14821                         {
14822                                 dbug(1, dprintf("Group 0x%x, valid appl = 0x%x", appl_number_group_type[i], i + 1));
14823                                 for (j = i + 1; j < max_appl; j++)   /* search other group members and mark them as busy        */
14824                                 {
14825                                         if (appl_number_group_type[i] == appl_number_group_type[j])
14826                                         {
14827                                                 dbug(1, dprintf("Appl 0x%x is member of group 0x%x, no call", j + 1, appl_number_group_type[j]));
14828                                                 clear_group_ind_mask_bit(plci, j);           /* disable call on other group members */
14829                                                 appl_number_group_type[j] = 0;       /* remove disabled group member from group list */
14830                                         }
14831                                 }
14832                         }
14833                 }
14834                 else                                                 /* application should not get a call */
14835                 {
14836                         clear_group_ind_mask_bit(plci, i);
14837                 }
14838         }
14839
14840 }
14841
14842
14843
14844 /* OS notifies the driver about a application Capi_Register */
14845 word CapiRegister(word id)
14846 {
14847         word i, j, appls_found;
14848
14849         PLCI *plci;
14850         DIVA_CAPI_ADAPTER *a;
14851
14852         for (i = 0, appls_found = 0; i < max_appl; i++)
14853         {
14854                 if (application[i].Id && (application[i].Id != id))
14855                 {
14856                         appls_found++;                       /* an application has been found */
14857                 }
14858         }
14859
14860         if (appls_found) return true;
14861         for (i = 0; i < max_adapter; i++)                   /* scan all adapters...    */
14862         {
14863                 a = &adapter[i];
14864                 if (a->request)
14865                 {
14866                         if (a->flag_dynamic_l1_down)  /* remove adapter from L1 tristate (Huntgroup) */
14867                         {
14868                                 if (!appls_found)           /* first application does a capi register   */
14869                                 {
14870                                         if ((j = get_plci(a)))                    /* activate L1 of all adapters */
14871                                         {
14872                                                 plci = &a->plci[j - 1];
14873                                                 plci->command = 0;
14874                                                 add_p(plci, OAD, "\x01\xfd");
14875                                                 add_p(plci, CAI, "\x01\x80");
14876                                                 add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
14877                                                 add_p(plci, SHIFT | 6, NULL);
14878                                                 add_p(plci, SIN, "\x02\x00\x00");
14879                                                 plci->internal_command = START_L1_SIG_ASSIGN_PEND;
14880                                                 sig_req(plci, ASSIGN, DSIG_ID);
14881                                                 add_p(plci, FTY, "\x02\xff\x07"); /* l1 start */
14882                                                 sig_req(plci, SIG_CTRL, 0);
14883                                                 send_req(plci);
14884                                         }
14885                                 }
14886                         }
14887                 }
14888         }
14889         return false;
14890 }
14891
14892 /*------------------------------------------------------------------*/
14893
14894 /* Functions for virtual Switching e.g. Transfer by join, Conference */
14895
14896 static void VSwitchReqInd(PLCI *plci, dword Id, byte **parms)
14897 {
14898         word i;
14899         /* Format of vswitch_t:
14900            0 byte length
14901            1 byte VSWITCHIE
14902            2 byte VSWITCH_REQ/VSWITCH_IND
14903            3 byte reserved
14904            4 word VSwitchcommand
14905            6 word returnerror
14906            8... Params
14907         */
14908         if (!plci ||
14909             !plci->appl ||
14910             !plci->State ||
14911             plci->Sig.Ind == NCR_FACILITY
14912                 )
14913                 return;
14914
14915         for (i = 0; i < MAX_MULTI_IE; i++)
14916         {
14917                 if (!parms[i][0]) continue;
14918                 if (parms[i][0] < 7)
14919                 {
14920                         parms[i][0] = 0; /* kill it */
14921                         continue;
14922                 }
14923                 dbug(1, dprintf("VSwitchReqInd(%d)", parms[i][4]));
14924                 switch (parms[i][4])
14925                 {
14926                 case VSJOIN:
14927                         if (!plci->relatedPTYPLCI ||
14928                             (plci->ptyState != S_ECT && plci->relatedPTYPLCI->ptyState != S_ECT))
14929                         { /* Error */
14930                                 break;
14931                         }
14932                         /* remember all necessary informations */
14933                         if (parms[i][0] != 11 || parms[i][8] != 3) /* Length Test */
14934                         {
14935                                 break;
14936                         }
14937                         if (parms[i][2] == VSWITCH_IND && parms[i][9] == 1)
14938                         {   /* first indication after ECT-Request on Consultation Call */
14939                                 plci->vswitchstate = parms[i][9];
14940                                 parms[i][9] = 2; /* State */
14941                                 /* now ask first Call to join */
14942                         }
14943                         else if (parms[i][2] == VSWITCH_REQ && parms[i][9] == 3)
14944                         { /* Answer of VSWITCH_REQ from first Call */
14945                                 plci->vswitchstate = parms[i][9];
14946                                 /* tell consultation call to join
14947                                    and the protocol capabilities of the first call */
14948                         }
14949                         else
14950                         { /* Error */
14951                                 break;
14952                         }
14953                         plci->vsprot = parms[i][10]; /* protocol */
14954                         plci->vsprotdialect = parms[i][11]; /* protocoldialect */
14955                         /* send join request to related PLCI */
14956                         parms[i][1] = VSWITCHIE;
14957                         parms[i][2] = VSWITCH_REQ;
14958
14959                         plci->relatedPTYPLCI->command = 0;
14960                         plci->relatedPTYPLCI->internal_command = VSWITCH_REQ_PEND;
14961                         add_p(plci->relatedPTYPLCI, ESC, &parms[i][0]);
14962                         sig_req(plci->relatedPTYPLCI, VSWITCH_REQ, 0);
14963                         send_req(plci->relatedPTYPLCI);
14964                         break;
14965                 case VSTRANSPORT:
14966                 default:
14967                         if (plci->relatedPTYPLCI &&
14968                             plci->vswitchstate == 3 &&
14969                             plci->relatedPTYPLCI->vswitchstate == 3)
14970                         {
14971                                 add_p(plci->relatedPTYPLCI, ESC, &parms[i][0]);
14972                                 sig_req(plci->relatedPTYPLCI, VSWITCH_REQ, 0);
14973                                 send_req(plci->relatedPTYPLCI);
14974                         }
14975                         break;
14976                 }
14977                 parms[i][0] = 0; /* kill it */
14978         }
14979 }
14980
14981
14982 /*------------------------------------------------------------------*/
14983
14984 static int diva_get_dma_descriptor(PLCI *plci, dword   *dma_magic) {
14985         ENTITY e;
14986         IDI_SYNC_REQ *pReq = (IDI_SYNC_REQ *)&e;
14987
14988         if (!(diva_xdi_extended_features & DIVA_CAPI_XDI_PROVIDES_RX_DMA)) {
14989                 return (-1);
14990         }
14991
14992         pReq->xdi_dma_descriptor_operation.Req = 0;
14993         pReq->xdi_dma_descriptor_operation.Rc = IDI_SYNC_REQ_DMA_DESCRIPTOR_OPERATION;
14994
14995         pReq->xdi_dma_descriptor_operation.info.operation = IDI_SYNC_REQ_DMA_DESCRIPTOR_ALLOC;
14996         pReq->xdi_dma_descriptor_operation.info.descriptor_number  = -1;
14997         pReq->xdi_dma_descriptor_operation.info.descriptor_address = NULL;
14998         pReq->xdi_dma_descriptor_operation.info.descriptor_magic   = 0;
14999
15000         e.user[0] = plci->adapter->Id - 1;
15001         plci->adapter->request((ENTITY *)pReq);
15002
15003         if (!pReq->xdi_dma_descriptor_operation.info.operation &&
15004             (pReq->xdi_dma_descriptor_operation.info.descriptor_number >= 0) &&
15005             pReq->xdi_dma_descriptor_operation.info.descriptor_magic) {
15006                 *dma_magic = pReq->xdi_dma_descriptor_operation.info.descriptor_magic;
15007                 dbug(3, dprintf("dma_alloc, a:%d (%d-%08x)",
15008                                 plci->adapter->Id,
15009                                 pReq->xdi_dma_descriptor_operation.info.descriptor_number,
15010                                 *dma_magic));
15011                 return (pReq->xdi_dma_descriptor_operation.info.descriptor_number);
15012         } else {
15013                 dbug(1, dprintf("dma_alloc failed"));
15014                 return (-1);
15015         }
15016 }
15017
15018 static void diva_free_dma_descriptor(PLCI *plci, int nr) {
15019         ENTITY e;
15020         IDI_SYNC_REQ *pReq = (IDI_SYNC_REQ *)&e;
15021
15022         if (nr < 0) {
15023                 return;
15024         }
15025
15026         pReq->xdi_dma_descriptor_operation.Req = 0;
15027         pReq->xdi_dma_descriptor_operation.Rc = IDI_SYNC_REQ_DMA_DESCRIPTOR_OPERATION;
15028
15029         pReq->xdi_dma_descriptor_operation.info.operation = IDI_SYNC_REQ_DMA_DESCRIPTOR_FREE;
15030         pReq->xdi_dma_descriptor_operation.info.descriptor_number  = nr;
15031         pReq->xdi_dma_descriptor_operation.info.descriptor_address = NULL;
15032         pReq->xdi_dma_descriptor_operation.info.descriptor_magic   = 0;
15033
15034         e.user[0] = plci->adapter->Id - 1;
15035         plci->adapter->request((ENTITY *)pReq);
15036
15037         if (!pReq->xdi_dma_descriptor_operation.info.operation) {
15038                 dbug(1, dprintf("dma_free(%d)", nr));
15039         } else {
15040                 dbug(1, dprintf("dma_free failed (%d)", nr));
15041         }
15042 }
15043
15044 /*------------------------------------------------------------------*/