Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
message.c
Go to the documentation of this file.
1 /*
2  *
3  Copyright (c) Eicon Networks, 2002.
4  *
5  This source file is supplied for the use with
6  Eicon Networks range of DIVA Server Adapters.
7  *
8  Eicon File Revision : 2.1
9  *
10  This program is free software; you can redistribute it and/or modify
11  it under the terms of the GNU General Public License as published by
12  the Free Software Foundation; either version 2, or (at your option)
13  any later version.
14  *
15  This program is distributed in the hope that it will be useful,
16  but WITHOUT ANY WARRANTY OF ANY KIND WHATSOEVER INCLUDING ANY
17  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
18  See the GNU General Public License for more details.
19  *
20  You should have received a copy of the GNU General Public License
21  along with this program; if not, write to the Free Software
22  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23  *
24  */
25 
26 
27 
28 
29 
30 #include "platform.h"
31 #include "di_defs.h"
32 #include "pc.h"
33 #include "capi20.h"
34 #include "divacapi.h"
35 #include "mdm_msg.h"
36 #include "divasync.h"
37 
38 
39 
40 #define FILE_ "MESSAGE.C"
41 #define dprintf
42 
43 
44 
45 
46 
47 
48 
49 
50 
51 /*------------------------------------------------------------------*/
52 /* This is options supported for all adapters that are server by */
53 /* XDI driver. Allo it is not necessary to ask it from every adapter*/
54 /* and it is not necessary to save it separate for every adapter */
55 /* Macrose defined here have only local meaning */
56 /*------------------------------------------------------------------*/
57 static dword diva_xdi_extended_features = 0;
58 
59 #define DIVA_CAPI_USE_CMA 0x00000001
60 #define DIVA_CAPI_XDI_PROVIDES_SDRAM_BAR 0x00000002
61 #define DIVA_CAPI_XDI_PROVIDES_NO_CANCEL 0x00000004
62 #define DIVA_CAPI_XDI_PROVIDES_RX_DMA 0x00000008
63 
64 /*
65  CAPI can request to process all return codes self only if:
66  protocol code supports this && xdi supports this
67 */
68 #define DIVA_CAPI_SUPPORTS_NO_CANCEL(__a__) (((__a__)->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL) && ((__a__)->manufacturer_features & MANUFACTURER_FEATURE_OK_FC_LABEL) && (diva_xdi_extended_features & DIVA_CAPI_XDI_PROVIDES_NO_CANCEL))
69 
70 /*------------------------------------------------------------------*/
71 /* local function prototypes */
72 /*------------------------------------------------------------------*/
73 
74 static void group_optimization(DIVA_CAPI_ADAPTER *a, PLCI *plci);
75 static void set_group_ind_mask(PLCI *plci);
76 static void clear_group_ind_mask_bit(PLCI *plci, word b);
77 static byte test_group_ind_mask_bit(PLCI *plci, word b);
78 void AutomaticLaw(DIVA_CAPI_ADAPTER *);
79 word CapiRelease(word);
80 word CapiRegister(word);
81 word api_put(APPL *, CAPI_MSG *);
82 static word api_parse(byte *, word, byte *, API_PARSE *);
83 static void api_save_msg(API_PARSE *in, byte *format, API_SAVE *out);
84 static void api_load_msg(API_SAVE *in, API_PARSE *out);
85 
86 word api_remove_start(void);
87 void api_remove_complete(void);
88 
89 static void plci_remove(PLCI *);
90 static void diva_get_extended_adapter_features(DIVA_CAPI_ADAPTER *a);
91 static void diva_ask_for_xdi_sdram_bar(DIVA_CAPI_ADAPTER *, IDI_SYNC_REQ *);
92 
93 void callback(ENTITY *);
94 
95 static void control_rc(PLCI *, byte, byte, byte, byte, byte);
96 static void data_rc(PLCI *, byte);
97 static void data_ack(PLCI *, byte);
98 static void sig_ind(PLCI *);
99 static void SendInfo(PLCI *, dword, byte **, byte);
100 static void SendSetupInfo(APPL *, PLCI *, dword, byte **, byte);
101 static void SendSSExtInd(APPL *, PLCI *plci, dword Id, byte **parms);
102 
103 static void VSwitchReqInd(PLCI *plci, dword Id, byte **parms);
104 
105 static void nl_ind(PLCI *);
106 
107 static byte connect_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
108 static byte connect_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
109 static byte connect_a_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
110 static byte disconnect_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
111 static byte disconnect_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
112 static byte listen_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
113 static byte info_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
114 static byte info_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
115 static byte alert_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
116 static byte facility_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
117 static byte facility_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
118 static byte connect_b3_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
119 static byte connect_b3_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
120 static byte connect_b3_a_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
121 static byte disconnect_b3_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
122 static byte disconnect_b3_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
123 static byte data_b3_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
124 static byte data_b3_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
125 static byte reset_b3_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
126 static byte reset_b3_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
127 static byte connect_b3_t90_a_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
128 static byte select_b_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
129 static byte manufacturer_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
130 static byte manufacturer_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
131 
132 static word get_plci(DIVA_CAPI_ADAPTER *);
133 static void add_p(PLCI *, byte, byte *);
134 static void add_s(PLCI *plci, byte code, API_PARSE *p);
135 static void add_ss(PLCI *plci, byte code, API_PARSE *p);
136 static void add_ie(PLCI *plci, byte code, byte *p, word p_length);
137 static void add_d(PLCI *, word, byte *);
138 static void add_ai(PLCI *, API_PARSE *);
139 static word add_b1(PLCI *, API_PARSE *, word, word);
140 static word add_b23(PLCI *, API_PARSE *);
141 static word add_modem_b23(PLCI *plci, API_PARSE *bp_parms);
142 static void sig_req(PLCI *, byte, byte);
143 static void nl_req_ncci(PLCI *, byte, byte);
144 static void send_req(PLCI *);
145 static void send_data(PLCI *);
146 static word plci_remove_check(PLCI *);
147 static void listen_check(DIVA_CAPI_ADAPTER *);
148 static byte AddInfo(byte **, byte **, byte *, byte *);
149 static byte getChannel(API_PARSE *);
150 static void IndParse(PLCI *, word *, byte **, byte);
151 static byte ie_compare(byte *, byte *);
152 static word find_cip(DIVA_CAPI_ADAPTER *, byte *, byte *);
153 static word CPN_filter_ok(byte *cpn, DIVA_CAPI_ADAPTER *, word);
154 
155 /*
156  XON protocol helpers
157 */
158 static void channel_flow_control_remove(PLCI *plci);
159 static void channel_x_off(PLCI *plci, byte ch, byte flag);
160 static void channel_x_on(PLCI *plci, byte ch);
161 static void channel_request_xon(PLCI *plci, byte ch);
162 static void channel_xmit_xon(PLCI *plci);
163 static int channel_can_xon(PLCI *plci, byte ch);
164 static void channel_xmit_extended_xon(PLCI *plci);
165 
166 static byte SendMultiIE(PLCI *plci, dword Id, byte **parms, byte ie_type, dword info_mask, byte setupParse);
167 static word AdvCodecSupport(DIVA_CAPI_ADAPTER *, PLCI *, APPL *, byte);
168 static void CodecIdCheck(DIVA_CAPI_ADAPTER *, PLCI *);
169 static void SetVoiceChannel(PLCI *, byte *, DIVA_CAPI_ADAPTER *);
170 static void VoiceChannelOff(PLCI *plci);
171 static void adv_voice_write_coefs(PLCI *plci, word write_command);
172 static void adv_voice_clear_config(PLCI *plci);
173 
174 static word get_b1_facilities(PLCI *plci, byte b1_resource);
175 static byte add_b1_facilities(PLCI *plci, byte b1_resource, word b1_facilities);
176 static void adjust_b1_facilities(PLCI *plci, byte new_b1_resource, word new_b1_facilities);
177 static word adjust_b_process(dword Id, PLCI *plci, byte Rc);
178 static void adjust_b1_resource(dword Id, PLCI *plci, API_SAVE *bp_msg, word b1_facilities, word internal_command);
179 static void adjust_b_restore(dword Id, PLCI *plci, byte Rc);
180 static void reset_b3_command(dword Id, PLCI *plci, byte Rc);
181 static void select_b_command(dword Id, PLCI *plci, byte Rc);
182 static void fax_connect_ack_command(dword Id, PLCI *plci, byte Rc);
183 static void fax_edata_ack_command(dword Id, PLCI *plci, byte Rc);
184 static void fax_connect_info_command(dword Id, PLCI *plci, byte Rc);
185 static void fax_adjust_b23_command(dword Id, PLCI *plci, byte Rc);
186 static void fax_disconnect_command(dword Id, PLCI *plci, byte Rc);
187 static void hold_save_command(dword Id, PLCI *plci, byte Rc);
188 static void retrieve_restore_command(dword Id, PLCI *plci, byte Rc);
189 static void init_b1_config(PLCI *plci);
190 static void clear_b1_config(PLCI *plci);
191 
192 static void dtmf_command(dword Id, PLCI *plci, byte Rc);
193 static byte dtmf_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg);
194 static void dtmf_confirmation(dword Id, PLCI *plci);
195 static void dtmf_indication(dword Id, PLCI *plci, byte *msg, word length);
196 static void dtmf_parameter_write(PLCI *plci);
197 
198 
199 static void mixer_set_bchannel_id_esc(PLCI *plci, byte bchannel_id);
200 static void mixer_set_bchannel_id(PLCI *plci, byte *chi);
201 static void mixer_clear_config(PLCI *plci);
202 static void mixer_notify_update(PLCI *plci, byte others);
203 static void mixer_command(dword Id, PLCI *plci, byte Rc);
204 static byte mixer_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg);
205 static void mixer_indication_coefs_set(dword Id, PLCI *plci);
206 static void mixer_indication_xconnect_from(dword Id, PLCI *plci, byte *msg, word length);
207 static void mixer_indication_xconnect_to(dword Id, PLCI *plci, byte *msg, word length);
208 static void mixer_remove(PLCI *plci);
209 
210 
211 static void ec_command(dword Id, PLCI *plci, byte Rc);
212 static byte ec_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg);
213 static void ec_indication(dword Id, PLCI *plci, byte *msg, word length);
214 
215 
216 static void rtp_connect_b3_req_command(dword Id, PLCI *plci, byte Rc);
217 static void rtp_connect_b3_res_command(dword Id, PLCI *plci, byte Rc);
218 
219 
220 static int diva_get_dma_descriptor(PLCI *plci, dword *dma_magic);
221 static void diva_free_dma_descriptor(PLCI *plci, int nr);
222 
223 /*------------------------------------------------------------------*/
224 /* external function prototypes */
225 /*------------------------------------------------------------------*/
226 
227 extern byte MapController(byte);
228 extern byte UnMapController(byte);
229 #define MapId(Id)(((Id) & 0xffffff00L) | MapController((byte)(Id)))
230 #define UnMapId(Id)(((Id) & 0xffffff00L) | UnMapController((byte)(Id)))
231 
232 void sendf(APPL *, word, dword, word, byte *, ...);
233 void *TransmitBufferSet(APPL *appl, dword ref);
234 void *TransmitBufferGet(APPL *appl, void *p);
235 void TransmitBufferFree(APPL *appl, void *p);
236 void *ReceiveBufferGet(APPL *appl, int Num);
237 
238 int fax_head_line_time(char *buffer);
239 
240 
241 /*------------------------------------------------------------------*/
242 /* Global data definitions */
243 /*------------------------------------------------------------------*/
244 extern byte max_adapter;
245 extern byte max_appl;
246 extern DIVA_CAPI_ADAPTER *adapter;
247 extern APPL *application;
248 
249 
250 
251 
252 
253 
254 
255 static byte remove_started = false;
256 static PLCI dummy_plci;
257 
258 
259 static struct _ftable {
260  word command;
261  byte *format;
262  byte (*function)(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
263 } ftable[] = {
264  {_DATA_B3_R, "dwww", data_b3_req},
265  {_DATA_B3_I | RESPONSE, "w", data_b3_res},
266  {_INFO_R, "ss", info_req},
267  {_INFO_I | RESPONSE, "", info_res},
268  {_CONNECT_R, "wsssssssss", connect_req},
269  {_CONNECT_I | RESPONSE, "wsssss", connect_res},
270  {_CONNECT_ACTIVE_I | RESPONSE, "", connect_a_res},
271  {_DISCONNECT_R, "s", disconnect_req},
272  {_DISCONNECT_I | RESPONSE, "", disconnect_res},
273  {_LISTEN_R, "dddss", listen_req},
274  {_ALERT_R, "s", alert_req},
275  {_FACILITY_R, "ws", facility_req},
276  {_FACILITY_I | RESPONSE, "ws", facility_res},
277  {_CONNECT_B3_R, "s", connect_b3_req},
278  {_CONNECT_B3_I | RESPONSE, "ws", connect_b3_res},
279  {_CONNECT_B3_ACTIVE_I | RESPONSE, "", connect_b3_a_res},
280  {_DISCONNECT_B3_R, "s", disconnect_b3_req},
281  {_DISCONNECT_B3_I | RESPONSE, "", disconnect_b3_res},
282  {_RESET_B3_R, "s", reset_b3_req},
283  {_RESET_B3_I | RESPONSE, "", reset_b3_res},
284  {_CONNECT_B3_T90_ACTIVE_I | RESPONSE, "ws", connect_b3_t90_a_res},
285  {_CONNECT_B3_T90_ACTIVE_I | RESPONSE, "", connect_b3_t90_a_res},
286  {_SELECT_B_REQ, "s", select_b_req},
287  {_MANUFACTURER_R, "dws", manufacturer_req},
288  {_MANUFACTURER_I | RESPONSE, "dws", manufacturer_res},
289  {_MANUFACTURER_I | RESPONSE, "", manufacturer_res}
290 };
291 
292 static byte *cip_bc[29][2] = {
293  { "", "" }, /* 0 */
294  { "\x03\x80\x90\xa3", "\x03\x80\x90\xa2" }, /* 1 */
295  { "\x02\x88\x90", "\x02\x88\x90" }, /* 2 */
296  { "\x02\x89\x90", "\x02\x89\x90" }, /* 3 */
297  { "\x03\x90\x90\xa3", "\x03\x90\x90\xa2" }, /* 4 */
298  { "\x03\x91\x90\xa5", "\x03\x91\x90\xa5" }, /* 5 */
299  { "\x02\x98\x90", "\x02\x98\x90" }, /* 6 */
300  { "\x04\x88\xc0\xc6\xe6", "\x04\x88\xc0\xc6\xe6" }, /* 7 */
301  { "\x04\x88\x90\x21\x8f", "\x04\x88\x90\x21\x8f" }, /* 8 */
302  { "\x03\x91\x90\xa5", "\x03\x91\x90\xa5" }, /* 9 */
303  { "", "" }, /* 10 */
304  { "", "" }, /* 11 */
305  { "", "" }, /* 12 */
306  { "", "" }, /* 13 */
307  { "", "" }, /* 14 */
308  { "", "" }, /* 15 */
309 
310  { "\x03\x80\x90\xa3", "\x03\x80\x90\xa2" }, /* 16 */
311  { "\x03\x90\x90\xa3", "\x03\x90\x90\xa2" }, /* 17 */
312  { "\x02\x88\x90", "\x02\x88\x90" }, /* 18 */
313  { "\x02\x88\x90", "\x02\x88\x90" }, /* 19 */
314  { "\x02\x88\x90", "\x02\x88\x90" }, /* 20 */
315  { "\x02\x88\x90", "\x02\x88\x90" }, /* 21 */
316  { "\x02\x88\x90", "\x02\x88\x90" }, /* 22 */
317  { "\x02\x88\x90", "\x02\x88\x90" }, /* 23 */
318  { "\x02\x88\x90", "\x02\x88\x90" }, /* 24 */
319  { "\x02\x88\x90", "\x02\x88\x90" }, /* 25 */
320  { "\x03\x91\x90\xa5", "\x03\x91\x90\xa5" }, /* 26 */
321  { "\x03\x91\x90\xa5", "\x03\x91\x90\xa5" }, /* 27 */
322  { "\x02\x88\x90", "\x02\x88\x90" } /* 28 */
323 };
324 
325 static byte *cip_hlc[29] = {
326  "", /* 0 */
327  "", /* 1 */
328  "", /* 2 */
329  "", /* 3 */
330  "", /* 4 */
331  "", /* 5 */
332  "", /* 6 */
333  "", /* 7 */
334  "", /* 8 */
335  "", /* 9 */
336  "", /* 10 */
337  "", /* 11 */
338  "", /* 12 */
339  "", /* 13 */
340  "", /* 14 */
341  "", /* 15 */
342 
343  "\x02\x91\x81", /* 16 */
344  "\x02\x91\x84", /* 17 */
345  "\x02\x91\xa1", /* 18 */
346  "\x02\x91\xa4", /* 19 */
347  "\x02\x91\xa8", /* 20 */
348  "\x02\x91\xb1", /* 21 */
349  "\x02\x91\xb2", /* 22 */
350  "\x02\x91\xb5", /* 23 */
351  "\x02\x91\xb8", /* 24 */
352  "\x02\x91\xc1", /* 25 */
353  "\x02\x91\x81", /* 26 */
354  "\x03\x91\xe0\x01", /* 27 */
355  "\x03\x91\xe0\x02" /* 28 */
356 };
357 
358 /*------------------------------------------------------------------*/
359 
360 #define V120_HEADER_LENGTH 1
361 #define V120_HEADER_EXTEND_BIT 0x80
362 #define V120_HEADER_BREAK_BIT 0x40
363 #define V120_HEADER_C1_BIT 0x04
364 #define V120_HEADER_C2_BIT 0x08
365 #define V120_HEADER_FLUSH_COND (V120_HEADER_BREAK_BIT | V120_HEADER_C1_BIT | V120_HEADER_C2_BIT)
366 
367 static byte v120_default_header[] =
368 {
369 
370  0x83 /* Ext, BR , res, res, C2 , C1 , B , F */
371 
372 };
373 
374 static byte v120_break_header[] =
375 {
376 
377  0xc3 | V120_HEADER_BREAK_BIT /* Ext, BR , res, res, C2 , C1 , B , F */
378 
379 };
380 
381 
382 /*------------------------------------------------------------------*/
383 /* API_PUT function */
384 /*------------------------------------------------------------------*/
385 
386 word api_put(APPL *appl, CAPI_MSG *msg)
387 {
388  word i, j, k, l, n;
389  word ret;
390  byte c;
391  byte controller;
392  DIVA_CAPI_ADAPTER *a;
393  PLCI *plci;
394  NCCI *ncci_ptr;
395  word ncci;
396  CAPI_MSG *m;
397  API_PARSE msg_parms[MAX_MSG_PARMS + 1];
398 
399  if (msg->header.length < sizeof(msg->header) ||
400  msg->header.length > MAX_MSG_SIZE) {
401  dbug(1, dprintf("bad len"));
402  return _BAD_MSG;
403  }
404 
405  controller = (byte)((msg->header.controller & 0x7f) - 1);
406 
407  /* controller starts with 0 up to (max_adapter - 1) */
408  if (controller >= max_adapter)
409  {
410  dbug(1, dprintf("invalid ctrl"));
411  return _BAD_MSG;
412  }
413 
414  a = &adapter[controller];
415  plci = NULL;
416  if ((msg->header.plci != 0) && (msg->header.plci <= a->max_plci) && !a->adapter_disabled)
417  {
418  dbug(1, dprintf("plci=%x", msg->header.plci));
419  plci = &a->plci[msg->header.plci - 1];
420  ncci = GET_WORD(&msg->header.ncci);
421  if (plci->Id
422  && (plci->appl
423  || (plci->State == INC_CON_PENDING)
424  || (plci->State == INC_CON_ALERT)
425  || (msg->header.command == (_DISCONNECT_I | RESPONSE)))
426  && ((ncci == 0)
427  || (msg->header.command == (_DISCONNECT_B3_I | RESPONSE))
428  || ((ncci < MAX_NCCI + 1) && (a->ncci_plci[ncci] == plci->Id))))
429  {
430  i = plci->msg_in_read_pos;
431  j = plci->msg_in_write_pos;
432  if (j >= i)
433  {
434  if (j + msg->header.length + MSG_IN_OVERHEAD <= MSG_IN_QUEUE_SIZE)
435  i += MSG_IN_QUEUE_SIZE - j;
436  else
437  j = 0;
438  }
439  else
440  {
441 
442  n = (((CAPI_MSG *)(plci->msg_in_queue))->header.length + MSG_IN_OVERHEAD + 3) & 0xfffc;
443 
444  if (i > MSG_IN_QUEUE_SIZE - n)
445  i = MSG_IN_QUEUE_SIZE - n + 1;
446  i -= j;
447  }
448 
449  if (i <= ((msg->header.length + MSG_IN_OVERHEAD + 3) & 0xfffc))
450 
451  {
452  dbug(0, dprintf("Q-FULL1(msg) - len=%d write=%d read=%d wrap=%d free=%d",
453  msg->header.length, plci->msg_in_write_pos,
454  plci->msg_in_read_pos, plci->msg_in_wrap_pos, i));
455 
456  return _QUEUE_FULL;
457  }
458  c = false;
459  if ((((byte *) msg) < ((byte *)(plci->msg_in_queue)))
460  || (((byte *) msg) >= ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
461  {
462  if (plci->msg_in_write_pos != plci->msg_in_read_pos)
463  c = true;
464  }
465  if (msg->header.command == _DATA_B3_R)
466  {
467  if (msg->header.length < 20)
468  {
469  dbug(1, dprintf("DATA_B3 REQ wrong length %d", msg->header.length));
470  return _BAD_MSG;
471  }
472  ncci_ptr = &(a->ncci[ncci]);
473  n = ncci_ptr->data_pending;
474  l = ncci_ptr->data_ack_pending;
475  k = plci->msg_in_read_pos;
476  while (k != plci->msg_in_write_pos)
477  {
478  if (k == plci->msg_in_wrap_pos)
479  k = 0;
480  if ((((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[k]))->header.command == _DATA_B3_R)
481  && (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[k]))->header.ncci == ncci))
482  {
483  n++;
484  if (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[k]))->info.data_b3_req.Flags & 0x0004)
485  l++;
486  }
487 
488  k += (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[k]))->header.length +
489  MSG_IN_OVERHEAD + 3) & 0xfffc;
490 
491  }
492  if ((n >= MAX_DATA_B3) || (l >= MAX_DATA_ACK))
493  {
494  dbug(0, dprintf("Q-FULL2(data) - pending=%d/%d ack_pending=%d/%d",
495  ncci_ptr->data_pending, n, ncci_ptr->data_ack_pending, l));
496 
497  return _QUEUE_FULL;
498  }
499  if (plci->req_in || plci->internal_command)
500  {
501  if ((((byte *) msg) >= ((byte *)(plci->msg_in_queue)))
502  && (((byte *) msg) < ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
503  {
504  dbug(0, dprintf("Q-FULL3(requeue)"));
505 
506  return _QUEUE_FULL;
507  }
508  c = true;
509  }
510  }
511  else
512  {
513  if (plci->req_in || plci->internal_command)
514  c = true;
515  else
516  {
517  plci->command = msg->header.command;
518  plci->number = msg->header.number;
519  }
520  }
521  if (c)
522  {
523  dbug(1, dprintf("enqueue msg(0x%04x,0x%x,0x%x) - len=%d write=%d read=%d wrap=%d free=%d",
524  msg->header.command, plci->req_in, plci->internal_command,
525  msg->header.length, plci->msg_in_write_pos,
526  plci->msg_in_read_pos, plci->msg_in_wrap_pos, i));
527  if (j == 0)
528  plci->msg_in_wrap_pos = plci->msg_in_write_pos;
529  m = (CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[j]);
530  for (i = 0; i < msg->header.length; i++)
531  ((byte *)(plci->msg_in_queue))[j++] = ((byte *) msg)[i];
532  if (m->header.command == _DATA_B3_R)
533  {
534 
535  m->info.data_b3_req.Data = (dword)(long)(TransmitBufferSet(appl, m->info.data_b3_req.Data));
536 
537  }
538 
539  j = (j + 3) & 0xfffc;
540 
541  *((APPL **)(&((byte *)(plci->msg_in_queue))[j])) = appl;
542  plci->msg_in_write_pos = j + MSG_IN_OVERHEAD;
543  return 0;
544  }
545  }
546  else
547  {
548  plci = NULL;
549  }
550  }
551  dbug(1, dprintf("com=%x", msg->header.command));
552 
553  for (j = 0; j < MAX_MSG_PARMS + 1; j++) msg_parms[j].length = 0;
554  for (i = 0, ret = _BAD_MSG; i < ARRAY_SIZE(ftable); i++) {
555 
556  if (ftable[i].command == msg->header.command) {
557  /* break loop if the message is correct, otherwise continue scan */
558  /* (for example: CONNECT_B3_T90_ACT_RES has two specifications) */
559  if (!api_parse(msg->info.b, (word)(msg->header.length - 12), ftable[i].format, msg_parms)) {
560  ret = 0;
561  break;
562  }
563  for (j = 0; j < MAX_MSG_PARMS + 1; j++) msg_parms[j].length = 0;
564  }
565  }
566  if (ret) {
567  dbug(1, dprintf("BAD_MSG"));
568  if (plci) plci->command = 0;
569  return ret;
570  }
571 
572 
573  c = ftable[i].function(GET_DWORD(&msg->header.controller),
574  msg->header.number,
575  a,
576  plci,
577  appl,
578  msg_parms);
579 
580  channel_xmit_extended_xon(plci);
581 
582  if (c == 1) send_req(plci);
583  if (c == 2 && plci) plci->req_in = plci->req_in_start = plci->req_out = 0;
584  if (plci && !plci->req_in) plci->command = 0;
585  return 0;
586 }
587 
588 
589 /*------------------------------------------------------------------*/
590 /* api_parse function, check the format of api messages */
591 /*------------------------------------------------------------------*/
592 
593 static word api_parse(byte *msg, word length, byte *format, API_PARSE *parms)
594 {
595  word i;
596  word p;
597 
598  for (i = 0, p = 0; format[i]; i++) {
599  if (parms)
600  {
601  parms[i].info = &msg[p];
602  }
603  switch (format[i]) {
604  case 'b':
605  p += 1;
606  break;
607  case 'w':
608  p += 2;
609  break;
610  case 'd':
611  p += 4;
612  break;
613  case 's':
614  if (msg[p] == 0xff) {
615  parms[i].info += 2;
616  parms[i].length = msg[p + 1] + (msg[p + 2] << 8);
617  p += (parms[i].length + 3);
618  }
619  else {
620  parms[i].length = msg[p];
621  p += (parms[i].length + 1);
622  }
623  break;
624  }
625 
626  if (p > length) return true;
627  }
628  if (parms) parms[i].info = NULL;
629  return false;
630 }
631 
632 static void api_save_msg(API_PARSE *in, byte *format, API_SAVE *out)
633 {
634  word i, j, n = 0;
635  byte *p;
636 
637  p = out->info;
638  for (i = 0; format[i] != '\0'; i++)
639  {
640  out->parms[i].info = p;
641  out->parms[i].length = in[i].length;
642  switch (format[i])
643  {
644  case 'b':
645  n = 1;
646  break;
647  case 'w':
648  n = 2;
649  break;
650  case 'd':
651  n = 4;
652  break;
653  case 's':
654  n = in[i].length + 1;
655  break;
656  }
657  for (j = 0; j < n; j++)
658  *(p++) = in[i].info[j];
659  }
660  out->parms[i].info = NULL;
661  out->parms[i].length = 0;
662 }
663 
664 static void api_load_msg(API_SAVE *in, API_PARSE *out)
665 {
666  word i;
667 
668  i = 0;
669  do
670  {
671  out[i].info = in->parms[i].info;
672  out[i].length = in->parms[i].length;
673  } while (in->parms[i++].info);
674 }
675 
676 
677 /*------------------------------------------------------------------*/
678 /* CAPI remove function */
679 /*------------------------------------------------------------------*/
680 
681 word api_remove_start(void)
682 {
683  word i;
684  word j;
685 
686  if (!remove_started) {
687  remove_started = true;
688  for (i = 0; i < max_adapter; i++) {
689  if (adapter[i].request) {
690  for (j = 0; j < adapter[i].max_plci; j++) {
691  if (adapter[i].plci[j].Sig.Id) plci_remove(&adapter[i].plci[j]);
692  }
693  }
694  }
695  return 1;
696  }
697  else {
698  for (i = 0; i < max_adapter; i++) {
699  if (adapter[i].request) {
700  for (j = 0; j < adapter[i].max_plci; j++) {
701  if (adapter[i].plci[j].Sig.Id) return 1;
702  }
703  }
704  }
705  }
706  api_remove_complete();
707  return 0;
708 }
709 
710 
711 /*------------------------------------------------------------------*/
712 /* internal command queue */
713 /*------------------------------------------------------------------*/
714 
715 static void init_internal_command_queue(PLCI *plci)
716 {
717  word i;
718 
719  dbug(1, dprintf("%s,%d: init_internal_command_queue",
720  (char *)(FILE_), __LINE__));
721 
722  plci->internal_command = 0;
723  for (i = 0; i < MAX_INTERNAL_COMMAND_LEVELS; i++)
724  plci->internal_command_queue[i] = NULL;
725 }
726 
727 
728 static void start_internal_command(dword Id, PLCI *plci, t_std_internal_command command_function)
729 {
730  word i;
731 
732  dbug(1, dprintf("[%06lx] %s,%d: start_internal_command",
733  UnMapId(Id), (char *)(FILE_), __LINE__));
734 
735  if (plci->internal_command == 0)
736  {
737  plci->internal_command_queue[0] = command_function;
738  (*command_function)(Id, plci, OK);
739  }
740  else
741  {
742  i = 1;
743  while (plci->internal_command_queue[i] != NULL)
744  i++;
745  plci->internal_command_queue[i] = command_function;
746  }
747 }
748 
749 
750 static void next_internal_command(dword Id, PLCI *plci)
751 {
752  word i;
753 
754  dbug(1, dprintf("[%06lx] %s,%d: next_internal_command",
755  UnMapId(Id), (char *)(FILE_), __LINE__));
756 
757  plci->internal_command = 0;
758  plci->internal_command_queue[0] = NULL;
759  while (plci->internal_command_queue[1] != NULL)
760  {
761  for (i = 0; i < MAX_INTERNAL_COMMAND_LEVELS - 1; i++)
762  plci->internal_command_queue[i] = plci->internal_command_queue[i + 1];
763  plci->internal_command_queue[MAX_INTERNAL_COMMAND_LEVELS - 1] = NULL;
764  (*(plci->internal_command_queue[0]))(Id, plci, OK);
765  if (plci->internal_command != 0)
766  return;
767  plci->internal_command_queue[0] = NULL;
768  }
769 }
770 
771 
772 /*------------------------------------------------------------------*/
773 /* NCCI allocate/remove function */
774 /*------------------------------------------------------------------*/
775 
776 static dword ncci_mapping_bug = 0;
777 
778 static word get_ncci(PLCI *plci, byte ch, word force_ncci)
779 {
780  DIVA_CAPI_ADAPTER *a;
781  word ncci, i, j, k;
782 
783  a = plci->adapter;
784  if (!ch || a->ch_ncci[ch])
785  {
786  ncci_mapping_bug++;
787  dbug(1, dprintf("NCCI mapping exists %ld %02x %02x %02x-%02x",
788  ncci_mapping_bug, ch, force_ncci, a->ncci_ch[a->ch_ncci[ch]], a->ch_ncci[ch]));
789  ncci = ch;
790  }
791  else
792  {
793  if (force_ncci)
794  ncci = force_ncci;
795  else
796  {
797  if ((ch < MAX_NCCI + 1) && !a->ncci_ch[ch])
798  ncci = ch;
799  else
800  {
801  ncci = 1;
802  while ((ncci < MAX_NCCI + 1) && a->ncci_ch[ncci])
803  ncci++;
804  if (ncci == MAX_NCCI + 1)
805  {
806  ncci_mapping_bug++;
807  i = 1;
808  do
809  {
810  j = 1;
811  while ((j < MAX_NCCI + 1) && (a->ncci_ch[j] != i))
812  j++;
813  k = j;
814  if (j < MAX_NCCI + 1)
815  {
816  do
817  {
818  j++;
819  } while ((j < MAX_NCCI + 1) && (a->ncci_ch[j] != i));
820  }
821  } while ((i < MAX_NL_CHANNEL + 1) && (j < MAX_NCCI + 1));
822  if (i < MAX_NL_CHANNEL + 1)
823  {
824  dbug(1, dprintf("NCCI mapping overflow %ld %02x %02x %02x-%02x-%02x",
825  ncci_mapping_bug, ch, force_ncci, i, k, j));
826  }
827  else
828  {
829  dbug(1, dprintf("NCCI mapping overflow %ld %02x %02x",
830  ncci_mapping_bug, ch, force_ncci));
831  }
832  ncci = ch;
833  }
834  }
835  a->ncci_plci[ncci] = plci->Id;
836  a->ncci_state[ncci] = IDLE;
837  if (!plci->ncci_ring_list)
838  plci->ncci_ring_list = ncci;
839  else
840  a->ncci_next[ncci] = a->ncci_next[plci->ncci_ring_list];
841  a->ncci_next[plci->ncci_ring_list] = (byte) ncci;
842  }
843  a->ncci_ch[ncci] = ch;
844  a->ch_ncci[ch] = (byte) ncci;
845  dbug(1, dprintf("NCCI mapping established %ld %02x %02x %02x-%02x",
846  ncci_mapping_bug, ch, force_ncci, ch, ncci));
847  }
848  return (ncci);
849 }
850 
851 
852 static void ncci_free_receive_buffers(PLCI *plci, word ncci)
853 {
854  DIVA_CAPI_ADAPTER *a;
855  APPL *appl;
856  word i, ncci_code;
857  dword Id;
858 
859  a = plci->adapter;
860  Id = (((dword) ncci) << 16) | (((word)(plci->Id)) << 8) | a->Id;
861  if (ncci)
862  {
863  if (a->ncci_plci[ncci] == plci->Id)
864  {
865  if (!plci->appl)
866  {
867  ncci_mapping_bug++;
868  dbug(1, dprintf("NCCI mapping appl expected %ld %08lx",
869  ncci_mapping_bug, Id));
870  }
871  else
872  {
873  appl = plci->appl;
874  ncci_code = ncci | (((word) a->Id) << 8);
875  for (i = 0; i < appl->MaxBuffer; i++)
876  {
877  if ((appl->DataNCCI[i] == ncci_code)
878  && (((byte)(appl->DataFlags[i] >> 8)) == plci->Id))
879  {
880  appl->DataNCCI[i] = 0;
881  }
882  }
883  }
884  }
885  }
886  else
887  {
888  for (ncci = 1; ncci < MAX_NCCI + 1; ncci++)
889  {
890  if (a->ncci_plci[ncci] == plci->Id)
891  {
892  if (!plci->appl)
893  {
894  ncci_mapping_bug++;
895  dbug(1, dprintf("NCCI mapping no appl %ld %08lx",
896  ncci_mapping_bug, Id));
897  }
898  else
899  {
900  appl = plci->appl;
901  ncci_code = ncci | (((word) a->Id) << 8);
902  for (i = 0; i < appl->MaxBuffer; i++)
903  {
904  if ((appl->DataNCCI[i] == ncci_code)
905  && (((byte)(appl->DataFlags[i] >> 8)) == plci->Id))
906  {
907  appl->DataNCCI[i] = 0;
908  }
909  }
910  }
911  }
912  }
913  }
914 }
915 
916 
917 static void cleanup_ncci_data(PLCI *plci, word ncci)
918 {
919  NCCI *ncci_ptr;
920 
921  if (ncci && (plci->adapter->ncci_plci[ncci] == plci->Id))
922  {
923  ncci_ptr = &(plci->adapter->ncci[ncci]);
924  if (plci->appl)
925  {
926  while (ncci_ptr->data_pending != 0)
927  {
928  if (!plci->data_sent || (ncci_ptr->DBuffer[ncci_ptr->data_out].P != plci->data_sent_ptr))
929  TransmitBufferFree(plci->appl, ncci_ptr->DBuffer[ncci_ptr->data_out].P);
930  (ncci_ptr->data_out)++;
931  if (ncci_ptr->data_out == MAX_DATA_B3)
932  ncci_ptr->data_out = 0;
933  (ncci_ptr->data_pending)--;
934  }
935  }
936  ncci_ptr->data_out = 0;
937  ncci_ptr->data_pending = 0;
938  ncci_ptr->data_ack_out = 0;
939  ncci_ptr->data_ack_pending = 0;
940  }
941 }
942 
943 
944 static void ncci_remove(PLCI *plci, word ncci, byte preserve_ncci)
945 {
946  DIVA_CAPI_ADAPTER *a;
947  dword Id;
948  word i;
949 
950  a = plci->adapter;
951  Id = (((dword) ncci) << 16) | (((word)(plci->Id)) << 8) | a->Id;
952  if (!preserve_ncci)
953  ncci_free_receive_buffers(plci, ncci);
954  if (ncci)
955  {
956  if (a->ncci_plci[ncci] != plci->Id)
957  {
958  ncci_mapping_bug++;
959  dbug(1, dprintf("NCCI mapping doesn't exist %ld %08lx %02x",
960  ncci_mapping_bug, Id, preserve_ncci));
961  }
962  else
963  {
964  cleanup_ncci_data(plci, ncci);
965  dbug(1, dprintf("NCCI mapping released %ld %08lx %02x %02x-%02x",
966  ncci_mapping_bug, Id, preserve_ncci, a->ncci_ch[ncci], ncci));
967  a->ch_ncci[a->ncci_ch[ncci]] = 0;
968  if (!preserve_ncci)
969  {
970  a->ncci_ch[ncci] = 0;
971  a->ncci_plci[ncci] = 0;
972  a->ncci_state[ncci] = IDLE;
973  i = plci->ncci_ring_list;
974  while ((i != 0) && (a->ncci_next[i] != plci->ncci_ring_list) && (a->ncci_next[i] != ncci))
975  i = a->ncci_next[i];
976  if ((i != 0) && (a->ncci_next[i] == ncci))
977  {
978  if (i == ncci)
979  plci->ncci_ring_list = 0;
980  else if (plci->ncci_ring_list == ncci)
981  plci->ncci_ring_list = i;
982  a->ncci_next[i] = a->ncci_next[ncci];
983  }
984  a->ncci_next[ncci] = 0;
985  }
986  }
987  }
988  else
989  {
990  for (ncci = 1; ncci < MAX_NCCI + 1; ncci++)
991  {
992  if (a->ncci_plci[ncci] == plci->Id)
993  {
994  cleanup_ncci_data(plci, ncci);
995  dbug(1, dprintf("NCCI mapping released %ld %08lx %02x %02x-%02x",
996  ncci_mapping_bug, Id, preserve_ncci, a->ncci_ch[ncci], ncci));
997  a->ch_ncci[a->ncci_ch[ncci]] = 0;
998  if (!preserve_ncci)
999  {
1000  a->ncci_ch[ncci] = 0;
1001  a->ncci_plci[ncci] = 0;
1002  a->ncci_state[ncci] = IDLE;
1003  a->ncci_next[ncci] = 0;
1004  }
1005  }
1006  }
1007  if (!preserve_ncci)
1008  plci->ncci_ring_list = 0;
1009  }
1010 }
1011 
1012 
1013 /*------------------------------------------------------------------*/
1014 /* PLCI remove function */
1015 /*------------------------------------------------------------------*/
1016 
1017 static void plci_free_msg_in_queue(PLCI *plci)
1018 {
1019  word i;
1020 
1021  if (plci->appl)
1022  {
1023  i = plci->msg_in_read_pos;
1024  while (i != plci->msg_in_write_pos)
1025  {
1026  if (i == plci->msg_in_wrap_pos)
1027  i = 0;
1028  if (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[i]))->header.command == _DATA_B3_R)
1029  {
1030 
1031  TransmitBufferFree(plci->appl,
1032  (byte *)(long)(((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[i]))->info.data_b3_req.Data));
1033 
1034  }
1035 
1036  i += (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[i]))->header.length +
1037  MSG_IN_OVERHEAD + 3) & 0xfffc;
1038 
1039  }
1040  }
1041  plci->msg_in_write_pos = MSG_IN_QUEUE_SIZE;
1042  plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
1043  plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
1044 }
1045 
1046 
1047 static void plci_remove(PLCI *plci)
1048 {
1049 
1050  if (!plci) {
1051  dbug(1, dprintf("plci_remove(no plci)"));
1052  return;
1053  }
1054  init_internal_command_queue(plci);
1055  dbug(1, dprintf("plci_remove(%x,tel=%x)", plci->Id, plci->tel));
1056  if (plci_remove_check(plci))
1057  {
1058  return;
1059  }
1060  if (plci->Sig.Id == 0xff)
1061  {
1062  dbug(1, dprintf("D-channel X.25 plci->NL.Id:%0x", plci->NL.Id));
1063  if (plci->NL.Id && !plci->nl_remove_id)
1064  {
1065  nl_req_ncci(plci, REMOVE, 0);
1066  send_req(plci);
1067  }
1068  }
1069  else
1070  {
1071  if (!plci->sig_remove_id
1072  && (plci->Sig.Id
1073  || (plci->req_in != plci->req_out)
1074  || (plci->nl_req || plci->sig_req)))
1075  {
1076  sig_req(plci, HANGUP, 0);
1077  send_req(plci);
1078  }
1079  }
1080  ncci_remove(plci, 0, false);
1081  plci_free_msg_in_queue(plci);
1082 
1083  plci->channels = 0;
1084  plci->appl = NULL;
1085  if ((plci->State == INC_CON_PENDING) || (plci->State == INC_CON_ALERT))
1086  plci->State = OUTG_DIS_PENDING;
1087 }
1088 
1089 /*------------------------------------------------------------------*/
1090 /* Application Group function helpers */
1091 /*------------------------------------------------------------------*/
1092 
1093 static void set_group_ind_mask(PLCI *plci)
1094 {
1095  word i;
1096 
1097  for (i = 0; i < C_IND_MASK_DWORDS; i++)
1098  plci->group_optimization_mask_table[i] = 0xffffffffL;
1099 }
1100 
1101 static void clear_group_ind_mask_bit(PLCI *plci, word b)
1102 {
1103  plci->group_optimization_mask_table[b >> 5] &= ~(1L << (b & 0x1f));
1104 }
1105 
1106 static byte test_group_ind_mask_bit(PLCI *plci, word b)
1107 {
1108  return ((plci->group_optimization_mask_table[b >> 5] & (1L << (b & 0x1f))) != 0);
1109 }
1110 
1111 /*------------------------------------------------------------------*/
1112 /* c_ind_mask operations for arbitrary MAX_APPL */
1113 /*------------------------------------------------------------------*/
1114 
1115 static void clear_c_ind_mask(PLCI *plci)
1116 {
1117  word i;
1118 
1119  for (i = 0; i < C_IND_MASK_DWORDS; i++)
1120  plci->c_ind_mask_table[i] = 0;
1121 }
1122 
1123 static byte c_ind_mask_empty(PLCI *plci)
1124 {
1125  word i;
1126 
1127  i = 0;
1128  while ((i < C_IND_MASK_DWORDS) && (plci->c_ind_mask_table[i] == 0))
1129  i++;
1130  return (i == C_IND_MASK_DWORDS);
1131 }
1132 
1133 static void set_c_ind_mask_bit(PLCI *plci, word b)
1134 {
1135  plci->c_ind_mask_table[b >> 5] |= (1L << (b & 0x1f));
1136 }
1137 
1138 static void clear_c_ind_mask_bit(PLCI *plci, word b)
1139 {
1140  plci->c_ind_mask_table[b >> 5] &= ~(1L << (b & 0x1f));
1141 }
1142 
1143 static byte test_c_ind_mask_bit(PLCI *plci, word b)
1144 {
1145  return ((plci->c_ind_mask_table[b >> 5] & (1L << (b & 0x1f))) != 0);
1146 }
1147 
1148 static void dump_c_ind_mask(PLCI *plci)
1149 {
1150  static char hex_digit_table[0x10] =
1151  {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
1152  word i, j, k;
1153  dword d;
1154  char *p;
1155  char buf[40];
1156 
1157  for (i = 0; i < C_IND_MASK_DWORDS; i += 4)
1158  {
1159  p = buf + 36;
1160  *p = '\0';
1161  for (j = 0; j < 4; j++)
1162  {
1163  if (i + j < C_IND_MASK_DWORDS)
1164  {
1165  d = plci->c_ind_mask_table[i + j];
1166  for (k = 0; k < 8; k++)
1167  {
1168  *(--p) = hex_digit_table[d & 0xf];
1169  d >>= 4;
1170  }
1171  }
1172  else if (i != 0)
1173  {
1174  for (k = 0; k < 8; k++)
1175  *(--p) = ' ';
1176  }
1177  *(--p) = ' ';
1178  }
1179  dbug(1, dprintf("c_ind_mask =%s", (char *) p));
1180  }
1181 }
1182 
1183 
1184 
1185 
1186 
1187 #define dump_plcis(a)
1188 
1189 
1190 
1191 /*------------------------------------------------------------------*/
1192 /* translation function for each message */
1193 /*------------------------------------------------------------------*/
1194 
1195 static byte connect_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1196  PLCI *plci, APPL *appl, API_PARSE *parms)
1197 {
1198  word ch;
1199  word i;
1200  word Info;
1201  byte LinkLayer;
1202  API_PARSE *ai;
1203  API_PARSE *bp;
1204  API_PARSE ai_parms[5];
1205  word channel = 0;
1206  dword ch_mask;
1207  byte m;
1208  static byte esc_chi[35] = {0x02, 0x18, 0x01};
1209  static byte lli[2] = {0x01, 0x00};
1210  byte noCh = 0;
1211  word dir = 0;
1212  byte *p_chi = "";
1213 
1214  for (i = 0; i < 5; i++) ai_parms[i].length = 0;
1215 
1216  dbug(1, dprintf("connect_req(%d)", parms->length));
1217  Info = _WRONG_IDENTIFIER;
1218  if (a)
1219  {
1220  if (a->adapter_disabled)
1221  {
1222  dbug(1, dprintf("adapter disabled"));
1223  Id = ((word)1 << 8) | a->Id;
1224  sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", 0);
1225  sendf(appl, _DISCONNECT_I, Id, 0, "w", _L1_ERROR);
1226  return false;
1227  }
1228  Info = _OUT_OF_PLCI;
1229  if ((i = get_plci(a)))
1230  {
1231  Info = 0;
1232  plci = &a->plci[i - 1];
1233  plci->appl = appl;
1234  plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
1235  /* check 'external controller' bit for codec support */
1236  if (Id & EXT_CONTROLLER)
1237  {
1238  if (AdvCodecSupport(a, plci, appl, 0))
1239  {
1240  plci->Id = 0;
1241  sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", _WRONG_IDENTIFIER);
1242  return 2;
1243  }
1244  }
1245  ai = &parms[9];
1246  bp = &parms[5];
1247  ch = 0;
1248  if (bp->length)LinkLayer = bp->info[3];
1249  else LinkLayer = 0;
1250  if (ai->length)
1251  {
1252  ch = 0xffff;
1253  if (!api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms))
1254  {
1255  ch = 0;
1256  if (ai_parms[0].length)
1257  {
1258  ch = GET_WORD(ai_parms[0].info + 1);
1259  if (ch > 4) ch = 0; /* safety -> ignore ChannelID */
1260  if (ch == 4) /* explizit CHI in message */
1261  {
1262  /* check length of B-CH struct */
1263  if ((ai_parms[0].info)[3] >= 1)
1264  {
1265  if ((ai_parms[0].info)[4] == CHI)
1266  {
1267  p_chi = &((ai_parms[0].info)[5]);
1268  }
1269  else
1270  {
1271  p_chi = &((ai_parms[0].info)[3]);
1272  }
1273  if (p_chi[0] > 35) /* check length of channel ID */
1274  {
1275  Info = _WRONG_MESSAGE_FORMAT;
1276  }
1277  }
1278  else Info = _WRONG_MESSAGE_FORMAT;
1279  }
1280 
1281  if (ch == 3 && ai_parms[0].length >= 7 && ai_parms[0].length <= 36)
1282  {
1283  dir = GET_WORD(ai_parms[0].info + 3);
1284  ch_mask = 0;
1285  m = 0x3f;
1286  for (i = 0; i + 5 <= ai_parms[0].length; i++)
1287  {
1288  if (ai_parms[0].info[i + 5] != 0)
1289  {
1290  if ((ai_parms[0].info[i + 5] | m) != 0xff)
1291  Info = _WRONG_MESSAGE_FORMAT;
1292  else
1293  {
1294  if (ch_mask == 0)
1295  channel = i;
1296  ch_mask |= 1L << i;
1297  }
1298  }
1299  m = 0;
1300  }
1301  if (ch_mask == 0)
1302  Info = _WRONG_MESSAGE_FORMAT;
1303  if (!Info)
1304  {
1305  if ((ai_parms[0].length == 36) || (ch_mask != ((dword)(1L << channel))))
1306  {
1307  esc_chi[0] = (byte)(ai_parms[0].length - 2);
1308  for (i = 0; i + 5 <= ai_parms[0].length; i++)
1309  esc_chi[i + 3] = ai_parms[0].info[i + 5];
1310  }
1311  else
1312  esc_chi[0] = 2;
1313  esc_chi[2] = (byte)channel;
1314  plci->b_channel = (byte)channel; /* not correct for ETSI ch 17..31 */
1315  add_p(plci, LLI, lli);
1316  add_p(plci, ESC, esc_chi);
1317  plci->State = LOCAL_CONNECT;
1318  if (!dir) plci->call_dir |= CALL_DIR_FORCE_OUTG_NL; /* dir 0=DTE, 1=DCE */
1319  }
1320  }
1321  }
1322  }
1323  else Info = _WRONG_MESSAGE_FORMAT;
1324  }
1325 
1326  dbug(1, dprintf("ch=%x,dir=%x,p_ch=%d", ch, dir, channel));
1327  plci->command = _CONNECT_R;
1328  plci->number = Number;
1329  /* x.31 or D-ch free SAPI in LinkLayer? */
1330  if (ch == 1 && LinkLayer != 3 && LinkLayer != 12) noCh = true;
1331  if ((ch == 0 || ch == 2 || noCh || ch == 3 || ch == 4) && !Info)
1332  {
1333  /* B-channel used for B3 connections (ch==0), or no B channel */
1334  /* is used (ch==2) or perm. connection (3) is used do a CALL */
1335  if (noCh) Info = add_b1(plci, &parms[5], 2, 0); /* no resource */
1336  else Info = add_b1(plci, &parms[5], ch, 0);
1337  add_s(plci, OAD, &parms[2]);
1338  add_s(plci, OSA, &parms[4]);
1339  add_s(plci, BC, &parms[6]);
1340  add_s(plci, LLC, &parms[7]);
1341  add_s(plci, HLC, &parms[8]);
1342  if (a->Info_Mask[appl->Id - 1] & 0x200)
1343  {
1344  /* early B3 connect (CIP mask bit 9) no release after a disc */
1345  add_p(plci, LLI, "\x01\x01");
1346  }
1347  if (GET_WORD(parms[0].info) < 29) {
1348  add_p(plci, BC, cip_bc[GET_WORD(parms[0].info)][a->u_law]);
1349  add_p(plci, HLC, cip_hlc[GET_WORD(parms[0].info)]);
1350  }
1351  add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
1352  sig_req(plci, ASSIGN, DSIG_ID);
1353  }
1354  else if (ch == 1) {
1355 
1356  /* D-Channel used for B3 connections */
1357  plci->Sig.Id = 0xff;
1358  Info = 0;
1359  }
1360 
1361  if (!Info && ch != 2 && !noCh) {
1362  Info = add_b23(plci, &parms[5]);
1363  if (!Info) {
1364  if (!(plci->tel && !plci->adv_nl))nl_req_ncci(plci, ASSIGN, 0);
1365  }
1366  }
1367 
1368  if (!Info)
1369  {
1370  if (ch == 0 || ch == 2 || ch == 3 || noCh || ch == 4)
1371  {
1372  if (plci->spoofed_msg == SPOOFING_REQUIRED)
1373  {
1374  api_save_msg(parms, "wsssssssss", &plci->saved_msg);
1375  plci->spoofed_msg = CALL_REQ;
1376  plci->internal_command = BLOCK_PLCI;
1377  plci->command = 0;
1378  dbug(1, dprintf("Spoof"));
1379  send_req(plci);
1380  return false;
1381  }
1382  if (ch == 4)add_p(plci, CHI, p_chi);
1383  add_s(plci, CPN, &parms[1]);
1384  add_s(plci, DSA, &parms[3]);
1385  if (noCh) add_p(plci, ESC, "\x02\x18\xfd"); /* D-channel, no B-L3 */
1386  add_ai(plci, &parms[9]);
1387  if (!dir)sig_req(plci, CALL_REQ, 0);
1388  else
1389  {
1390  plci->command = PERM_LIST_REQ;
1391  plci->appl = appl;
1392  sig_req(plci, LISTEN_REQ, 0);
1393  send_req(plci);
1394  return false;
1395  }
1396  }
1397  send_req(plci);
1398  return false;
1399  }
1400  plci->Id = 0;
1401  }
1402  }
1403  sendf(appl,
1404  _CONNECT_R | CONFIRM,
1405  Id,
1406  Number,
1407  "w", Info);
1408  return 2;
1409 }
1410 
1411 static byte connect_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1412  PLCI *plci, APPL *appl, API_PARSE *parms)
1413 {
1414  word i, Info;
1415  word Reject;
1416  static byte cau_t[] = {0, 0, 0x90, 0x91, 0xac, 0x9d, 0x86, 0xd8, 0x9b};
1417  static byte esc_t[] = {0x03, 0x08, 0x00, 0x00};
1418  API_PARSE *ai;
1419  API_PARSE ai_parms[5];
1420  word ch = 0;
1421 
1422  if (!plci) {
1423  dbug(1, dprintf("connect_res(no plci)"));
1424  return 0; /* no plci, no send */
1425  }
1426 
1427  dbug(1, dprintf("connect_res(State=0x%x)", plci->State));
1428  for (i = 0; i < 5; i++) ai_parms[i].length = 0;
1429  ai = &parms[5];
1430  dbug(1, dprintf("ai->length=%d", ai->length));
1431 
1432  if (ai->length)
1433  {
1434  if (!api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms))
1435  {
1436  dbug(1, dprintf("ai_parms[0].length=%d/0x%x", ai_parms[0].length, GET_WORD(ai_parms[0].info + 1)));
1437  ch = 0;
1438  if (ai_parms[0].length)
1439  {
1440  ch = GET_WORD(ai_parms[0].info + 1);
1441  dbug(1, dprintf("BCH-I=0x%x", ch));
1442  }
1443  }
1444  }
1445 
1446  if (plci->State == INC_CON_CONNECTED_ALERT)
1447  {
1448  dbug(1, dprintf("Connected Alert Call_Res"));
1449  if (a->Info_Mask[appl->Id - 1] & 0x200)
1450  {
1451  /* early B3 connect (CIP mask bit 9) no release after a disc */
1452  add_p(plci, LLI, "\x01\x01");
1453  }
1454  add_s(plci, CONN_NR, &parms[2]);
1455  add_s(plci, LLC, &parms[4]);
1456  add_ai(plci, &parms[5]);
1457  plci->State = INC_CON_ACCEPT;
1458  sig_req(plci, CALL_RES, 0);
1459  return 1;
1460  }
1461  else if (plci->State == INC_CON_PENDING || plci->State == INC_CON_ALERT) {
1462  clear_c_ind_mask_bit(plci, (word)(appl->Id - 1));
1463  dump_c_ind_mask(plci);
1464  Reject = GET_WORD(parms[0].info);
1465  dbug(1, dprintf("Reject=0x%x", Reject));
1466  if (Reject)
1467  {
1468  if (c_ind_mask_empty(plci))
1469  {
1470  if ((Reject & 0xff00) == 0x3400)
1471  {
1472  esc_t[2] = ((byte)(Reject & 0x00ff)) | 0x80;
1473  add_p(plci, ESC, esc_t);
1474  add_ai(plci, &parms[5]);
1475  sig_req(plci, REJECT, 0);
1476  }
1477  else if (Reject == 1 || Reject > 9)
1478  {
1479  add_ai(plci, &parms[5]);
1480  sig_req(plci, HANGUP, 0);
1481  }
1482  else
1483  {
1484  esc_t[2] = cau_t[(Reject&0x000f)];
1485  add_p(plci, ESC, esc_t);
1486  add_ai(plci, &parms[5]);
1487  sig_req(plci, REJECT, 0);
1488  }
1489  plci->appl = appl;
1490  }
1491  else
1492  {
1493  sendf(appl, _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED);
1494  }
1495  }
1496  else {
1497  plci->appl = appl;
1498  if (Id & EXT_CONTROLLER) {
1499  if (AdvCodecSupport(a, plci, appl, 0)) {
1500  dbug(1, dprintf("connect_res(error from AdvCodecSupport)"));
1501  sig_req(plci, HANGUP, 0);
1502  return 1;
1503  }
1504  if (plci->tel == ADV_VOICE && a->AdvCodecPLCI)
1505  {
1506  Info = add_b23(plci, &parms[1]);
1507  if (Info)
1508  {
1509  dbug(1, dprintf("connect_res(error from add_b23)"));
1510  sig_req(plci, HANGUP, 0);
1511  return 1;
1512  }
1513  if (plci->adv_nl)
1514  {
1515  nl_req_ncci(plci, ASSIGN, 0);
1516  }
1517  }
1518  }
1519  else
1520  {
1521  plci->tel = 0;
1522  if (ch != 2)
1523  {
1524  Info = add_b23(plci, &parms[1]);
1525  if (Info)
1526  {
1527  dbug(1, dprintf("connect_res(error from add_b23 2)"));
1528  sig_req(plci, HANGUP, 0);
1529  return 1;
1530  }
1531  }
1532  nl_req_ncci(plci, ASSIGN, 0);
1533  }
1534 
1535  if (plci->spoofed_msg == SPOOFING_REQUIRED)
1536  {
1537  api_save_msg(parms, "wsssss", &plci->saved_msg);
1538  plci->spoofed_msg = CALL_RES;
1539  plci->internal_command = BLOCK_PLCI;
1540  plci->command = 0;
1541  dbug(1, dprintf("Spoof"));
1542  }
1543  else
1544  {
1545  add_b1(plci, &parms[1], ch, plci->B1_facilities);
1546  if (a->Info_Mask[appl->Id - 1] & 0x200)
1547  {
1548  /* early B3 connect (CIP mask bit 9) no release after a disc */
1549  add_p(plci, LLI, "\x01\x01");
1550  }
1551  add_s(plci, CONN_NR, &parms[2]);
1552  add_s(plci, LLC, &parms[4]);
1553  add_ai(plci, &parms[5]);
1554  plci->State = INC_CON_ACCEPT;
1555  sig_req(plci, CALL_RES, 0);
1556  }
1557 
1558  for (i = 0; i < max_appl; i++) {
1559  if (test_c_ind_mask_bit(plci, i)) {
1560  sendf(&application[i], _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED);
1561  }
1562  }
1563  }
1564  }
1565  return 1;
1566 }
1567 
1568 static byte connect_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1569  PLCI *plci, APPL *appl, API_PARSE *msg)
1570 {
1571  dbug(1, dprintf("connect_a_res"));
1572  return false;
1573 }
1574 
1575 static byte disconnect_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1576  PLCI *plci, APPL *appl, API_PARSE *msg)
1577 {
1578  word Info;
1579  word i;
1580 
1581  dbug(1, dprintf("disconnect_req"));
1582 
1583  Info = _WRONG_IDENTIFIER;
1584 
1585  if (plci)
1586  {
1587  if (plci->State == INC_CON_PENDING || plci->State == INC_CON_ALERT)
1588  {
1589  clear_c_ind_mask_bit(plci, (word)(appl->Id - 1));
1590  plci->appl = appl;
1591  for (i = 0; i < max_appl; i++)
1592  {
1593  if (test_c_ind_mask_bit(plci, i))
1594  sendf(&application[i], _DISCONNECT_I, Id, 0, "w", 0);
1595  }
1596  plci->State = OUTG_DIS_PENDING;
1597  }
1598  if (plci->Sig.Id && plci->appl)
1599  {
1600  Info = 0;
1601  if (plci->Sig.Id != 0xff)
1602  {
1603  if (plci->State != INC_DIS_PENDING)
1604  {
1605  add_ai(plci, &msg[0]);
1606  sig_req(plci, HANGUP, 0);
1607  plci->State = OUTG_DIS_PENDING;
1608  return 1;
1609  }
1610  }
1611  else
1612  {
1613  if (plci->NL.Id && !plci->nl_remove_id)
1614  {
1615  mixer_remove(plci);
1616  nl_req_ncci(plci, REMOVE, 0);
1617  sendf(appl, _DISCONNECT_R | CONFIRM, Id, Number, "w", 0);
1618  sendf(appl, _DISCONNECT_I, Id, 0, "w", 0);
1619  plci->State = INC_DIS_PENDING;
1620  }
1621  return 1;
1622  }
1623  }
1624  }
1625 
1626  if (!appl) return false;
1627  sendf(appl, _DISCONNECT_R | CONFIRM, Id, Number, "w", Info);
1628  return false;
1629 }
1630 
1631 static byte disconnect_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1632  PLCI *plci, APPL *appl, API_PARSE *msg)
1633 {
1634  dbug(1, dprintf("disconnect_res"));
1635  if (plci)
1636  {
1637  /* clear ind mask bit, just in case of collsion of */
1638  /* DISCONNECT_IND and CONNECT_RES */
1639  clear_c_ind_mask_bit(plci, (word)(appl->Id - 1));
1640  ncci_free_receive_buffers(plci, 0);
1641  if (plci_remove_check(plci))
1642  {
1643  return 0;
1644  }
1645  if (plci->State == INC_DIS_PENDING
1646  || plci->State == SUSPENDING) {
1647  if (c_ind_mask_empty(plci)) {
1648  if (plci->State != SUSPENDING) plci->State = IDLE;
1649  dbug(1, dprintf("chs=%d", plci->channels));
1650  if (!plci->channels) {
1651  plci_remove(plci);
1652  }
1653  }
1654  }
1655  }
1656  return 0;
1657 }
1658 
1659 static byte listen_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1660  PLCI *plci, APPL *appl, API_PARSE *parms)
1661 {
1662  word Info;
1663  byte i;
1664 
1665  dbug(1, dprintf("listen_req(Appl=0x%x)", appl->Id));
1666 
1667  Info = _WRONG_IDENTIFIER;
1668  if (a) {
1669  Info = 0;
1670  a->Info_Mask[appl->Id - 1] = GET_DWORD(parms[0].info);
1671  a->CIP_Mask[appl->Id - 1] = GET_DWORD(parms[1].info);
1672  dbug(1, dprintf("CIP_MASK=0x%lx", GET_DWORD(parms[1].info)));
1673  if (a->Info_Mask[appl->Id - 1] & 0x200) { /* early B3 connect provides */
1674  a->Info_Mask[appl->Id - 1] |= 0x10; /* call progression infos */
1675  }
1676 
1677  /* check if external controller listen and switch listen on or off*/
1678  if (Id&EXT_CONTROLLER && GET_DWORD(parms[1].info)) {
1679  if (a->profile.Global_Options & ON_BOARD_CODEC) {
1680  dummy_plci.State = IDLE;
1681  a->codec_listen[appl->Id - 1] = &dummy_plci;
1682  a->TelOAD[0] = (byte)(parms[3].length);
1683  for (i = 1; parms[3].length >= i && i < 22; i++) {
1684  a->TelOAD[i] = parms[3].info[i];
1685  }
1686  a->TelOAD[i] = 0;
1687  a->TelOSA[0] = (byte)(parms[4].length);
1688  for (i = 1; parms[4].length >= i && i < 22; i++) {
1689  a->TelOSA[i] = parms[4].info[i];
1690  }
1691  a->TelOSA[i] = 0;
1692  }
1693  else Info = 0x2002; /* wrong controller, codec not supported */
1694  }
1695  else{ /* clear listen */
1696  a->codec_listen[appl->Id - 1] = (PLCI *)0;
1697  }
1698  }
1699  sendf(appl,
1700  _LISTEN_R | CONFIRM,
1701  Id,
1702  Number,
1703  "w", Info);
1704 
1705  if (a) listen_check(a);
1706  return false;
1707 }
1708 
1709 static byte info_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1710  PLCI *plci, APPL *appl, API_PARSE *msg)
1711 {
1712  word i;
1713  API_PARSE *ai;
1714  PLCI *rc_plci = NULL;
1715  API_PARSE ai_parms[5];
1716  word Info = 0;
1717 
1718  dbug(1, dprintf("info_req"));
1719  for (i = 0; i < 5; i++) ai_parms[i].length = 0;
1720 
1721  ai = &msg[1];
1722 
1723  if (ai->length)
1724  {
1725  if (api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms))
1726  {
1727  dbug(1, dprintf("AddInfo wrong"));
1728  Info = _WRONG_MESSAGE_FORMAT;
1729  }
1730  }
1731  if (!a) Info = _WRONG_STATE;
1732 
1733  if (!Info && plci)
1734  { /* no fac, with CPN, or KEY */
1735  rc_plci = plci;
1736  if (!ai_parms[3].length && plci->State && (msg[0].length || ai_parms[1].length))
1737  {
1738  /* overlap sending option */
1739  dbug(1, dprintf("OvlSnd"));
1740  add_s(plci, CPN, &msg[0]);
1741  add_s(plci, KEY, &ai_parms[1]);
1742  sig_req(plci, INFO_REQ, 0);
1743  send_req(plci);
1744  return false;
1745  }
1746 
1747  if (plci->State && ai_parms[2].length)
1748  {
1749  /* User_Info option */
1750  dbug(1, dprintf("UUI"));
1751  add_s(plci, UUI, &ai_parms[2]);
1752  sig_req(plci, USER_DATA, 0);
1753  }
1754  else if (plci->State && ai_parms[3].length)
1755  {
1756  /* Facility option */
1757  dbug(1, dprintf("FAC"));
1758  add_s(plci, CPN, &msg[0]);
1759  add_ai(plci, &msg[1]);
1760  sig_req(plci, FACILITY_REQ, 0);
1761  }
1762  else
1763  {
1764  Info = _WRONG_STATE;
1765  }
1766  }
1767  else if ((ai_parms[1].length || ai_parms[2].length || ai_parms[3].length) && !Info)
1768  {
1769  /* NCR_Facility option -> send UUI and Keypad too */
1770  dbug(1, dprintf("NCR_FAC"));
1771  if ((i = get_plci(a)))
1772  {
1773  rc_plci = &a->plci[i - 1];
1774  appl->NullCREnable = true;
1775  rc_plci->internal_command = C_NCR_FAC_REQ;
1776  rc_plci->appl = appl;
1777  add_p(rc_plci, CAI, "\x01\x80");
1778  add_p(rc_plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
1779  sig_req(rc_plci, ASSIGN, DSIG_ID);
1780  send_req(rc_plci);
1781  }
1782  else
1783  {
1784  Info = _OUT_OF_PLCI;
1785  }
1786 
1787  if (!Info)
1788  {
1789  add_s(rc_plci, CPN, &msg[0]);
1790  add_ai(rc_plci, &msg[1]);
1791  sig_req(rc_plci, NCR_FACILITY, 0);
1792  send_req(rc_plci);
1793  return false;
1794  /* for application controlled supplementary services */
1795  }
1796  }
1797 
1798  if (!rc_plci)
1799  {
1800  Info = _WRONG_MESSAGE_FORMAT;
1801  }
1802 
1803  if (!Info)
1804  {
1805  send_req(rc_plci);
1806  }
1807  else
1808  { /* appl is not assigned to a PLCI or error condition */
1809  dbug(1, dprintf("localInfoCon"));
1810  sendf(appl,
1811  _INFO_R | CONFIRM,
1812  Id,
1813  Number,
1814  "w", Info);
1815  }
1816  return false;
1817 }
1818 
1819 static byte info_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1820  PLCI *plci, APPL *appl, API_PARSE *msg)
1821 {
1822  dbug(1, dprintf("info_res"));
1823  return false;
1824 }
1825 
1826 static byte alert_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1827  PLCI *plci, APPL *appl, API_PARSE *msg)
1828 {
1829  word Info;
1830  byte ret;
1831 
1832  dbug(1, dprintf("alert_req"));
1833 
1834  Info = _WRONG_IDENTIFIER;
1835  ret = false;
1836  if (plci) {
1837  Info = _ALERT_IGNORED;
1838  if (plci->State != INC_CON_ALERT) {
1839  Info = _WRONG_STATE;
1840  if (plci->State == INC_CON_PENDING) {
1841  Info = 0;
1842  plci->State = INC_CON_ALERT;
1843  add_ai(plci, &msg[0]);
1844  sig_req(plci, CALL_ALERT, 0);
1845  ret = 1;
1846  }
1847  }
1848  }
1849  sendf(appl,
1850  _ALERT_R | CONFIRM,
1851  Id,
1852  Number,
1853  "w", Info);
1854  return ret;
1855 }
1856 
1857 static byte facility_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1858  PLCI *plci, APPL *appl, API_PARSE *msg)
1859 {
1860  word Info = 0;
1861  word i = 0;
1862 
1863  word selector;
1864  word SSreq;
1865  long relatedPLCIvalue;
1866  DIVA_CAPI_ADAPTER *relatedadapter;
1867  byte *SSparms = "";
1868  byte RCparms[] = "\x05\x00\x00\x02\x00\x00";
1869  byte SSstruct[] = "\x09\x00\x00\x06\x00\x00\x00\x00\x00\x00";
1870  API_PARSE *parms;
1871  API_PARSE ss_parms[11];
1872  PLCI *rplci;
1873  byte cai[15];
1874  dword d;
1875  API_PARSE dummy;
1876 
1877  dbug(1, dprintf("facility_req"));
1878  for (i = 0; i < 9; i++) ss_parms[i].length = 0;
1879 
1880  parms = &msg[1];
1881 
1882  if (!a)
1883  {
1884  dbug(1, dprintf("wrong Ctrl"));
1885  Info = _WRONG_IDENTIFIER;
1886  }
1887 
1888  selector = GET_WORD(msg[0].info);
1889 
1890  if (!Info)
1891  {
1892  switch (selector)
1893  {
1894  case SELECTOR_HANDSET:
1895  Info = AdvCodecSupport(a, plci, appl, HOOK_SUPPORT);
1896  break;
1897 
1898  case SELECTOR_SU_SERV:
1899  if (!msg[1].length)
1900  {
1901  Info = _WRONG_MESSAGE_FORMAT;
1902  break;
1903  }
1904  SSreq = GET_WORD(&(msg[1].info[1]));
1905  PUT_WORD(&RCparms[1], SSreq);
1906  SSparms = RCparms;
1907  switch (SSreq)
1908  {
1909  case S_GET_SUPPORTED_SERVICES:
1910  if ((i = get_plci(a)))
1911  {
1912  rplci = &a->plci[i - 1];
1913  rplci->appl = appl;
1914  add_p(rplci, CAI, "\x01\x80");
1915  add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
1916  sig_req(rplci, ASSIGN, DSIG_ID);
1917  send_req(rplci);
1918  }
1919  else
1920  {
1921  PUT_DWORD(&SSstruct[6], MASK_TERMINAL_PORTABILITY);
1922  SSparms = (byte *)SSstruct;
1923  break;
1924  }
1925  rplci->internal_command = GETSERV_REQ_PEND;
1926  rplci->number = Number;
1927  rplci->appl = appl;
1928  sig_req(rplci, S_SUPPORTED, 0);
1929  send_req(rplci);
1930  return false;
1931  break;
1932 
1933  case S_LISTEN:
1934  if (parms->length == 7)
1935  {
1936  if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms))
1937  {
1938  dbug(1, dprintf("format wrong"));
1939  Info = _WRONG_MESSAGE_FORMAT;
1940  break;
1941  }
1942  }
1943  else
1944  {
1945  Info = _WRONG_MESSAGE_FORMAT;
1946  break;
1947  }
1948  a->Notification_Mask[appl->Id - 1] = GET_DWORD(ss_parms[2].info);
1949  if (a->Notification_Mask[appl->Id - 1] & SMASK_MWI) /* MWI active? */
1950  {
1951  if ((i = get_plci(a)))
1952  {
1953  rplci = &a->plci[i - 1];
1954  rplci->appl = appl;
1955  add_p(rplci, CAI, "\x01\x80");
1956  add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
1957  sig_req(rplci, ASSIGN, DSIG_ID);
1958  send_req(rplci);
1959  }
1960  else
1961  {
1962  break;
1963  }
1964  rplci->internal_command = GET_MWI_STATE;
1965  rplci->number = Number;
1966  sig_req(rplci, MWI_POLL, 0);
1967  send_req(rplci);
1968  }
1969  break;
1970 
1971  case S_HOLD:
1972  api_parse(&parms->info[1], (word)parms->length, "ws", ss_parms);
1973  if (plci && plci->State && plci->SuppState == IDLE)
1974  {
1975  plci->SuppState = HOLD_REQUEST;
1976  plci->command = C_HOLD_REQ;
1977  add_s(plci, CAI, &ss_parms[1]);
1978  sig_req(plci, CALL_HOLD, 0);
1979  send_req(plci);
1980  return false;
1981  }
1982  else Info = 0x3010; /* wrong state */
1983  break;
1984  case S_RETRIEVE:
1985  if (plci && plci->State && plci->SuppState == CALL_HELD)
1986  {
1987  if (Id & EXT_CONTROLLER)
1988  {
1989  if (AdvCodecSupport(a, plci, appl, 0))
1990  {
1991  Info = 0x3010; /* wrong state */
1992  break;
1993  }
1994  }
1995  else plci->tel = 0;
1996 
1997  plci->SuppState = RETRIEVE_REQUEST;
1998  plci->command = C_RETRIEVE_REQ;
1999  if (plci->spoofed_msg == SPOOFING_REQUIRED)
2000  {
2001  plci->spoofed_msg = CALL_RETRIEVE;
2002  plci->internal_command = BLOCK_PLCI;
2003  plci->command = 0;
2004  dbug(1, dprintf("Spoof"));
2005  return false;
2006  }
2007  else
2008  {
2009  sig_req(plci, CALL_RETRIEVE, 0);
2010  send_req(plci);
2011  return false;
2012  }
2013  }
2014  else Info = 0x3010; /* wrong state */
2015  break;
2016  case S_SUSPEND:
2017  if (parms->length)
2018  {
2019  if (api_parse(&parms->info[1], (word)parms->length, "wbs", ss_parms))
2020  {
2021  dbug(1, dprintf("format wrong"));
2022  Info = _WRONG_MESSAGE_FORMAT;
2023  break;
2024  }
2025  }
2026  if (plci && plci->State)
2027  {
2028  add_s(plci, CAI, &ss_parms[2]);
2029  plci->command = SUSPEND_REQ;
2030  sig_req(plci, SUSPEND, 0);
2031  plci->State = SUSPENDING;
2032  send_req(plci);
2033  }
2034  else Info = 0x3010; /* wrong state */
2035  break;
2036 
2037  case S_RESUME:
2038  if (!(i = get_plci(a)))
2039  {
2040  Info = _OUT_OF_PLCI;
2041  break;
2042  }
2043  rplci = &a->plci[i - 1];
2044  rplci->appl = appl;
2045  rplci->number = Number;
2046  rplci->tel = 0;
2047  rplci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
2048  /* check 'external controller' bit for codec support */
2049  if (Id & EXT_CONTROLLER)
2050  {
2051  if (AdvCodecSupport(a, rplci, appl, 0))
2052  {
2053  rplci->Id = 0;
2054  Info = 0x300A;
2055  break;
2056  }
2057  }
2058  if (parms->length)
2059  {
2060  if (api_parse(&parms->info[1], (word)parms->length, "wbs", ss_parms))
2061  {
2062  dbug(1, dprintf("format wrong"));
2063  rplci->Id = 0;
2064  Info = _WRONG_MESSAGE_FORMAT;
2065  break;
2066  }
2067  }
2068  dummy.length = 0;
2069  dummy.info = "\x00";
2070  add_b1(rplci, &dummy, 0, 0);
2071  if (a->Info_Mask[appl->Id - 1] & 0x200)
2072  {
2073  /* early B3 connect (CIP mask bit 9) no release after a disc */
2074  add_p(rplci, LLI, "\x01\x01");
2075  }
2076  add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
2077  sig_req(rplci, ASSIGN, DSIG_ID);
2078  send_req(rplci);
2079  add_s(rplci, CAI, &ss_parms[2]);
2080  rplci->command = RESUME_REQ;
2081  sig_req(rplci, RESUME, 0);
2082  rplci->State = RESUMING;
2083  send_req(rplci);
2084  break;
2085 
2086  case S_CONF_BEGIN: /* Request */
2087  case S_CONF_DROP:
2088  case S_CONF_ISOLATE:
2089  case S_CONF_REATTACH:
2090  if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms))
2091  {
2092  dbug(1, dprintf("format wrong"));
2093  Info = _WRONG_MESSAGE_FORMAT;
2094  break;
2095  }
2096  if (plci && plci->State && ((plci->SuppState == IDLE) || (plci->SuppState == CALL_HELD)))
2097  {
2098  d = GET_DWORD(ss_parms[2].info);
2099  if (d >= 0x80)
2100  {
2101  dbug(1, dprintf("format wrong"));
2102  Info = _WRONG_MESSAGE_FORMAT;
2103  break;
2104  }
2105  plci->ptyState = (byte)SSreq;
2106  plci->command = 0;
2107  cai[0] = 2;
2108  switch (SSreq)
2109  {
2110  case S_CONF_BEGIN:
2111  cai[1] = CONF_BEGIN;
2112  plci->internal_command = CONF_BEGIN_REQ_PEND;
2113  break;
2114  case S_CONF_DROP:
2115  cai[1] = CONF_DROP;
2116  plci->internal_command = CONF_DROP_REQ_PEND;
2117  break;
2118  case S_CONF_ISOLATE:
2119  cai[1] = CONF_ISOLATE;
2120  plci->internal_command = CONF_ISOLATE_REQ_PEND;
2121  break;
2122  case S_CONF_REATTACH:
2123  cai[1] = CONF_REATTACH;
2124  plci->internal_command = CONF_REATTACH_REQ_PEND;
2125  break;
2126  }
2127  cai[2] = (byte)d; /* Conference Size resp. PartyId */
2128  add_p(plci, CAI, cai);
2129  sig_req(plci, S_SERVICE, 0);
2130  send_req(plci);
2131  return false;
2132  }
2133  else Info = 0x3010; /* wrong state */
2134  break;
2135 
2136  case S_ECT:
2137  case S_3PTY_BEGIN:
2138  case S_3PTY_END:
2139  case S_CONF_ADD:
2140  if (parms->length == 7)
2141  {
2142  if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms))
2143  {
2144  dbug(1, dprintf("format wrong"));
2145  Info = _WRONG_MESSAGE_FORMAT;
2146  break;
2147  }
2148  }
2149  else if (parms->length == 8) /* workaround for the T-View-S */
2150  {
2151  if (api_parse(&parms->info[1], (word)parms->length, "wbdb", ss_parms))
2152  {
2153  dbug(1, dprintf("format wrong"));
2154  Info = _WRONG_MESSAGE_FORMAT;
2155  break;
2156  }
2157  }
2158  else
2159  {
2160  Info = _WRONG_MESSAGE_FORMAT;
2161  break;
2162  }
2163  if (!msg[1].length)
2164  {
2165  Info = _WRONG_MESSAGE_FORMAT;
2166  break;
2167  }
2168  if (!plci)
2169  {
2170  Info = _WRONG_IDENTIFIER;
2171  break;
2172  }
2173  relatedPLCIvalue = GET_DWORD(ss_parms[2].info);
2174  relatedPLCIvalue &= 0x0000FFFF;
2175  dbug(1, dprintf("PTY/ECT/addCONF,relPLCI=%lx", relatedPLCIvalue));
2176  /* controller starts with 0 up to (max_adapter - 1) */
2177  if (((relatedPLCIvalue & 0x7f) == 0)
2178  || (MapController((byte)(relatedPLCIvalue & 0x7f)) == 0)
2179  || (MapController((byte)(relatedPLCIvalue & 0x7f)) > max_adapter))
2180  {
2181  if (SSreq == S_3PTY_END)
2182  {
2183  dbug(1, dprintf("wrong Controller use 2nd PLCI=PLCI"));
2184  rplci = plci;
2185  }
2186  else
2187  {
2188  Info = 0x3010; /* wrong state */
2189  break;
2190  }
2191  }
2192  else
2193  {
2194  relatedadapter = &adapter[MapController((byte)(relatedPLCIvalue & 0x7f)) - 1];
2195  relatedPLCIvalue >>= 8;
2196  /* find PLCI PTR*/
2197  for (i = 0, rplci = NULL; i < relatedadapter->max_plci; i++)
2198  {
2199  if (relatedadapter->plci[i].Id == (byte)relatedPLCIvalue)
2200  {
2201  rplci = &relatedadapter->plci[i];
2202  }
2203  }
2204  if (!rplci || !relatedPLCIvalue)
2205  {
2206  if (SSreq == S_3PTY_END)
2207  {
2208  dbug(1, dprintf("use 2nd PLCI=PLCI"));
2209  rplci = plci;
2210  }
2211  else
2212  {
2213  Info = 0x3010; /* wrong state */
2214  break;
2215  }
2216  }
2217  }
2218 /*
2219  dbug(1, dprintf("rplci:%x", rplci));
2220  dbug(1, dprintf("plci:%x", plci));
2221  dbug(1, dprintf("rplci->ptyState:%x", rplci->ptyState));
2222  dbug(1, dprintf("plci->ptyState:%x", plci->ptyState));
2223  dbug(1, dprintf("SSreq:%x", SSreq));
2224  dbug(1, dprintf("rplci->internal_command:%x", rplci->internal_command));
2225  dbug(1, dprintf("rplci->appl:%x", rplci->appl));
2226  dbug(1, dprintf("rplci->Id:%x", rplci->Id));
2227 */
2228  /* send PTY/ECT req, cannot check all states because of US stuff */
2229  if (!rplci->internal_command && rplci->appl)
2230  {
2231  plci->command = 0;
2232  rplci->relatedPTYPLCI = plci;
2233  plci->relatedPTYPLCI = rplci;
2234  rplci->ptyState = (byte)SSreq;
2235  if (SSreq == S_ECT)
2236  {
2237  rplci->internal_command = ECT_REQ_PEND;
2238  cai[1] = ECT_EXECUTE;
2239 
2240  rplci->vswitchstate = 0;
2241  rplci->vsprot = 0;
2242  rplci->vsprotdialect = 0;
2243  plci->vswitchstate = 0;
2244  plci->vsprot = 0;
2245  plci->vsprotdialect = 0;
2246 
2247  }
2248  else if (SSreq == S_CONF_ADD)
2249  {
2250  rplci->internal_command = CONF_ADD_REQ_PEND;
2251  cai[1] = CONF_ADD;
2252  }
2253  else
2254  {
2255  rplci->internal_command = PTY_REQ_PEND;
2256  cai[1] = (byte)(SSreq - 3);
2257  }
2258  rplci->number = Number;
2259  if (plci != rplci) /* explicit invocation */
2260  {
2261  cai[0] = 2;
2262  cai[2] = plci->Sig.Id;
2263  dbug(1, dprintf("explicit invocation"));
2264  }
2265  else
2266  {
2267  dbug(1, dprintf("implicit invocation"));
2268  cai[0] = 1;
2269  }
2270  add_p(rplci, CAI, cai);
2271  sig_req(rplci, S_SERVICE, 0);
2272  send_req(rplci);
2273  return false;
2274  }
2275  else
2276  {
2277  dbug(0, dprintf("Wrong line"));
2278  Info = 0x3010; /* wrong state */
2279  break;
2280  }
2281  break;
2282 
2283  case S_CALL_DEFLECTION:
2284  if (api_parse(&parms->info[1], (word)parms->length, "wbwss", ss_parms))
2285  {
2286  dbug(1, dprintf("format wrong"));
2287  Info = _WRONG_MESSAGE_FORMAT;
2288  break;
2289  }
2290  if (!plci)
2291  {
2292  Info = _WRONG_IDENTIFIER;
2293  break;
2294  }
2295  /* reuse unused screening indicator */
2296  ss_parms[3].info[3] = (byte)GET_WORD(&(ss_parms[2].info[0]));
2297  plci->command = 0;
2298  plci->internal_command = CD_REQ_PEND;
2299  appl->CDEnable = true;
2300  cai[0] = 1;
2301  cai[1] = CALL_DEFLECTION;
2302  add_p(plci, CAI, cai);
2303  add_p(plci, CPN, ss_parms[3].info);
2304  sig_req(plci, S_SERVICE, 0);
2305  send_req(plci);
2306  return false;
2307  break;
2308 
2309  case S_CALL_FORWARDING_START:
2310  if (api_parse(&parms->info[1], (word)parms->length, "wbdwwsss", ss_parms))
2311  {
2312  dbug(1, dprintf("format wrong"));
2313  Info = _WRONG_MESSAGE_FORMAT;
2314  break;
2315  }
2316 
2317  if ((i = get_plci(a)))
2318  {
2319  rplci = &a->plci[i - 1];
2320  rplci->appl = appl;
2321  add_p(rplci, CAI, "\x01\x80");
2322  add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
2323  sig_req(rplci, ASSIGN, DSIG_ID);
2324  send_req(rplci);
2325  }
2326  else
2327  {
2328  Info = _OUT_OF_PLCI;
2329  break;
2330  }
2331 
2332  /* reuse unused screening indicator */
2333  rplci->internal_command = CF_START_PEND;
2334  rplci->appl = appl;
2335  rplci->number = Number;
2336  appl->S_Handle = GET_DWORD(&(ss_parms[2].info[0]));
2337  cai[0] = 2;
2338  cai[1] = 0x70 | (byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */
2339  cai[2] = (byte)GET_WORD(&(ss_parms[4].info[0])); /* Basic Service */
2340  add_p(rplci, CAI, cai);
2341  add_p(rplci, OAD, ss_parms[5].info);
2342  add_p(rplci, CPN, ss_parms[6].info);
2343  sig_req(rplci, S_SERVICE, 0);
2344  send_req(rplci);
2345  return false;
2346  break;
2347 
2348  case S_INTERROGATE_DIVERSION:
2349  case S_INTERROGATE_NUMBERS:
2350  case S_CALL_FORWARDING_STOP:
2351  case S_CCBS_REQUEST:
2352  case S_CCBS_DEACTIVATE:
2353  case S_CCBS_INTERROGATE:
2354  switch (SSreq)
2355  {
2356  case S_INTERROGATE_NUMBERS:
2357  if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms))
2358  {
2359  dbug(0, dprintf("format wrong"));
2360  Info = _WRONG_MESSAGE_FORMAT;
2361  }
2362  break;
2363  case S_CCBS_REQUEST:
2364  case S_CCBS_DEACTIVATE:
2365  if (api_parse(&parms->info[1], (word)parms->length, "wbdw", ss_parms))
2366  {
2367  dbug(0, dprintf("format wrong"));
2368  Info = _WRONG_MESSAGE_FORMAT;
2369  }
2370  break;
2371  case S_CCBS_INTERROGATE:
2372  if (api_parse(&parms->info[1], (word)parms->length, "wbdws", ss_parms))
2373  {
2374  dbug(0, dprintf("format wrong"));
2375  Info = _WRONG_MESSAGE_FORMAT;
2376  }
2377  break;
2378  default:
2379  if (api_parse(&parms->info[1], (word)parms->length, "wbdwws", ss_parms))
2380  {
2381  dbug(0, dprintf("format wrong"));
2382  Info = _WRONG_MESSAGE_FORMAT;
2383  break;
2384  }
2385  break;
2386  }
2387 
2388  if (Info) break;
2389  if ((i = get_plci(a)))
2390  {
2391  rplci = &a->plci[i - 1];
2392  switch (SSreq)
2393  {
2394  case S_INTERROGATE_DIVERSION: /* use cai with S_SERVICE below */
2395  cai[1] = 0x60 | (byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */
2396  rplci->internal_command = INTERR_DIVERSION_REQ_PEND; /* move to rplci if assigned */
2397  break;
2398  case S_INTERROGATE_NUMBERS: /* use cai with S_SERVICE below */
2399  cai[1] = DIVERSION_INTERROGATE_NUM; /* Function */
2400  rplci->internal_command = INTERR_NUMBERS_REQ_PEND; /* move to rplci if assigned */
2401  break;
2402  case S_CALL_FORWARDING_STOP:
2403  rplci->internal_command = CF_STOP_PEND;
2404  cai[1] = 0x80 | (byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */
2405  break;
2406  case S_CCBS_REQUEST:
2407  cai[1] = CCBS_REQUEST;
2408  rplci->internal_command = CCBS_REQUEST_REQ_PEND;
2409  break;
2410  case S_CCBS_DEACTIVATE:
2411  cai[1] = CCBS_DEACTIVATE;
2412  rplci->internal_command = CCBS_DEACTIVATE_REQ_PEND;
2413  break;
2414  case S_CCBS_INTERROGATE:
2415  cai[1] = CCBS_INTERROGATE;
2416  rplci->internal_command = CCBS_INTERROGATE_REQ_PEND;
2417  break;
2418  default:
2419  cai[1] = 0;
2420  break;
2421  }
2422  rplci->appl = appl;
2423  rplci->number = Number;
2424  add_p(rplci, CAI, "\x01\x80");
2425  add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
2426  sig_req(rplci, ASSIGN, DSIG_ID);
2427  send_req(rplci);
2428  }
2429  else
2430  {
2431  Info = _OUT_OF_PLCI;
2432  break;
2433  }
2434 
2435  appl->S_Handle = GET_DWORD(&(ss_parms[2].info[0]));
2436  switch (SSreq)
2437  {
2438  case S_INTERROGATE_NUMBERS:
2439  cai[0] = 1;
2440  add_p(rplci, CAI, cai);
2441  break;
2442  case S_CCBS_REQUEST:
2443  case S_CCBS_DEACTIVATE:
2444  cai[0] = 3;
2445  PUT_WORD(&cai[2], GET_WORD(&(ss_parms[3].info[0])));
2446  add_p(rplci, CAI, cai);
2447  break;
2448  case S_CCBS_INTERROGATE:
2449  cai[0] = 3;
2450  PUT_WORD(&cai[2], GET_WORD(&(ss_parms[3].info[0])));
2451  add_p(rplci, CAI, cai);
2452  add_p(rplci, OAD, ss_parms[4].info);
2453  break;
2454  default:
2455  cai[0] = 2;
2456  cai[2] = (byte)GET_WORD(&(ss_parms[4].info[0])); /* Basic Service */
2457  add_p(rplci, CAI, cai);
2458  add_p(rplci, OAD, ss_parms[5].info);
2459  break;
2460  }
2461 
2462  sig_req(rplci, S_SERVICE, 0);
2463  send_req(rplci);
2464  return false;
2465  break;
2466 
2467  case S_MWI_ACTIVATE:
2468  if (api_parse(&parms->info[1], (word)parms->length, "wbwdwwwssss", ss_parms))
2469  {
2470  dbug(1, dprintf("format wrong"));
2471  Info = _WRONG_MESSAGE_FORMAT;
2472  break;
2473  }
2474  if (!plci)
2475  {
2476  if ((i = get_plci(a)))
2477  {
2478  rplci = &a->plci[i - 1];
2479  rplci->appl = appl;
2480  rplci->cr_enquiry = true;
2481  add_p(rplci, CAI, "\x01\x80");
2482  add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
2483  sig_req(rplci, ASSIGN, DSIG_ID);
2484  send_req(rplci);
2485  }
2486  else
2487  {
2488  Info = _OUT_OF_PLCI;
2489  break;
2490  }
2491  }
2492  else
2493  {
2494  rplci = plci;
2495  rplci->cr_enquiry = false;
2496  }
2497 
2498  rplci->command = 0;
2499  rplci->internal_command = MWI_ACTIVATE_REQ_PEND;
2500  rplci->appl = appl;
2501  rplci->number = Number;
2502 
2503  cai[0] = 13;
2504  cai[1] = ACTIVATION_MWI; /* Function */
2505  PUT_WORD(&cai[2], GET_WORD(&(ss_parms[2].info[0]))); /* Basic Service */
2506  PUT_DWORD(&cai[4], GET_DWORD(&(ss_parms[3].info[0]))); /* Number of Messages */
2507  PUT_WORD(&cai[8], GET_WORD(&(ss_parms[4].info[0]))); /* Message Status */
2508  PUT_WORD(&cai[10], GET_WORD(&(ss_parms[5].info[0]))); /* Message Reference */
2509  PUT_WORD(&cai[12], GET_WORD(&(ss_parms[6].info[0]))); /* Invocation Mode */
2510  add_p(rplci, CAI, cai);
2511  add_p(rplci, CPN, ss_parms[7].info); /* Receiving User Number */
2512  add_p(rplci, OAD, ss_parms[8].info); /* Controlling User Number */
2513  add_p(rplci, OSA, ss_parms[9].info); /* Controlling User Provided Number */
2514  add_p(rplci, UID, ss_parms[10].info); /* Time */
2515  sig_req(rplci, S_SERVICE, 0);
2516  send_req(rplci);
2517  return false;
2518 
2519  case S_MWI_DEACTIVATE:
2520  if (api_parse(&parms->info[1], (word)parms->length, "wbwwss", ss_parms))
2521  {
2522  dbug(1, dprintf("format wrong"));
2523  Info = _WRONG_MESSAGE_FORMAT;
2524  break;
2525  }
2526  if (!plci)
2527  {
2528  if ((i = get_plci(a)))
2529  {
2530  rplci = &a->plci[i - 1];
2531  rplci->appl = appl;
2532  rplci->cr_enquiry = true;
2533  add_p(rplci, CAI, "\x01\x80");
2534  add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
2535  sig_req(rplci, ASSIGN, DSIG_ID);
2536  send_req(rplci);
2537  }
2538  else
2539  {
2540  Info = _OUT_OF_PLCI;
2541  break;
2542  }
2543  }
2544  else
2545  {
2546  rplci = plci;
2547  rplci->cr_enquiry = false;
2548  }
2549 
2550  rplci->command = 0;
2551  rplci->internal_command = MWI_DEACTIVATE_REQ_PEND;
2552  rplci->appl = appl;
2553  rplci->number = Number;
2554 
2555  cai[0] = 5;
2556  cai[1] = DEACTIVATION_MWI; /* Function */
2557  PUT_WORD(&cai[2], GET_WORD(&(ss_parms[2].info[0]))); /* Basic Service */
2558  PUT_WORD(&cai[4], GET_WORD(&(ss_parms[3].info[0]))); /* Invocation Mode */
2559  add_p(rplci, CAI, cai);
2560  add_p(rplci, CPN, ss_parms[4].info); /* Receiving User Number */
2561  add_p(rplci, OAD, ss_parms[5].info); /* Controlling User Number */
2562  sig_req(rplci, S_SERVICE, 0);
2563  send_req(rplci);
2564  return false;
2565 
2566  default:
2567  Info = 0x300E; /* not supported */
2568  break;
2569  }
2570  break; /* case SELECTOR_SU_SERV: end */
2571 
2572 
2573  case SELECTOR_DTMF:
2574  return (dtmf_request(Id, Number, a, plci, appl, msg));
2575 
2576 
2577 
2578  case SELECTOR_LINE_INTERCONNECT:
2579  return (mixer_request(Id, Number, a, plci, appl, msg));
2580 
2581 
2582 
2583  case PRIV_SELECTOR_ECHO_CANCELLER:
2584  appl->appl_flags |= APPL_FLAG_PRIV_EC_SPEC;
2585  return (ec_request(Id, Number, a, plci, appl, msg));
2586 
2587  case SELECTOR_ECHO_CANCELLER:
2588  appl->appl_flags &= ~APPL_FLAG_PRIV_EC_SPEC;
2589  return (ec_request(Id, Number, a, plci, appl, msg));
2590 
2591 
2592  case SELECTOR_V42BIS:
2593  default:
2594  Info = _FACILITY_NOT_SUPPORTED;
2595  break;
2596  } /* end of switch (selector) */
2597  }
2598 
2599  dbug(1, dprintf("SendFacRc"));
2600  sendf(appl,
2601  _FACILITY_R | CONFIRM,
2602  Id,
2603  Number,
2604  "wws", Info, selector, SSparms);
2605  return false;
2606 }
2607 
2608 static byte facility_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2609  PLCI *plci, APPL *appl, API_PARSE *msg)
2610 {
2611  dbug(1, dprintf("facility_res"));
2612  return false;
2613 }
2614 
2615 static byte connect_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2616  PLCI *plci, APPL *appl, API_PARSE *parms)
2617 {
2618  word Info = 0;
2619  byte req;
2620  byte len;
2621  word w;
2622  word fax_control_bits, fax_feature_bits, fax_info_change;
2623  API_PARSE *ncpi;
2624  byte pvc[2];
2625 
2626  API_PARSE fax_parms[9];
2627  word i;
2628 
2629 
2630  dbug(1, dprintf("connect_b3_req"));
2631  if (plci)
2632  {
2633  if ((plci->State == IDLE) || (plci->State == OUTG_DIS_PENDING)
2634  || (plci->State == INC_DIS_PENDING) || (plci->SuppState != IDLE))
2635  {
2636  Info = _WRONG_STATE;
2637  }
2638  else
2639  {
2640  /* local reply if assign unsuccessful
2641  or B3 protocol allows only one layer 3 connection
2642  and already connected
2643  or B2 protocol not any LAPD
2644  and connect_b3_req contradicts originate/answer direction */
2645  if (!plci->NL.Id
2646  || (((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE))
2647  && ((plci->channels != 0)
2648  || (((plci->B2_prot != B2_SDLC) && (plci->B2_prot != B2_LAPD) && (plci->B2_prot != B2_LAPD_FREE_SAPI_SEL))
2649  && ((plci->call_dir & CALL_DIR_ANSWER) && !(plci->call_dir & CALL_DIR_FORCE_OUTG_NL))))))
2650  {
2651  dbug(1, dprintf("B3 already connected=%d or no NL.Id=0x%x, dir=%d sstate=0x%x",
2652  plci->channels, plci->NL.Id, plci->call_dir, plci->SuppState));
2653  Info = _WRONG_STATE;
2654  sendf(appl,
2655  _CONNECT_B3_R | CONFIRM,
2656  Id,
2657  Number,
2658  "w", Info);
2659  return false;
2660  }
2661  plci->requested_options_conn = 0;
2662 
2663  req = N_CONNECT;
2664  ncpi = &parms[0];
2665  if (plci->B3_prot == 2 || plci->B3_prot == 3)
2666  {
2667  if (ncpi->length > 2)
2668  {
2669  /* check for PVC */
2670  if (ncpi->info[2] || ncpi->info[3])
2671  {
2672  pvc[0] = ncpi->info[3];
2673  pvc[1] = ncpi->info[2];
2674  add_d(plci, 2, pvc);
2675  req = N_RESET;
2676  }
2677  else
2678  {
2679  if (ncpi->info[1] & 1) req = N_CONNECT | N_D_BIT;
2680  add_d(plci, (word)(ncpi->length - 3), &ncpi->info[4]);
2681  }
2682  }
2683  }
2684  else if (plci->B3_prot == 5)
2685  {
2686  if (plci->NL.Id && !plci->nl_remove_id)
2687  {
2688  fax_control_bits = GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low);
2689  fax_feature_bits = GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->feature_bits_low);
2690  if (!(fax_control_bits & T30_CONTROL_BIT_MORE_DOCUMENTS)
2691  || (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS))
2692  {
2693  len = offsetof(T30_INFO, universal_6);
2694  fax_info_change = false;
2695  if (ncpi->length >= 4)
2696  {
2697  w = GET_WORD(&ncpi->info[3]);
2698  if ((w & 0x0001) != ((word)(((T30_INFO *)(plci->fax_connect_info_buffer))->resolution & 0x0001)))
2699  {
2700  ((T30_INFO *)(plci->fax_connect_info_buffer))->resolution =
2701  (byte)((((T30_INFO *)(plci->fax_connect_info_buffer))->resolution & ~T30_RESOLUTION_R8_0770_OR_200) |
2702  ((w & 0x0001) ? T30_RESOLUTION_R8_0770_OR_200 : 0));
2703  fax_info_change = true;
2704  }
2705  fax_control_bits &= ~(T30_CONTROL_BIT_REQUEST_POLLING | T30_CONTROL_BIT_MORE_DOCUMENTS);
2706  if (w & 0x0002) /* Fax-polling request */
2707  fax_control_bits |= T30_CONTROL_BIT_REQUEST_POLLING;
2708  if ((w & 0x0004) /* Request to send / poll another document */
2709  && (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_MORE_DOCUMENTS))
2710  {
2711  fax_control_bits |= T30_CONTROL_BIT_MORE_DOCUMENTS;
2712  }
2713  if (ncpi->length >= 6)
2714  {
2715  w = GET_WORD(&ncpi->info[5]);
2716  if (((byte) w) != ((T30_INFO *)(plci->fax_connect_info_buffer))->data_format)
2717  {
2718  ((T30_INFO *)(plci->fax_connect_info_buffer))->data_format = (byte) w;
2719  fax_info_change = true;
2720  }
2721 
2722  if ((a->man_profile.private_options & (1L << PRIVATE_FAX_SUB_SEP_PWD))
2723  && (GET_WORD(&ncpi->info[5]) & 0x8000)) /* Private SEP/SUB/PWD enable */
2724  {
2725  plci->requested_options_conn |= (1L << PRIVATE_FAX_SUB_SEP_PWD);
2726  }
2727  if ((a->man_profile.private_options & (1L << PRIVATE_FAX_NONSTANDARD))
2728  && (GET_WORD(&ncpi->info[5]) & 0x4000)) /* Private non-standard facilities enable */
2729  {
2730  plci->requested_options_conn |= (1L << PRIVATE_FAX_NONSTANDARD);
2731  }
2732  fax_control_bits &= ~(T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_SEL_POLLING |
2733  T30_CONTROL_BIT_ACCEPT_PASSWORD);
2734  if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id - 1])
2735  & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
2736  {
2737  if (api_parse(&ncpi->info[1], ncpi->length, "wwwwsss", fax_parms))
2738  Info = _WRONG_MESSAGE_FORMAT;
2739  else
2740  {
2741  if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id - 1])
2742  & (1L << PRIVATE_FAX_SUB_SEP_PWD))
2743  {
2744  fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_PASSWORD;
2745  if (fax_control_bits & T30_CONTROL_BIT_ACCEPT_POLLING)
2746  fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SEL_POLLING;
2747  }
2748  w = fax_parms[4].length;
2749  if (w > 20)
2750  w = 20;
2751  ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id_len = (byte) w;
2752  for (i = 0; i < w; i++)
2753  ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id[i] = fax_parms[4].info[1 + i];
2754  ((T30_INFO *)(plci->fax_connect_info_buffer))->head_line_len = 0;
2755  len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
2756  w = fax_parms[5].length;
2757  if (w > 20)
2758  w = 20;
2759  plci->fax_connect_info_buffer[len++] = (byte) w;
2760  for (i = 0; i < w; i++)
2761  plci->fax_connect_info_buffer[len++] = fax_parms[5].info[1 + i];
2762  w = fax_parms[6].length;
2763  if (w > 20)
2764  w = 20;
2765  plci->fax_connect_info_buffer[len++] = (byte) w;
2766  for (i = 0; i < w; i++)
2767  plci->fax_connect_info_buffer[len++] = fax_parms[6].info[1 + i];
2768  if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id - 1])
2769  & (1L << PRIVATE_FAX_NONSTANDARD))
2770  {
2771  if (api_parse(&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms))
2772  {
2773  dbug(1, dprintf("non-standard facilities info missing or wrong format"));
2774  plci->fax_connect_info_buffer[len++] = 0;
2775  }
2776  else
2777  {
2778  if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2))
2779  plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]);
2780  plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length);
2781  for (i = 0; i < fax_parms[7].length; i++)
2782  plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1 + i];
2783  }
2784  }
2785  }
2786  }
2787  else
2788  {
2789  len = offsetof(T30_INFO, universal_6);
2790  }
2791  fax_info_change = true;
2792 
2793  }
2794  if (fax_control_bits != GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low))
2795  {
2796  PUT_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low, fax_control_bits);
2797  fax_info_change = true;
2798  }
2799  }
2800  if (Info == GOOD)
2801  {
2802  plci->fax_connect_info_length = len;
2803  if (fax_info_change)
2804  {
2805  if (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS)
2806  {
2807  start_internal_command(Id, plci, fax_connect_info_command);
2808  return false;
2809  }
2810  else
2811  {
2812  start_internal_command(Id, plci, fax_adjust_b23_command);
2813  return false;
2814  }
2815  }
2816  }
2817  }
2818  else Info = _WRONG_STATE;
2819  }
2820  else Info = _WRONG_STATE;
2821  }
2822 
2823  else if (plci->B3_prot == B3_RTP)
2824  {
2825  plci->internal_req_buffer[0] = ncpi->length + 1;
2826  plci->internal_req_buffer[1] = UDATA_REQUEST_RTP_RECONFIGURE;
2827  for (w = 0; w < ncpi->length; w++)
2828  plci->internal_req_buffer[2 + w] = ncpi->info[1 + w];
2829  start_internal_command(Id, plci, rtp_connect_b3_req_command);
2830  return false;
2831  }
2832 
2833  if (!Info)
2834  {
2835  nl_req_ncci(plci, req, 0);
2836  return 1;
2837  }
2838  }
2839  }
2840  else Info = _WRONG_IDENTIFIER;
2841 
2842  sendf(appl,
2843  _CONNECT_B3_R | CONFIRM,
2844  Id,
2845  Number,
2846  "w", Info);
2847  return false;
2848 }
2849 
2850 static byte connect_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2851  PLCI *plci, APPL *appl, API_PARSE *parms)
2852 {
2853  word ncci;
2854  API_PARSE *ncpi;
2855  byte req;
2856 
2857  word w;
2858 
2859 
2860  API_PARSE fax_parms[9];
2861  word i;
2862  byte len;
2863 
2864 
2865  dbug(1, dprintf("connect_b3_res"));
2866 
2867  ncci = (word)(Id >> 16);
2868  if (plci && ncci) {
2869  if (a->ncci_state[ncci] == INC_CON_PENDING) {
2870  if (GET_WORD(&parms[0].info[0]) != 0)
2871  {
2872  a->ncci_state[ncci] = OUTG_REJ_PENDING;
2873  channel_request_xon(plci, a->ncci_ch[ncci]);
2874  channel_xmit_xon(plci);
2875  cleanup_ncci_data(plci, ncci);
2876  nl_req_ncci(plci, N_DISC, (byte)ncci);
2877  return 1;
2878  }
2879  a->ncci_state[ncci] = INC_ACT_PENDING;
2880 
2881  req = N_CONNECT_ACK;
2882  ncpi = &parms[1];
2883  if ((plci->B3_prot == 4) || (plci->B3_prot == 5) || (plci->B3_prot == 7))
2884  {
2885 
2886  if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id - 1])
2887  & (1L << PRIVATE_FAX_NONSTANDARD))
2888  {
2889  if (((plci->B3_prot == 4) || (plci->B3_prot == 5))
2890  && (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF)
2891  && (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP))
2892  {
2893  len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
2894  if (plci->fax_connect_info_length < len)
2895  {
2896  ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id_len = 0;
2897  ((T30_INFO *)(plci->fax_connect_info_buffer))->head_line_len = 0;
2898  }
2899  if (api_parse(&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms))
2900  {
2901  dbug(1, dprintf("non-standard facilities info missing or wrong format"));
2902  }
2903  else
2904  {
2905  if (plci->fax_connect_info_length <= len)
2906  plci->fax_connect_info_buffer[len] = 0;
2907  len += 1 + plci->fax_connect_info_buffer[len];
2908  if (plci->fax_connect_info_length <= len)
2909  plci->fax_connect_info_buffer[len] = 0;
2910  len += 1 + plci->fax_connect_info_buffer[len];
2911  if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2))
2912  plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]);
2913  plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length);
2914  for (i = 0; i < fax_parms[7].length; i++)
2915  plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1 + i];
2916  }
2917  plci->fax_connect_info_length = len;
2918  ((T30_INFO *)(plci->fax_connect_info_buffer))->code = 0;
2919  start_internal_command(Id, plci, fax_connect_ack_command);
2920  return false;
2921  }
2922  }
2923 
2924  nl_req_ncci(plci, req, (byte)ncci);
2925  if ((plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
2926  && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
2927  {
2928  if (plci->B3_prot == 4)
2929  sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
2930  else
2931  sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
2932  plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
2933  }
2934  }
2935 
2936  else if (plci->B3_prot == B3_RTP)
2937  {
2938  plci->internal_req_buffer[0] = ncpi->length + 1;
2939  plci->internal_req_buffer[1] = UDATA_REQUEST_RTP_RECONFIGURE;
2940  for (w = 0; w < ncpi->length; w++)
2941  plci->internal_req_buffer[2 + w] = ncpi->info[1+w];
2942  start_internal_command(Id, plci, rtp_connect_b3_res_command);
2943  return false;
2944  }
2945 
2946  else
2947  {
2948  if (ncpi->length > 2) {
2949  if (ncpi->info[1] & 1) req = N_CONNECT_ACK | N_D_BIT;
2950  add_d(plci, (word)(ncpi->length - 3), &ncpi->info[4]);
2951  }
2952  nl_req_ncci(plci, req, (byte)ncci);
2953  sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
2954  if (plci->adjust_b_restore)
2955  {
2956  plci->adjust_b_restore = false;
2957  start_internal_command(Id, plci, adjust_b_restore);
2958  }
2959  }
2960  return 1;
2961  }
2962  }
2963  return false;
2964 }
2965 
2966 static byte connect_b3_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2967  PLCI *plci, APPL *appl, API_PARSE *parms)
2968 {
2969  word ncci;
2970 
2971  ncci = (word)(Id >> 16);
2972  dbug(1, dprintf("connect_b3_a_res(ncci=0x%x)", ncci));
2973 
2974  if (plci && ncci && (plci->State != IDLE) && (plci->State != INC_DIS_PENDING)
2975  && (plci->State != OUTG_DIS_PENDING))
2976  {
2977  if (a->ncci_state[ncci] == INC_ACT_PENDING) {
2978  a->ncci_state[ncci] = CONNECTED;
2979  if (plci->State != INC_CON_CONNECTED_ALERT) plci->State = CONNECTED;
2980  channel_request_xon(plci, a->ncci_ch[ncci]);
2981  channel_xmit_xon(plci);
2982  }
2983  }
2984  return false;
2985 }
2986 
2987 static byte disconnect_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2988  PLCI *plci, APPL *appl, API_PARSE *parms)
2989 {
2990  word Info;
2991  word ncci;
2992  API_PARSE *ncpi;
2993 
2994  dbug(1, dprintf("disconnect_b3_req"));
2995 
2996  Info = _WRONG_IDENTIFIER;
2997  ncci = (word)(Id >> 16);
2998  if (plci && ncci)
2999  {
3000  Info = _WRONG_STATE;
3001  if ((a->ncci_state[ncci] == CONNECTED)
3002  || (a->ncci_state[ncci] == OUTG_CON_PENDING)
3003  || (a->ncci_state[ncci] == INC_CON_PENDING)
3004  || (a->ncci_state[ncci] == INC_ACT_PENDING))
3005  {
3006  a->ncci_state[ncci] = OUTG_DIS_PENDING;
3007  channel_request_xon(plci, a->ncci_ch[ncci]);
3008  channel_xmit_xon(plci);
3009 
3010  if (a->ncci[ncci].data_pending
3011  && ((plci->B3_prot == B3_TRANSPARENT)
3012  || (plci->B3_prot == B3_T30)
3013  || (plci->B3_prot == B3_T30_WITH_EXTENSIONS)))
3014  {
3015  plci->send_disc = (byte)ncci;
3016  plci->command = 0;
3017  return false;
3018  }
3019  else
3020  {
3021  cleanup_ncci_data(plci, ncci);
3022 
3023  if (plci->B3_prot == 2 || plci->B3_prot == 3)
3024  {
3025  ncpi = &parms[0];
3026  if (ncpi->length > 3)
3027  {
3028  add_d(plci, (word)(ncpi->length - 3), (byte *)&(ncpi->info[4]));
3029  }
3030  }
3031  nl_req_ncci(plci, N_DISC, (byte)ncci);
3032  }
3033  return 1;
3034  }
3035  }
3036  sendf(appl,
3037  _DISCONNECT_B3_R | CONFIRM,
3038  Id,
3039  Number,
3040  "w", Info);
3041  return false;
3042 }
3043 
3044 static byte disconnect_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3045  PLCI *plci, APPL *appl, API_PARSE *parms)
3046 {
3047  word ncci;
3048  word i;
3049 
3050  ncci = (word)(Id >> 16);
3051  dbug(1, dprintf("disconnect_b3_res(ncci=0x%x", ncci));
3052  if (plci && ncci) {
3053  plci->requested_options_conn = 0;
3054  plci->fax_connect_info_length = 0;
3055  plci->ncpi_state = 0x00;
3056  if (((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE))
3057  && ((plci->B2_prot != B2_LAPD) && (plci->B2_prot != B2_LAPD_FREE_SAPI_SEL)))
3058  {
3059  plci->call_dir |= CALL_DIR_FORCE_OUTG_NL;
3060  }
3061  for (i = 0; i < MAX_CHANNELS_PER_PLCI && plci->inc_dis_ncci_table[i] != (byte)ncci; i++);
3062  if (i < MAX_CHANNELS_PER_PLCI) {
3063  if (plci->channels)plci->channels--;
3064  for (; i < MAX_CHANNELS_PER_PLCI - 1; i++) plci->inc_dis_ncci_table[i] = plci->inc_dis_ncci_table[i + 1];
3065  plci->inc_dis_ncci_table[MAX_CHANNELS_PER_PLCI - 1] = 0;
3066 
3067  ncci_free_receive_buffers(plci, ncci);
3068 
3069  if ((plci->State == IDLE || plci->State == SUSPENDING) && !plci->channels) {
3070  if (plci->State == SUSPENDING) {
3071  sendf(plci->appl,
3072  _FACILITY_I,
3073  Id & 0xffffL,
3074  0,
3075  "ws", (word)3, "\x03\x04\x00\x00");
3076  sendf(plci->appl, _DISCONNECT_I, Id & 0xffffL, 0, "w", 0);
3077  }
3078  plci_remove(plci);
3079  plci->State = IDLE;
3080  }
3081  }
3082  else
3083  {
3084  if ((a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
3085  && ((plci->B3_prot == 4) || (plci->B3_prot == 5))
3086  && (a->ncci_state[ncci] == INC_DIS_PENDING))
3087  {
3088  ncci_free_receive_buffers(plci, ncci);
3089 
3090  nl_req_ncci(plci, N_EDATA, (byte)ncci);
3091 
3092  plci->adapter->ncci_state[ncci] = IDLE;
3093  start_internal_command(Id, plci, fax_disconnect_command);
3094  return 1;
3095  }
3096  }
3097  }
3098  return false;
3099 }
3100 
3101 static byte data_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3102  PLCI *plci, APPL *appl, API_PARSE *parms)
3103 {
3104  NCCI *ncci_ptr;
3105  DATA_B3_DESC *data;
3106  word Info;
3107  word ncci;
3108  word i;
3109 
3110  dbug(1, dprintf("data_b3_req"));
3111 
3112  Info = _WRONG_IDENTIFIER;
3113  ncci = (word)(Id >> 16);
3114  dbug(1, dprintf("ncci=0x%x, plci=0x%x", ncci, plci));
3115 
3116  if (plci && ncci)
3117  {
3118  Info = _WRONG_STATE;
3119  if ((a->ncci_state[ncci] == CONNECTED)
3120  || (a->ncci_state[ncci] == INC_ACT_PENDING))
3121  {
3122  /* queue data */
3123  ncci_ptr = &(a->ncci[ncci]);
3124  i = ncci_ptr->data_out + ncci_ptr->data_pending;
3125  if (i >= MAX_DATA_B3)
3126  i -= MAX_DATA_B3;
3127  data = &(ncci_ptr->DBuffer[i]);
3128  data->Number = Number;
3129  if ((((byte *)(parms[0].info)) >= ((byte *)(plci->msg_in_queue)))
3130  && (((byte *)(parms[0].info)) < ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
3131  {
3132 
3133  data->P = (byte *)(long)(*((dword *)(parms[0].info)));
3134 
3135  }
3136  else
3137  data->P = TransmitBufferSet(appl, *(dword *)parms[0].info);
3138  data->Length = GET_WORD(parms[1].info);
3139  data->Handle = GET_WORD(parms[2].info);
3140  data->Flags = GET_WORD(parms[3].info);
3141  (ncci_ptr->data_pending)++;
3142 
3143  /* check for delivery confirmation */
3144  if (data->Flags & 0x0004)
3145  {
3146  i = ncci_ptr->data_ack_out + ncci_ptr->data_ack_pending;
3147  if (i >= MAX_DATA_ACK)
3148  i -= MAX_DATA_ACK;
3149  ncci_ptr->DataAck[i].Number = data->Number;
3150  ncci_ptr->DataAck[i].Handle = data->Handle;
3151  (ncci_ptr->data_ack_pending)++;
3152  }
3153 
3154  send_data(plci);
3155  return false;
3156  }
3157  }
3158  if (appl)
3159  {
3160  if (plci)
3161  {
3162  if ((((byte *)(parms[0].info)) >= ((byte *)(plci->msg_in_queue)))
3163  && (((byte *)(parms[0].info)) < ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
3164  {
3165 
3166  TransmitBufferFree(appl, (byte *)(long)(*((dword *)(parms[0].info))));
3167 
3168  }
3169  }
3170  sendf(appl,
3171  _DATA_B3_R | CONFIRM,
3172  Id,
3173  Number,
3174  "ww", GET_WORD(parms[2].info), Info);
3175  }
3176  return false;
3177 }
3178 
3179 static byte data_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3180  PLCI *plci, APPL *appl, API_PARSE *parms)
3181 {
3182  word n;
3183  word ncci;
3184  word NCCIcode;
3185 
3186  dbug(1, dprintf("data_b3_res"));
3187 
3188  ncci = (word)(Id >> 16);
3189  if (plci && ncci) {
3190  n = GET_WORD(parms[0].info);
3191  dbug(1, dprintf("free(%d)", n));
3192  NCCIcode = ncci | (((word) a->Id) << 8);
3193  if (n < appl->MaxBuffer &&
3194  appl->DataNCCI[n] == NCCIcode &&
3195  (byte)(appl->DataFlags[n] >> 8) == plci->Id) {
3196  dbug(1, dprintf("found"));
3197  appl->DataNCCI[n] = 0;
3198 
3199  if (channel_can_xon(plci, a->ncci_ch[ncci])) {
3200  channel_request_xon(plci, a->ncci_ch[ncci]);
3201  }
3202  channel_xmit_xon(plci);
3203 
3204  if (appl->DataFlags[n] & 4) {
3205  nl_req_ncci(plci, N_DATA_ACK, (byte)ncci);
3206  return 1;
3207  }
3208  }
3209  }
3210  return false;
3211 }
3212 
3213 static byte reset_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3214  PLCI *plci, APPL *appl, API_PARSE *parms)
3215 {
3216  word Info;
3217  word ncci;
3218 
3219  dbug(1, dprintf("reset_b3_req"));
3220 
3221  Info = _WRONG_IDENTIFIER;
3222  ncci = (word)(Id >> 16);
3223  if (plci && ncci)
3224  {
3225  Info = _WRONG_STATE;
3226  switch (plci->B3_prot)
3227  {
3228  case B3_ISO8208:
3229  case B3_X25_DCE:
3230  if (a->ncci_state[ncci] == CONNECTED)
3231  {
3232  nl_req_ncci(plci, N_RESET, (byte)ncci);
3233  send_req(plci);
3234  Info = GOOD;
3235  }
3236  break;
3237  case B3_TRANSPARENT:
3238  if (a->ncci_state[ncci] == CONNECTED)
3239  {
3240  start_internal_command(Id, plci, reset_b3_command);
3241  Info = GOOD;
3242  }
3243  break;
3244  }
3245  }
3246  /* reset_b3 must result in a reset_b3_con & reset_b3_Ind */
3247  sendf(appl,
3248  _RESET_B3_R | CONFIRM,
3249  Id,
3250  Number,
3251  "w", Info);
3252  return false;
3253 }
3254 
3255 static byte reset_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3256  PLCI *plci, APPL *appl, API_PARSE *parms)
3257 {
3258  word ncci;
3259 
3260  dbug(1, dprintf("reset_b3_res"));
3261 
3262  ncci = (word)(Id >> 16);
3263  if (plci && ncci) {
3264  switch (plci->B3_prot)
3265  {
3266  case B3_ISO8208:
3267  case B3_X25_DCE:
3268  if (a->ncci_state[ncci] == INC_RES_PENDING)
3269  {
3270  a->ncci_state[ncci] = CONNECTED;
3271  nl_req_ncci(plci, N_RESET_ACK, (byte)ncci);
3272  return true;
3273  }
3274  break;
3275  }
3276  }
3277  return false;
3278 }
3279 
3280 static byte connect_b3_t90_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3281  PLCI *plci, APPL *appl, API_PARSE *parms)
3282 {
3283  word ncci;
3284  API_PARSE *ncpi;
3285  byte req;
3286 
3287  dbug(1, dprintf("connect_b3_t90_a_res"));
3288 
3289  ncci = (word)(Id >> 16);
3290  if (plci && ncci) {
3291  if (a->ncci_state[ncci] == INC_ACT_PENDING) {
3292  a->ncci_state[ncci] = CONNECTED;
3293  }
3294  else if (a->ncci_state[ncci] == INC_CON_PENDING) {
3295  a->ncci_state[ncci] = CONNECTED;
3296 
3297  req = N_CONNECT_ACK;
3298 
3299  /* parms[0]==0 for CAPI original message definition! */
3300  if (parms[0].info) {
3301  ncpi = &parms[1];
3302  if (ncpi->length > 2) {
3303  if (ncpi->info[1] & 1) req = N_CONNECT_ACK | N_D_BIT;
3304  add_d(plci, (word)(ncpi->length - 3), &ncpi->info[4]);
3305  }
3306  }
3307  nl_req_ncci(plci, req, (byte)ncci);
3308  return 1;
3309  }
3310  }
3311  return false;
3312 }
3313 
3314 
3315 static byte select_b_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3316  PLCI *plci, APPL *appl, API_PARSE *msg)
3317 {
3318  word Info = 0;
3319  word i;
3320  byte tel;
3321  API_PARSE bp_parms[7];
3322 
3323  if (!plci || !msg)
3324  {
3325  Info = _WRONG_IDENTIFIER;
3326  }
3327  else
3328  {
3329  dbug(1, dprintf("select_b_req[%d],PLCI=0x%x,Tel=0x%x,NL=0x%x,appl=0x%x,sstate=0x%x",
3330  msg->length, plci->Id, plci->tel, plci->NL.Id, plci->appl, plci->SuppState));
3331  dbug(1, dprintf("PlciState=0x%x", plci->State));
3332  for (i = 0; i < 7; i++) bp_parms[i].length = 0;
3333 
3334  /* check if no channel is open, no B3 connected only */
3335  if ((plci->State == IDLE) || (plci->State == OUTG_DIS_PENDING) || (plci->State == INC_DIS_PENDING)
3336  || (plci->SuppState != IDLE) || plci->channels || plci->nl_remove_id)
3337  {
3338  Info = _WRONG_STATE;
3339  }
3340  /* check message format and fill bp_parms pointer */
3341  else if (msg->length && api_parse(&msg->info[1], (word)msg->length, "wwwsss", bp_parms))
3342  {
3343  Info = _WRONG_MESSAGE_FORMAT;
3344  }
3345  else
3346  {
3347  if ((plci->State == INC_CON_PENDING) || (plci->State == INC_CON_ALERT)) /* send alert tone inband to the network, */
3348  { /* e.g. Qsig or RBS or Cornet-N or xess PRI */
3349  if (Id & EXT_CONTROLLER)
3350  {
3351  sendf(appl, _SELECT_B_REQ | CONFIRM, Id, Number, "w", 0x2002); /* wrong controller */
3352  return 0;
3353  }
3354  plci->State = INC_CON_CONNECTED_ALERT;
3355  plci->appl = appl;
3356  clear_c_ind_mask_bit(plci, (word)(appl->Id - 1));
3357  dump_c_ind_mask(plci);
3358  for (i = 0; i < max_appl; i++) /* disconnect the other appls */
3359  { /* its quasi a connect */
3360  if (test_c_ind_mask_bit(plci, i))
3361  sendf(&application[i], _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED);
3362  }
3363  }
3364 
3365  api_save_msg(msg, "s", &plci->saved_msg);
3366  tel = plci->tel;
3367  if (Id & EXT_CONTROLLER)
3368  {
3369  if (tel) /* external controller in use by this PLCI */
3370  {
3371  if (a->AdvSignalAppl && a->AdvSignalAppl != appl)
3372  {
3373  dbug(1, dprintf("Ext_Ctrl in use 1"));
3374  Info = _WRONG_STATE;
3375  }
3376  }
3377  else /* external controller NOT in use by this PLCI ? */
3378  {
3379  if (a->AdvSignalPLCI)
3380  {
3381  dbug(1, dprintf("Ext_Ctrl in use 2"));
3382  Info = _WRONG_STATE;
3383  }
3384  else /* activate the codec */
3385  {
3386  dbug(1, dprintf("Ext_Ctrl start"));
3387  if (AdvCodecSupport(a, plci, appl, 0))
3388  {
3389  dbug(1, dprintf("Error in codec procedures"));
3390  Info = _WRONG_STATE;
3391  }
3392  else if (plci->spoofed_msg == SPOOFING_REQUIRED) /* wait until codec is active */
3393  {
3394  plci->spoofed_msg = AWAITING_SELECT_B;
3395  plci->internal_command = BLOCK_PLCI; /* lock other commands */
3396  plci->command = 0;
3397  dbug(1, dprintf("continue if codec loaded"));
3398  return false;
3399  }
3400  }
3401  }
3402  }
3403  else /* external controller bit is OFF */
3404  {
3405  if (tel) /* external controller in use, need to switch off */
3406  {
3407  if (a->AdvSignalAppl == appl)
3408  {
3409  CodecIdCheck(a, plci);
3410  plci->tel = 0;
3411  plci->adv_nl = 0;
3412  dbug(1, dprintf("Ext_Ctrl disable"));
3413  }
3414  else
3415  {
3416  dbug(1, dprintf("Ext_Ctrl not requested"));
3417  }
3418  }
3419  }
3420  if (!Info)
3421  {
3422  if (plci->call_dir & CALL_DIR_OUT)
3423  plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
3424  else if (plci->call_dir & CALL_DIR_IN)
3425  plci->call_dir = CALL_DIR_IN | CALL_DIR_ANSWER;
3426  start_internal_command(Id, plci, select_b_command);
3427  return false;
3428  }
3429  }
3430  }
3431  sendf(appl, _SELECT_B_REQ | CONFIRM, Id, Number, "w", Info);
3432  return false;
3433 }
3434 
3435 static byte manufacturer_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3436  PLCI *plci, APPL *appl, API_PARSE *parms)
3437 {
3438  word command;
3439  word i;
3440  word ncci;
3441  API_PARSE *m;
3442  API_PARSE m_parms[5];
3443  word codec;
3444  byte req;
3445  byte ch;
3446  byte dir;
3447  static byte chi[2] = {0x01, 0x00};
3448  static byte lli[2] = {0x01, 0x00};
3449  static byte codec_cai[2] = {0x01, 0x01};
3450  static byte null_msg = {0};
3451  static API_PARSE null_parms = { 0, &null_msg };
3452  PLCI *v_plci;
3453  word Info = 0;
3454 
3455  dbug(1, dprintf("manufacturer_req"));
3456  for (i = 0; i < 5; i++) m_parms[i].length = 0;
3457 
3458  if (GET_DWORD(parms[0].info) != _DI_MANU_ID) {
3459  Info = _WRONG_MESSAGE_FORMAT;
3460  }
3461  command = GET_WORD(parms[1].info);
3462  m = &parms[2];
3463  if (!Info)
3464  {
3465  switch (command) {
3466  case _DI_ASSIGN_PLCI:
3467  if (api_parse(&m->info[1], (word)m->length, "wbbs", m_parms)) {
3468  Info = _WRONG_MESSAGE_FORMAT;
3469  break;
3470  }
3471  codec = GET_WORD(m_parms[0].info);
3472  ch = m_parms[1].info[0];
3473  dir = m_parms[2].info[0];
3474  if ((i = get_plci(a))) {
3475  plci = &a->plci[i - 1];
3476  plci->appl = appl;
3477  plci->command = _MANUFACTURER_R;
3478  plci->m_command = command;
3479  plci->number = Number;
3480  plci->State = LOCAL_CONNECT;
3481  Id = (((word)plci->Id << 8) | plci->adapter->Id | 0x80);
3482  dbug(1, dprintf("ManCMD,plci=0x%x", Id));
3483 
3484  if ((ch == 1 || ch == 2) && (dir <= 2)) {
3485  chi[1] = (byte)(0x80 | ch);
3486  lli[1] = 0;
3487  plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
3488  switch (codec)
3489  {
3490  case 0:
3491  Info = add_b1(plci, &m_parms[3], 0, 0);
3492  break;
3493  case 1:
3494  add_p(plci, CAI, codec_cai);
3495  break;
3496  /* manual 'swich on' to the codec support without signalling */
3497  /* first 'assign plci' with this function, then use */
3498  case 2:
3499  if (AdvCodecSupport(a, plci, appl, 0)) {
3500  Info = _RESOURCE_ERROR;
3501  }
3502  else {
3503  Info = add_b1(plci, &null_parms, 0, B1_FACILITY_LOCAL);
3504  lli[1] = 0x10; /* local call codec stream */
3505  }
3506  break;
3507  }
3508 
3509  plci->State = LOCAL_CONNECT;
3510  plci->manufacturer = true;
3511  plci->command = _MANUFACTURER_R;
3512  plci->m_command = command;
3513  plci->number = Number;
3514 
3515  if (!Info)
3516  {
3517  add_p(plci, LLI, lli);
3518  add_p(plci, CHI, chi);
3519  add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
3520  sig_req(plci, ASSIGN, DSIG_ID);
3521 
3522  if (!codec)
3523  {
3524  Info = add_b23(plci, &m_parms[3]);
3525  if (!Info)
3526  {
3527  nl_req_ncci(plci, ASSIGN, 0);
3528  send_req(plci);
3529  }
3530  }
3531  if (!Info)
3532  {
3533  dbug(1, dprintf("dir=0x%x,spoof=0x%x", dir, plci->spoofed_msg));
3534  if (plci->spoofed_msg == SPOOFING_REQUIRED)
3535  {
3536  api_save_msg(m_parms, "wbbs", &plci->saved_msg);
3537  plci->spoofed_msg = AWAITING_MANUF_CON;
3538  plci->internal_command = BLOCK_PLCI; /* reject other req meanwhile */
3539  plci->command = 0;
3540  send_req(plci);
3541  return false;
3542  }
3543  if (dir == 1) {
3544  sig_req(plci, CALL_REQ, 0);
3545  }
3546  else if (!dir) {
3547  sig_req(plci, LISTEN_REQ, 0);
3548  }
3549  send_req(plci);
3550  }
3551  else
3552  {
3553  sendf(appl,
3554  _MANUFACTURER_R | CONFIRM,
3555  Id,
3556  Number,
3557  "dww", _DI_MANU_ID, command, Info);
3558  return 2;
3559  }
3560  }
3561  }
3562  }
3563  else Info = _OUT_OF_PLCI;
3564  break;
3565 
3566  case _DI_IDI_CTRL:
3567  if (!plci)
3568  {
3569  Info = _WRONG_IDENTIFIER;
3570  break;
3571  }
3572  if (api_parse(&m->info[1], (word)m->length, "bs", m_parms)) {
3573  Info = _WRONG_MESSAGE_FORMAT;
3574  break;
3575  }
3576  req = m_parms[0].info[0];
3577  plci->command = _MANUFACTURER_R;
3578  plci->m_command = command;
3579  plci->number = Number;
3580  if (req == CALL_REQ)
3581  {
3582  plci->b_channel = getChannel(&m_parms[1]);
3583  mixer_set_bchannel_id_esc(plci, plci->b_channel);
3584  if (plci->spoofed_msg == SPOOFING_REQUIRED)
3585  {
3586  plci->spoofed_msg = CALL_REQ | AWAITING_MANUF_CON;
3587  plci->internal_command = BLOCK_PLCI; /* reject other req meanwhile */
3588  plci->command = 0;
3589  break;
3590  }
3591  }
3592  else if (req == LAW_REQ)
3593  {
3594  plci->cr_enquiry = true;
3595  }
3596  add_ss(plci, FTY, &m_parms[1]);
3597  sig_req(plci, req, 0);
3598  send_req(plci);
3599  if (req == HANGUP)
3600  {
3601  if (plci->NL.Id && !plci->nl_remove_id)
3602  {
3603  if (plci->channels)
3604  {
3605  for (ncci = 1; ncci < MAX_NCCI + 1; ncci++)
3606  {
3607  if ((a->ncci_plci[ncci] == plci->Id) && (a->ncci_state[ncci] == CONNECTED))
3608  {
3609  a->ncci_state[ncci] = OUTG_DIS_PENDING;
3610  cleanup_ncci_data(plci, ncci);
3611  nl_req_ncci(plci, N_DISC, (byte)ncci);
3612  }
3613  }
3614  }
3615  mixer_remove(plci);
3616  nl_req_ncci(plci, REMOVE, 0);
3617  send_req(plci);
3618  }
3619  }
3620  break;
3621 
3622  case _DI_SIG_CTRL:
3623  /* signalling control for loop activation B-channel */
3624  if (!plci)
3625  {
3626  Info = _WRONG_IDENTIFIER;
3627  break;
3628  }
3629  if (m->length) {
3630  plci->command = _MANUFACTURER_R;
3631  plci->number = Number;
3632  add_ss(plci, FTY, m);
3633  sig_req(plci, SIG_CTRL, 0);
3634  send_req(plci);
3635  }
3636  else Info = _WRONG_MESSAGE_FORMAT;
3637  break;
3638 
3639  case _DI_RXT_CTRL:
3640  /* activation control for receiver/transmitter B-channel */
3641  if (!plci)
3642  {
3643  Info = _WRONG_IDENTIFIER;
3644  break;
3645  }
3646  if (m->length) {
3647  plci->command = _MANUFACTURER_R;
3648  plci->number = Number;
3649  add_ss(plci, FTY, m);
3650  sig_req(plci, DSP_CTRL, 0);
3651  send_req(plci);
3652  }
3653  else Info = _WRONG_MESSAGE_FORMAT;
3654  break;
3655 
3656  case _DI_ADV_CODEC:
3657  case _DI_DSP_CTRL:
3658  /* TEL_CTRL commands to support non standard adjustments: */
3659  /* Ring on/off, Handset micro volume, external micro vol. */
3660  /* handset+external speaker volume, receiver+transm. gain,*/
3661  /* handsfree on (hookinfo off), set mixer command */
3662 
3663  if (command == _DI_ADV_CODEC)
3664  {
3665  if (!a->AdvCodecPLCI) {
3666  Info = _WRONG_STATE;
3667  break;
3668  }
3669  v_plci = a->AdvCodecPLCI;
3670  }
3671  else
3672  {
3673  if (plci
3674  && (m->length >= 3)
3675  && (m->info[1] == 0x1c)
3676  && (m->info[2] >= 1))
3677  {
3678  if (m->info[3] == DSP_CTRL_OLD_SET_MIXER_COEFFICIENTS)
3679  {
3680  if ((plci->tel != ADV_VOICE) || (plci != a->AdvSignalPLCI))
3681  {
3682  Info = _WRONG_STATE;
3683  break;
3684  }
3685  a->adv_voice_coef_length = m->info[2] - 1;
3686  if (a->adv_voice_coef_length > m->length - 3)
3687  a->adv_voice_coef_length = (byte)(m->length - 3);
3688  if (a->adv_voice_coef_length > ADV_VOICE_COEF_BUFFER_SIZE)
3689  a->adv_voice_coef_length = ADV_VOICE_COEF_BUFFER_SIZE;
3690  for (i = 0; i < a->adv_voice_coef_length; i++)
3691  a->adv_voice_coef_buffer[i] = m->info[4 + i];
3692  if (plci->B1_facilities & B1_FACILITY_VOICE)
3693  adv_voice_write_coefs(plci, ADV_VOICE_WRITE_UPDATE);
3694  break;
3695  }
3696  else if (m->info[3] == DSP_CTRL_SET_DTMF_PARAMETERS)
3697  {
3698  if (!(a->manufacturer_features & MANUFACTURER_FEATURE_DTMF_PARAMETERS))
3699  {
3700  Info = _FACILITY_NOT_SUPPORTED;
3701  break;
3702  }
3703 
3704  plci->dtmf_parameter_length = m->info[2] - 1;
3705  if (plci->dtmf_parameter_length > m->length - 3)
3706  plci->dtmf_parameter_length = (byte)(m->length - 3);
3707  if (plci->dtmf_parameter_length > DTMF_PARAMETER_BUFFER_SIZE)
3708  plci->dtmf_parameter_length = DTMF_PARAMETER_BUFFER_SIZE;
3709  for (i = 0; i < plci->dtmf_parameter_length; i++)
3710  plci->dtmf_parameter_buffer[i] = m->info[4 + i];
3711  if (plci->B1_facilities & B1_FACILITY_DTMFR)
3712  dtmf_parameter_write(plci);
3713  break;
3714 
3715  }
3716  }
3717  v_plci = plci;
3718  }
3719 
3720  if (!v_plci)
3721  {
3722  Info = _WRONG_IDENTIFIER;
3723  break;
3724  }
3725  if (m->length) {
3726  add_ss(v_plci, FTY, m);
3727  sig_req(v_plci, TEL_CTRL, 0);
3728  send_req(v_plci);
3729  }
3730  else Info = _WRONG_MESSAGE_FORMAT;
3731 
3732  break;
3733 
3734  case _DI_OPTIONS_REQUEST:
3735  if (api_parse(&m->info[1], (word)m->length, "d", m_parms)) {
3736  Info = _WRONG_MESSAGE_FORMAT;
3737  break;
3738  }
3739  if (GET_DWORD(m_parms[0].info) & ~a->man_profile.private_options)
3740  {
3741  Info = _FACILITY_NOT_SUPPORTED;
3742  break;
3743  }
3744  a->requested_options_table[appl->Id - 1] = GET_DWORD(m_parms[0].info);
3745  break;
3746 
3747 
3748 
3749  default:
3750  Info = _WRONG_MESSAGE_FORMAT;
3751  break;
3752  }
3753  }
3754 
3755  sendf(appl,
3756  _MANUFACTURER_R | CONFIRM,
3757  Id,
3758  Number,
3759  "dww", _DI_MANU_ID, command, Info);
3760  return false;
3761 }
3762 
3763 
3764 static byte manufacturer_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3765  PLCI *plci, APPL *appl, API_PARSE *msg)
3766 {
3767  word indication;
3768 
3769  API_PARSE m_parms[3];
3770  API_PARSE *ncpi;
3771  API_PARSE fax_parms[9];
3772  word i;
3773  byte len;
3774 
3775 
3776  dbug(1, dprintf("manufacturer_res"));
3777 
3778  if ((msg[0].length == 0)
3779  || (msg[1].length == 0)
3780  || (GET_DWORD(msg[0].info) != _DI_MANU_ID))
3781  {
3782  return false;
3783  }
3784  indication = GET_WORD(msg[1].info);
3785  switch (indication)
3786  {
3787 
3788  case _DI_NEGOTIATE_B3:
3789  if (!plci)
3790  break;
3791  if (((plci->B3_prot != 4) && (plci->B3_prot != 5))
3792  || !(plci->ncpi_state & NCPI_NEGOTIATE_B3_SENT))
3793  {
3794  dbug(1, dprintf("wrong state for NEGOTIATE_B3 parameters"));
3795  break;
3796  }
3797  if (api_parse(&msg[2].info[1], msg[2].length, "ws", m_parms))
3798  {
3799  dbug(1, dprintf("wrong format in NEGOTIATE_B3 parameters"));
3800  break;
3801  }
3802  ncpi = &m_parms[1];
3803  len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
3804  if (plci->fax_connect_info_length < len)
3805  {
3806  ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id_len = 0;
3807  ((T30_INFO *)(plci->fax_connect_info_buffer))->head_line_len = 0;
3808  }
3809  if (api_parse(&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms))
3810  {
3811  dbug(1, dprintf("non-standard facilities info missing or wrong format"));
3812  }
3813  else
3814  {
3815  if (plci->fax_connect_info_length <= len)
3816  plci->fax_connect_info_buffer[len] = 0;
3817  len += 1 + plci->fax_connect_info_buffer[len];
3818  if (plci->fax_connect_info_length <= len)
3819  plci->fax_connect_info_buffer[len] = 0;
3820  len += 1 + plci->fax_connect_info_buffer[len];
3821  if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2))
3822  plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]);
3823  plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length);
3824  for (i = 0; i < fax_parms[7].length; i++)
3825  plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1 + i];
3826  }
3827  plci->fax_connect_info_length = len;
3828  plci->fax_edata_ack_length = plci->fax_connect_info_length;
3829  start_internal_command(Id, plci, fax_edata_ack_command);
3830  break;
3831 
3832  }
3833  return false;
3834 }
3835 
3836 /*------------------------------------------------------------------*/
3837 /* IDI callback function */
3838 /*------------------------------------------------------------------*/
3839 
3840 void callback(ENTITY *e)
3841 {
3842  DIVA_CAPI_ADAPTER *a;
3843  APPL *appl;
3844  PLCI *plci;
3845  CAPI_MSG *m;
3846  word i, j;
3847  byte rc;
3848  byte ch;
3849  byte req;
3850  byte global_req;
3851  int no_cancel_rc;
3852 
3853  dbug(1, dprintf("%x:CB(%x:Req=%x,Rc=%x,Ind=%x)",
3854  (e->user[0] + 1) & 0x7fff, e->Id, e->Req, e->Rc, e->Ind));
3855 
3856  a = &(adapter[(byte)e->user[0]]);
3857  plci = &(a->plci[e->user[1]]);
3858  no_cancel_rc = DIVA_CAPI_SUPPORTS_NO_CANCEL(a);
3859 
3860  /*
3861  If new protocol code and new XDI is used then CAPI should work
3862  fully in accordance with IDI cpec an look on callback field instead
3863  of Rc field for return codes.
3864  */
3865  if (((e->complete == 0xff) && no_cancel_rc) ||
3866  (e->Rc && !no_cancel_rc)) {
3867  rc = e->Rc;
3868  ch = e->RcCh;
3869  req = e->Req;
3870  e->Rc = 0;
3871 
3872  if (e->user[0] & 0x8000)
3873  {
3874  /*
3875  If REMOVE request was sent then we have to wait until
3876  return code with Id set to zero arrives.
3877  All other return codes should be ignored.
3878  */
3879  if (req == REMOVE)
3880  {
3881  if (e->Id)
3882  {
3883  dbug(1, dprintf("cancel RC in REMOVE state"));
3884  return;
3885  }
3886  channel_flow_control_remove(plci);
3887  for (i = 0; i < 256; i++)
3888  {
3889  if (a->FlowControlIdTable[i] == plci->nl_remove_id)
3890  a->FlowControlIdTable[i] = 0;
3891  }
3892  plci->nl_remove_id = 0;
3893  if (plci->rx_dma_descriptor > 0) {
3894  diva_free_dma_descriptor(plci, plci->rx_dma_descriptor - 1);
3895  plci->rx_dma_descriptor = 0;
3896  }
3897  }
3898  if (rc == OK_FC)
3899  {
3900  a->FlowControlIdTable[ch] = e->Id;
3901  a->FlowControlSkipTable[ch] = 0;
3902 
3903  a->ch_flow_control[ch] |= N_OK_FC_PENDING;
3904  a->ch_flow_plci[ch] = plci->Id;
3905  plci->nl_req = 0;
3906  }
3907  else
3908  {
3909  /*
3910  Cancel return codes self, if feature was requested
3911  */
3912  if (no_cancel_rc && (a->FlowControlIdTable[ch] == e->Id) && e->Id) {
3913  a->FlowControlIdTable[ch] = 0;
3914  if ((rc == OK) && a->FlowControlSkipTable[ch]) {
3915  dbug(3, dprintf("XDI CAPI: RC cancelled Id:0x02, Ch:%02x", e->Id, ch));
3916  return;
3917  }
3918  }
3919 
3920  if (a->ch_flow_control[ch] & N_OK_FC_PENDING)
3921  {
3922  a->ch_flow_control[ch] &= ~N_OK_FC_PENDING;
3923  if (ch == e->ReqCh)
3924  plci->nl_req = 0;
3925  }
3926  else
3927  plci->nl_req = 0;
3928  }
3929  if (plci->nl_req)
3930  control_rc(plci, 0, rc, ch, 0, true);
3931  else
3932  {
3933  if (req == N_XON)
3934  {
3935  channel_x_on(plci, ch);
3936  if (plci->internal_command)
3937  control_rc(plci, req, rc, ch, 0, true);
3938  }
3939  else
3940  {
3941  if (plci->nl_global_req)
3942  {
3943  global_req = plci->nl_global_req;
3944  plci->nl_global_req = 0;
3945  if (rc != ASSIGN_OK) {
3946  e->Id = 0;
3947  if (plci->rx_dma_descriptor > 0) {
3948  diva_free_dma_descriptor(plci, plci->rx_dma_descriptor - 1);
3949  plci->rx_dma_descriptor = 0;
3950  }
3951  }
3952  channel_xmit_xon(plci);
3953  control_rc(plci, 0, rc, ch, global_req, true);
3954  }
3955  else if (plci->data_sent)
3956  {
3957  channel_xmit_xon(plci);
3958  plci->data_sent = false;
3959  plci->NL.XNum = 1;
3960  data_rc(plci, ch);
3961  if (plci->internal_command)
3962  control_rc(plci, req, rc, ch, 0, true);
3963  }
3964  else
3965  {
3966  channel_xmit_xon(plci);
3967  control_rc(plci, req, rc, ch, 0, true);
3968  }
3969  }
3970  }
3971  }
3972  else
3973  {
3974  /*
3975  If REMOVE request was sent then we have to wait until
3976  return code with Id set to zero arrives.
3977  All other return codes should be ignored.
3978  */
3979  if (req == REMOVE)
3980  {
3981  if (e->Id)
3982  {
3983  dbug(1, dprintf("cancel RC in REMOVE state"));
3984  return;
3985  }
3986  plci->sig_remove_id = 0;
3987  }
3988  plci->sig_req = 0;
3989  if (plci->sig_global_req)
3990  {
3991  global_req = plci->sig_global_req;
3992  plci->sig_global_req = 0;
3993  if (rc != ASSIGN_OK)
3994  e->Id = 0;
3995  channel_xmit_xon(plci);
3996  control_rc(plci, 0, rc, ch, global_req, false);
3997  }
3998  else
3999  {
4000  channel_xmit_xon(plci);
4001  control_rc(plci, req, rc, ch, 0, false);
4002  }
4003  }
4004  /*
4005  Again: in accordance with IDI spec Rc and Ind can't be delivered in the
4006  same callback. Also if new XDI and protocol code used then jump
4007  direct to finish.
4008  */
4009  if (no_cancel_rc) {
4010  channel_xmit_xon(plci);
4011  goto capi_callback_suffix;
4012  }
4013  }
4014 
4015  channel_xmit_xon(plci);
4016 
4017  if (e->Ind) {
4018  if (e->user[0] & 0x8000) {
4019  byte Ind = e->Ind & 0x0f;
4020  byte Ch = e->IndCh;
4021  if (((Ind == N_DISC) || (Ind == N_DISC_ACK)) &&
4022  (a->ch_flow_plci[Ch] == plci->Id)) {
4023  if (a->ch_flow_control[Ch] & N_RX_FLOW_CONTROL_MASK) {
4024  dbug(3, dprintf("XDI CAPI: I: pending N-XON Ch:%02x", Ch));
4025  }
4026  a->ch_flow_control[Ch] &= ~N_RX_FLOW_CONTROL_MASK;
4027  }
4028  nl_ind(plci);
4029  if ((e->RNR != 1) &&
4030  (a->ch_flow_plci[Ch] == plci->Id) &&
4031  (a->ch_flow_control[Ch] & N_RX_FLOW_CONTROL_MASK)) {
4032  a->ch_flow_control[Ch] &= ~N_RX_FLOW_CONTROL_MASK;
4033  dbug(3, dprintf("XDI CAPI: I: remove faked N-XON Ch:%02x", Ch));
4034  }
4035  } else {
4036  sig_ind(plci);
4037  }
4038  e->Ind = 0;
4039  }
4040 
4041 capi_callback_suffix:
4042 
4043  while (!plci->req_in
4044  && !plci->internal_command
4045  && (plci->msg_in_write_pos != plci->msg_in_read_pos))
4046  {
4047  j = (plci->msg_in_read_pos == plci->msg_in_wrap_pos) ? 0 : plci->msg_in_read_pos;
4048 
4049  i = (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[j]))->header.length + 3) & 0xfffc;
4050 
4051  m = (CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[j]);
4052  appl = *((APPL **)(&((byte *)(plci->msg_in_queue))[j + i]));
4053  dbug(1, dprintf("dequeue msg(0x%04x) - write=%d read=%d wrap=%d",
4054  m->header.command, plci->msg_in_write_pos, plci->msg_in_read_pos, plci->msg_in_wrap_pos));
4055  if (plci->msg_in_read_pos == plci->msg_in_wrap_pos)
4056  {
4057  plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
4058  plci->msg_in_read_pos = i + MSG_IN_OVERHEAD;
4059  }
4060  else
4061  {
4062  plci->msg_in_read_pos = j + i + MSG_IN_OVERHEAD;
4063  }
4064  if (plci->msg_in_read_pos == plci->msg_in_write_pos)
4065  {
4066  plci->msg_in_write_pos = MSG_IN_QUEUE_SIZE;
4067  plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
4068  }
4069  else if (plci->msg_in_read_pos == plci->msg_in_wrap_pos)
4070  {
4071  plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
4072  plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
4073  }
4074  i = api_put(appl, m);
4075  if (i != 0)
4076  {
4077  if (m->header.command == _DATA_B3_R)
4078 
4079  TransmitBufferFree(appl, (byte *)(long)(m->info.data_b3_req.Data));
4080 
4081  dbug(1, dprintf("Error 0x%04x from msg(0x%04x)", i, m->header.command));
4082  break;
4083  }
4084 
4085  if (plci->li_notify_update)
4086  {
4087  plci->li_notify_update = false;
4088  mixer_notify_update(plci, false);
4089  }
4090 
4091  }
4092  send_data(plci);
4093  send_req(plci);
4094 }
4095 
4096 
4097 static void control_rc(PLCI *plci, byte req, byte rc, byte ch, byte global_req,
4098  byte nl_rc)
4099 {
4100  dword Id;
4101  dword rId;
4102  word Number;
4103  word Info = 0;
4104  word i;
4105  word ncci;
4106  DIVA_CAPI_ADAPTER *a;
4107  APPL *appl;
4108  PLCI *rplci;
4109  byte SSparms[] = "\x05\x00\x00\x02\x00\x00";
4110  byte SSstruct[] = "\x09\x00\x00\x06\x00\x00\x00\x00\x00\x00";
4111 
4112  if (!plci) {
4113  dbug(0, dprintf("A: control_rc, no plci %02x:%02x:%02x:%02x:%02x", req, rc, ch, global_req, nl_rc));
4114  return;
4115  }
4116  dbug(1, dprintf("req0_in/out=%d/%d", plci->req_in, plci->req_out));
4117  if (plci->req_in != plci->req_out)
4118  {
4119  if (nl_rc || (global_req != ASSIGN) || (rc == ASSIGN_OK))
4120  {
4121  dbug(1, dprintf("req_1return"));
4122  return;
4123  }
4124  /* cancel outstanding request on the PLCI after SIG ASSIGN failure */
4125  }
4126  plci->req_in = plci->req_in_start = plci->req_out = 0;
4127  dbug(1, dprintf("control_rc"));
4128 
4129  appl = plci->appl;
4130  a = plci->adapter;
4131  ncci = a->ch_ncci[ch];
4132  if (appl)
4133  {
4134  Id = (((dword)(ncci ? ncci : ch)) << 16) | ((word)plci->Id << 8) | a->Id;
4135  if (plci->tel && plci->SuppState != CALL_HELD) Id |= EXT_CONTROLLER;
4136  Number = plci->number;
4137  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));
4138  dbug(1, dprintf("channels=0x%x", plci->channels));
4139  if (plci_remove_check(plci))
4140  return;
4141  if (req == REMOVE && rc == ASSIGN_OK)
4142  {
4143  sig_req(plci, HANGUP, 0);
4144  sig_req(plci, REMOVE, 0);
4145  send_req(plci);
4146  }
4147  if (plci->command)
4148  {
4149  switch (plci->command)
4150  {
4151  case C_HOLD_REQ:
4152  dbug(1, dprintf("HoldRC=0x%x", rc));
4153  SSparms[1] = (byte)S_HOLD;
4154  if (rc != OK)
4155  {
4156  plci->SuppState = IDLE;
4157  Info = 0x2001;
4158  }
4159  sendf(appl, _FACILITY_R | CONFIRM, Id, Number, "wws", Info, 3, SSparms);
4160  break;
4161 
4162  case C_RETRIEVE_REQ:
4163  dbug(1, dprintf("RetrieveRC=0x%x", rc));
4164  SSparms[1] = (byte)S_RETRIEVE;
4165  if (rc != OK)
4166  {
4167  plci->SuppState = CALL_HELD;
4168  Info = 0x2001;
4169  }
4170  sendf(appl, _FACILITY_R | CONFIRM, Id, Number, "wws", Info, 3, SSparms);
4171  break;
4172 
4173  case _INFO_R:
4174  dbug(1, dprintf("InfoRC=0x%x", rc));
4175  if (rc != OK) Info = _WRONG_STATE;
4176  sendf(appl, _INFO_R | CONFIRM, Id, Number, "w", Info);
4177  break;
4178 
4179  case _CONNECT_R:
4180  dbug(1, dprintf("Connect_R=0x%x/0x%x/0x%x/0x%x", req, rc, global_req, nl_rc));
4181  if (plci->State == INC_DIS_PENDING)
4182  break;
4183  if (plci->Sig.Id != 0xff)
4184  {
4185  if (((global_req == ASSIGN) && (rc != ASSIGN_OK))
4186  || (!nl_rc && (req == CALL_REQ) && (rc != OK)))
4187  {
4188  dbug(1, dprintf("No more IDs/Call_Req failed"));
4189  sendf(appl, _CONNECT_R | CONFIRM, Id & 0xffL, Number, "w", _OUT_OF_PLCI);
4190  plci_remove(plci);
4191  plci->State = IDLE;
4192  break;
4193  }
4194  if (plci->State != LOCAL_CONNECT) plci->State = OUTG_CON_PENDING;
4195  sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", 0);
4196  }
4197  else /* D-ch activation */
4198  {
4199  if (rc != ASSIGN_OK)
4200  {
4201  dbug(1, dprintf("No more IDs/X.25 Call_Req failed"));
4202  sendf(appl, _CONNECT_R | CONFIRM, Id & 0xffL, Number, "w", _OUT_OF_PLCI);
4203  plci_remove(plci);
4204  plci->State = IDLE;
4205  break;
4206  }
4207  sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", 0);
4208  sendf(plci->appl, _CONNECT_ACTIVE_I, Id, 0, "sss", "", "", "");
4209  plci->State = INC_ACT_PENDING;
4210  }
4211  break;
4212 
4213  case _CONNECT_I | RESPONSE:
4214  if (plci->State != INC_DIS_PENDING)
4215  plci->State = INC_CON_ACCEPT;
4216  break;
4217 
4218  case _DISCONNECT_R:
4219  if (plci->State == INC_DIS_PENDING)
4220  break;
4221  if (plci->Sig.Id != 0xff)
4222  {
4223  plci->State = OUTG_DIS_PENDING;
4224  sendf(appl, _DISCONNECT_R | CONFIRM, Id, Number, "w", 0);
4225  }
4226  break;
4227 
4228  case SUSPEND_REQ:
4229  break;
4230 
4231  case RESUME_REQ:
4232  break;
4233 
4234  case _CONNECT_B3_R:
4235  if (rc != OK)
4236  {
4237  sendf(appl, _CONNECT_B3_R | CONFIRM, Id, Number, "w", _WRONG_IDENTIFIER);
4238  break;
4239  }
4240  ncci = get_ncci(plci, ch, 0);
4241  Id = (Id & 0xffff) | (((dword) ncci) << 16);
4242  plci->channels++;
4243  if (req == N_RESET)
4244  {
4245  a->ncci_state[ncci] = INC_ACT_PENDING;
4246  sendf(appl, _CONNECT_B3_R | CONFIRM, Id, Number, "w", 0);
4247  sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
4248  }
4249  else
4250  {
4251  a->ncci_state[ncci] = OUTG_CON_PENDING;
4252  sendf(appl, _CONNECT_B3_R | CONFIRM, Id, Number, "w", 0);
4253  }
4254  break;
4255 
4256  case _CONNECT_B3_I | RESPONSE:
4257  break;
4258 
4259  case _RESET_B3_R:
4260 /* sendf(appl, _RESET_B3_R | CONFIRM, Id, Number, "w", 0);*/
4261  break;
4262 
4263  case _DISCONNECT_B3_R:
4264  sendf(appl, _DISCONNECT_B3_R | CONFIRM, Id, Number, "w", 0);
4265  break;
4266 
4267  case _MANUFACTURER_R:
4268  break;
4269 
4270  case PERM_LIST_REQ:
4271  if (rc != OK)
4272  {
4273  Info = _WRONG_IDENTIFIER;
4274  sendf(plci->appl, _CONNECT_R | CONFIRM, Id, Number, "w", Info);
4275  plci_remove(plci);
4276  }
4277  else
4278  sendf(plci->appl, _CONNECT_R | CONFIRM, Id, Number, "w", Info);
4279  break;
4280 
4281  default:
4282  break;
4283  }
4284  plci->command = 0;
4285  }
4286  else if (plci->internal_command)
4287  {
4288  switch (plci->internal_command)
4289  {
4290  case BLOCK_PLCI:
4291  return;
4292 
4293  case GET_MWI_STATE:
4294  if (rc == OK) /* command supported, wait for indication */
4295  {
4296  return;
4297  }
4298  plci_remove(plci);
4299  break;
4300 
4301  /* Get Supported Services */
4302  case GETSERV_REQ_PEND:
4303  if (rc == OK) /* command supported, wait for indication */
4304  {
4305  break;
4306  }
4307  PUT_DWORD(&SSstruct[6], MASK_TERMINAL_PORTABILITY);
4308  sendf(appl, _FACILITY_R | CONFIRM, Id, Number, "wws", 0, 3, SSstruct);
4309  plci_remove(plci);
4310  break;
4311 
4312  case INTERR_DIVERSION_REQ_PEND: /* Interrogate Parameters */
4313  case INTERR_NUMBERS_REQ_PEND:
4314  case CF_START_PEND: /* Call Forwarding Start pending */
4315  case CF_STOP_PEND: /* Call Forwarding Stop pending */
4316  case CCBS_REQUEST_REQ_PEND:
4317  case CCBS_DEACTIVATE_REQ_PEND:
4318  case CCBS_INTERROGATE_REQ_PEND:
4319  switch (plci->internal_command)
4320  {
4321  case INTERR_DIVERSION_REQ_PEND:
4322  SSparms[1] = S_INTERROGATE_DIVERSION;
4323  break;
4324  case INTERR_NUMBERS_REQ_PEND:
4325  SSparms[1] = S_INTERROGATE_NUMBERS;
4326  break;
4327  case CF_START_PEND:
4328  SSparms[1] = S_CALL_FORWARDING_START;
4329  break;
4330  case CF_STOP_PEND:
4331  SSparms[1] = S_CALL_FORWARDING_STOP;
4332  break;
4333  case CCBS_REQUEST_REQ_PEND:
4334  SSparms[1] = S_CCBS_REQUEST;
4335  break;
4336  case CCBS_DEACTIVATE_REQ_PEND:
4337  SSparms[1] = S_CCBS_DEACTIVATE;
4338  break;
4339  case CCBS_INTERROGATE_REQ_PEND:
4340  SSparms[1] = S_CCBS_INTERROGATE;
4341  break;
4342  }
4343  if (global_req == ASSIGN)
4344  {
4345  dbug(1, dprintf("AssignDiversion_RC=0x%x/0x%x", req, rc));
4346  return;
4347  }
4348  if (!plci->appl) break;
4349  if (rc == ISDN_GUARD_REJ)
4350  {
4351  Info = _CAPI_GUARD_ERROR;
4352  }
4353  else if (rc != OK)
4354  {
4355  Info = _SUPPLEMENTARY_SERVICE_NOT_SUPPORTED;
4356  }
4357  sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0x7,
4358  plci->number, "wws", Info, (word)3, SSparms);
4359  if (Info) plci_remove(plci);
4360  break;
4361 
4362  /* 3pty conference pending */
4363  case PTY_REQ_PEND:
4364  if (!plci->relatedPTYPLCI) break;
4365  rplci = plci->relatedPTYPLCI;
4366  SSparms[1] = plci->ptyState;
4367  rId = ((word)rplci->Id << 8) | rplci->adapter->Id;
4368  if (rplci->tel) rId |= EXT_CONTROLLER;
4369  if (rc != OK)
4370  {
4371  Info = 0x300E; /* not supported */
4372  plci->relatedPTYPLCI = NULL;
4373  plci->ptyState = 0;
4374  }
4375  sendf(rplci->appl,
4376  _FACILITY_R | CONFIRM,
4377  rId,
4378  plci->number,
4379  "wws", Info, (word)3, SSparms);
4380  break;
4381 
4382  /* Explicit Call Transfer pending */
4383  case ECT_REQ_PEND:
4384  dbug(1, dprintf("ECT_RC=0x%x/0x%x", req, rc));
4385  if (!plci->relatedPTYPLCI) break;
4386  rplci = plci->relatedPTYPLCI;
4387  SSparms[1] = S_ECT;
4388  rId = ((word)rplci->Id << 8) | rplci->adapter->Id;
4389  if (rplci->tel) rId |= EXT_CONTROLLER;
4390  if (rc != OK)
4391  {
4392  Info = 0x300E; /* not supported */
4393  plci->relatedPTYPLCI = NULL;
4394  plci->ptyState = 0;
4395  }
4396  sendf(rplci->appl,
4397  _FACILITY_R | CONFIRM,
4398  rId,
4399  plci->number,
4400  "wws", Info, (word)3, SSparms);
4401  break;
4402 
4403  case _MANUFACTURER_R:
4404  dbug(1, dprintf("_Manufacturer_R=0x%x/0x%x", req, rc));
4405  if ((global_req == ASSIGN) && (rc != ASSIGN_OK))
4406  {
4407  dbug(1, dprintf("No more IDs"));
4408  sendf(appl, _MANUFACTURER_R | CONFIRM, Id, Number, "dww", _DI_MANU_ID, _MANUFACTURER_R, _OUT_OF_PLCI);
4409  plci_remove(plci); /* after codec init, internal codec commands pending */
4410  }
4411  break;
4412 
4413  case _CONNECT_R:
4414  dbug(1, dprintf("_Connect_R=0x%x/0x%x", req, rc));
4415  if ((global_req == ASSIGN) && (rc != ASSIGN_OK))
4416  {
4417  dbug(1, dprintf("No more IDs"));
4418  sendf(appl, _CONNECT_R | CONFIRM, Id & 0xffL, Number, "w", _OUT_OF_PLCI);
4419  plci_remove(plci); /* after codec init, internal codec commands pending */
4420  }
4421  break;
4422 
4423  case PERM_COD_HOOK: /* finished with Hook_Ind */
4424  return;
4425 
4426  case PERM_COD_CALL:
4427  dbug(1, dprintf("***Codec Connect_Pending A, Rc = 0x%x", rc));
4428  plci->internal_command = PERM_COD_CONN_PEND;
4429  return;
4430 
4431  case PERM_COD_ASSIGN:
4432  dbug(1, dprintf("***Codec Assign A, Rc = 0x%x", rc));
4433  if (rc != ASSIGN_OK) break;
4434  sig_req(plci, CALL_REQ, 0);
4435  send_req(plci);
4436  plci->internal_command = PERM_COD_CALL;
4437  return;
4438 
4439  /* Null Call Reference Request pending */
4440  case C_NCR_FAC_REQ:
4441  dbug(1, dprintf("NCR_FAC=0x%x/0x%x", req, rc));
4442  if (global_req == ASSIGN)
4443  {
4444  if (rc == ASSIGN_OK)
4445  {
4446  return;
4447  }
4448  else
4449  {
4450  sendf(appl, _INFO_R | CONFIRM, Id & 0xf, Number, "w", _WRONG_STATE);
4451  appl->NullCREnable = false;
4452  plci_remove(plci);
4453  }
4454  }
4455  else if (req == NCR_FACILITY)
4456  {
4457  if (rc == OK)
4458  {
4459  sendf(appl, _INFO_R | CONFIRM, Id & 0xf, Number, "w", 0);
4460  }
4461  else
4462  {
4463  sendf(appl, _INFO_R | CONFIRM, Id & 0xf, Number, "w", _WRONG_STATE);
4464  appl->NullCREnable = false;
4465  }
4466  plci_remove(plci);
4467  }
4468  break;
4469 
4470  case HOOK_ON_REQ:
4471  if (plci->channels)
4472  {
4473  if (a->ncci_state[ncci] == CONNECTED)
4474  {
4475  a->ncci_state[ncci] = OUTG_DIS_PENDING;
4476  cleanup_ncci_data(plci, ncci);
4477  nl_req_ncci(plci, N_DISC, (byte)ncci);
4478  }
4479  break;
4480  }
4481  break;
4482 
4483  case HOOK_OFF_REQ:
4484  if (plci->State == INC_DIS_PENDING)
4485  break;
4486  sig_req(plci, CALL_REQ, 0);
4487  send_req(plci);
4488  plci->State = OUTG_CON_PENDING;
4489  break;
4490 
4491 
4492  case MWI_ACTIVATE_REQ_PEND:
4493  case MWI_DEACTIVATE_REQ_PEND:
4494  if (global_req == ASSIGN && rc == ASSIGN_OK)
4495  {
4496  dbug(1, dprintf("MWI_REQ assigned"));
4497  return;
4498  }
4499  else if (rc != OK)
4500  {
4501  if (rc == WRONG_IE)
4502  {
4503  Info = 0x2007; /* Illegal message parameter coding */
4504  dbug(1, dprintf("MWI_REQ invalid parameter"));
4505  }
4506  else
4507  {
4508  Info = 0x300B; /* not supported */
4509  dbug(1, dprintf("MWI_REQ not supported"));
4510  }
4511  /* 0x3010: Request not allowed in this state */
4512  PUT_WORD(&SSparms[4], 0x300E); /* SS not supported */
4513 
4514  }
4515  if (plci->internal_command == MWI_ACTIVATE_REQ_PEND)
4516  {
4517  PUT_WORD(&SSparms[1], S_MWI_ACTIVATE);
4518  }
4519  else PUT_WORD(&SSparms[1], S_MWI_DEACTIVATE);
4520 
4521  if (plci->cr_enquiry)
4522  {
4523  sendf(plci->appl,
4524  _FACILITY_R | CONFIRM,
4525  Id & 0xf,
4526  plci->number,
4527  "wws", Info, (word)3, SSparms);
4528  if (rc != OK) plci_remove(plci);
4529  }
4530  else
4531  {
4532  sendf(plci->appl,
4533  _FACILITY_R | CONFIRM,
4534  Id,
4535  plci->number,
4536  "wws", Info, (word)3, SSparms);
4537  }
4538  break;
4539 
4540  case CONF_BEGIN_REQ_PEND:
4541  case CONF_ADD_REQ_PEND:
4542  case CONF_SPLIT_REQ_PEND:
4543  case CONF_DROP_REQ_PEND:
4544  case CONF_ISOLATE_REQ_PEND:
4545  case CONF_REATTACH_REQ_PEND:
4546  dbug(1, dprintf("CONF_RC=0x%x/0x%x", req, rc));
4547  if ((plci->internal_command == CONF_ADD_REQ_PEND) && (!plci->relatedPTYPLCI)) break;
4548  rplci = plci;
4549  rId = Id;
4550  switch (plci->internal_command)
4551  {
4552  case CONF_BEGIN_REQ_PEND:
4553  SSparms[1] = S_CONF_BEGIN;
4554  break;
4555  case CONF_ADD_REQ_PEND:
4556  SSparms[1] = S_CONF_ADD;
4557  rplci = plci->relatedPTYPLCI;
4558  rId = ((word)rplci->Id << 8) | rplci->adapter->Id;
4559  break;
4560  case CONF_SPLIT_REQ_PEND:
4561  SSparms[1] = S_CONF_SPLIT;
4562  break;
4563  case CONF_DROP_REQ_PEND:
4564  SSparms[1] = S_CONF_DROP;
4565  break;
4566  case CONF_ISOLATE_REQ_PEND:
4567  SSparms[1] = S_CONF_ISOLATE;
4568  break;
4569  case CONF_REATTACH_REQ_PEND:
4570  SSparms[1] = S_CONF_REATTACH;
4571  break;
4572  }
4573 
4574  if (rc != OK)
4575  {
4576  Info = 0x300E; /* not supported */
4577  plci->relatedPTYPLCI = NULL;
4578  plci->ptyState = 0;
4579  }
4580  sendf(rplci->appl,
4581  _FACILITY_R | CONFIRM,
4582  rId,
4583  plci->number,
4584  "wws", Info, (word)3, SSparms);
4585  break;
4586 
4587  case VSWITCH_REQ_PEND:
4588  if (rc != OK)
4589  {
4590  if (plci->relatedPTYPLCI)
4591  {
4592  plci->relatedPTYPLCI->vswitchstate = 0;
4593  plci->relatedPTYPLCI->vsprot = 0;
4594  plci->relatedPTYPLCI->vsprotdialect = 0;
4595  }
4596  plci->vswitchstate = 0;
4597  plci->vsprot = 0;
4598  plci->vsprotdialect = 0;
4599  }
4600  else
4601  {
4602  if (plci->relatedPTYPLCI &&
4603  plci->vswitchstate == 1 &&
4604  plci->relatedPTYPLCI->vswitchstate == 3) /* join complete */
4605  plci->vswitchstate = 3;
4606  }
4607  break;
4608 
4609  /* Call Deflection Request pending (SSCT) */
4610  case CD_REQ_PEND:
4611  SSparms[1] = S_CALL_DEFLECTION;
4612  if (rc != OK)
4613  {
4614  Info = 0x300E; /* not supported */
4615  plci->appl->CDEnable = 0;
4616  }
4617  sendf(plci->appl, _FACILITY_R | CONFIRM, Id,
4618  plci->number, "wws", Info, (word)3, SSparms);
4619  break;
4620 
4621  case RTP_CONNECT_B3_REQ_COMMAND_2:
4622  if (rc == OK)
4623  {
4624  ncci = get_ncci(plci, ch, 0);
4625  Id = (Id & 0xffff) | (((dword) ncci) << 16);
4626  plci->channels++;
4627  a->ncci_state[ncci] = OUTG_CON_PENDING;
4628  }
4629 
4630  default:
4631  if (plci->internal_command_queue[0])
4632  {
4633  (*(plci->internal_command_queue[0]))(Id, plci, rc);
4634  if (plci->internal_command)
4635  return;
4636  }
4637  break;
4638  }
4639  next_internal_command(Id, plci);
4640  }
4641  }
4642  else /* appl==0 */
4643  {
4644  Id = ((word)plci->Id << 8) | plci->adapter->Id;
4645  if (plci->tel) Id |= EXT_CONTROLLER;
4646 
4647  switch (plci->internal_command)
4648  {
4649  case BLOCK_PLCI:
4650  return;
4651 
4652  case START_L1_SIG_ASSIGN_PEND:
4653  case REM_L1_SIG_ASSIGN_PEND:
4654  if (global_req == ASSIGN)
4655  {
4656  break;
4657  }
4658  else
4659  {
4660  dbug(1, dprintf("***L1 Req rem PLCI"));
4661  plci->internal_command = 0;
4662  sig_req(plci, REMOVE, 0);
4663  send_req(plci);
4664  }
4665  break;
4666 
4667  /* Call Deflection Request pending, just no appl ptr assigned */
4668  case CD_REQ_PEND:
4669  SSparms[1] = S_CALL_DEFLECTION;
4670  if (rc != OK)
4671  {
4672  Info = 0x300E; /* not supported */
4673  }
4674  for (i = 0; i < max_appl; i++)
4675  {
4676  if (application[i].CDEnable)
4677  {
4678  if (!application[i].Id) application[i].CDEnable = 0;
4679  else
4680  {
4681  sendf(&application[i], _FACILITY_R | CONFIRM, Id,
4682  plci->number, "wws", Info, (word)3, SSparms);
4683  if (Info) application[i].CDEnable = 0;
4684  }
4685  }
4686  }
4687  plci->internal_command = 0;
4688  break;
4689 
4690  case PERM_COD_HOOK: /* finished with Hook_Ind */
4691  return;
4692 
4693  case PERM_COD_CALL:
4694  plci->internal_command = PERM_COD_CONN_PEND;
4695  dbug(1, dprintf("***Codec Connect_Pending, Rc = 0x%x", rc));
4696  return;
4697 
4698  case PERM_COD_ASSIGN:
4699  dbug(1, dprintf("***Codec Assign, Rc = 0x%x", rc));
4700  plci->internal_command = 0;
4701  if (rc != ASSIGN_OK) break;
4702  plci->internal_command = PERM_COD_CALL;
4703  sig_req(plci, CALL_REQ, 0);
4704  send_req(plci);
4705  return;
4706 
4707  case LISTEN_SIG_ASSIGN_PEND:
4708  if (rc == ASSIGN_OK)
4709  {
4710  plci->internal_command = 0;
4711  dbug(1, dprintf("ListenCheck, new SIG_ID = 0x%x", plci->Sig.Id));
4712  add_p(plci, ESC, "\x02\x18\x00"); /* support call waiting */
4713  sig_req(plci, INDICATE_REQ, 0);
4714  send_req(plci);
4715  }
4716  else
4717  {
4718  dbug(1, dprintf("ListenCheck failed (assignRc=0x%x)", rc));
4719  a->listen_active--;
4720  plci_remove(plci);
4721  plci->State = IDLE;
4722  }
4723  break;
4724 
4725  case USELAW_REQ:
4726  if (global_req == ASSIGN)
4727  {
4728  if (rc == ASSIGN_OK)
4729  {
4730  sig_req(plci, LAW_REQ, 0);
4731  send_req(plci);
4732  dbug(1, dprintf("Auto-Law assigned"));
4733  }
4734  else
4735  {
4736  dbug(1, dprintf("Auto-Law assign failed"));
4737  a->automatic_law = 3;
4738  plci->internal_command = 0;
4739  a->automatic_lawPLCI = NULL;
4740  }
4741  break;
4742  }
4743  else if (req == LAW_REQ && rc == OK)
4744  {
4745  dbug(1, dprintf("Auto-Law initiated"));
4746  a->automatic_law = 2;
4747  plci->internal_command = 0;
4748  }
4749  else
4750  {
4751  dbug(1, dprintf("Auto-Law not supported"));
4752  a->automatic_law = 3;
4753  plci->internal_command = 0;
4754  sig_req(plci, REMOVE, 0);
4755  send_req(plci);
4756  a->automatic_lawPLCI = NULL;
4757  }
4758  break;
4759  }
4760  plci_remove_check(plci);
4761  }
4762 }
4763 
4764 static void data_rc(PLCI *plci, byte ch)
4765 {
4766  dword Id;
4767  DIVA_CAPI_ADAPTER *a;
4768  NCCI *ncci_ptr;
4769  DATA_B3_DESC *data;
4770  word ncci;
4771 
4772  if (plci->appl)
4773  {
4774  TransmitBufferFree(plci->appl, plci->data_sent_ptr);
4775  a = plci->adapter;
4776  ncci = a->ch_ncci[ch];
4777  if (ncci && (a->ncci_plci[ncci] == plci->Id))
4778  {
4779  ncci_ptr = &(a->ncci[ncci]);
4780  dbug(1, dprintf("data_out=%d, data_pending=%d", ncci_ptr->data_out, ncci_ptr->data_pending));
4781  if (ncci_ptr->data_pending)
4782  {
4783  data = &(ncci_ptr->DBuffer[ncci_ptr->data_out]);
4784  if (!(data->Flags & 4) && a->ncci_state[ncci])
4785  {
4786  Id = (((dword)ncci) << 16) | ((word)plci->Id << 8) | a->Id;
4787  if (plci->tel) Id |= EXT_CONTROLLER;
4788  sendf(plci->appl, _DATA_B3_R | CONFIRM, Id, data->Number,
4789  "ww", data->Handle, 0);
4790  }
4791  (ncci_ptr->data_out)++;
4792  if (ncci_ptr->data_out == MAX_DATA_B3)
4793  ncci_ptr->data_out = 0;
4794  (ncci_ptr->data_pending)--;
4795  }
4796  }
4797  }
4798 }
4799 
4800 static void data_ack(PLCI *plci, byte ch)
4801 {
4802  dword Id;
4803  DIVA_CAPI_ADAPTER *a;
4804  NCCI *ncci_ptr;
4805  word ncci;
4806 
4807  a = plci->adapter;
4808  ncci = a->ch_ncci[ch];
4809  ncci_ptr = &(a->ncci[ncci]);
4810  if (ncci_ptr->data_ack_pending)
4811  {
4812  if (a->ncci_state[ncci] && (a->ncci_plci[ncci] == plci->Id))
4813  {
4814  Id = (((dword)ncci) << 16) | ((word)plci->Id << 8) | a->Id;
4815  if (plci->tel) Id |= EXT_CONTROLLER;
4816  sendf(plci->appl, _DATA_B3_R | CONFIRM, Id, ncci_ptr->DataAck[ncci_ptr->data_ack_out].Number,
4817  "ww", ncci_ptr->DataAck[ncci_ptr->data_ack_out].Handle, 0);
4818  }
4819  (ncci_ptr->data_ack_out)++;
4820  if (ncci_ptr->data_ack_out == MAX_DATA_ACK)
4821  ncci_ptr->data_ack_out = 0;
4822  (ncci_ptr->data_ack_pending)--;
4823  }
4824 }
4825 
4826 static void sig_ind(PLCI *plci)
4827 {
4828  dword x_Id;
4829  dword Id;
4830  dword rId;
4831  word i;
4832  word cip;
4833  dword cip_mask;
4834  byte *ie;
4835  DIVA_CAPI_ADAPTER *a;
4836  API_PARSE saved_parms[MAX_MSG_PARMS + 1];
4837 #define MAXPARMSIDS 31
4838  byte *parms[MAXPARMSIDS];
4839  byte *add_i[4];
4840  byte *multi_fac_parms[MAX_MULTI_IE];
4841  byte *multi_pi_parms[MAX_MULTI_IE];
4842  byte *multi_ssext_parms[MAX_MULTI_IE];
4843  byte *multi_CiPN_parms[MAX_MULTI_IE];
4844 
4845  byte *multi_vswitch_parms[MAX_MULTI_IE];
4846 
4847  byte ai_len;
4848  byte *esc_chi = "";
4849  byte *esc_law = "";
4850  byte *pty_cai = "";
4851  byte *esc_cr = "";
4852  byte *esc_profile = "";
4853 
4854  byte facility[256];
4855  PLCI *tplci = NULL;
4856  byte chi[] = "\x02\x18\x01";
4857  byte voice_cai[] = "\x06\x14\x00\x00\x00\x00\x08";
4858  byte resume_cau[] = "\x05\x05\x00\x02\x00\x00";
4859  /* ESC_MSGTYPE must be the last but one message, a new IE has to be */
4860  /* included before the ESC_MSGTYPE and MAXPARMSIDS has to be incremented */
4861  /* SMSG is situated at the end because its 0 (for compatibility reasons */
4862  /* (see Info_Mask Bit 4, first IE. then the message type) */
4863  word parms_id[] =
4864  {MAXPARMSIDS, CPN, 0xff, DSA, OSA, BC, LLC, HLC, ESC_CAUSE, DSP, DT, CHA,
4865  UUI, CONG_RR, CONG_RNR, ESC_CHI, KEY, CHI, CAU, ESC_LAW,
4866  RDN, RDX, CONN_NR, RIN, NI, CAI, ESC_CR,
4867  CST, ESC_PROFILE, 0xff, ESC_MSGTYPE, SMSG};
4868  /* 14 FTY repl by ESC_CHI */
4869  /* 18 PI repl by ESC_LAW */
4870  /* removed OAD changed to 0xff for future use, OAD is multiIE now */
4871  word multi_fac_id[] = {1, FTY};
4872  word multi_pi_id[] = {1, PI};
4873  word multi_CiPN_id[] = {1, OAD};
4874  word multi_ssext_id[] = {1, ESC_SSEXT};
4875 
4876  word multi_vswitch_id[] = {1, ESC_VSWITCH};
4877 
4878  byte *cau;
4879  word ncci;
4880  byte SS_Ind[] = "\x05\x02\x00\x02\x00\x00"; /* Hold_Ind struct*/
4881  byte CF_Ind[] = "\x09\x02\x00\x06\x00\x00\x00\x00\x00\x00";
4882  byte Interr_Err_Ind[] = "\x0a\x02\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
4883  byte CONF_Ind[] = "\x09\x16\x00\x06\x00\x00\0x00\0x00\0x00\0x00";
4884  byte force_mt_info = false;
4885  byte dir;
4886  dword d;
4887  word w;
4888 
4889  a = plci->adapter;
4890  Id = ((word)plci->Id << 8) | a->Id;
4891  PUT_WORD(&SS_Ind[4], 0x0000);
4892 
4893  if (plci->sig_remove_id)
4894  {
4895  plci->Sig.RNR = 2; /* discard */
4896  dbug(1, dprintf("SIG discard while remove pending"));
4897  return;
4898  }
4899  if (plci->tel && plci->SuppState != CALL_HELD) Id |= EXT_CONTROLLER;
4900  dbug(1, dprintf("SigInd-Id=%08lx,plci=%x,tel=%x,state=0x%x,channels=%d,Discflowcl=%d",
4901  Id, plci->Id, plci->tel, plci->State, plci->channels, plci->hangup_flow_ctrl_timer));
4902  if (plci->Sig.Ind == CALL_HOLD_ACK && plci->channels)
4903  {
4904  plci->Sig.RNR = 1;
4905  return;
4906  }
4907  if (plci->Sig.Ind == HANGUP && plci->channels)
4908  {
4909  plci->Sig.RNR = 1;
4910  plci->hangup_flow_ctrl_timer++;
4911  /* recover the network layer after timeout */
4912  if (plci->hangup_flow_ctrl_timer == 100)
4913  {
4914  dbug(1, dprintf("Exceptional disc"));
4915  plci->Sig.RNR = 0;
4916  plci->hangup_flow_ctrl_timer = 0;
4917  for (ncci = 1; ncci < MAX_NCCI + 1; ncci++)
4918  {
4919  if (a->ncci_plci[ncci] == plci->Id)
4920  {
4921  cleanup_ncci_data(plci, ncci);
4922  if (plci->channels)plci->channels--;
4923  if (plci->appl)
4924  sendf(plci->appl, _DISCONNECT_B3_I, (((dword) ncci) << 16) | Id, 0, "ws", 0, "");
4925  }
4926  }
4927  if (plci->appl)
4928  sendf(plci->appl, _DISCONNECT_I, Id, 0, "w", 0);
4929  plci_remove(plci);
4930  plci->State = IDLE;
4931  }
4932  return;
4933  }
4934 
4935  /* do first parse the info with no OAD in, because OAD will be converted */
4936  /* first the multiple facility IE, then mult. progress ind. */
4937  /* then the parameters for the info_ind + conn_ind */
4938  IndParse(plci, multi_fac_id, multi_fac_parms, MAX_MULTI_IE);
4939  IndParse(plci, multi_pi_id, multi_pi_parms, MAX_MULTI_IE);
4940  IndParse(plci, multi_ssext_id, multi_ssext_parms, MAX_MULTI_IE);
4941 
4942  IndParse(plci, multi_vswitch_id, multi_vswitch_parms, MAX_MULTI_IE);
4943 
4944  IndParse(plci, parms_id, parms, 0);
4945  IndParse(plci, multi_CiPN_id, multi_CiPN_parms, MAX_MULTI_IE);
4946  esc_chi = parms[14];
4947  esc_law = parms[18];
4948  pty_cai = parms[24];
4949  esc_cr = parms[25];
4950  esc_profile = parms[27];
4951  if (esc_cr[0] && plci)
4952  {
4953  if (plci->cr_enquiry && plci->appl)
4954  {
4955  plci->cr_enquiry = false;
4956  /* d = MANU_ID */
4957  /* w = m_command */
4958  /* b = total length */
4959  /* b = indication type */
4960  /* b = length of all IEs */
4961  /* b = IE1 */
4962  /* S = IE1 length + cont. */
4963  /* b = IE2 */
4964  /* S = IE2 length + cont. */
4965  sendf(plci->appl,
4966  _MANUFACTURER_I,
4967  Id,
4968  0,
4969  "dwbbbbSbS", _DI_MANU_ID, plci->m_command,
4970  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);
4971  }
4972  }
4973  /* create the additional info structure */
4974  add_i[1] = parms[15]; /* KEY of additional info */
4975  add_i[2] = parms[11]; /* UUI of additional info */
4976  ai_len = AddInfo(add_i, multi_fac_parms, esc_chi, facility);
4977 
4978  /* the ESC_LAW indicates if u-Law or a-Law is actually used by the card */
4979  /* indication returns by the card if requested by the function */
4980  /* AutomaticLaw() after driver init */
4981  if (a->automatic_law < 4)
4982  {
4983  if (esc_law[0]) {
4984  if (esc_law[2]) {
4985  dbug(0, dprintf("u-Law selected"));
4986  a->u_law = 1;
4987  }
4988  else {
4989  dbug(0, dprintf("a-Law selected"));
4990  a->u_law = 0;
4991  }
4992  a->automatic_law = 4;
4993  if (plci == a->automatic_lawPLCI) {
4994  plci->internal_command = 0;
4995  sig_req(plci, REMOVE, 0);
4996  send_req(plci);
4997  a->automatic_lawPLCI = NULL;
4998  }
4999  }
5000  if (esc_profile[0])
5001  {
5002  dbug(1, dprintf("[%06x] CardProfile: %lx %lx %lx %lx %lx",
5003  UnMapController(a->Id), GET_DWORD(&esc_profile[6]),
5004  GET_DWORD(&esc_profile[10]), GET_DWORD(&esc_profile[14]),
5005  GET_DWORD(&esc_profile[18]), GET_DWORD(&esc_profile[46])));
5006 
5007  a->profile.Global_Options &= 0x000000ffL;
5008  a->profile.B1_Protocols &= 0x000003ffL;
5009  a->profile.B2_Protocols &= 0x00001fdfL;
5010  a->profile.B3_Protocols &= 0x000000b7L;
5011 
5012  a->profile.Global_Options &= GET_DWORD(&esc_profile[6]) |
5013  GL_BCHANNEL_OPERATION_SUPPORTED;
5014  a->profile.B1_Protocols &= GET_DWORD(&esc_profile[10]);
5015  a->profile.B2_Protocols &= GET_DWORD(&esc_profile[14]);
5016  a->profile.B3_Protocols &= GET_DWORD(&esc_profile[18]);
5017  a->manufacturer_features = GET_DWORD(&esc_profile[46]);
5018  a->man_profile.private_options = 0;
5019 
5020  if (a->manufacturer_features & MANUFACTURER_FEATURE_ECHO_CANCELLER)
5021  {
5022  a->man_profile.private_options |= 1L << PRIVATE_ECHO_CANCELLER;
5023  a->profile.Global_Options |= GL_ECHO_CANCELLER_SUPPORTED;
5024  }
5025 
5026 
5027  if (a->manufacturer_features & MANUFACTURER_FEATURE_RTP)
5028  a->man_profile.private_options |= 1L << PRIVATE_RTP;
5029  a->man_profile.rtp_primary_payloads = GET_DWORD(&esc_profile[50]);
5030  a->man_profile.rtp_additional_payloads = GET_DWORD(&esc_profile[54]);
5031 
5032 
5033  if (a->manufacturer_features & MANUFACTURER_FEATURE_T38)
5034  a->man_profile.private_options |= 1L << PRIVATE_T38;
5035 
5036 
5037  if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_SUB_SEP_PWD)
5038  a->man_profile.private_options |= 1L << PRIVATE_FAX_SUB_SEP_PWD;
5039 
5040 
5041  if (a->manufacturer_features & MANUFACTURER_FEATURE_V18)
5042  a->man_profile.private_options |= 1L << PRIVATE_V18;
5043 
5044 
5045  if (a->manufacturer_features & MANUFACTURER_FEATURE_DTMF_TONE)
5046  a->man_profile.private_options |= 1L << PRIVATE_DTMF_TONE;
5047 
5048 
5049  if (a->manufacturer_features & MANUFACTURER_FEATURE_PIAFS)
5050  a->man_profile.private_options |= 1L << PRIVATE_PIAFS;
5051 
5052 
5053  if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
5054  a->man_profile.private_options |= 1L << PRIVATE_FAX_PAPER_FORMATS;
5055 
5056 
5057  if (a->manufacturer_features & MANUFACTURER_FEATURE_VOWN)
5058  a->man_profile.private_options |= 1L << PRIVATE_VOWN;
5059 
5060 
5061  if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_NONSTANDARD)
5062  a->man_profile.private_options |= 1L << PRIVATE_FAX_NONSTANDARD;
5063 
5064  }
5065  else
5066  {
5067  a->profile.Global_Options &= 0x0000007fL;
5068  a->profile.B1_Protocols &= 0x000003dfL;
5069  a->profile.B2_Protocols &= 0x00001adfL;
5070  a->profile.B3_Protocols &= 0x000000b7L;
5071  a->manufacturer_features &= MANUFACTURER_FEATURE_HARDDTMF;
5072  }
5073  if (a->manufacturer_features & (MANUFACTURER_FEATURE_HARDDTMF |
5074  MANUFACTURER_FEATURE_SOFTDTMF_SEND | MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE))
5075  {
5076  a->profile.Global_Options |= GL_DTMF_SUPPORTED;
5077  }
5078  a->manufacturer_features &= ~MANUFACTURER_FEATURE_OOB_CHANNEL;
5079  dbug(1, dprintf("[%06x] Profile: %lx %lx %lx %lx %lx",
5080  UnMapController(a->Id), a->profile.Global_Options,
5081  a->profile.B1_Protocols, a->profile.B2_Protocols,
5082  a->profile.B3_Protocols, a->manufacturer_features));
5083  }
5084  /* codec plci for the handset/hook state support is just an internal id */
5085  if (plci != a->AdvCodecPLCI)
5086  {
5087  force_mt_info = SendMultiIE(plci, Id, multi_fac_parms, FTY, 0x20, 0);
5088  force_mt_info |= SendMultiIE(plci, Id, multi_pi_parms, PI, 0x210, 0);
5089  SendSSExtInd(NULL, plci, Id, multi_ssext_parms);
5090  SendInfo(plci, Id, parms, force_mt_info);
5091 
5092  VSwitchReqInd(plci, Id, multi_vswitch_parms);
5093 
5094  }
5095 
5096  /* switch the codec to the b-channel */
5097  if (esc_chi[0] && plci && !plci->SuppState) {
5098  plci->b_channel = esc_chi[esc_chi[0]]&0x1f;
5099  mixer_set_bchannel_id_esc(plci, plci->b_channel);
5100  dbug(1, dprintf("storeChannel=0x%x", plci->b_channel));
5101  if (plci->tel == ADV_VOICE && plci->appl) {
5102  SetVoiceChannel(a->AdvCodecPLCI, esc_chi, a);
5103  }
5104  }
5105 
5106  if (plci->appl) plci->appl->Number++;
5107 
5108  switch (plci->Sig.Ind) {
5109  /* Response to Get_Supported_Services request */
5110  case S_SUPPORTED:
5111  dbug(1, dprintf("S_Supported"));
5112  if (!plci->appl) break;
5113  if (pty_cai[0] == 4)
5114  {
5115  PUT_DWORD(&CF_Ind[6], GET_DWORD(&pty_cai[1]));
5116  }
5117  else
5118  {
5119  PUT_DWORD(&CF_Ind[6], MASK_TERMINAL_PORTABILITY | MASK_HOLD_RETRIEVE);
5120  }
5121  PUT_WORD(&CF_Ind[1], 0);
5122  PUT_WORD(&CF_Ind[4], 0);
5123  sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0x7, plci->number, "wws", 0, 3, CF_Ind);
5124  plci_remove(plci);
5125  break;
5126 
5127  /* Supplementary Service rejected */
5128  case S_SERVICE_REJ:
5129  dbug(1, dprintf("S_Reject=0x%x", pty_cai[5]));
5130  if (!pty_cai[0]) break;
5131  switch (pty_cai[5])
5132  {
5133  case ECT_EXECUTE:
5134  case THREE_PTY_END:
5135  case THREE_PTY_BEGIN:
5136  if (!plci->relatedPTYPLCI) break;
5137  tplci = plci->relatedPTYPLCI;
5138  rId = ((word)tplci->Id << 8) | tplci->adapter->Id;
5139  if (tplci->tel) rId |= EXT_CONTROLLER;
5140  if (pty_cai[5] == ECT_EXECUTE)
5141  {
5142  PUT_WORD(&SS_Ind[1], S_ECT);
5143 
5144  plci->vswitchstate = 0;
5145  plci->relatedPTYPLCI->vswitchstate = 0;
5146 
5147  }
5148  else
5149  {
5150  PUT_WORD(&SS_Ind[1], pty_cai[5] + 3);
5151  }
5152  if (pty_cai[2] != 0xff)
5153  {
5154  PUT_WORD(&SS_Ind[4], 0x3600 | (word)pty_cai[2]);
5155  }
5156  else
5157  {
5158  PUT_WORD(&SS_Ind[4], 0x300E);
5159  }
5160  plci->relatedPTYPLCI = NULL;
5161  plci->ptyState = 0;
5162  sendf(tplci->appl, _FACILITY_I, rId, 0, "ws", 3, SS_Ind);
5163  break;
5164 
5165  case CALL_DEFLECTION:
5166  if (pty_cai[2] != 0xff)
5167  {
5168  PUT_WORD(&SS_Ind[4], 0x3600 | (word)pty_cai[2]);
5169  }
5170  else
5171  {
5172  PUT_WORD(&SS_Ind[4], 0x300E);
5173  }
5174  PUT_WORD(&SS_Ind[1], pty_cai[5]);
5175  for (i = 0; i < max_appl; i++)
5176  {
5177  if (application[i].CDEnable)
5178  {
5179  if (application[i].Id) sendf(&application[i], _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5180  application[i].CDEnable = false;
5181  }
5182  }
5183  break;
5184 
5185  case DEACTIVATION_DIVERSION:
5186  case ACTIVATION_DIVERSION:
5187  case DIVERSION_INTERROGATE_CFU:
5188  case DIVERSION_INTERROGATE_CFB:
5189  case DIVERSION_INTERROGATE_CFNR:
5190  case DIVERSION_INTERROGATE_NUM:
5191  case CCBS_REQUEST:
5192  case CCBS_DEACTIVATE:
5193  case CCBS_INTERROGATE:
5194  if (!plci->appl) break;
5195  if (pty_cai[2] != 0xff)
5196  {
5197  PUT_WORD(&Interr_Err_Ind[4], 0x3600 | (word)pty_cai[2]);
5198  }
5199  else
5200  {
5201  PUT_WORD(&Interr_Err_Ind[4], 0x300E);
5202  }
5203  switch (pty_cai[5])
5204  {
5205  case DEACTIVATION_DIVERSION:
5206  dbug(1, dprintf("Deact_Div"));
5207  Interr_Err_Ind[0] = 0x9;
5208  Interr_Err_Ind[3] = 0x6;
5209  PUT_WORD(&Interr_Err_Ind[1], S_CALL_FORWARDING_STOP);
5210  break;
5211  case ACTIVATION_DIVERSION:
5212  dbug(1, dprintf("Act_Div"));
5213  Interr_Err_Ind[0] = 0x9;
5214  Interr_Err_Ind[3] = 0x6;
5215  PUT_WORD(&Interr_Err_Ind[1], S_CALL_FORWARDING_START);
5216  break;
5217  case DIVERSION_INTERROGATE_CFU:
5218  case DIVERSION_INTERROGATE_CFB:
5219  case DIVERSION_INTERROGATE_CFNR:
5220  dbug(1, dprintf("Interr_Div"));
5221  Interr_Err_Ind[0] = 0xa;
5222  Interr_Err_Ind[3] = 0x7;
5223  PUT_WORD(&Interr_Err_Ind[1], S_INTERROGATE_DIVERSION);
5224  break;
5225  case DIVERSION_INTERROGATE_NUM:
5226  dbug(1, dprintf("Interr_Num"));
5227  Interr_Err_Ind[0] = 0xa;
5228  Interr_Err_Ind[3] = 0x7;
5229  PUT_WORD(&Interr_Err_Ind[1], S_INTERROGATE_NUMBERS);
5230  break;
5231  case CCBS_REQUEST:
5232  dbug(1, dprintf("CCBS Request"));
5233  Interr_Err_Ind[0] = 0xd;
5234  Interr_Err_Ind[3] = 0xa;
5235  PUT_WORD(&Interr_Err_Ind[1], S_CCBS_REQUEST);
5236  break;
5237  case CCBS_DEACTIVATE:
5238  dbug(1, dprintf("CCBS Deactivate"));
5239  Interr_Err_Ind[0] = 0x9;
5240  Interr_Err_Ind[3] = 0x6;
5241  PUT_WORD(&Interr_Err_Ind[1], S_CCBS_DEACTIVATE);
5242  break;
5243  case CCBS_INTERROGATE:
5244  dbug(1, dprintf("CCBS Interrogate"));
5245  Interr_Err_Ind[0] = 0xb;
5246  Interr_Err_Ind[3] = 0x8;
5247  PUT_WORD(&Interr_Err_Ind[1], S_CCBS_INTERROGATE);
5248  break;
5249  }
5250  PUT_DWORD(&Interr_Err_Ind[6], plci->appl->S_Handle);
5251  sendf(plci->appl, _FACILITY_I, Id & 0x7, 0, "ws", 3, Interr_Err_Ind);
5252  plci_remove(plci);
5253  break;
5254  case ACTIVATION_MWI:
5255  case DEACTIVATION_MWI:
5256  if (pty_cai[5] == ACTIVATION_MWI)
5257  {
5258  PUT_WORD(&SS_Ind[1], S_MWI_ACTIVATE);
5259  }
5260  else PUT_WORD(&SS_Ind[1], S_MWI_DEACTIVATE);
5261 
5262  if (pty_cai[2] != 0xff)
5263  {
5264  PUT_WORD(&SS_Ind[4], 0x3600 | (word)pty_cai[2]);
5265  }
5266  else
5267  {
5268  PUT_WORD(&SS_Ind[4], 0x300E);
5269  }
5270 
5271  if (plci->cr_enquiry)
5272  {
5273  sendf(plci->appl, _FACILITY_I, Id & 0xf, 0, "ws", 3, SS_Ind);
5274  plci_remove(plci);
5275  }
5276  else
5277  {
5278  sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5279  }
5280  break;
5281  case CONF_ADD: /* ERROR */
5282  case CONF_BEGIN:
5283  case CONF_DROP:
5284  case CONF_ISOLATE:
5285  case CONF_REATTACH:
5286  CONF_Ind[0] = 9;
5287  CONF_Ind[3] = 6;
5288  switch (pty_cai[5])
5289  {
5290  case CONF_BEGIN:
5291  PUT_WORD(&CONF_Ind[1], S_CONF_BEGIN);
5292  plci->ptyState = 0;
5293  break;
5294  case CONF_DROP:
5295  CONF_Ind[0] = 5;
5296  CONF_Ind[3] = 2;
5297  PUT_WORD(&CONF_Ind[1], S_CONF_DROP);
5298  plci->ptyState = CONNECTED;
5299  break;
5300  case CONF_ISOLATE:
5301  CONF_Ind[0] = 5;
5302  CONF_Ind[3] = 2;
5303  PUT_WORD(&CONF_Ind[1], S_CONF_ISOLATE);
5304  plci->ptyState = CONNECTED;
5305  break;
5306  case CONF_REATTACH:
5307  CONF_Ind[0] = 5;
5308  CONF_Ind[3] = 2;
5309  PUT_WORD(&CONF_Ind[1], S_CONF_REATTACH);
5310  plci->ptyState = CONNECTED;
5311  break;
5312  case CONF_ADD:
5313  PUT_WORD(&CONF_Ind[1], S_CONF_ADD);
5314  plci->relatedPTYPLCI = NULL;
5315  tplci = plci->relatedPTYPLCI;
5316  if (tplci) tplci->ptyState = CONNECTED;
5317  plci->ptyState = CONNECTED;
5318  break;
5319  }
5320 
5321  if (pty_cai[2] != 0xff)
5322  {
5323  PUT_WORD(&CONF_Ind[4], 0x3600 | (word)pty_cai[2]);
5324  }
5325  else
5326  {
5327  PUT_WORD(&CONF_Ind[4], 0x3303); /* Time-out: network did not respond
5328  within the required time */
5329  }
5330 
5331  PUT_DWORD(&CONF_Ind[6], 0x0);
5332  sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, CONF_Ind);
5333  break;
5334  }
5335  break;
5336 
5337  /* Supplementary Service indicates success */
5338  case S_SERVICE:
5339  dbug(1, dprintf("Service_Ind"));
5340  PUT_WORD(&CF_Ind[4], 0);
5341  switch (pty_cai[5])
5342  {
5343  case THREE_PTY_END:
5344  case THREE_PTY_BEGIN:
5345  case ECT_EXECUTE:
5346  if (!plci->relatedPTYPLCI) break;
5347  tplci = plci->relatedPTYPLCI;
5348  rId = ((word)tplci->Id << 8) | tplci->adapter->Id;
5349  if (tplci->tel) rId |= EXT_CONTROLLER;
5350  if (pty_cai[5] == ECT_EXECUTE)
5351  {
5352  PUT_WORD(&SS_Ind[1], S_ECT);
5353 
5354  if (plci->vswitchstate != 3)
5355  {
5356 
5357  plci->ptyState = IDLE;
5358  plci->relatedPTYPLCI = NULL;
5359  plci->ptyState = 0;
5360 
5361  }
5362 
5363  dbug(1, dprintf("ECT OK"));
5364  sendf(tplci->appl, _FACILITY_I, rId, 0, "ws", 3, SS_Ind);
5365 
5366 
5367 
5368  }
5369  else
5370  {
5371  switch (plci->ptyState)
5372  {
5373  case S_3PTY_BEGIN:
5374  plci->ptyState = CONNECTED;
5375  dbug(1, dprintf("3PTY ON"));
5376  break;
5377 
5378  case S_3PTY_END:
5379  plci->ptyState = IDLE;
5380  plci->relatedPTYPLCI = NULL;
5381  plci->ptyState = 0;
5382  dbug(1, dprintf("3PTY OFF"));
5383  break;
5384  }
5385  PUT_WORD(&SS_Ind[1], pty_cai[5] + 3);
5386  sendf(tplci->appl, _FACILITY_I, rId, 0, "ws", 3, SS_Ind);
5387  }
5388  break;
5389 
5390  case CALL_DEFLECTION:
5391  PUT_WORD(&SS_Ind[1], pty_cai[5]);
5392  for (i = 0; i < max_appl; i++)
5393  {
5394  if (application[i].CDEnable)
5395  {
5396  if (application[i].Id) sendf(&application[i], _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5397  application[i].CDEnable = false;
5398  }
5399  }
5400  break;
5401 
5402  case DEACTIVATION_DIVERSION:
5403  case ACTIVATION_DIVERSION:
5404  if (!plci->appl) break;
5405  PUT_WORD(&CF_Ind[1], pty_cai[5] + 2);
5406  PUT_DWORD(&CF_Ind[6], plci->appl->S_Handle);
5407  sendf(plci->appl, _FACILITY_I, Id & 0x7, 0, "ws", 3, CF_Ind);
5408  plci_remove(plci);
5409  break;
5410 
5411  case DIVERSION_INTERROGATE_CFU:
5412  case DIVERSION_INTERROGATE_CFB:
5413  case DIVERSION_INTERROGATE_CFNR:
5414  case DIVERSION_INTERROGATE_NUM:
5415  case CCBS_REQUEST:
5416  case CCBS_DEACTIVATE:
5417  case CCBS_INTERROGATE:
5418  if (!plci->appl) break;
5419  switch (pty_cai[5])
5420  {
5421  case DIVERSION_INTERROGATE_CFU:
5422  case DIVERSION_INTERROGATE_CFB:
5423  case DIVERSION_INTERROGATE_CFNR:
5424  dbug(1, dprintf("Interr_Div"));
5425  PUT_WORD(&pty_cai[1], S_INTERROGATE_DIVERSION);
5426  pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
5427  break;
5428  case DIVERSION_INTERROGATE_NUM:
5429  dbug(1, dprintf("Interr_Num"));
5430  PUT_WORD(&pty_cai[1], S_INTERROGATE_NUMBERS);
5431  pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
5432  break;
5433  case CCBS_REQUEST:
5434  dbug(1, dprintf("CCBS Request"));
5435  PUT_WORD(&pty_cai[1], S_CCBS_REQUEST);
5436  pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
5437  break;
5438  case CCBS_DEACTIVATE:
5439  dbug(1, dprintf("CCBS Deactivate"));
5440  PUT_WORD(&pty_cai[1], S_CCBS_DEACTIVATE);
5441  pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
5442  break;
5443  case CCBS_INTERROGATE:
5444  dbug(1, dprintf("CCBS Interrogate"));
5445  PUT_WORD(&pty_cai[1], S_CCBS_INTERROGATE);
5446  pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
5447  break;
5448  }
5449  PUT_WORD(&pty_cai[4], 0); /* Supplementary Service Reason */
5450  PUT_DWORD(&pty_cai[6], plci->appl->S_Handle);
5451  sendf(plci->appl, _FACILITY_I, Id & 0x7, 0, "wS", 3, pty_cai);
5452  plci_remove(plci);
5453  break;
5454 
5455  case ACTIVATION_MWI:
5456  case DEACTIVATION_MWI:
5457  if (pty_cai[5] == ACTIVATION_MWI)
5458  {
5459  PUT_WORD(&SS_Ind[1], S_MWI_ACTIVATE);
5460  }
5461  else PUT_WORD(&SS_Ind[1], S_MWI_DEACTIVATE);
5462  if (plci->cr_enquiry)
5463  {
5464  sendf(plci->appl, _FACILITY_I, Id & 0xf, 0, "ws", 3, SS_Ind);
5465  plci_remove(plci);
5466  }
5467  else
5468  {
5469  sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5470  }
5471  break;
5472  case MWI_INDICATION:
5473  if (pty_cai[0] >= 0x12)
5474  {
5475  PUT_WORD(&pty_cai[3], S_MWI_INDICATE);
5476  pty_cai[2] = pty_cai[0] - 2; /* len Parameter */
5477  pty_cai[5] = pty_cai[0] - 5; /* Supplementary Service-specific parameter len */
5478  if (plci->appl && (a->Notification_Mask[plci->appl->Id - 1] & SMASK_MWI))
5479  {
5480  if (plci->internal_command == GET_MWI_STATE) /* result on Message Waiting Listen */
5481  {
5482  sendf(plci->appl, _FACILITY_I, Id & 0xf, 0, "wS", 3, &pty_cai[2]);
5483  plci_remove(plci);
5484  return;
5485  }
5486  else sendf(plci->appl, _FACILITY_I, Id, 0, "wS", 3, &pty_cai[2]);
5487  pty_cai[0] = 0;
5488  }
5489  else
5490  {
5491  for (i = 0; i < max_appl; i++)
5492  {
5493  if (a->Notification_Mask[i]&SMASK_MWI)
5494  {
5495  sendf(&application[i], _FACILITY_I, Id & 0x7, 0, "wS", 3, &pty_cai[2]);
5496  pty_cai[0] = 0;
5497  }
5498  }
5499  }
5500 
5501  if (!pty_cai[0])
5502  { /* acknowledge */
5503  facility[2] = 0; /* returncode */
5504  }
5505  else facility[2] = 0xff;
5506  }
5507  else
5508  {
5509  /* reject */
5510  facility[2] = 0xff; /* returncode */
5511  }
5512  facility[0] = 2;
5513  facility[1] = MWI_RESPONSE; /* Function */
5514  add_p(plci, CAI, facility);
5515  add_p(plci, ESC, multi_ssext_parms[0]); /* remembered parameter -> only one possible */
5516  sig_req(plci, S_SERVICE, 0);
5517  send_req(plci);
5518  plci->command = 0;
5519  next_internal_command(Id, plci);
5520  break;
5521  case CONF_ADD: /* OK */
5522  case CONF_BEGIN:
5523  case CONF_DROP:
5524  case CONF_ISOLATE:
5525  case CONF_REATTACH:
5526  case CONF_PARTYDISC:
5527  CONF_Ind[0] = 9;
5528  CONF_Ind[3] = 6;
5529  switch (pty_cai[5])
5530  {
5531  case CONF_BEGIN:
5532  PUT_WORD(&CONF_Ind[1], S_CONF_BEGIN);
5533  if (pty_cai[0] == 6)
5534  {
5535  d = pty_cai[6];
5536  PUT_DWORD(&CONF_Ind[6], d); /* PartyID */
5537  }
5538  else
5539  {
5540  PUT_DWORD(&CONF_Ind[6], 0x0);
5541  }
5542  break;
5543  case CONF_ISOLATE:
5544  PUT_WORD(&CONF_Ind[1], S_CONF_ISOLATE);
5545  CONF_Ind[0] = 5;
5546  CONF_Ind[3] = 2;
5547  break;
5548  case CONF_REATTACH:
5549  PUT_WORD(&CONF_Ind[1], S_CONF_REATTACH);
5550  CONF_Ind[0] = 5;
5551  CONF_Ind[3] = 2;
5552  break;
5553  case CONF_DROP:
5554  PUT_WORD(&CONF_Ind[1], S_CONF_DROP);
5555  CONF_Ind[0] = 5;
5556  CONF_Ind[3] = 2;
5557  break;
5558  case CONF_ADD:
5559  PUT_WORD(&CONF_Ind[1], S_CONF_ADD);
5560  d = pty_cai[6];
5561  PUT_DWORD(&CONF_Ind[6], d); /* PartyID */
5562  tplci = plci->relatedPTYPLCI;
5563  if (tplci) tplci->ptyState = CONNECTED;
5564  break;
5565  case CONF_PARTYDISC:
5566  CONF_Ind[0] = 7;
5567  CONF_Ind[3] = 4;
5568  PUT_WORD(&CONF_Ind[1], S_CONF_PARTYDISC);
5569  d = pty_cai[6];
5570  PUT_DWORD(&CONF_Ind[4], d); /* PartyID */
5571  break;
5572  }
5573  plci->ptyState = CONNECTED;
5574  sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, CONF_Ind);
5575  break;
5576  case CCBS_INFO_RETAIN:
5577  case CCBS_ERASECALLLINKAGEID:
5578  case CCBS_STOP_ALERTING:
5579  CONF_Ind[0] = 5;
5580  CONF_Ind[3] = 2;
5581  switch (pty_cai[5])
5582  {
5583  case CCBS_INFO_RETAIN:
5584  PUT_WORD(&CONF_Ind[1], S_CCBS_INFO_RETAIN);
5585  break;
5586  case CCBS_STOP_ALERTING:
5587  PUT_WORD(&CONF_Ind[1], S_CCBS_STOP_ALERTING);
5588  break;
5589  case CCBS_ERASECALLLINKAGEID:
5590  PUT_WORD(&CONF_Ind[1], S_CCBS_ERASECALLLINKAGEID);
5591  CONF_Ind[0] = 7;
5592  CONF_Ind[3] = 4;
5593  CONF_Ind[6] = 0;
5594  CONF_Ind[7] = 0;
5595  break;
5596  }
5597  w = pty_cai[6];
5598  PUT_WORD(&CONF_Ind[4], w); /* PartyID */
5599 
5600  if (plci->appl && (a->Notification_Mask[plci->appl->Id - 1] & SMASK_CCBS))
5601  {
5602  sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, CONF_Ind);
5603  }
5604  else
5605  {
5606  for (i = 0; i < max_appl; i++)
5607  if (a->Notification_Mask[i] & SMASK_CCBS)
5608  sendf(&application[i], _FACILITY_I, Id & 0x7, 0, "ws", 3, CONF_Ind);
5609  }
5610  break;
5611  }
5612  break;
5613  case CALL_HOLD_REJ:
5614  cau = parms[7];
5615  if (cau)
5616  {
5617  i = _L3_CAUSE | cau[2];
5618  if (cau[2] == 0) i = 0x3603;
5619  }
5620  else
5621  {
5622  i = 0x3603;
5623  }
5624  PUT_WORD(&SS_Ind[1], S_HOLD);
5625  PUT_WORD(&SS_Ind[4], i);
5626  if (plci->SuppState == HOLD_REQUEST)
5627  {
5628  plci->SuppState = IDLE;
5629  sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5630  }
5631  break;
5632 
5633  case CALL_HOLD_ACK:
5634  if (plci->SuppState == HOLD_REQUEST)
5635  {
5636  plci->SuppState = CALL_HELD;
5637  CodecIdCheck(a, plci);
5638  start_internal_command(Id, plci, hold_save_command);
5639  }
5640  break;
5641 
5642  case CALL_RETRIEVE_REJ:
5643  cau = parms[7];
5644  if (cau)
5645  {
5646  i = _L3_CAUSE | cau[2];
5647  if (cau[2] == 0) i = 0x3603;
5648  }
5649  else
5650  {
5651  i = 0x3603;
5652  }
5653  PUT_WORD(&SS_Ind[1], S_RETRIEVE);
5654  PUT_WORD(&SS_Ind[4], i);
5655  if (plci->SuppState == RETRIEVE_REQUEST)
5656  {
5657  plci->SuppState = CALL_HELD;
5658  CodecIdCheck(a, plci);
5659  sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5660  }
5661  break;
5662 
5663  case CALL_RETRIEVE_ACK:
5664  PUT_WORD(&SS_Ind[1], S_RETRIEVE);
5665  if (plci->SuppState == RETRIEVE_REQUEST)
5666  {
5667  plci->SuppState = IDLE;
5668  plci->call_dir |= CALL_DIR_FORCE_OUTG_NL;
5669  plci->b_channel = esc_chi[esc_chi[0]]&0x1f;
5670  if (plci->tel)
5671  {
5672  mixer_set_bchannel_id_esc(plci, plci->b_channel);
5673  dbug(1, dprintf("RetrChannel=0x%x", plci->b_channel));
5674  SetVoiceChannel(a->AdvCodecPLCI, esc_chi, a);
5675  if (plci->B2_prot == B2_TRANSPARENT && plci->B3_prot == B3_TRANSPARENT)
5676  {
5677  dbug(1, dprintf("Get B-ch"));
5678  start_internal_command(Id, plci, retrieve_restore_command);
5679  }
5680  else
5681  sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5682  }
5683  else
5684  start_internal_command(Id, plci, retrieve_restore_command);
5685  }
5686  break;
5687 
5688  case INDICATE_IND:
5689  if (plci->State != LISTENING) {
5690  sig_req(plci, HANGUP, 0);
5691  send_req(plci);
5692  break;
5693  }
5694  cip = find_cip(a, parms[4], parms[6]);
5695  cip_mask = 1L << cip;
5696  dbug(1, dprintf("cip=%d,cip_mask=%lx", cip, cip_mask));
5697  clear_c_ind_mask(plci);
5698  if (!remove_started && !a->adapter_disabled)
5699  {
5700  set_c_ind_mask_bit(plci, MAX_APPL);
5701  group_optimization(a, plci);
5702  for (i = 0; i < max_appl; i++) {
5703  if (application[i].Id
5704  && (a->CIP_Mask[i] & 1 || a->CIP_Mask[i] & cip_mask)
5705  && CPN_filter_ok(parms[0], a, i)
5706  && test_group_ind_mask_bit(plci, i)) {
5707  dbug(1, dprintf("storedcip_mask[%d]=0x%lx", i, a->CIP_Mask[i]));
5708  set_c_ind_mask_bit(plci, i);
5709  dump_c_ind_mask(plci);
5710  plci->State = INC_CON_PENDING;
5711  plci->call_dir = (plci->call_dir & ~(CALL_DIR_OUT | CALL_DIR_ORIGINATE)) |
5712  CALL_DIR_IN | CALL_DIR_ANSWER;
5713  if (esc_chi[0]) {
5714  plci->b_channel = esc_chi[esc_chi[0]] & 0x1f;
5715  mixer_set_bchannel_id_esc(plci, plci->b_channel);
5716  }
5717  /* if a listen on the ext controller is done, check if hook states */
5718  /* are supported or if just a on board codec must be activated */
5719  if (a->codec_listen[i] && !a->AdvSignalPLCI) {
5720  if (a->profile.Global_Options & HANDSET)
5721  plci->tel = ADV_VOICE;
5722  else if (a->profile.Global_Options & ON_BOARD_CODEC)
5723  plci->tel = CODEC;
5724  if (plci->tel) Id |= EXT_CONTROLLER;
5725  a->codec_listen[i] = plci;
5726  }
5727 
5728  sendf(&application[i], _CONNECT_I, Id, 0,
5729  "wSSSSSSSbSSSSS", cip, /* CIP */
5730  parms[0], /* CalledPartyNumber */
5731  multi_CiPN_parms[0], /* CallingPartyNumber */
5732  parms[2], /* CalledPartySubad */
5733  parms[3], /* CallingPartySubad */
5734  parms[4], /* BearerCapability */
5735  parms[5], /* LowLC */
5736  parms[6], /* HighLC */
5737  ai_len, /* nested struct add_i */
5738  add_i[0], /* B channel info */
5739  add_i[1], /* keypad facility */
5740  add_i[2], /* user user data */
5741  add_i[3], /* nested facility */
5742  multi_CiPN_parms[1] /* second CiPN(SCR) */
5743  );
5744  SendSSExtInd(&application[i],
5745  plci,
5746  Id,
5747  multi_ssext_parms);
5748  SendSetupInfo(&application[i],
5749  plci,
5750  Id,
5751  parms,
5752  SendMultiIE(plci, Id, multi_pi_parms, PI, 0x210, true));
5753  }
5754  }
5755  clear_c_ind_mask_bit(plci, MAX_APPL);
5756  dump_c_ind_mask(plci);
5757  }
5758  if (c_ind_mask_empty(plci)) {
5759  sig_req(plci, HANGUP, 0);
5760  send_req(plci);
5761  plci->State = IDLE;
5762  }
5763  plci->notifiedcall = 0;
5764  a->listen_active--;
5765  listen_check(a);
5766  break;
5767 
5768  case CALL_PEND_NOTIFY:
5769  plci->notifiedcall = 1;
5770  listen_check(a);
5771  break;
5772 
5773  case CALL_IND:
5774  case CALL_CON:
5775  if (plci->State == ADVANCED_VOICE_SIG || plci->State == ADVANCED_VOICE_NOSIG)
5776  {
5777  if (plci->internal_command == PERM_COD_CONN_PEND)
5778  {
5779  if (plci->State == ADVANCED_VOICE_NOSIG)
5780  {
5781  dbug(1, dprintf("***Codec OK"));
5782  if (a->AdvSignalPLCI)
5783  {
5784  tplci = a->AdvSignalPLCI;
5785  if (tplci->spoofed_msg)
5786  {
5787  dbug(1, dprintf("***Spoofed Msg(0x%x)", tplci->spoofed_msg));
5788  tplci->command = 0;
5789  tplci->internal_command = 0;
5790  x_Id = ((word)tplci->Id << 8) | tplci->adapter->Id | 0x80;
5791  switch (tplci->spoofed_msg)
5792  {
5793  case CALL_RES:
5794  tplci->command = _CONNECT_I | RESPONSE;
5795  api_load_msg(&tplci->saved_msg, saved_parms);
5796  add_b1(tplci, &saved_parms[1], 0, tplci->B1_facilities);
5797  if (tplci->adapter->Info_Mask[tplci->appl->Id - 1] & 0x200)
5798  {
5799  /* early B3 connect (CIP mask bit 9) no release after a disc */
5800  add_p(tplci, LLI, "\x01\x01");
5801  }
5802  add_s(tplci, CONN_NR, &saved_parms[2]);
5803  add_s(tplci, LLC, &saved_parms[4]);
5804  add_ai(tplci, &saved_parms[5]);
5805  tplci->State = INC_CON_ACCEPT;
5806  sig_req(tplci, CALL_RES, 0);
5807  send_req(tplci);
5808  break;
5809 
5810  case AWAITING_SELECT_B:
5811  dbug(1, dprintf("Select_B continue"));
5812  start_internal_command(x_Id, tplci, select_b_command);
5813  break;
5814 
5815  case AWAITING_MANUF_CON: /* Get_Plci per Manufacturer_Req to ext controller */
5816  if (!tplci->Sig.Id)
5817  {
5818  dbug(1, dprintf("No SigID!"));
5819  sendf(tplci->appl, _MANUFACTURER_R | CONFIRM, x_Id, tplci->number, "dww", _DI_MANU_ID, _MANUFACTURER_R, _OUT_OF_PLCI);
5820  plci_remove(tplci);
5821  break;
5822  }
5823  tplci->command = _MANUFACTURER_R;
5824  api_load_msg(&tplci->saved_msg, saved_parms);
5825  dir = saved_parms[2].info[0];
5826  if (dir == 1) {
5827  sig_req(tplci, CALL_REQ, 0);
5828  }
5829  else if (!dir) {
5830  sig_req(tplci, LISTEN_REQ, 0);
5831  }
5832  send_req(tplci);
5833  sendf(tplci->appl, _MANUFACTURER_R | CONFIRM, x_Id, tplci->number, "dww", _DI_MANU_ID, _MANUFACTURER_R, 0);
5834  break;
5835 
5836  case (CALL_REQ | AWAITING_MANUF_CON):
5837  sig_req(tplci, CALL_REQ, 0);
5838  send_req(tplci);
5839  break;
5840 
5841  case CALL_REQ:
5842  if (!tplci->Sig.Id)
5843  {
5844  dbug(1, dprintf("No SigID!"));
5845  sendf(tplci->appl, _CONNECT_R | CONFIRM, tplci->adapter->Id, 0, "w", _OUT_OF_PLCI);
5846  plci_remove(tplci);
5847  break;
5848  }
5849  tplci->command = _CONNECT_R;
5850  api_load_msg(&tplci->saved_msg, saved_parms);
5851  add_s(tplci, CPN, &saved_parms[1]);
5852  add_s(tplci, DSA, &saved_parms[3]);
5853  add_ai(tplci, &saved_parms[9]);
5854  sig_req(tplci, CALL_REQ, 0);
5855  send_req(tplci);
5856  break;
5857 
5858  case CALL_RETRIEVE:
5859  tplci->command = C_RETRIEVE_REQ;
5860  sig_req(tplci, CALL_RETRIEVE, 0);
5861  send_req(tplci);
5862  break;
5863  }
5864  tplci->spoofed_msg = 0;
5865  if (tplci->internal_command == 0)
5866  next_internal_command(x_Id, tplci);
5867  }
5868  }
5869  next_internal_command(Id, plci);
5870  break;
5871  }
5872  dbug(1, dprintf("***Codec Hook Init Req"));
5873  plci->internal_command = PERM_COD_HOOK;
5874  add_p(plci, FTY, "\x01\x09"); /* Get Hook State*/
5875  sig_req(plci, TEL_CTRL, 0);
5876  send_req(plci);
5877  }
5878  }
5879  else if (plci->command != _MANUFACTURER_R /* old style permanent connect */
5880  && plci->State != INC_ACT_PENDING)
5881  {
5882  mixer_set_bchannel_id_esc(plci, plci->b_channel);
5883  if (plci->tel == ADV_VOICE && plci->SuppState == IDLE) /* with permanent codec switch on immediately */
5884  {
5885  chi[2] = plci->b_channel;
5886  SetVoiceChannel(a->AdvCodecPLCI, chi, a);
5887  }
5888  sendf(plci->appl, _CONNECT_ACTIVE_I, Id, 0, "Sss", parms[21], "", "");
5889  plci->State = INC_ACT_PENDING;
5890  }
5891  break;
5892 
5893  case TEL_CTRL:
5894  ie = multi_fac_parms[0]; /* inspect the facility hook indications */
5895  if (plci->State == ADVANCED_VOICE_SIG && ie[0]) {
5896  switch (ie[1] & 0x91) {
5897  case 0x80: /* hook off */
5898  case 0x81:
5899  if (plci->internal_command == PERM_COD_HOOK)
5900  {
5901  dbug(1, dprintf("init:hook_off"));
5902  plci->hook_state = ie[1];
5903  next_internal_command(Id, plci);
5904  break;
5905  }
5906  else /* ignore doubled hook indications */
5907  {
5908  if (((plci->hook_state) & 0xf0) == 0x80)
5909  {
5910  dbug(1, dprintf("ignore hook"));
5911  break;
5912  }
5913  plci->hook_state = ie[1]&0x91;
5914  }
5915  /* check for incoming call pending */
5916  /* and signal '+'.Appl must decide */
5917  /* with connect_res if call must */
5918  /* accepted or not */
5919  for (i = 0, tplci = NULL; i < max_appl; i++) {
5920  if (a->codec_listen[i]
5921  && (a->codec_listen[i]->State == INC_CON_PENDING
5922  || a->codec_listen[i]->State == INC_CON_ALERT)) {
5923  tplci = a->codec_listen[i];
5924  tplci->appl = &application[i];
5925  }
5926  }
5927  /* no incoming call, do outgoing call */
5928  /* and signal '+' if outg. setup */
5929  if (!a->AdvSignalPLCI && !tplci) {
5930  if ((i = get_plci(a))) {
5931  a->AdvSignalPLCI = &a->plci[i - 1];
5932  tplci = a->AdvSignalPLCI;
5933  tplci->tel = ADV_VOICE;
5934  PUT_WORD(&voice_cai[5], a->AdvSignalAppl->MaxDataLength);
5935  if (a->Info_Mask[a->AdvSignalAppl->Id - 1] & 0x200) {
5936  /* early B3 connect (CIP mask bit 9) no release after a disc */
5937  add_p(tplci, LLI, "\x01\x01");
5938  }
5939  add_p(tplci, CAI, voice_cai);
5940  add_p(tplci, OAD, a->TelOAD);
5941  add_p(tplci, OSA, a->TelOSA);
5942  add_p(tplci, SHIFT | 6, NULL);
5943  add_p(tplci, SIN, "\x02\x01\x00");
5944  add_p(tplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
5945  sig_req(tplci, ASSIGN, DSIG_ID);
5946  a->AdvSignalPLCI->internal_command = HOOK_OFF_REQ;
5947  a->AdvSignalPLCI->command = 0;
5948  tplci->appl = a->AdvSignalAppl;
5949  tplci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
5950  send_req(tplci);
5951  }
5952 
5953  }
5954 
5955  if (!tplci) break;
5956  Id = ((word)tplci->Id << 8) | a->Id;
5957  Id |= EXT_CONTROLLER;
5958  sendf(tplci->appl,
5959  _FACILITY_I,
5960  Id,
5961  0,
5962  "ws", (word)0, "\x01+");
5963  break;
5964 
5965  case 0x90: /* hook on */
5966  case 0x91:
5967  if (plci->internal_command == PERM_COD_HOOK)
5968  {
5969  dbug(1, dprintf("init:hook_on"));
5970  plci->hook_state = ie[1] & 0x91;
5971  next_internal_command(Id, plci);
5972  break;
5973  }
5974  else /* ignore doubled hook indications */
5975  {
5976  if (((plci->hook_state) & 0xf0) == 0x90) break;
5977  plci->hook_state = ie[1] & 0x91;
5978  }
5979  /* hangup the adv. voice call and signal '-' to the appl */
5980  if (a->AdvSignalPLCI) {
5981  Id = ((word)a->AdvSignalPLCI->Id << 8) | a->Id;
5982  if (plci->tel) Id |= EXT_CONTROLLER;
5983  sendf(a->AdvSignalAppl,
5984  _FACILITY_I,
5985  Id,
5986  0,
5987  "ws", (word)0, "\x01-");
5988  a->AdvSignalPLCI->internal_command = HOOK_ON_REQ;
5989  a->AdvSignalPLCI->command = 0;
5990  sig_req(a->AdvSignalPLCI, HANGUP, 0);
5991  send_req(a->AdvSignalPLCI);
5992  }
5993  break;
5994  }
5995  }
5996  break;
5997 
5998  case RESUME:
5999  clear_c_ind_mask_bit(plci, (word)(plci->appl->Id - 1));
6000  PUT_WORD(&resume_cau[4], GOOD);
6001  sendf(plci->appl, _FACILITY_I, Id, 0, "ws", (word)3, resume_cau);
6002  break;
6003 
6004  case SUSPEND:
6005  clear_c_ind_mask(plci);
6006 
6007  if (plci->NL.Id && !plci->nl_remove_id) {
6008  mixer_remove(plci);
6009  nl_req_ncci(plci, REMOVE, 0);
6010  }
6011  if (!plci->sig_remove_id) {
6012  plci->internal_command = 0;
6013  sig_req(plci, REMOVE, 0);
6014  }
6015  send_req(plci);
6016  if (!plci->channels) {
6017  sendf(plci->appl, _FACILITY_I, Id, 0, "ws", (word)3, "\x05\x04\x00\x02\x00\x00");
6018  sendf(plci->appl, _DISCONNECT_I, Id, 0, "w", 0);
6019  }
6020  break;
6021 
6022  case SUSPEND_REJ:
6023  break;
6024 
6025  case HANGUP:
6026  plci->hangup_flow_ctrl_timer = 0;
6027  if (plci->manufacturer && plci->State == LOCAL_CONNECT) break;
6028  cau = parms[7];
6029  if (cau) {
6030  i = _L3_CAUSE | cau[2];
6031  if (cau[2] == 0) i = 0;
6032  else if (cau[2] == 8) i = _L1_ERROR;
6033  else if (cau[2] == 9 || cau[2] == 10) i = _L2_ERROR;
6034  else if (cau[2] == 5) i = _CAPI_GUARD_ERROR;
6035  }
6036  else {
6037  i = _L3_ERROR;
6038  }
6039 
6040  if (plci->State == INC_CON_PENDING || plci->State == INC_CON_ALERT)
6041  {
6042  for (i = 0; i < max_appl; i++)
6043  {
6044  if (test_c_ind_mask_bit(plci, i))
6045  sendf(&application[i], _DISCONNECT_I, Id, 0, "w", 0);
6046  }
6047  }
6048  else
6049  {
6050  clear_c_ind_mask(plci);
6051  }
6052  if (!plci->appl)
6053  {
6054  if (plci->State == LISTENING)
6055  {
6056  plci->notifiedcall = 0;
6057  a->listen_active--;
6058  }
6059  plci->State = INC_DIS_PENDING;
6060  if (c_ind_mask_empty(plci))
6061  {
6062  plci->State = IDLE;
6063  if (plci->NL.Id && !plci->nl_remove_id)
6064  {
6065  mixer_remove(plci);
6066  nl_req_ncci(plci, REMOVE, 0);
6067  }
6068  if (!plci->sig_remove_id)
6069  {
6070  plci->internal_command = 0;
6071  sig_req(plci, REMOVE, 0);
6072  }
6073  send_req(plci);
6074  }
6075  }
6076  else
6077  {
6078  /* collision of DISCONNECT or CONNECT_RES with HANGUP can */
6079  /* result in a second HANGUP! Don't generate another */
6080  /* DISCONNECT */
6081  if (plci->State != IDLE && plci->State != INC_DIS_PENDING)
6082  {
6083  if (plci->State == RESUMING)
6084  {
6085  PUT_WORD(&resume_cau[4], i);
6086  sendf(plci->appl, _FACILITY_I, Id, 0, "ws", (word)3, resume_cau);
6087  }
6088  plci->State = INC_DIS_PENDING;
6089  sendf(plci->appl, _DISCONNECT_I, Id, 0, "w", i);
6090  }
6091  }
6092  break;
6093 
6094  case SSEXT_IND:
6095  SendSSExtInd(NULL, plci, Id, multi_ssext_parms);
6096  break;
6097 
6098  case VSWITCH_REQ:
6099  VSwitchReqInd(plci, Id, multi_vswitch_parms);
6100  break;
6101  case VSWITCH_IND:
6102  if (plci->relatedPTYPLCI &&
6103  plci->vswitchstate == 3 &&
6104  plci->relatedPTYPLCI->vswitchstate == 3 &&
6105  parms[MAXPARMSIDS - 1][0])
6106  {
6107  add_p(plci->relatedPTYPLCI, SMSG, parms[MAXPARMSIDS - 1]);
6108  sig_req(plci->relatedPTYPLCI, VSWITCH_REQ, 0);
6109  send_req(plci->relatedPTYPLCI);
6110  }
6111  else VSwitchReqInd(plci, Id, multi_vswitch_parms);
6112  break;
6113 
6114  }
6115 }
6116 
6117 
6118 static void SendSetupInfo(APPL *appl, PLCI *plci, dword Id, byte **parms, byte Info_Sent_Flag)
6119 {
6120  word i;
6121  byte *ie;
6122  word Info_Number;
6123  byte *Info_Element;
6124  word Info_Mask = 0;
6125 
6126  dbug(1, dprintf("SetupInfo"));
6127 
6128  for (i = 0; i < MAXPARMSIDS; i++) {
6129  ie = parms[i];
6130  Info_Number = 0;
6131  Info_Element = ie;
6132  if (ie[0]) {
6133  switch (i) {
6134  case 0:
6135  dbug(1, dprintf("CPN "));
6136  Info_Number = 0x0070;
6137  Info_Mask = 0x80;
6138  Info_Sent_Flag = true;
6139  break;
6140  case 8: /* display */
6141  dbug(1, dprintf("display(%d)", i));
6142  Info_Number = 0x0028;
6143  Info_Mask = 0x04;
6144  Info_Sent_Flag = true;
6145  break;
6146  case 16: /* Channel Id */
6147  dbug(1, dprintf("CHI"));
6148  Info_Number = 0x0018;
6149  Info_Mask = 0x100;
6150  Info_Sent_Flag = true;
6151  mixer_set_bchannel_id(plci, Info_Element);
6152  break;
6153  case 19: /* Redirected Number */
6154  dbug(1, dprintf("RDN"));
6155  Info_Number = 0x0074;
6156  Info_Mask = 0x400;
6157  Info_Sent_Flag = true;
6158  break;
6159  case 20: /* Redirected Number extended */
6160  dbug(1, dprintf("RDX"));
6161  Info_Number = 0x0073;
6162  Info_Mask = 0x400;
6163  Info_Sent_Flag = true;
6164  break;
6165  case 22: /* Redirecing Number */
6166  dbug(1, dprintf("RIN"));
6167  Info_Number = 0x0076;
6168  Info_Mask = 0x400;
6169  Info_Sent_Flag = true;
6170  break;
6171  default:
6172  Info_Number = 0;
6173  break;
6174  }
6175  }
6176 
6177  if (i == MAXPARMSIDS - 2) { /* to indicate the message type "Setup" */
6178  Info_Number = 0x8000 | 5;
6179  Info_Mask = 0x10;
6180  Info_Element = "";
6181  }
6182 
6183  if (Info_Sent_Flag && Info_Number) {
6184  if (plci->adapter->Info_Mask[appl->Id - 1] & Info_Mask) {
6185  sendf(appl, _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
6186  }
6187  }
6188  }
6189 }
6190 
6191 
6192 static void SendInfo(PLCI *plci, dword Id, byte **parms, byte iesent)
6193 {
6194  word i;
6195  word j;
6196  word k;
6197  byte *ie;
6198  word Info_Number;
6199  byte *Info_Element;
6200  word Info_Mask = 0;
6201  static byte charges[5] = {4, 0, 0, 0, 0};
6202  static byte cause[] = {0x02, 0x80, 0x00};
6203  APPL *appl;
6204 
6205  dbug(1, dprintf("InfoParse "));
6206 
6207  if (
6208  !plci->appl
6209  && !plci->State
6210  && plci->Sig.Ind != NCR_FACILITY
6211  )
6212  {
6213  dbug(1, dprintf("NoParse "));
6214  return;
6215  }
6216  cause[2] = 0;
6217  for (i = 0; i < MAXPARMSIDS; i++) {
6218  ie = parms[i];
6219  Info_Number = 0;
6220  Info_Element = ie;
6221  if (ie[0]) {
6222  switch (i) {
6223  case 0:
6224  dbug(1, dprintf("CPN "));
6225  Info_Number = 0x0070;
6226  Info_Mask = 0x80;
6227  break;
6228  case 7: /* ESC_CAU */
6229  dbug(1, dprintf("cau(0x%x)", ie[2]));
6230  Info_Number = 0x0008;
6231  Info_Mask = 0x00;
6232  cause[2] = ie[2];
6233  Info_Element = NULL;
6234  break;
6235  case 8: /* display */
6236  dbug(1, dprintf("display(%d)", i));
6237  Info_Number = 0x0028;
6238  Info_Mask = 0x04;
6239  break;
6240  case 9: /* Date display */
6241  dbug(1, dprintf("date(%d)", i));
6242  Info_Number = 0x0029;
6243  Info_Mask = 0x02;
6244  break;
6245  case 10: /* charges */
6246  for (j = 0; j < 4; j++) charges[1 + j] = 0;
6247  for (j = 0; j < ie[0] && !(ie[1 + j] & 0x80); j++);
6248  for (k = 1, j++; j < ie[0] && k <= 4; j++, k++) charges[k] = ie[1 + j];
6249  Info_Number = 0x4000;
6250  Info_Mask = 0x40;
6251  Info_Element = charges;
6252  break;
6253  case 11: /* user user info */
6254  dbug(1, dprintf("uui"));
6255  Info_Number = 0x007E;
6256  Info_Mask = 0x08;
6257  break;
6258  case 12: /* congestion receiver ready */
6259  dbug(1, dprintf("clRDY"));
6260  Info_Number = 0x00B0;
6261  Info_Mask = 0x08;
6262  Info_Element = "";
6263  break;
6264  case 13: /* congestion receiver not ready */
6265  dbug(1, dprintf("clNRDY"));
6266  Info_Number = 0x00BF;
6267  Info_Mask = 0x08;
6268  Info_Element = "";
6269  break;
6270  case 15: /* Keypad Facility */
6271  dbug(1, dprintf("KEY"));
6272  Info_Number = 0x002C;
6273  Info_Mask = 0x20;
6274  break;
6275  case 16: /* Channel Id */
6276  dbug(1, dprintf("CHI"));
6277  Info_Number = 0x0018;
6278  Info_Mask = 0x100;
6279  mixer_set_bchannel_id(plci, Info_Element);
6280  break;
6281  case 17: /* if no 1tr6 cause, send full cause, else esc_cause */
6282  dbug(1, dprintf("q9cau(0x%x)", ie[2]));
6283  if (!cause[2] || cause[2] < 0x80) break; /* eg. layer 1 error */
6284  Info_Number = 0x0008;
6285  Info_Mask = 0x01;
6286  if (cause[2] != ie[2]) Info_Element = cause;
6287  break;
6288  case 19: /* Redirected Number */
6289  dbug(1, dprintf("RDN"));
6290  Info_Number = 0x0074;
6291  Info_Mask = 0x400;
6292  break;
6293  case 22: /* Redirecing Number */
6294  dbug(1, dprintf("RIN"));
6295  Info_Number = 0x0076;
6296  Info_Mask = 0x400;
6297  break;
6298  case 23: /* Notification Indicator */
6299  dbug(1, dprintf("NI"));
6300  Info_Number = (word)NI;
6301  Info_Mask = 0x210;
6302  break;
6303  case 26: /* Call State */
6304  dbug(1, dprintf("CST"));
6305  Info_Number = (word)CST;
6306  Info_Mask = 0x01; /* do with cause i.e. for now */
6307  break;
6308  case MAXPARMSIDS - 2: /* Escape Message Type, must be the last indication */
6309  dbug(1, dprintf("ESC/MT[0x%x]", ie[3]));
6310  Info_Number = 0x8000 | ie[3];
6311  if (iesent) Info_Mask = 0xffff;
6312  else Info_Mask = 0x10;
6313  Info_Element = "";
6314  break;
6315  default:
6316  Info_Number = 0;
6317  Info_Mask = 0;
6318  Info_Element = "";
6319  break;
6320  }
6321  }
6322 
6323  if (plci->Sig.Ind == NCR_FACILITY) /* check controller broadcast */
6324  {
6325  for (j = 0; j < max_appl; j++)
6326  {
6327  appl = &application[j];
6328  if (Info_Number
6329  && appl->Id
6330  && plci->adapter->Info_Mask[appl->Id - 1] & Info_Mask)
6331  {
6332  dbug(1, dprintf("NCR_Ind"));
6333  iesent = true;
6334  sendf(&application[j], _INFO_I, Id & 0x0f, 0, "wS", Info_Number, Info_Element);
6335  }
6336  }
6337  }
6338  else if (!plci->appl)
6339  { /* overlap receiving broadcast */
6340  if (Info_Number == CPN
6341  || Info_Number == KEY
6342  || Info_Number == NI
6343  || Info_Number == DSP
6344  || Info_Number == UUI)
6345  {
6346  for (j = 0; j < max_appl; j++)
6347  {
6348  if (test_c_ind_mask_bit(plci, j))
6349  {
6350  dbug(1, dprintf("Ovl_Ind"));
6351  iesent = true;
6352  sendf(&application[j], _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
6353  }
6354  }
6355  }
6356  } /* all other signalling states */
6357  else if (Info_Number
6358  && plci->adapter->Info_Mask[plci->appl->Id - 1] & Info_Mask)
6359  {
6360  dbug(1, dprintf("Std_Ind"));
6361  iesent = true;
6362  sendf(plci->appl, _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
6363  }
6364  }
6365 }
6366 
6367 
6368 static byte SendMultiIE(PLCI *plci, dword Id, byte **parms, byte ie_type,
6369  dword info_mask, byte setupParse)
6370 {
6371  word i;
6372  word j;
6373  byte *ie;
6374  word Info_Number;
6375  byte *Info_Element;
6376  APPL *appl;
6377  word Info_Mask = 0;
6378  byte iesent = 0;
6379 
6380  if (
6381  !plci->appl
6382  && !plci->State
6383  && plci->Sig.Ind != NCR_FACILITY
6384  && !setupParse
6385  )
6386  {
6387  dbug(1, dprintf("NoM-IEParse "));
6388  return 0;
6389  }
6390  dbug(1, dprintf("M-IEParse "));
6391 
6392  for (i = 0; i < MAX_MULTI_IE; i++)
6393  {
6394  ie = parms[i];
6395  Info_Number = 0;
6396  Info_Element = ie;
6397  if (ie[0])
6398  {
6399  dbug(1, dprintf("[Ind0x%x]:IE=0x%x", plci->Sig.Ind, ie_type));
6400  Info_Number = (word)ie_type;
6401  Info_Mask = (word)info_mask;
6402  }
6403 
6404  if (plci->Sig.Ind == NCR_FACILITY) /* check controller broadcast */
6405  {
6406  for (j = 0; j < max_appl; j++)
6407  {
6408  appl = &application[j];
6409  if (Info_Number
6410  && appl->Id
6411  && plci->adapter->Info_Mask[appl->Id - 1] & Info_Mask)
6412  {
6413  iesent = true;
6414  dbug(1, dprintf("Mlt_NCR_Ind"));
6415  sendf(&application[j], _INFO_I, Id & 0x0f, 0, "wS", Info_Number, Info_Element);
6416  }
6417  }
6418  }
6419  else if (!plci->appl && Info_Number)
6420  { /* overlap receiving broadcast */
6421  for (j = 0; j < max_appl; j++)
6422  {
6423  if (test_c_ind_mask_bit(plci, j))
6424  {
6425  iesent = true;
6426  dbug(1, dprintf("Mlt_Ovl_Ind"));
6427  sendf(&application[j] , _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
6428  }
6429  }
6430  } /* all other signalling states */
6431  else if (Info_Number
6432  && plci->adapter->Info_Mask[plci->appl->Id - 1] & Info_Mask)
6433  {
6434  iesent = true;
6435  dbug(1, dprintf("Mlt_Std_Ind"));
6436  sendf(plci->appl, _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
6437  }
6438  }
6439  return iesent;
6440 }
6441 
6442 static void SendSSExtInd(APPL *appl, PLCI *plci, dword Id, byte **parms)
6443 {
6444  word i;
6445  /* Format of multi_ssext_parms[i][]:
6446  0 byte length
6447  1 byte SSEXTIE
6448  2 byte SSEXT_REQ/SSEXT_IND
6449  3 byte length
6450  4 word SSExtCommand
6451  6... Params
6452  */
6453  if (
6454  plci
6455  && plci->State
6456  && plci->Sig.Ind != NCR_FACILITY
6457  )
6458  for (i = 0; i < MAX_MULTI_IE; i++)
6459  {
6460  if (parms[i][0] < 6) continue;
6461  if (parms[i][2] == SSEXT_REQ) continue;
6462 
6463  if (appl)
6464  {
6465  parms[i][0] = 0; /* kill it */
6466  sendf(appl, _MANUFACTURER_I,
6467  Id,
6468  0,
6469  "dwS",
6470  _DI_MANU_ID,
6471  _DI_SSEXT_CTRL,
6472  &parms[i][3]);
6473  }
6474  else if (plci->appl)
6475  {
6476  parms[i][0] = 0; /* kill it */
6477  sendf(plci->appl, _MANUFACTURER_I,
6478  Id,
6479  0,
6480  "dwS",
6481  _DI_MANU_ID,
6482  _DI_SSEXT_CTRL,
6483  &parms[i][3]);
6484  }
6485  }
6486 };
6487 
6488 static void nl_ind(PLCI *plci)
6489 {
6490  byte ch;
6491  word ncci;
6492  dword Id;
6493  DIVA_CAPI_ADAPTER *a;
6494  word NCCIcode;
6495  APPL *APPLptr;
6496  word count;
6497  word Num;
6498  word i, ncpi_state;
6499  byte len, ncci_state;
6500  word msg;
6501  word info = 0;
6502  word fax_feature_bits;
6503  byte fax_send_edata_ack;
6504  static byte v120_header_buffer[2 + 3];
6505  static word fax_info[] = {
6506  0, /* T30_SUCCESS */
6507  _FAX_NO_CONNECTION, /* T30_ERR_NO_DIS_RECEIVED */
6508  _FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_NO_RESPONSE */
6509  _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_RESPONSE */
6510  _FAX_PROTOCOL_ERROR, /* T30_ERR_TOO_MANY_REPEATS */
6511  _FAX_PROTOCOL_ERROR, /* T30_ERR_UNEXPECTED_MESSAGE */
6512  _FAX_REMOTE_ABORT, /* T30_ERR_UNEXPECTED_DCN */
6513  _FAX_LOCAL_ABORT, /* T30_ERR_DTC_UNSUPPORTED */
6514  _FAX_TRAINING_ERROR, /* T30_ERR_ALL_RATES_FAILED */
6515  _FAX_TRAINING_ERROR, /* T30_ERR_TOO_MANY_TRAINS */
6516  _FAX_PARAMETER_ERROR, /* T30_ERR_RECEIVE_CORRUPTED */
6517  _FAX_REMOTE_ABORT, /* T30_ERR_UNEXPECTED_DISC */
6518  _FAX_LOCAL_ABORT, /* T30_ERR_APPLICATION_DISC */
6519  _FAX_REMOTE_REJECT, /* T30_ERR_INCOMPATIBLE_DIS */
6520  _FAX_LOCAL_ABORT, /* T30_ERR_INCOMPATIBLE_DCS */
6521  _FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_NO_COMMAND */
6522  _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_COMMAND */
6523  _FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_COMMAND_TOO_LONG */
6524  _FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_RESPONSE_TOO_LONG */
6525  _FAX_NO_CONNECTION, /* T30_ERR_NOT_IDENTIFIED */
6526  _FAX_PROTOCOL_ERROR, /* T30_ERR_SUPERVISORY_TIMEOUT */
6527  _FAX_PARAMETER_ERROR, /* T30_ERR_TOO_LONG_SCAN_LINE */
6528  _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_PAGE_AFTER_MPS */
6529  _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_PAGE_AFTER_CFR */
6530  _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCS_AFTER_FTT */
6531  _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCS_AFTER_EOM */
6532  _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCS_AFTER_MPS */
6533  _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCN_AFTER_MCF */
6534  _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCN_AFTER_RTN */
6535  _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_CFR */
6536  _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_MCF_AFTER_EOP */
6537  _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_MCF_AFTER_EOM */
6538  _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_MCF_AFTER_MPS */
6539  0x331d, /* T30_ERR_SUB_SEP_UNSUPPORTED */
6540  0x331e, /* T30_ERR_PWD_UNSUPPORTED */
6541  0x331f, /* T30_ERR_SUB_SEP_PWD_UNSUPPORTED */
6542  _FAX_PROTOCOL_ERROR, /* T30_ERR_INVALID_COMMAND_FRAME */
6543  _FAX_PARAMETER_ERROR, /* T30_ERR_UNSUPPORTED_PAGE_CODING */
6544  _FAX_PARAMETER_ERROR, /* T30_ERR_INVALID_PAGE_CODING */
6545  _FAX_REMOTE_REJECT, /* T30_ERR_INCOMPATIBLE_PAGE_CONFIG */
6546  _FAX_LOCAL_ABORT, /* T30_ERR_TIMEOUT_FROM_APPLICATION */
6547  _FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_NO_REACTION_ON_MARK */
6548  _FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_TRAINING_TIMEOUT */
6549  _FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_UNEXPECTED_V21 */
6550  _FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_PRIMARY_CTS_ON */
6551  _FAX_LOCAL_ABORT, /* T30_ERR_V34FAX_TURNAROUND_POLLING */
6552  _FAX_LOCAL_ABORT /* T30_ERR_V34FAX_V8_INCOMPATIBILITY */
6553  };
6554 
6555  byte dtmf_code_buffer[CAPIDTMF_RECV_DIGIT_BUFFER_SIZE + 1];
6556 
6557 
6558  static word rtp_info[] = {
6559  GOOD, /* RTP_SUCCESS */
6560  0x3600 /* RTP_ERR_SSRC_OR_PAYLOAD_CHANGE */
6561  };
6562 
6563  static dword udata_forwarding_table[0x100 / sizeof(dword)] =
6564  {
6565  0x0020301e, 0x00000000, 0x00000000, 0x00000000,
6566  0x00000000, 0x00000000, 0x00000000, 0x00000000
6567  };
6568 
6569  ch = plci->NL.IndCh;
6570  a = plci->adapter;
6571  ncci = a->ch_ncci[ch];
6572  Id = (((dword)(ncci ? ncci : ch)) << 16) | (((word) plci->Id) << 8) | a->Id;
6573  if (plci->tel) Id |= EXT_CONTROLLER;
6574  APPLptr = plci->appl;
6575  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",
6576  plci->NL.Id, Id, plci->Id, plci->tel, plci->State, ch, plci->channels, plci->NL.Ind & 0x0f));
6577 
6578  /* in the case if no connect_active_Ind was sent to the appl we wait for */
6579 
6580  if (plci->nl_remove_id)
6581  {
6582  plci->NL.RNR = 2; /* discard */
6583  dbug(1, dprintf("NL discard while remove pending"));
6584  return;
6585  }
6586  if ((plci->NL.Ind & 0x0f) == N_CONNECT)
6587  {
6588  if (plci->State == INC_DIS_PENDING
6589  || plci->State == OUTG_DIS_PENDING
6590  || plci->State == IDLE)
6591  {
6592  plci->NL.RNR = 2; /* discard */
6593  dbug(1, dprintf("discard n_connect"));
6594  return;
6595  }
6596  if (plci->State < INC_ACT_PENDING)
6597  {
6598  plci->NL.RNR = 1; /* flow control */
6599  channel_x_off(plci, ch, N_XON_CONNECT_IND);
6600  return;
6601  }
6602  }
6603 
6604  if (!APPLptr) /* no application or invalid data */
6605  { /* while reloading the DSP */
6606  dbug(1, dprintf("discard1"));
6607  plci->NL.RNR = 2;
6608  return;
6609  }
6610 
6611  if (((plci->NL.Ind & 0x0f) == N_UDATA)
6612  && (((plci->B2_prot != B2_SDLC) && ((plci->B1_resource == 17) || (plci->B1_resource == 18)))
6613  || (plci->B2_prot == 7)
6614  || (plci->B3_prot == 7)))
6615  {
6616  plci->ncpi_buffer[0] = 0;
6617 
6618  ncpi_state = plci->ncpi_state;
6619  if (plci->NL.complete == 1)
6620  {
6621  byte *data = &plci->NL.RBuffer->P[0];
6622 
6623  if ((plci->NL.RBuffer->length >= 12)
6624  && ((*data == DSP_UDATA_INDICATION_DCD_ON)
6625  || (*data == DSP_UDATA_INDICATION_CTS_ON)))
6626  {
6627  word conn_opt, ncpi_opt = 0x00;
6628 /* HexDump ("MDM N_UDATA:", plci->NL.RBuffer->length, data); */
6629 
6630  if (*data == DSP_UDATA_INDICATION_DCD_ON)
6631  plci->ncpi_state |= NCPI_MDM_DCD_ON_RECEIVED;
6632  if (*data == DSP_UDATA_INDICATION_CTS_ON)
6633  plci->ncpi_state |= NCPI_MDM_CTS_ON_RECEIVED;
6634 
6635  data++; /* indication code */
6636  data += 2; /* timestamp */
6637  if ((*data == DSP_CONNECTED_NORM_V18) || (*data == DSP_CONNECTED_NORM_VOWN))
6638  ncpi_state &= ~(NCPI_MDM_DCD_ON_RECEIVED | NCPI_MDM_CTS_ON_RECEIVED);
6639  data++; /* connected norm */
6640  conn_opt = GET_WORD(data);
6641  data += 2; /* connected options */
6642 
6643  PUT_WORD(&(plci->ncpi_buffer[1]), (word)(GET_DWORD(data) & 0x0000FFFF));
6644 
6645  if (conn_opt & DSP_CONNECTED_OPTION_MASK_V42)
6646  {
6647  ncpi_opt |= MDM_NCPI_ECM_V42;
6648  }
6649  else if (conn_opt & DSP_CONNECTED_OPTION_MASK_MNP)
6650  {
6651  ncpi_opt |= MDM_NCPI_ECM_MNP;
6652  }
6653  else
6654  {
6655  ncpi_opt |= MDM_NCPI_TRANSPARENT;
6656  }
6657  if (conn_opt & DSP_CONNECTED_OPTION_MASK_COMPRESSION)
6658  {
6659  ncpi_opt |= MDM_NCPI_COMPRESSED;
6660  }
6661  PUT_WORD(&(plci->ncpi_buffer[3]), ncpi_opt);
6662  plci->ncpi_buffer[0] = 4;
6663 
6664  plci->ncpi_state |= NCPI_VALID_CONNECT_B3_IND | NCPI_VALID_CONNECT_B3_ACT | NCPI_VALID_DISC_B3_IND;
6665  }
6666  }
6667  if (plci->B3_prot == 7)
6668  {
6669  if (((a->ncci_state[ncci] == INC_ACT_PENDING) || (a->ncci_state[ncci] == OUTG_CON_PENDING))
6670  && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6671  && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6672  {
6673  a->ncci_state[ncci] = INC_ACT_PENDING;
6674  sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
6675  plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6676  }
6677  }
6678 
6679  if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
6680  & ((1L << PRIVATE_V18) | (1L << PRIVATE_VOWN)))
6681  || !(ncpi_state & NCPI_MDM_DCD_ON_RECEIVED)
6682  || !(ncpi_state & NCPI_MDM_CTS_ON_RECEIVED))
6683 
6684  {
6685  plci->NL.RNR = 2;
6686  return;
6687  }
6688  }
6689 
6690  if (plci->NL.complete == 2)
6691  {
6692  if (((plci->NL.Ind & 0x0f) == N_UDATA)
6693  && !(udata_forwarding_table[plci->RData[0].P[0] >> 5] & (1L << (plci->RData[0].P[0] & 0x1f))))
6694  {
6695  switch (plci->RData[0].P[0])
6696  {
6697 
6698  case DTMF_UDATA_INDICATION_FAX_CALLING_TONE:
6699  if (plci->dtmf_rec_active & DTMF_LISTEN_ACTIVE_FLAG)
6700  sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", SELECTOR_DTMF, "\x01X");
6701  break;
6702  case DTMF_UDATA_INDICATION_ANSWER_TONE:
6703  if (plci->dtmf_rec_active & DTMF_LISTEN_ACTIVE_FLAG)
6704  sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", SELECTOR_DTMF, "\x01Y");
6705  break;
6706  case DTMF_UDATA_INDICATION_DIGITS_RECEIVED:
6707  dtmf_indication(Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6708  break;
6709  case DTMF_UDATA_INDICATION_DIGITS_SENT:
6710  dtmf_confirmation(Id, plci);
6711  break;
6712 
6713 
6714  case UDATA_INDICATION_MIXER_TAP_DATA:
6715  capidtmf_recv_process_block(&(plci->capidtmf_state), plci->RData[0].P + 1, (word)(plci->RData[0].PLength - 1));
6716  i = capidtmf_indication(&(plci->capidtmf_state), dtmf_code_buffer + 1);
6717  if (i != 0)
6718  {
6719  dtmf_code_buffer[0] = DTMF_UDATA_INDICATION_DIGITS_RECEIVED;
6720  dtmf_indication(Id, plci, dtmf_code_buffer, (word)(i + 1));
6721  }
6722  break;
6723 
6724 
6725  case UDATA_INDICATION_MIXER_COEFS_SET:
6726  mixer_indication_coefs_set(Id, plci);
6727  break;
6728  case UDATA_INDICATION_XCONNECT_FROM:
6729  mixer_indication_xconnect_from(Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6730  break;
6731  case UDATA_INDICATION_XCONNECT_TO:
6732  mixer_indication_xconnect_to(Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6733  break;
6734 
6735 
6736  case LEC_UDATA_INDICATION_DISABLE_DETECT:
6737  ec_indication(Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6738  break;
6739 
6740 
6741 
6742  default:
6743  break;
6744  }
6745  }
6746  else
6747  {
6748  if ((plci->RData[0].PLength != 0)
6749  && ((plci->B2_prot == B2_V120_ASYNC)
6750  || (plci->B2_prot == B2_V120_ASYNC_V42BIS)
6751  || (plci->B2_prot == B2_V120_BIT_TRANSPARENT)))
6752  {
6753 
6754  sendf(plci->appl, _DATA_B3_I, Id, 0,
6755  "dwww",
6756  plci->RData[1].P,
6757  (plci->NL.RNum < 2) ? 0 : plci->RData[1].PLength,
6758  plci->RNum,
6759  plci->RFlags);
6760 
6761  }
6762  else
6763  {
6764 
6765  sendf(plci->appl, _DATA_B3_I, Id, 0,
6766  "dwww",
6767  plci->RData[0].P,
6768  plci->RData[0].PLength,
6769  plci->RNum,
6770  plci->RFlags);
6771 
6772  }
6773  }
6774  return;
6775  }
6776 
6777  fax_feature_bits = 0;
6778  if ((plci->NL.Ind & 0x0f) == N_CONNECT ||
6779  (plci->NL.Ind & 0x0f) == N_CONNECT_ACK ||
6780  (plci->NL.Ind & 0x0f) == N_DISC ||
6781  (plci->NL.Ind & 0x0f) == N_EDATA ||
6782  (plci->NL.Ind & 0x0f) == N_DISC_ACK)
6783  {
6784  info = 0;
6785  plci->ncpi_buffer[0] = 0;
6786  switch (plci->B3_prot) {
6787  case 0: /*XPARENT*/
6788  case 1: /*T.90 NL*/
6789  break; /* no network control protocol info - jfr */
6790  case 2: /*ISO8202*/
6791  case 3: /*X25 DCE*/
6792  for (i = 0; i < plci->NL.RLength; i++) plci->ncpi_buffer[4 + i] = plci->NL.RBuffer->P[i];
6793  plci->ncpi_buffer[0] = (byte)(i + 3);
6794  plci->ncpi_buffer[1] = (byte)(plci->NL.Ind & N_D_BIT ? 1 : 0);
6795  plci->ncpi_buffer[2] = 0;
6796  plci->ncpi_buffer[3] = 0;
6797  break;
6798  case 4: /*T.30 - FAX*/
6799  case 5: /*T.30 - FAX*/
6800  if (plci->NL.RLength >= sizeof(T30_INFO))
6801  {
6802  dbug(1, dprintf("FaxStatus %04x", ((T30_INFO *)plci->NL.RBuffer->P)->code));
6803  len = 9;
6804  PUT_WORD(&(plci->ncpi_buffer[1]), ((T30_INFO *)plci->NL.RBuffer->P)->rate_div_2400 * 2400);
6805  fax_feature_bits = GET_WORD(&((T30_INFO *)plci->NL.RBuffer->P)->feature_bits_low);
6806  i = (((T30_INFO *)plci->NL.RBuffer->P)->resolution & T30_RESOLUTION_R8_0770_OR_200) ? 0x0001 : 0x0000;
6807  if (plci->B3_prot == 5)
6808  {
6809  if (!(fax_feature_bits & T30_FEATURE_BIT_ECM))
6810  i |= 0x8000; /* This is not an ECM connection */
6811  if (fax_feature_bits & T30_FEATURE_BIT_T6_CODING)
6812  i |= 0x4000; /* This is a connection with MMR compression */
6813  if (fax_feature_bits & T30_FEATURE_BIT_2D_CODING)
6814  i |= 0x2000; /* This is a connection with MR compression */
6815  if (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS)
6816  i |= 0x0004; /* More documents */
6817  if (fax_feature_bits & T30_FEATURE_BIT_POLLING)
6818  i |= 0x0002; /* Fax-polling indication */
6819  }
6820  dbug(1, dprintf("FAX Options %04x %04x", fax_feature_bits, i));
6821  PUT_WORD(&(plci->ncpi_buffer[3]), i);
6822  PUT_WORD(&(plci->ncpi_buffer[5]), ((T30_INFO *)plci->NL.RBuffer->P)->data_format);
6823  plci->ncpi_buffer[7] = ((T30_INFO *)plci->NL.RBuffer->P)->pages_low;
6824  plci->ncpi_buffer[8] = ((T30_INFO *)plci->NL.RBuffer->P)->pages_high;
6825  plci->ncpi_buffer[len] = 0;
6826  if (((T30_INFO *)plci->NL.RBuffer->P)->station_id_len)
6827  {
6828  plci->ncpi_buffer[len] = 20;
6829  for (i = 0; i < T30_MAX_STATION_ID_LENGTH; i++)
6830  plci->ncpi_buffer[++len] = ((T30_INFO *)plci->NL.RBuffer->P)->station_id[i];
6831  }
6832  if (((plci->NL.Ind & 0x0f) == N_DISC) || ((plci->NL.Ind & 0x0f) == N_DISC_ACK))
6833  {
6834  if (((T30_INFO *)plci->NL.RBuffer->P)->code < ARRAY_SIZE(fax_info))
6835  info = fax_info[((T30_INFO *)plci->NL.RBuffer->P)->code];
6836  else
6837  info = _FAX_PROTOCOL_ERROR;
6838  }
6839 
6840  if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id - 1])
6841  & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
6842  {
6843  i = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + ((T30_INFO *)plci->NL.RBuffer->P)->head_line_len;
6844  while (i < plci->NL.RBuffer->length)
6845  plci->ncpi_buffer[++len] = plci->NL.RBuffer->P[i++];
6846  }
6847 
6848  plci->ncpi_buffer[0] = len;
6849  fax_feature_bits = GET_WORD(&((T30_INFO *)plci->NL.RBuffer->P)->feature_bits_low);
6850  PUT_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->feature_bits_low, fax_feature_bits);
6851 
6852  plci->ncpi_state |= NCPI_VALID_CONNECT_B3_IND;
6853  if (((plci->NL.Ind & 0x0f) == N_CONNECT_ACK)
6854  || (((plci->NL.Ind & 0x0f) == N_CONNECT)
6855  && (fax_feature_bits & T30_FEATURE_BIT_POLLING))
6856  || (((plci->NL.Ind & 0x0f) == N_EDATA)
6857  && ((((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_TRAIN_OK)
6858  || (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_DIS)
6859  || (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_DTC))))
6860  {
6861  plci->ncpi_state |= NCPI_VALID_CONNECT_B3_ACT;
6862  }
6863  if (((plci->NL.Ind & 0x0f) == N_DISC)
6864  || ((plci->NL.Ind & 0x0f) == N_DISC_ACK)
6865  || (((plci->NL.Ind & 0x0f) == N_EDATA)
6866  && (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_EOP_CAPI)))
6867  {
6868  plci->ncpi_state |= NCPI_VALID_CONNECT_B3_ACT | NCPI_VALID_DISC_B3_IND;
6869  }
6870  }
6871  break;
6872 
6873  case B3_RTP:
6874  if (((plci->NL.Ind & 0x0f) == N_DISC) || ((plci->NL.Ind & 0x0f) == N_DISC_ACK))
6875  {
6876  if (plci->NL.RLength != 0)
6877  {
6878  info = rtp_info[plci->NL.RBuffer->P[0]];
6879  plci->ncpi_buffer[0] = plci->NL.RLength - 1;
6880  for (i = 1; i < plci->NL.RLength; i++)
6881  plci->ncpi_buffer[i] = plci->NL.RBuffer->P[i];
6882  }
6883  }
6884  break;
6885 
6886  }
6887  plci->NL.RNR = 2;
6888  }
6889  switch (plci->NL.Ind & 0x0f) {
6890  case N_EDATA:
6891  if ((plci->B3_prot == 4) || (plci->B3_prot == 5))
6892  {
6893  dbug(1, dprintf("EDATA ncci=0x%x state=%d code=%02x", ncci, a->ncci_state[ncci],
6894  ((T30_INFO *)plci->NL.RBuffer->P)->code));
6895  fax_send_edata_ack = (((T30_INFO *)(plci->fax_connect_info_buffer))->operating_mode == T30_OPERATING_MODE_CAPI_NEG);
6896 
6897  if ((plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF)
6898  && (plci->nsf_control_bits & (T30_NSF_CONTROL_BIT_NEGOTIATE_IND | T30_NSF_CONTROL_BIT_NEGOTIATE_RESP))
6899  && (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_DIS)
6900  && (a->ncci_state[ncci] == OUTG_CON_PENDING)
6901  && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6902  && !(plci->ncpi_state & NCPI_NEGOTIATE_B3_SENT))
6903  {
6904  ((T30_INFO *)(plci->fax_connect_info_buffer))->code = ((T30_INFO *)plci->NL.RBuffer->P)->code;
6905  sendf(plci->appl, _MANUFACTURER_I, Id, 0, "dwbS", _DI_MANU_ID, _DI_NEGOTIATE_B3,
6906  (byte)(plci->ncpi_buffer[0] + 1), plci->ncpi_buffer);
6907  plci->ncpi_state |= NCPI_NEGOTIATE_B3_SENT;
6908  if (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP)
6909  fax_send_edata_ack = false;
6910  }
6911 
6912  if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
6913  {
6914  switch (((T30_INFO *)plci->NL.RBuffer->P)->code)
6915  {
6916  case EDATA_T30_DIS:
6917  if ((a->ncci_state[ncci] == OUTG_CON_PENDING)
6918  && !(GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low) & T30_CONTROL_BIT_REQUEST_POLLING)
6919  && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6920  && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6921  {
6922  a->ncci_state[ncci] = INC_ACT_PENDING;
6923  if (plci->B3_prot == 4)
6924  sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
6925  else
6926  sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
6927  plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6928  }
6929  break;
6930 
6931  case EDATA_T30_TRAIN_OK:
6932  if ((a->ncci_state[ncci] == INC_ACT_PENDING)
6933  && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6934  && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6935  {
6936  if (plci->B3_prot == 4)
6937  sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
6938  else
6939  sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
6940  plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6941  }
6942  break;
6943 
6944  case EDATA_T30_EOP_CAPI:
6945  if (a->ncci_state[ncci] == CONNECTED)
6946  {
6947  sendf(plci->appl, _DISCONNECT_B3_I, Id, 0, "wS", GOOD, plci->ncpi_buffer);
6948  a->ncci_state[ncci] = INC_DIS_PENDING;
6949  plci->ncpi_state = 0;
6950  fax_send_edata_ack = false;
6951  }
6952  break;
6953  }
6954  }
6955  else
6956  {
6957  switch (((T30_INFO *)plci->NL.RBuffer->P)->code)
6958  {
6959  case EDATA_T30_TRAIN_OK:
6960  if ((a->ncci_state[ncci] == INC_ACT_PENDING)
6961  && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6962  && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6963  {
6964  if (plci->B3_prot == 4)
6965  sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
6966  else
6967  sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
6968  plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6969  }
6970  break;
6971  }
6972  }
6973  if (fax_send_edata_ack)
6974  {
6975  ((T30_INFO *)(plci->fax_connect_info_buffer))->code = ((T30_INFO *)plci->NL.RBuffer->P)->code;
6976  plci->fax_edata_ack_length = 1;
6977  start_internal_command(Id, plci, fax_edata_ack_command);
6978  }
6979  }
6980  else
6981  {
6982  dbug(1, dprintf("EDATA ncci=0x%x state=%d", ncci, a->ncci_state[ncci]));
6983  }
6984  break;
6985  case N_CONNECT:
6986  if (!a->ch_ncci[ch])
6987  {
6988  ncci = get_ncci(plci, ch, 0);
6989  Id = (Id & 0xffff) | (((dword) ncci) << 16);
6990  }
6991  dbug(1, dprintf("N_CONNECT: ch=%d state=%d plci=%lx plci_Id=%lx plci_State=%d",
6992  ch, a->ncci_state[ncci], a->ncci_plci[ncci], plci->Id, plci->State));
6993 
6994  msg = _CONNECT_B3_I;
6995  if (a->ncci_state[ncci] == IDLE)
6996  plci->channels++;
6997  else if (plci->B3_prot == 1)
6998  msg = _CONNECT_B3_T90_ACTIVE_I;
6999 
7000  a->ncci_state[ncci] = INC_CON_PENDING;
7001  if (plci->B3_prot == 4)
7002  sendf(plci->appl, msg, Id, 0, "s", "");
7003  else
7004  sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer);
7005  break;
7006  case N_CONNECT_ACK:
7007  dbug(1, dprintf("N_connect_Ack"));
7008  if (plci->internal_command_queue[0]
7009  && ((plci->adjust_b_state == ADJUST_B_CONNECT_2)
7010  || (plci->adjust_b_state == ADJUST_B_CONNECT_3)
7011  || (plci->adjust_b_state == ADJUST_B_CONNECT_4)))
7012  {
7013  (*(plci->internal_command_queue[0]))(Id, plci, 0);
7014  if (!plci->internal_command)
7015  next_internal_command(Id, plci);
7016  break;
7017  }
7018  msg = _CONNECT_B3_ACTIVE_I;
7019  if (plci->B3_prot == 1)
7020  {
7021  if (a->ncci_state[ncci] != OUTG_CON_PENDING)
7022  msg = _CONNECT_B3_T90_ACTIVE_I;
7023  a->ncci_state[ncci] = INC_ACT_PENDING;
7024  sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer);
7025  }
7026  else if ((plci->B3_prot == 4) || (plci->B3_prot == 5) || (plci->B3_prot == 7))
7027  {
7028  if ((a->ncci_state[ncci] == OUTG_CON_PENDING)
7029  && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
7030  && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
7031  {
7032  a->ncci_state[ncci] = INC_ACT_PENDING;
7033  if (plci->B3_prot == 4)
7034  sendf(plci->appl, msg, Id, 0, "s", "");
7035  else
7036  sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer);
7037  plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
7038  }
7039  }
7040  else
7041  {
7042  a->ncci_state[ncci] = INC_ACT_PENDING;
7043  sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer);
7044  }
7045  if (plci->adjust_b_restore)
7046  {
7047  plci->adjust_b_restore = false;
7048  start_internal_command(Id, plci, adjust_b_restore);
7049  }
7050  break;
7051  case N_DISC:
7052  case N_DISC_ACK:
7053  if (plci->internal_command_queue[0]
7054  && ((plci->internal_command == FAX_DISCONNECT_COMMAND_1)
7055  || (plci->internal_command == FAX_DISCONNECT_COMMAND_2)
7056  || (plci->internal_command == FAX_DISCONNECT_COMMAND_3)))
7057  {
7058  (*(plci->internal_command_queue[0]))(Id, plci, 0);
7059  if (!plci->internal_command)
7060  next_internal_command(Id, plci);
7061  }
7062  ncci_state = a->ncci_state[ncci];
7063  ncci_remove(plci, ncci, false);
7064 
7065  /* with N_DISC or N_DISC_ACK the IDI frees the respective */
7066  /* channel, so we cannot store the state in ncci_state! The */
7067  /* information which channel we received a N_DISC is thus */
7068  /* stored in the inc_dis_ncci_table buffer. */
7069  for (i = 0; plci->inc_dis_ncci_table[i]; i++);
7070  plci->inc_dis_ncci_table[i] = (byte) ncci;
7071 
7072  /* need a connect_b3_ind before a disconnect_b3_ind with FAX */
7073  if (!plci->channels
7074  && (plci->B1_resource == 16)
7075  && (plci->State <= CONNECTED))
7076  {
7077  len = 9;
7078  i = ((T30_INFO *)plci->fax_connect_info_buffer)->rate_div_2400 * 2400;
7079  PUT_WORD(&plci->ncpi_buffer[1], i);
7080  PUT_WORD(&plci->ncpi_buffer[3], 0);
7081  i = ((T30_INFO *)plci->fax_connect_info_buffer)->data_format;
7082  PUT_WORD(&plci->ncpi_buffer[5], i);
7083  PUT_WORD(&plci->ncpi_buffer[7], 0);
7084  plci->ncpi_buffer[len] = 0;
7085  plci->ncpi_buffer[0] = len;
7086  if (plci->B3_prot == 4)
7087  sendf(plci->appl, _CONNECT_B3_I, Id, 0, "s", "");
7088  else
7089  {
7090 
7091  if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id - 1])
7092  & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
7093  {
7094  plci->ncpi_buffer[++len] = 0;
7095  plci->ncpi_buffer[++len] = 0;
7096  plci->ncpi_buffer[++len] = 0;
7097  plci->ncpi_buffer[0] = len;
7098  }
7099 
7100  sendf(plci->appl, _CONNECT_B3_I, Id, 0, "S", plci->ncpi_buffer);
7101  }
7102  sendf(plci->appl, _DISCONNECT_B3_I, Id, 0, "wS", info, plci->ncpi_buffer);
7103  plci->ncpi_state = 0;
7104  sig_req(plci, HANGUP, 0);
7105  send_req(plci);
7106  plci->State = OUTG_DIS_PENDING;
7107  /* disc here */
7108  }
7109  else if ((a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
7110  && ((plci->B3_prot == 4) || (plci->B3_prot == 5))
7111  && ((ncci_state == INC_DIS_PENDING) || (ncci_state == IDLE)))
7112  {
7113  if (ncci_state == IDLE)
7114  {
7115  if (plci->channels)
7116  plci->channels--;
7117  if ((plci->State == IDLE || plci->State == SUSPENDING) && !plci->channels) {
7118  if (plci->State == SUSPENDING) {
7119  sendf(plci->appl,
7120  _FACILITY_I,
7121  Id & 0xffffL,
7122  0,
7123  "ws", (word)3, "\x03\x04\x00\x00");
7124  sendf(plci->appl, _DISCONNECT_I, Id & 0xffffL, 0, "w", 0);
7125  }
7126  plci_remove(plci);
7127  plci->State = IDLE;
7128  }
7129  }
7130  }
7131  else if (plci->channels)
7132  {
7133  sendf(plci->appl, _DISCONNECT_B3_I, Id, 0, "wS", info, plci->ncpi_buffer);
7134  plci->ncpi_state = 0;
7135  if ((ncci_state == OUTG_REJ_PENDING)
7136  && ((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE)))
7137  {
7138  sig_req(plci, HANGUP, 0);
7139  send_req(plci);
7140  plci->State = OUTG_DIS_PENDING;
7141  }
7142  }
7143  break;
7144  case N_RESET:
7145  a->ncci_state[ncci] = INC_RES_PENDING;
7146  sendf(plci->appl, _RESET_B3_I, Id, 0, "S", plci->ncpi_buffer);
7147  break;
7148  case N_RESET_ACK:
7149  a->ncci_state[ncci] = CONNECTED;
7150  sendf(plci->appl, _RESET_B3_I, Id, 0, "S", plci->ncpi_buffer);
7151  break;
7152 
7153  case N_UDATA:
7154  if (!(udata_forwarding_table[plci->NL.RBuffer->P[0] >> 5] & (1L << (plci->NL.RBuffer->P[0] & 0x1f))))
7155  {
7156  plci->RData[0].P = plci->internal_ind_buffer + (-((int)(long)(plci->internal_ind_buffer)) & 3);
7157  plci->RData[0].PLength = INTERNAL_IND_BUFFER_SIZE;
7158  plci->NL.R = plci->RData;
7159  plci->NL.RNum = 1;
7160  return;
7161  }
7162  case N_BDATA:
7163  case N_DATA:
7164  if (((a->ncci_state[ncci] != CONNECTED) && (plci->B2_prot == 1)) /* transparent */
7165  || (a->ncci_state[ncci] == IDLE)
7166  || (a->ncci_state[ncci] == INC_DIS_PENDING))
7167  {
7168  plci->NL.RNR = 2;
7169  break;
7170  }
7171  if ((a->ncci_state[ncci] != CONNECTED)
7172  && (a->ncci_state[ncci] != OUTG_DIS_PENDING)
7173  && (a->ncci_state[ncci] != OUTG_REJ_PENDING))
7174  {
7175  dbug(1, dprintf("flow control"));
7176  plci->NL.RNR = 1; /* flow control */
7177  channel_x_off(plci, ch, 0);
7178  break;
7179  }
7180 
7181  NCCIcode = ncci | (((word)a->Id) << 8);
7182 
7183  /* count all buffers within the Application pool */
7184  /* belonging to the same NCCI. If this is below the */
7185  /* number of buffers available per NCCI we accept */
7186  /* this packet, otherwise we reject it */
7187  count = 0;
7188  Num = 0xffff;
7189  for (i = 0; i < APPLptr->MaxBuffer; i++) {
7190  if (NCCIcode == APPLptr->DataNCCI[i]) count++;
7191  if (!APPLptr->DataNCCI[i] && Num == 0xffff) Num = i;
7192  }
7193 
7194  if (count >= APPLptr->MaxNCCIData || Num == 0xffff)
7195  {
7196  dbug(3, dprintf("Flow-Control"));
7197  plci->NL.RNR = 1;
7198  if (++(APPLptr->NCCIDataFlowCtrlTimer) >=
7199  (word)((a->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL) ? 40 : 2000))
7200  {
7201  plci->NL.RNR = 2;
7202  dbug(3, dprintf("DiscardData"));
7203  } else {
7204  channel_x_off(plci, ch, 0);
7205  }
7206  break;
7207  }
7208  else
7209  {
7210  APPLptr->NCCIDataFlowCtrlTimer = 0;
7211  }
7212 
7213  plci->RData[0].P = ReceiveBufferGet(APPLptr, Num);
7214  if (!plci->RData[0].P) {
7215  plci->NL.RNR = 1;
7216  channel_x_off(plci, ch, 0);
7217  break;
7218  }
7219 
7220  APPLptr->DataNCCI[Num] = NCCIcode;
7221  APPLptr->DataFlags[Num] = (plci->Id << 8) | (plci->NL.Ind >> 4);
7222  dbug(3, dprintf("Buffer(%d), Max = %d", Num, APPLptr->MaxBuffer));
7223 
7224  plci->RNum = Num;
7225  plci->RFlags = plci->NL.Ind >> 4;
7226  plci->RData[0].PLength = APPLptr->MaxDataLength;
7227  plci->NL.R = plci->RData;
7228  if ((plci->NL.RLength != 0)
7229  && ((plci->B2_prot == B2_V120_ASYNC)
7230  || (plci->B2_prot == B2_V120_ASYNC_V42BIS)
7231  || (plci->B2_prot == B2_V120_BIT_TRANSPARENT)))
7232  {
7233  plci->RData[1].P = plci->RData[0].P;
7234  plci->RData[1].PLength = plci->RData[0].PLength;
7235  plci->RData[0].P = v120_header_buffer + (-((unsigned long)v120_header_buffer) & 3);
7236  if ((plci->NL.RBuffer->P[0] & V120_HEADER_EXTEND_BIT) || (plci->NL.RLength == 1))
7237  plci->RData[0].PLength = 1;
7238  else
7239  plci->RData[0].PLength = 2;
7240  if (plci->NL.RBuffer->P[0] & V120_HEADER_BREAK_BIT)
7241  plci->RFlags |= 0x0010;
7242  if (plci->NL.RBuffer->P[0] & (V120_HEADER_C1_BIT | V120_HEADER_C2_BIT))
7243  plci->RFlags |= 0x8000;
7244  plci->NL.RNum = 2;
7245  }
7246  else
7247  {
7248  if ((plci->NL.Ind & 0x0f) == N_UDATA)
7249  plci->RFlags |= 0x0010;
7250 
7251  else if ((plci->B3_prot == B3_RTP) && ((plci->NL.Ind & 0x0f) == N_BDATA))
7252  plci->RFlags |= 0x0001;
7253 
7254  plci->NL.RNum = 1;
7255  }
7256  break;
7257  case N_DATA_ACK:
7258  data_ack(plci, ch);
7259  break;
7260  default:
7261  plci->NL.RNR = 2;
7262  break;
7263  }
7264 }
7265 
7266 /*------------------------------------------------------------------*/
7267 /* find a free PLCI */
7268 /*------------------------------------------------------------------*/
7269 
7270 static word get_plci(DIVA_CAPI_ADAPTER *a)
7271 {
7272  word i, j;
7273  PLCI *plci;
7274 
7275  dump_plcis(a);
7276  for (i = 0; i < a->max_plci && a->plci[i].Id; i++);
7277  if (i == a->max_plci) {
7278  dbug(1, dprintf("get_plci: out of PLCIs"));
7279  return 0;
7280  }
7281  plci = &a->plci[i];
7282  plci->Id = (byte)(i + 1);
7283 
7284  plci->Sig.Id = 0;
7285  plci->NL.Id = 0;
7286  plci->sig_req = 0;
7287  plci->nl_req = 0;
7288 
7289  plci->appl = NULL;
7290  plci->relatedPTYPLCI = NULL;
7291  plci->State = IDLE;
7292  plci->SuppState = IDLE;
7293  plci->channels = 0;
7294  plci->tel = 0;
7295  plci->B1_resource = 0;
7296  plci->B2_prot = 0;
7297  plci->B3_prot = 0;
7298 
7299  plci->command = 0;
7300  plci->m_command = 0;
7301  init_internal_command_queue(plci);
7302  plci->number = 0;
7303  plci->req_in_start = 0;
7304  plci->req_in = 0;
7305  plci->req_out = 0;
7306  plci->msg_in_write_pos = MSG_IN_QUEUE_SIZE;
7307  plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
7308  plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
7309 
7310  plci->data_sent = false;
7311  plci->send_disc = 0;
7312  plci->sig_global_req = 0;
7313  plci->sig_remove_id = 0;
7314  plci->nl_global_req = 0;
7315  plci->nl_remove_id = 0;
7316  plci->adv_nl = 0;
7317  plci->manufacturer = false;
7318  plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
7319  plci->spoofed_msg = 0;
7320  plci->ptyState = 0;
7321  plci->cr_enquiry = false;
7322  plci->hangup_flow_ctrl_timer = 0;
7323 
7324  plci->ncci_ring_list = 0;
7325  for (j = 0; j < MAX_CHANNELS_PER_PLCI; j++) plci->inc_dis_ncci_table[j] = 0;
7326  clear_c_ind_mask(plci);
7327  set_group_ind_mask(plci);
7328  plci->fax_connect_info_length = 0;
7329  plci->nsf_control_bits = 0;
7330  plci->ncpi_state = 0x00;
7331  plci->ncpi_buffer[0] = 0;
7332 
7333  plci->requested_options_conn = 0;
7334  plci->requested_options = 0;
7335  plci->notifiedcall = 0;
7336  plci->vswitchstate = 0;
7337  plci->vsprot = 0;
7338  plci->vsprotdialect = 0;
7339  init_b1_config(plci);
7340  dbug(1, dprintf("get_plci(%x)", plci->Id));
7341  return i + 1;
7342 }
7343 
7344 /*------------------------------------------------------------------*/
7345 /* put a parameter in the parameter buffer */
7346 /*------------------------------------------------------------------*/
7347 
7348 static void add_p(PLCI *plci, byte code, byte *p)
7349 {
7350  word p_length;
7351 
7352  p_length = 0;
7353  if (p) p_length = p[0];
7354  add_ie(plci, code, p, p_length);
7355 }
7356 
7357 /*------------------------------------------------------------------*/
7358 /* put a structure in the parameter buffer */
7359 /*------------------------------------------------------------------*/
7360 static void add_s(PLCI *plci, byte code, API_PARSE *p)
7361 {
7362  if (p) add_ie(plci, code, p->info, (word)p->length);
7363 }
7364 
7365 /*------------------------------------------------------------------*/
7366 /* put multiple structures in the parameter buffer */
7367 /*------------------------------------------------------------------*/
7368 static void add_ss(PLCI *plci, byte code, API_PARSE *p)
7369 {
7370  byte i;
7371 
7372  if (p) {
7373  dbug(1, dprintf("add_ss(%x,len=%d)", code, p->length));
7374  for (i = 2; i < (byte)p->length; i += p->info[i] + 2) {
7375  dbug(1, dprintf("add_ss_ie(%x,len=%d)", p->info[i - 1], p->info[i]));
7376  add_ie(plci, p->info[i - 1], (byte *)&(p->info[i]), (word)p->info[i]);
7377  }
7378  }
7379 }
7380 
7381 /*------------------------------------------------------------------*/
7382 /* return the channel number sent by the application in a esc_chi */
7383 /*------------------------------------------------------------------*/
7384 static byte getChannel(API_PARSE *p)
7385 {
7386  byte i;
7387 
7388  if (p) {
7389  for (i = 2; i < (byte)p->length; i += p->info[i] + 2) {
7390  if (p->info[i] == 2) {
7391  if (p->info[i - 1] == ESC && p->info[i + 1] == CHI) return (p->info[i + 2]);
7392  }
7393  }
7394  }
7395  return 0;
7396 }
7397 
7398 
7399 /*------------------------------------------------------------------*/
7400 /* put an information element in the parameter buffer */
7401 /*------------------------------------------------------------------*/
7402 
7403 static void add_ie(PLCI *plci, byte code, byte *p, word p_length)
7404 {
7405  word i;
7406 
7407  if (!(code & 0x80) && !p_length) return;
7408 
7409  if (plci->req_in == plci->req_in_start) {
7410  plci->req_in += 2;
7411  }
7412  else {
7413  plci->req_in--;
7414  }
7415  plci->RBuffer[plci->req_in++] = code;
7416 
7417  if (p) {
7418  plci->RBuffer[plci->req_in++] = (byte)p_length;
7419  for (i = 0; i < p_length; i++) plci->RBuffer[plci->req_in++] = p[1 + i];
7420  }
7421 
7422  plci->RBuffer[plci->req_in++] = 0;
7423 }
7424 
7425 /*------------------------------------------------------------------*/
7426 /* put a unstructured data into the buffer */
7427 /*------------------------------------------------------------------*/
7428 
7429 static void add_d(PLCI *plci, word length, byte *p)
7430 {
7431  word i;
7432 
7433  if (plci->req_in == plci->req_in_start) {
7434  plci->req_in += 2;
7435  }
7436  else {
7437  plci->req_in--;
7438  }
7439  for (i = 0; i < length; i++) plci->RBuffer[plci->req_in++] = p[i];
7440 }
7441 
7442 /*------------------------------------------------------------------*/
7443 /* put parameters from the Additional Info parameter in the */
7444 /* parameter buffer */
7445 /*------------------------------------------------------------------*/
7446 
7447 static void add_ai(PLCI *plci, API_PARSE *ai)
7448 {
7449  word i;
7450  API_PARSE ai_parms[5];
7451 
7452  for (i = 0; i < 5; i++) ai_parms[i].length = 0;
7453 
7454  if (!ai->length)
7455  return;
7456  if (api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms))
7457  return;
7458 
7459  add_s(plci, KEY, &ai_parms[1]);
7460  add_s(plci, UUI, &ai_parms[2]);
7461  add_ss(plci, FTY, &ai_parms[3]);
7462 }
7463 
7464 /*------------------------------------------------------------------*/
7465 /* put parameter for b1 protocol in the parameter buffer */
7466 /*------------------------------------------------------------------*/
7467 
7468 static word add_b1(PLCI *plci, API_PARSE *bp, word b_channel_info,
7469  word b1_facilities)
7470 {
7471  API_PARSE bp_parms[8];
7472  API_PARSE mdm_cfg[9];
7473  API_PARSE global_config[2];
7474  byte cai[256];
7475  byte resource[] = {5, 9, 13, 12, 16, 39, 9, 17, 17, 18};
7476  byte voice_cai[] = "\x06\x14\x00\x00\x00\x00\x08";
7477  word i;
7478 
7479  API_PARSE mdm_cfg_v18[4];
7480  word j, n, w;
7481  dword d;
7482 
7483 
7484  for (i = 0; i < 8; i++) bp_parms[i].length = 0;
7485  for (i = 0; i < 2; i++) global_config[i].length = 0;
7486 
7487  dbug(1, dprintf("add_b1"));
7488  api_save_msg(bp, "s", &plci->B_protocol);
7489 
7490  if (b_channel_info == 2) {
7491  plci->B1_resource = 0;
7492  adjust_b1_facilities(plci, plci->B1_resource, b1_facilities);
7493  add_p(plci, CAI, "\x01\x00");
7494  dbug(1, dprintf("Cai=1,0 (no resource)"));
7495  return 0;
7496  }
7497 
7498  if (plci->tel == CODEC_PERMANENT) return 0;
7499  else if (plci->tel == CODEC) {
7500  plci->B1_resource = 1;
7501  adjust_b1_facilities(plci, plci->B1_resource, b1_facilities);
7502  add_p(plci, CAI, "\x01\x01");
7503  dbug(1, dprintf("Cai=1,1 (Codec)"));
7504  return 0;
7505  }
7506  else if (plci->tel == ADV_VOICE) {
7507  plci->B1_resource = add_b1_facilities(plci, 9, (word)(b1_facilities | B1_FACILITY_VOICE));
7508  adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities | B1_FACILITY_VOICE));
7509  voice_cai[1] = plci->B1_resource;
7510  PUT_WORD(&voice_cai[5], plci->appl->MaxDataLength);
7511  add_p(plci, CAI, voice_cai);
7512  dbug(1, dprintf("Cai=1,0x%x (AdvVoice)", voice_cai[1]));
7513  return 0;
7514  }
7515  plci->call_dir &= ~(CALL_DIR_ORIGINATE | CALL_DIR_ANSWER);
7516  if (plci->call_dir & CALL_DIR_OUT)
7517  plci->call_dir |= CALL_DIR_ORIGINATE;
7518  else if (plci->call_dir & CALL_DIR_IN)
7519  plci->call_dir |= CALL_DIR_ANSWER;
7520 
7521  if (!bp->length) {
7522  plci->B1_resource = 0x5;
7523  adjust_b1_facilities(plci, plci->B1_resource, b1_facilities);
7524  add_p(plci, CAI, "\x01\x05");
7525  return 0;
7526  }
7527 
7528  dbug(1, dprintf("b_prot_len=%d", (word)bp->length));
7529  if (bp->length > 256) return _WRONG_MESSAGE_FORMAT;
7530  if (api_parse(&bp->info[1], (word)bp->length, "wwwsssb", bp_parms))
7531  {
7532  bp_parms[6].length = 0;
7533  if (api_parse(&bp->info[1], (word)bp->length, "wwwsss", bp_parms))
7534  {
7535  dbug(1, dprintf("b-form.!"));
7536  return _WRONG_MESSAGE_FORMAT;
7537  }
7538  }
7539  else if (api_parse(&bp->info[1], (word)bp->length, "wwwssss", bp_parms))
7540  {
7541  dbug(1, dprintf("b-form.!"));
7542  return _WRONG_MESSAGE_FORMAT;
7543  }
7544 
7545  if (bp_parms[6].length)
7546  {
7547  if (api_parse(&bp_parms[6].info[1], (word)bp_parms[6].length, "w", global_config))
7548  {
7549  return _WRONG_MESSAGE_FORMAT;
7550  }
7551  switch (GET_WORD(global_config[0].info))
7552  {
7553  case 1:
7554  plci->call_dir = (plci->call_dir & ~CALL_DIR_ANSWER) | CALL_DIR_ORIGINATE;
7555  break;
7556  case 2:
7557  plci->call_dir = (plci->call_dir & ~CALL_DIR_ORIGINATE) | CALL_DIR_ANSWER;
7558  break;
7559  }
7560  }
7561  dbug(1, dprintf("call_dir=%04x", plci->call_dir));
7562 
7563 
7564  if ((GET_WORD(bp_parms[0].info) == B1_RTP)
7565  && (plci->adapter->man_profile.private_options & (1L << PRIVATE_RTP)))
7566  {
7567  plci->B1_resource = add_b1_facilities(plci, 31, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7568  adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7569  cai[1] = plci->B1_resource;
7570  cai[2] = 0;
7571  cai[3] = 0;
7572  cai[4] = 0;
7573  PUT_WORD(&cai[5], plci->appl->MaxDataLength);
7574  for (i = 0; i < bp_parms[3].length; i++)
7575  cai[7 + i] = bp_parms[3].info[1 + i];
7576  cai[0] = 6 + bp_parms[3].length;
7577  add_p(plci, CAI, cai);
7578  return 0;
7579  }
7580 
7581 
7582  if ((GET_WORD(bp_parms[0].info) == B1_PIAFS)
7583  && (plci->adapter->man_profile.private_options & (1L << PRIVATE_PIAFS)))
7584  {
7585  plci->B1_resource = add_b1_facilities(plci, 35/* PIAFS HARDWARE FACILITY */, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7586  adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7587  cai[1] = plci->B1_resource;
7588  cai[2] = 0;
7589  cai[3] = 0;
7590  cai[4] = 0;
7591  PUT_WORD(&cai[5], plci->appl->MaxDataLength);
7592  cai[0] = 6;
7593  add_p(plci, CAI, cai);
7594  return 0;
7595  }
7596 
7597 
7598  if ((GET_WORD(bp_parms[0].info) >= 32)
7599  || (!((1L << GET_WORD(bp_parms[0].info)) & plci->adapter->profile.B1_Protocols)
7600  && ((GET_WORD(bp_parms[0].info) != 3)
7601  || !((1L << B1_HDLC) & plci->adapter->profile.B1_Protocols)
7602  || ((bp_parms[3].length != 0) && (GET_WORD(&bp_parms[3].info[1]) != 0) && (GET_WORD(&bp_parms[3].info[1]) != 56000)))))
7603  {
7604  return _B1_NOT_SUPPORTED;
7605  }
7606  plci->B1_resource = add_b1_facilities(plci, resource[GET_WORD(bp_parms[0].info)],
7607  (word)(b1_facilities & ~B1_FACILITY_VOICE));
7608  adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7609  cai[0] = 6;
7610  cai[1] = plci->B1_resource;
7611  for (i = 2; i < sizeof(cai); i++) cai[i] = 0;
7612 
7613  if ((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE)
7614  || (GET_WORD(bp_parms[0].info) == B1_MODEM_ASYNC)
7615  || (GET_WORD(bp_parms[0].info) == B1_MODEM_SYNC_HDLC))
7616  { /* B1 - modem */
7617  for (i = 0; i < 7; i++) mdm_cfg[i].length = 0;
7618 
7619  if (bp_parms[3].length)
7620  {
7621  if (api_parse(&bp_parms[3].info[1], (word)bp_parms[3].length, "wwwwww", mdm_cfg))
7622  {
7623  return (_WRONG_MESSAGE_FORMAT);
7624  }
7625 
7626  cai[2] = 0; /* Bit rate for adaptation */
7627 
7628  dbug(1, dprintf("MDM Max Bit Rate:<%d>", GET_WORD(mdm_cfg[0].info)));
7629 
7630  PUT_WORD(&cai[13], 0); /* Min Tx speed */
7631  PUT_WORD(&cai[15], GET_WORD(mdm_cfg[0].info)); /* Max Tx speed */
7632  PUT_WORD(&cai[17], 0); /* Min Rx speed */
7633  PUT_WORD(&cai[19], GET_WORD(mdm_cfg[0].info)); /* Max Rx speed */
7634 
7635  cai[3] = 0; /* Async framing parameters */
7636  switch (GET_WORD(mdm_cfg[2].info))
7637  { /* Parity */
7638  case 1: /* odd parity */
7639  cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_ODD);
7640  dbug(1, dprintf("MDM: odd parity"));
7641  break;
7642 
7643  case 2: /* even parity */
7644  cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_EVEN);
7645  dbug(1, dprintf("MDM: even parity"));
7646  break;
7647 
7648  default:
7649  dbug(1, dprintf("MDM: no parity"));
7650  break;
7651  }
7652 
7653  switch (GET_WORD(mdm_cfg[3].info))
7654  { /* stop bits */
7655  case 1: /* 2 stop bits */
7656  cai[3] |= DSP_CAI_ASYNC_TWO_STOP_BITS;
7657  dbug(1, dprintf("MDM: 2 stop bits"));
7658  break;
7659 
7660  default:
7661  dbug(1, dprintf("MDM: 1 stop bit"));
7662  break;
7663  }
7664 
7665  switch (GET_WORD(mdm_cfg[1].info))
7666  { /* char length */
7667  case 5:
7668  cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_5;
7669  dbug(1, dprintf("MDM: 5 bits"));
7670  break;
7671 
7672  case 6:
7673  cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_6;
7674  dbug(1, dprintf("MDM: 6 bits"));
7675  break;
7676 
7677  case 7:
7678  cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_7;
7679  dbug(1, dprintf("MDM: 7 bits"));
7680  break;
7681 
7682  default:
7683  dbug(1, dprintf("MDM: 8 bits"));
7684  break;
7685  }
7686 
7687  cai[7] = 0; /* Line taking options */
7688  cai[8] = 0; /* Modulation negotiation options */
7689  cai[9] = 0; /* Modulation options */
7690 
7691  if (((plci->call_dir & CALL_DIR_ORIGINATE) != 0) ^ ((plci->call_dir & CALL_DIR_OUT) != 0))
7692  {
7693  cai[9] |= DSP_CAI_MODEM_REVERSE_DIRECTION;
7694  dbug(1, dprintf("MDM: Reverse direction"));
7695  }
7696 
7697  if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_DISABLE_RETRAIN)
7698  {
7699  cai[9] |= DSP_CAI_MODEM_DISABLE_RETRAIN;
7700  dbug(1, dprintf("MDM: Disable retrain"));
7701  }
7702 
7703  if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_DISABLE_RING_TONE)
7704  {
7705  cai[7] |= DSP_CAI_MODEM_DISABLE_CALLING_TONE | DSP_CAI_MODEM_DISABLE_ANSWER_TONE;
7706  dbug(1, dprintf("MDM: Disable ring tone"));
7707  }
7708 
7709  if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_GUARD_1800)
7710  {
7711  cai[8] |= DSP_CAI_MODEM_GUARD_TONE_1800HZ;
7712  dbug(1, dprintf("MDM: 1800 guard tone"));
7713  }
7714  else if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_GUARD_550)
7715  {
7716  cai[8] |= DSP_CAI_MODEM_GUARD_TONE_550HZ;
7717  dbug(1, dprintf("MDM: 550 guard tone"));
7718  }
7719 
7720  if ((GET_WORD(mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_V100)
7721  {
7722  cai[8] |= DSP_CAI_MODEM_NEGOTIATE_V100;
7723  dbug(1, dprintf("MDM: V100"));
7724  }
7725  else if ((GET_WORD(mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_MOD_CLASS)
7726  {
7727  cai[8] |= DSP_CAI_MODEM_NEGOTIATE_IN_CLASS;
7728  dbug(1, dprintf("MDM: IN CLASS"));
7729  }
7730  else if ((GET_WORD(mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_DISABLED)
7731  {
7732  cai[8] |= DSP_CAI_MODEM_NEGOTIATE_DISABLED;
7733  dbug(1, dprintf("MDM: DISABLED"));
7734  }
7735  cai[0] = 20;
7736 
7737  if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_V18))
7738  && (GET_WORD(mdm_cfg[5].info) & 0x8000)) /* Private V.18 enable */
7739  {
7740  plci->requested_options |= 1L << PRIVATE_V18;
7741  }
7742  if (GET_WORD(mdm_cfg[5].info) & 0x4000) /* Private VOWN enable */
7743  plci->requested_options |= 1L << PRIVATE_VOWN;
7744 
7745  if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
7746  & ((1L << PRIVATE_V18) | (1L << PRIVATE_VOWN)))
7747  {
7748  if (!api_parse(&bp_parms[3].info[1], (word)bp_parms[3].length, "wwwwwws", mdm_cfg))
7749  {
7750  i = 27;
7751  if (mdm_cfg[6].length >= 4)
7752  {
7753  d = GET_DWORD(&mdm_cfg[6].info[1]);
7754  cai[7] |= (byte) d; /* line taking options */
7755  cai[9] |= (byte)(d >> 8); /* modulation options */
7756  cai[++i] = (byte)(d >> 16); /* vown modulation options */
7757  cai[++i] = (byte)(d >> 24);
7758  if (mdm_cfg[6].length >= 8)
7759  {
7760  d = GET_DWORD(&mdm_cfg[6].info[5]);
7761  cai[10] |= (byte) d; /* disabled modulations mask */
7762  cai[11] |= (byte)(d >> 8);
7763  if (mdm_cfg[6].length >= 12)
7764  {
7765  d = GET_DWORD(&mdm_cfg[6].info[9]);
7766  cai[12] = (byte) d; /* enabled modulations mask */
7767  cai[++i] = (byte)(d >> 8); /* vown enabled modulations */
7768  cai[++i] = (byte)(d >> 16);
7769  cai[++i] = (byte)(d >> 24);
7770  cai[++i] = 0;
7771  if (mdm_cfg[6].length >= 14)
7772  {
7773  w = GET_WORD(&mdm_cfg[6].info[13]);
7774  if (w != 0)
7775  PUT_WORD(&cai[13], w); /* min tx speed */
7776  if (mdm_cfg[6].length >= 16)
7777  {
7778  w = GET_WORD(&mdm_cfg[6].info[15]);
7779  if (w != 0)
7780  PUT_WORD(&cai[15], w); /* max tx speed */
7781  if (mdm_cfg[6].length >= 18)
7782  {
7783  w = GET_WORD(&mdm_cfg[6].info[17]);
7784  if (w != 0)
7785  PUT_WORD(&cai[17], w); /* min rx speed */
7786  if (mdm_cfg[6].length >= 20)
7787  {
7788  w = GET_WORD(&mdm_cfg[6].info[19]);
7789  if (w != 0)
7790  PUT_WORD(&cai[19], w); /* max rx speed */
7791  if (mdm_cfg[6].length >= 22)
7792  {
7793  w = GET_WORD(&mdm_cfg[6].info[21]);
7794  cai[23] = (byte)(-((short) w)); /* transmit level */
7795  if (mdm_cfg[6].length >= 24)
7796  {
7797  w = GET_WORD(&mdm_cfg[6].info[23]);
7798  cai[22] |= (byte) w; /* info options mask */
7799  cai[21] |= (byte)(w >> 8); /* disabled symbol rates */
7800  }
7801  }
7802  }
7803  }
7804  }
7805  }
7806  }
7807  }
7808  }
7809  cai[27] = i - 27;
7810  i++;
7811  if (!api_parse(&bp_parms[3].info[1], (word)bp_parms[3].length, "wwwwwwss", mdm_cfg))
7812  {
7813  if (!api_parse(&mdm_cfg[7].info[1], (word)mdm_cfg[7].length, "sss", mdm_cfg_v18))
7814  {
7815  for (n = 0; n < 3; n++)
7816  {
7817  cai[i] = (byte)(mdm_cfg_v18[n].length);
7818  for (j = 1; j < ((word)(cai[i] + 1)); j++)
7819  cai[i + j] = mdm_cfg_v18[n].info[j];
7820  i += cai[i] + 1;
7821  }
7822  }
7823  }
7824  cai[0] = (byte)(i - 1);
7825  }
7826  }
7827 
7828  }
7829  }
7830  if (GET_WORD(bp_parms[0].info) == 2 || /* V.110 async */
7831  GET_WORD(bp_parms[0].info) == 3) /* V.110 sync */
7832  {
7833  if (bp_parms[3].length) {
7834  dbug(1, dprintf("V.110,%d", GET_WORD(&bp_parms[3].info[1])));
7835  switch (GET_WORD(&bp_parms[3].info[1])) { /* Rate */
7836  case 0:
7837  case 56000:
7838  if (GET_WORD(bp_parms[0].info) == 3) { /* V.110 sync 56k */
7839  dbug(1, dprintf("56k sync HSCX"));
7840  cai[1] = 8;
7841  cai[2] = 0;
7842  cai[3] = 0;
7843  }
7844  else if (GET_WORD(bp_parms[0].info) == 2) {
7845  dbug(1, dprintf("56k async DSP"));
7846  cai[2] = 9;
7847  }
7848  break;
7849  case 50: cai[2] = 1; break;
7850  case 75: cai[2] = 1; break;
7851  case 110: cai[2] = 1; break;
7852  case 150: cai[2] = 1; break;
7853  case 200: cai[2] = 1; break;
7854  case 300: cai[2] = 1; break;
7855  case 600: cai[2] = 1; break;
7856  case 1200: cai[2] = 2; break;
7857  case 2400: cai[2] = 3; break;
7858  case 4800: cai[2] = 4; break;
7859  case 7200: cai[2] = 10; break;
7860  case 9600: cai[2] = 5; break;
7861  case 12000: cai[2] = 13; break;
7862  case 24000: cai[2] = 0; break;
7863  case 14400: cai[2] = 11; break;
7864  case 19200: cai[2] = 6; break;
7865  case 28800: cai[2] = 12; break;
7866  case 38400: cai[2] = 7; break;
7867  case 48000: cai[2] = 8; break;
7868  case 76: cai[2] = 15; break; /* 75/1200 */
7869  case 1201: cai[2] = 14; break; /* 1200/75 */
7870  case 56001: cai[2] = 9; break; /* V.110 56000 */
7871 
7872  default:
7873  return _B1_PARM_NOT_SUPPORTED;
7874  }
7875  cai[3] = 0;
7876  if (cai[1] == 13) /* v.110 async */
7877  {
7878  if (bp_parms[3].length >= 8)
7879  {
7880  switch (GET_WORD(&bp_parms[3].info[3]))
7881  { /* char length */
7882  case 5:
7883  cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_5;
7884  break;
7885  case 6:
7886  cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_6;
7887  break;
7888  case 7:
7889  cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_7;
7890  break;
7891  }
7892  switch (GET_WORD(&bp_parms[3].info[5]))
7893  { /* Parity */
7894  case 1: /* odd parity */
7895  cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_ODD);
7896  break;
7897  case 2: /* even parity */
7898  cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_EVEN);
7899  break;
7900  }
7901  switch (GET_WORD(&bp_parms[3].info[7]))
7902  { /* stop bits */
7903  case 1: /* 2 stop bits */
7904  cai[3] |= DSP_CAI_ASYNC_TWO_STOP_BITS;
7905  break;
7906  }
7907  }
7908  }
7909  }
7910  else if (cai[1] == 8 || GET_WORD(bp_parms[0].info) == 3) {
7911  dbug(1, dprintf("V.110 default 56k sync"));
7912  cai[1] = 8;
7913  cai[2] = 0;
7914  cai[3] = 0;
7915  }
7916  else {
7917  dbug(1, dprintf("V.110 default 9600 async"));
7918  cai[2] = 5;
7919  }
7920  }
7921  PUT_WORD(&cai[5], plci->appl->MaxDataLength);
7922  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]));
7923 /* HexDump ("CAI", sizeof(cai), &cai[0]); */
7924 
7925  add_p(plci, CAI, cai);
7926  return 0;
7927 }
7928 
7929 /*------------------------------------------------------------------*/
7930 /* put parameter for b2 and B3 protocol in the parameter buffer */
7931 /*------------------------------------------------------------------*/
7932 
7933 static word add_b23(PLCI *plci, API_PARSE *bp)
7934 {
7935  word i, fax_control_bits;
7936  byte pos, len;
7937  byte SAPI = 0x40; /* default SAPI 16 for x.31 */
7938  API_PARSE bp_parms[8];
7939  API_PARSE *b1_config;
7940  API_PARSE *b2_config;
7941  API_PARSE b2_config_parms[8];
7942  API_PARSE *b3_config;
7943  API_PARSE b3_config_parms[6];
7944  API_PARSE global_config[2];
7945 
7946  static byte llc[3] = {2,0,0};
7947  static byte dlc[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
7948  static byte nlc[256];
7949  static byte lli[12] = {1,1};
7950 
7951  const byte llc2_out[] = {1,2,4,6,2,0,0,0, X75_V42BIS,V120_L2,V120_V42BIS,V120_L2,6};
7952  const byte llc2_in[] = {1,3,4,6,3,0,0,0, X75_V42BIS,V120_L2,V120_V42BIS,V120_L2,6};
7953 
7954  const byte llc3[] = {4,3,2,2,6,6,0};
7955  const byte header[] = {0,2,3,3,0,0,0};
7956 
7957  for (i = 0; i < 8; i++) bp_parms[i].length = 0;
7958  for (i = 0; i < 6; i++) b2_config_parms[i].length = 0;
7959  for (i = 0; i < 5; i++) b3_config_parms[i].length = 0;
7960 
7961  lli[0] = 1;
7962  lli[1] = 1;
7963  if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL)
7964  lli[1] |= 2;
7965  if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL)
7966  lli[1] |= 4;
7967 
7968  if ((lli[1] & 0x02) && (diva_xdi_extended_features & DIVA_CAPI_USE_CMA)) {
7969  lli[1] |= 0x10;
7970  if (plci->rx_dma_descriptor <= 0) {
7971  plci->rx_dma_descriptor = diva_get_dma_descriptor(plci, &plci->rx_dma_magic);
7972  if (plci->rx_dma_descriptor >= 0)
7973  plci->rx_dma_descriptor++;
7974  }
7975  if (plci->rx_dma_descriptor > 0) {
7976  lli[0] = 6;
7977  lli[1] |= 0x40;
7978  lli[2] = (byte)(plci->rx_dma_descriptor - 1);
7979  lli[3] = (byte)plci->rx_dma_magic;
7980  lli[4] = (byte)(plci->rx_dma_magic >> 8);
7981  lli[5] = (byte)(plci->rx_dma_magic >> 16);
7982  lli[6] = (byte)(plci->rx_dma_magic >> 24);
7983  }
7984  }
7985 
7986  if (DIVA_CAPI_SUPPORTS_NO_CANCEL(plci->adapter)) {
7987  lli[1] |= 0x20;
7988  }
7989 
7990  dbug(1, dprintf("add_b23"));
7991  api_save_msg(bp, "s", &plci->B_protocol);
7992 
7993  if (!bp->length && plci->tel)
7994  {
7995  plci->adv_nl = true;
7996  dbug(1, dprintf("Default adv.Nl"));
7997  add_p(plci, LLI, lli);
7998  plci->B2_prot = 1 /*XPARENT*/;
7999  plci->B3_prot = 0 /*XPARENT*/;
8000  llc[1] = 2;
8001  llc[2] = 4;
8002  add_p(plci, LLC, llc);
8003  dlc[0] = 2;
8004  PUT_WORD(&dlc[1], plci->appl->MaxDataLength);
8005  add_p(plci, DLC, dlc);
8006  return 0;
8007  }
8008 
8009  if (!bp->length) /*default*/
8010  {
8011  dbug(1, dprintf("ret default"));
8012  add_p(plci, LLI, lli);
8013  plci->B2_prot = 0 /*X.75 */;
8014  plci->B3_prot = 0 /*XPARENT*/;
8015  llc[1] = 1;
8016  llc[2] = 4;
8017  add_p(plci, LLC, llc);
8018  dlc[0] = 2;
8019  PUT_WORD(&dlc[1], plci->appl->MaxDataLength);
8020  add_p(plci, DLC, dlc);
8021  return 0;
8022  }
8023  dbug(1, dprintf("b_prot_len=%d", (word)bp->length));
8024  if ((word)bp->length > 256) return _WRONG_MESSAGE_FORMAT;
8025 
8026  if (api_parse(&bp->info[1], (word)bp->length, "wwwsssb", bp_parms))
8027  {
8028  bp_parms[6].length = 0;
8029  if (api_parse(&bp->info[1], (word)bp->length, "wwwsss", bp_parms))
8030  {
8031  dbug(1, dprintf("b-form.!"));
8032  return _WRONG_MESSAGE_FORMAT;
8033  }
8034  }
8035  else if (api_parse(&bp->info[1], (word)bp->length, "wwwssss", bp_parms))
8036  {
8037  dbug(1, dprintf("b-form.!"));
8038  return _WRONG_MESSAGE_FORMAT;
8039  }
8040 
8041  if (plci->tel == ADV_VOICE) /* transparent B on advanced voice */
8042  {
8043  if (GET_WORD(bp_parms[1].info) != 1
8044  || GET_WORD(bp_parms[2].info) != 0) return _B2_NOT_SUPPORTED;
8045  plci->adv_nl = true;
8046  }
8047  else if (plci->tel) return _B2_NOT_SUPPORTED;
8048 
8049 
8050  if ((GET_WORD(bp_parms[1].info) == B2_RTP)
8051  && (GET_WORD(bp_parms[2].info) == B3_RTP)
8052  && (plci->adapter->man_profile.private_options & (1L << PRIVATE_RTP)))
8053  {
8054  add_p(plci, LLI, lli);
8055  plci->B2_prot = (byte) GET_WORD(bp_parms[1].info);
8056  plci->B3_prot = (byte) GET_WORD(bp_parms[2].info);
8057  llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ? 14 : 13;
8058  llc[2] = 4;
8059  add_p(plci, LLC, llc);
8060  dlc[0] = 2;
8061  PUT_WORD(&dlc[1], plci->appl->MaxDataLength);
8062  dlc[3] = 3; /* Addr A */
8063  dlc[4] = 1; /* Addr B */
8064  dlc[5] = 7; /* modulo mode */
8065  dlc[6] = 7; /* window size */
8066  dlc[7] = 0; /* XID len Lo */
8067  dlc[8] = 0; /* XID len Hi */
8068  for (i = 0; i < bp_parms[4].length; i++)
8069  dlc[9 + i] = bp_parms[4].info[1 + i];
8070  dlc[0] = (byte)(8 + bp_parms[4].length);
8071  add_p(plci, DLC, dlc);
8072  for (i = 0; i < bp_parms[5].length; i++)
8073  nlc[1 + i] = bp_parms[5].info[1 + i];
8074  nlc[0] = (byte)(bp_parms[5].length);
8075  add_p(plci, NLC, nlc);
8076  return 0;
8077  }
8078 
8079 
8080 
8081  if ((GET_WORD(bp_parms[1].info) >= 32)
8082  || (!((1L << GET_WORD(bp_parms[1].info)) & plci->adapter->profile.B2_Protocols)
8083  && ((GET_WORD(bp_parms[1].info) != B2_PIAFS)
8084  || !(plci->adapter->man_profile.private_options & (1L << PRIVATE_PIAFS)))))
8085 
8086  {
8087  return _B2_NOT_SUPPORTED;
8088  }
8089  if ((GET_WORD(bp_parms[2].info) >= 32)
8090  || !((1L << GET_WORD(bp_parms[2].info)) & plci->adapter->profile.B3_Protocols))
8091  {
8092  return _B3_NOT_SUPPORTED;
8093  }
8094  if ((GET_WORD(bp_parms[1].info) != B2_SDLC)
8095  && ((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE)
8096  || (GET_WORD(bp_parms[0].info) == B1_MODEM_ASYNC)
8097  || (GET_WORD(bp_parms[0].info) == B1_MODEM_SYNC_HDLC)))
8098  {
8099  return (add_modem_b23(plci, bp_parms));
8100  }
8101 
8102  add_p(plci, LLI, lli);
8103 
8104  plci->B2_prot = (byte)GET_WORD(bp_parms[1].info);
8105  plci->B3_prot = (byte)GET_WORD(bp_parms[2].info);
8106  if (plci->B2_prot == 12) SAPI = 0; /* default SAPI D-channel */
8107 
8108  if (bp_parms[6].length)
8109  {
8110  if (api_parse(&bp_parms[6].info[1], (word)bp_parms[6].length, "w", global_config))
8111  {
8112  return _WRONG_MESSAGE_FORMAT;
8113  }
8114  switch (GET_WORD(global_config[0].info))
8115  {
8116  case 1:
8117  plci->call_dir = (plci->call_dir & ~CALL_DIR_ANSWER) | CALL_DIR_ORIGINATE;
8118  break;
8119  case 2:
8120  plci->call_dir = (plci->call_dir & ~CALL_DIR_ORIGINATE) | CALL_DIR_ANSWER;
8121  break;
8122  }
8123  }
8124  dbug(1, dprintf("call_dir=%04x", plci->call_dir));
8125 
8126 
8127  if (plci->B2_prot == B2_PIAFS)
8128  llc[1] = PIAFS_CRC;
8129  else
8130 /* IMPLEMENT_PIAFS */
8131  {
8132  llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ?
8133  llc2_out[GET_WORD(bp_parms[1].info)] : llc2_in[GET_WORD(bp_parms[1].info)];
8134  }
8135  llc[2] = llc3[GET_WORD(bp_parms[2].info)];
8136 
8137  add_p(plci, LLC, llc);
8138 
8139  dlc[0] = 2;
8140  PUT_WORD(&dlc[1], plci->appl->MaxDataLength +
8141  header[GET_WORD(bp_parms[2].info)]);
8142 
8143  b1_config = &bp_parms[3];
8144  nlc[0] = 0;
8145  if (plci->B3_prot == 4
8146  || plci->B3_prot == 5)
8147  {
8148  for (i = 0; i < sizeof(T30_INFO); i++) nlc[i] = 0;
8149  nlc[0] = sizeof(T30_INFO);
8150  if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
8151  ((T30_INFO *)&nlc[1])->operating_mode = T30_OPERATING_MODE_CAPI;
8152  ((T30_INFO *)&nlc[1])->rate_div_2400 = 0xff;
8153  if (b1_config->length >= 2)
8154  {
8155  ((T30_INFO *)&nlc[1])->rate_div_2400 = (byte)(GET_WORD(&b1_config->info[1]) / 2400);
8156  }
8157  }
8158  b2_config = &bp_parms[4];
8159 
8160 
8161  if (llc[1] == PIAFS_CRC)
8162  {
8163  if (plci->B3_prot != B3_TRANSPARENT)
8164  {
8165  return _B_STACK_NOT_SUPPORTED;
8166  }
8167  if (b2_config->length && api_parse(&b2_config->info[1], (word)b2_config->length, "bwww", b2_config_parms)) {
8168  return _WRONG_MESSAGE_FORMAT;
8169  }
8170  PUT_WORD(&dlc[1], plci->appl->MaxDataLength);
8171  dlc[3] = 0; /* Addr A */
8172  dlc[4] = 0; /* Addr B */
8173  dlc[5] = 0; /* modulo mode */
8174  dlc[6] = 0; /* window size */
8175  if (b2_config->length >= 7) {
8176  dlc[7] = 7;
8177  dlc[8] = 0;
8178  dlc[9] = b2_config_parms[0].info[0]; /* PIAFS protocol Speed configuration */
8179  dlc[10] = b2_config_parms[1].info[0]; /* V.42bis P0 */
8180  dlc[11] = b2_config_parms[1].info[1]; /* V.42bis P0 */
8181  dlc[12] = b2_config_parms[2].info[0]; /* V.42bis P1 */
8182  dlc[13] = b2_config_parms[2].info[1]; /* V.42bis P1 */
8183  dlc[14] = b2_config_parms[3].info[0]; /* V.42bis P2 */
8184  dlc[15] = b2_config_parms[3].info[1]; /* V.42bis P2 */
8185  dlc[0] = 15;
8186  if (b2_config->length >= 8) { /* PIAFS control abilities */
8187  dlc[7] = 10;
8188  dlc[16] = 2; /* Length of PIAFS extension */
8189  dlc[17] = PIAFS_UDATA_ABILITIES; /* control (UDATA) ability */
8190  dlc[18] = b2_config_parms[4].info[0]; /* value */
8191  dlc[0] = 18;
8192  }
8193  }
8194  else /* default values, 64K, variable, no compression */
8195  {
8196  dlc[7] = 7;
8197  dlc[8] = 0;
8198  dlc[9] = 0x03; /* PIAFS protocol Speed configuration */
8199  dlc[10] = 0x03; /* V.42bis P0 */
8200  dlc[11] = 0; /* V.42bis P0 */
8201  dlc[12] = 0; /* V.42bis P1 */
8202  dlc[13] = 0; /* V.42bis P1 */
8203  dlc[14] = 0; /* V.42bis P2 */
8204  dlc[15] = 0; /* V.42bis P2 */
8205  dlc[0] = 15;
8206  }
8207  add_p(plci, DLC, dlc);
8208  }
8209  else
8210 
8211  if ((llc[1] == V120_L2) || (llc[1] == V120_V42BIS))
8212  {
8213  if (plci->B3_prot != B3_TRANSPARENT)
8214  return _B_STACK_NOT_SUPPORTED;
8215 
8216  dlc[0] = 6;
8217  PUT_WORD(&dlc[1], GET_WORD(&dlc[1]) + 2);
8218  dlc[3] = 0x08;
8219  dlc[4] = 0x01;
8220  dlc[5] = 127;
8221  dlc[6] = 7;
8222  if (b2_config->length != 0)
8223  {
8224  if ((llc[1] == V120_V42BIS) && api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbwww", b2_config_parms)) {
8225  return _WRONG_MESSAGE_FORMAT;
8226  }
8227  dlc[3] = (byte)((b2_config->info[2] << 3) | ((b2_config->info[1] >> 5) & 0x04));
8228  dlc[4] = (byte)((b2_config->info[1] << 1) | 0x01);
8229  if (b2_config->info[3] != 128)
8230  {
8231  dbug(1, dprintf("1D-dlc= %x %x %x %x %x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4]));
8232  return _B2_PARM_NOT_SUPPORTED;
8233  }
8234  dlc[5] = (byte)(b2_config->info[3] - 1);
8235  dlc[6] = b2_config->info[4];
8236  if (llc[1] == V120_V42BIS) {
8237  if (b2_config->length >= 10) {
8238  dlc[7] = 6;
8239  dlc[8] = 0;
8240  dlc[9] = b2_config_parms[4].info[0];
8241  dlc[10] = b2_config_parms[4].info[1];
8242  dlc[11] = b2_config_parms[5].info[0];
8243  dlc[12] = b2_config_parms[5].info[1];
8244  dlc[13] = b2_config_parms[6].info[0];
8245  dlc[14] = b2_config_parms[6].info[1];
8246  dlc[0] = 14;
8247  dbug(1, dprintf("b2_config_parms[4].info[0] [1]: %x %x", b2_config_parms[4].info[0], b2_config_parms[4].info[1]));
8248  dbug(1, dprintf("b2_config_parms[5].info[0] [1]: %x %x", b2_config_parms[5].info[0], b2_config_parms[5].info[1]));
8249  dbug(1, dprintf("b2_config_parms[6].info[0] [1]: %x %x", b2_config_parms[6].info[0], b2_config_parms[6].info[1]));
8250  }
8251  else {
8252  dlc[6] = 14;
8253  }
8254  }
8255  }
8256  }
8257  else
8258  {
8259  if (b2_config->length)
8260  {
8261  dbug(1, dprintf("B2-Config"));
8262  if (llc[1] == X75_V42BIS) {
8263  if (api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbwww", b2_config_parms))
8264  {
8265  return _WRONG_MESSAGE_FORMAT;
8266  }
8267  }
8268  else {
8269  if (api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbs", b2_config_parms))
8270  {
8271  return _WRONG_MESSAGE_FORMAT;
8272  }
8273  }
8274  /* if B2 Protocol is LAPD, b2_config structure is different */
8275  if (llc[1] == 6)
8276  {
8277  dlc[0] = 4;
8278  if (b2_config->length >= 1) dlc[2] = b2_config->info[1]; /* TEI */
8279  else dlc[2] = 0x01;
8280  if ((b2_config->length >= 2) && (plci->B2_prot == 12))
8281  {
8282  SAPI = b2_config->info[2]; /* SAPI */
8283  }
8284  dlc[1] = SAPI;
8285  if ((b2_config->length >= 3) && (b2_config->info[3] == 128))
8286  {
8287  dlc[3] = 127; /* Mode */
8288  }
8289  else
8290  {
8291  dlc[3] = 7; /* Mode */
8292  }
8293 
8294  if (b2_config->length >= 4) dlc[4] = b2_config->info[4]; /* Window */
8295  else dlc[4] = 1;
8296  dbug(1, dprintf("D-dlc[%d]=%x,%x,%x,%x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4]));
8297  if (b2_config->length > 5) return _B2_PARM_NOT_SUPPORTED;
8298  }
8299  else
8300  {
8301  dlc[0] = (byte)(b2_config_parms[4].length + 6);
8302  dlc[3] = b2_config->info[1];
8303  dlc[4] = b2_config->info[2];
8304  if (b2_config->info[3] != 8 && b2_config->info[3] != 128) {
8305  dbug(1, dprintf("1D-dlc= %x %x %x %x %x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4]));
8306  return _B2_PARM_NOT_SUPPORTED;
8307  }
8308 
8309  dlc[5] = (byte)(b2_config->info[3] - 1);
8310  dlc[6] = b2_config->info[4];
8311  if (dlc[6] > dlc[5]) {
8312  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]));
8313  return _B2_PARM_NOT_SUPPORTED;
8314  }
8315 
8316  if (llc[1] == X75_V42BIS) {
8317  if (b2_config->length >= 10) {
8318  dlc[7] = 6;
8319  dlc[8] = 0;
8320  dlc[9] = b2_config_parms[4].info[0];
8321  dlc[10] = b2_config_parms[4].info[1];
8322  dlc[11] = b2_config_parms[5].info[0];
8323  dlc[12] = b2_config_parms[5].info[1];
8324  dlc[13] = b2_config_parms[6].info[0];
8325  dlc[14] = b2_config_parms[6].info[1];
8326  dlc[0] = 14;
8327  dbug(1, dprintf("b2_config_parms[4].info[0] [1]: %x %x", b2_config_parms[4].info[0], b2_config_parms[4].info[1]));
8328  dbug(1, dprintf("b2_config_parms[5].info[0] [1]: %x %x", b2_config_parms[5].info[0], b2_config_parms[5].info[1]));
8329  dbug(1, dprintf("b2_config_parms[6].info[0] [1]: %x %x", b2_config_parms[6].info[0], b2_config_parms[6].info[1]));
8330  }
8331  else {
8332  dlc[6] = 14;
8333  }
8334 
8335  }
8336  else {
8337  PUT_WORD(&dlc[7], (word)b2_config_parms[4].length);
8338  for (i = 0; i < b2_config_parms[4].length; i++)
8339  dlc[11 + i] = b2_config_parms[4].info[1 + i];
8340  }
8341  }
8342  }
8343  }
8344  add_p(plci, DLC, dlc);
8345 
8346  b3_config = &bp_parms[5];
8347  if (b3_config->length)
8348  {
8349  if (plci->B3_prot == 4
8350  || plci->B3_prot == 5)
8351  {
8352  if (api_parse(&b3_config->info[1], (word)b3_config->length, "wwss", b3_config_parms))
8353  {
8354  return _WRONG_MESSAGE_FORMAT;
8355  }
8356  i = GET_WORD((byte *)(b3_config_parms[0].info));
8357  ((T30_INFO *)&nlc[1])->resolution = (byte)(((i & 0x0001) ||
8358  ((plci->B3_prot == 4) && (((byte)(GET_WORD((byte *)b3_config_parms[1].info))) != 5))) ? T30_RESOLUTION_R8_0770_OR_200 : 0);
8359  ((T30_INFO *)&nlc[1])->data_format = (byte)(GET_WORD((byte *)b3_config_parms[1].info));
8360  fax_control_bits = T30_CONTROL_BIT_ALL_FEATURES;
8361  if ((((T30_INFO *)&nlc[1])->rate_div_2400 != 0) && (((T30_INFO *)&nlc[1])->rate_div_2400 <= 6))
8362  fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_V34FAX;
8363  if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
8364  {
8365 
8366  if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
8367  & (1L << PRIVATE_FAX_PAPER_FORMATS))
8368  {
8369  ((T30_INFO *)&nlc[1])->resolution |= T30_RESOLUTION_R8_1540 |
8370  T30_RESOLUTION_R16_1540_OR_400 | T30_RESOLUTION_300_300 |
8371  T30_RESOLUTION_INCH_BASED | T30_RESOLUTION_METRIC_BASED;
8372  }
8373 
8374  ((T30_INFO *)&nlc[1])->recording_properties =
8375  T30_RECORDING_WIDTH_ISO_A3 |
8376  (T30_RECORDING_LENGTH_UNLIMITED << 2) |
8377  (T30_MIN_SCANLINE_TIME_00_00_00 << 4);
8378  }
8379  if (plci->B3_prot == 5)
8380  {
8381  if (i & 0x0002) /* Accept incoming fax-polling requests */
8382  fax_control_bits |= T30_CONTROL_BIT_ACCEPT_POLLING;
8383  if (i & 0x2000) /* Do not use MR compression */
8384  fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_2D_CODING;
8385  if (i & 0x4000) /* Do not use MMR compression */
8386  fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_T6_CODING;
8387  if (i & 0x8000) /* Do not use ECM */
8388  fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_ECM;
8389  if (plci->fax_connect_info_length != 0)
8390  {
8391  ((T30_INFO *)&nlc[1])->resolution = ((T30_INFO *)plci->fax_connect_info_buffer)->resolution;
8392  ((T30_INFO *)&nlc[1])->data_format = ((T30_INFO *)plci->fax_connect_info_buffer)->data_format;
8393  ((T30_INFO *)&nlc[1])->recording_properties = ((T30_INFO *)plci->fax_connect_info_buffer)->recording_properties;
8394  fax_control_bits |= GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low) &
8395  (T30_CONTROL_BIT_REQUEST_POLLING | T30_CONTROL_BIT_MORE_DOCUMENTS);
8396  }
8397  }
8398  /* copy station id to NLC */
8399  for (i = 0; i < T30_MAX_STATION_ID_LENGTH; i++)
8400  {
8401  if (i < b3_config_parms[2].length)
8402  {
8403  ((T30_INFO *)&nlc[1])->station_id[i] = ((byte *)b3_config_parms[2].info)[1 + i];
8404  }
8405  else
8406  {
8407  ((T30_INFO *)&nlc[1])->station_id[i] = ' ';
8408  }
8409  }
8410  ((T30_INFO *)&nlc[1])->station_id_len = T30_MAX_STATION_ID_LENGTH;
8411  /* copy head line to NLC */
8412  if (b3_config_parms[3].length)
8413  {
8414 
8415  pos = (byte)(fax_head_line_time(&(((T30_INFO *)&nlc[1])->station_id[T30_MAX_STATION_ID_LENGTH])));
8416  if (pos != 0)
8417  {
8418  if (CAPI_MAX_DATE_TIME_LENGTH + 2 + b3_config_parms[3].length > CAPI_MAX_HEAD_LINE_SPACE)
8419  pos = 0;
8420  else
8421  {
8422  nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
8423  nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
8424  len = (byte)b3_config_parms[2].length;
8425  if (len > 20)
8426  len = 20;
8427  if (CAPI_MAX_DATE_TIME_LENGTH + 2 + len + 2 + b3_config_parms[3].length <= CAPI_MAX_HEAD_LINE_SPACE)
8428  {
8429  for (i = 0; i < len; i++)
8430  nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ((byte *)b3_config_parms[2].info)[1 + i];
8431  nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
8432  nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
8433  }
8434  }
8435  }
8436 
8437  len = (byte)b3_config_parms[3].length;
8438  if (len > CAPI_MAX_HEAD_LINE_SPACE - pos)
8439  len = (byte)(CAPI_MAX_HEAD_LINE_SPACE - pos);
8440  ((T30_INFO *)&nlc[1])->head_line_len = (byte)(pos + len);
8441  nlc[0] += (byte)(pos + len);
8442  for (i = 0; i < len; i++)
8443  nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ((byte *)b3_config_parms[3].info)[1 + i];
8444  } else
8445  ((T30_INFO *)&nlc[1])->head_line_len = 0;
8446 
8447  plci->nsf_control_bits = 0;
8448  if (plci->B3_prot == 5)
8449  {
8450  if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_FAX_SUB_SEP_PWD))
8451  && (GET_WORD((byte *)b3_config_parms[1].info) & 0x8000)) /* Private SUB/SEP/PWD enable */
8452  {
8453  plci->requested_options |= 1L << PRIVATE_FAX_SUB_SEP_PWD;
8454  }
8455  if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_FAX_NONSTANDARD))
8456  && (GET_WORD((byte *)b3_config_parms[1].info) & 0x4000)) /* Private non-standard facilities enable */
8457  {
8458  plci->requested_options |= 1L << PRIVATE_FAX_NONSTANDARD;
8459  }
8460  if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
8461  & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
8462  {
8463  if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
8464  & (1L << PRIVATE_FAX_SUB_SEP_PWD))
8465  {
8466  fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_PASSWORD;
8467  if (fax_control_bits & T30_CONTROL_BIT_ACCEPT_POLLING)
8468  fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SEL_POLLING;
8469  }
8470  len = nlc[0];
8471  pos = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
8472  if (pos < plci->fax_connect_info_length)
8473  {
8474  for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--)
8475  nlc[++len] = plci->fax_connect_info_buffer[pos++];
8476  }
8477  else
8478  nlc[++len] = 0;
8479  if (pos < plci->fax_connect_info_length)
8480  {
8481  for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--)
8482  nlc[++len] = plci->fax_connect_info_buffer[pos++];
8483  }
8484  else
8485  nlc[++len] = 0;
8486  if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
8487  & (1L << PRIVATE_FAX_NONSTANDARD))
8488  {
8489  if ((pos < plci->fax_connect_info_length) && (plci->fax_connect_info_buffer[pos] != 0))
8490  {
8491  if ((plci->fax_connect_info_buffer[pos] >= 3) && (plci->fax_connect_info_buffer[pos + 1] >= 2))
8492  plci->nsf_control_bits = GET_WORD(&plci->fax_connect_info_buffer[pos + 2]);
8493  for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--)
8494  nlc[++len] = plci->fax_connect_info_buffer[pos++];
8495  }
8496  else
8497  {
8498  if (api_parse(&b3_config->info[1], (word)b3_config->length, "wwsss", b3_config_parms))
8499  {
8500  dbug(1, dprintf("non-standard facilities info missing or wrong format"));
8501  nlc[++len] = 0;
8502  }
8503  else
8504  {
8505  if ((b3_config_parms[4].length >= 3) && (b3_config_parms[4].info[1] >= 2))
8506  plci->nsf_control_bits = GET_WORD(&b3_config_parms[4].info[2]);
8507  nlc[++len] = (byte)(b3_config_parms[4].length);
8508  for (i = 0; i < b3_config_parms[4].length; i++)
8509  nlc[++len] = b3_config_parms[4].info[1 + i];
8510  }
8511  }
8512  }
8513  nlc[0] = len;
8514  if ((plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF)
8515  && (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP))
8516  {
8517  ((T30_INFO *)&nlc[1])->operating_mode = T30_OPERATING_MODE_CAPI_NEG;
8518  }
8519  }
8520  }
8521 
8522  PUT_WORD(&(((T30_INFO *)&nlc[1])->control_bits_low), fax_control_bits);
8523  len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
8524  for (i = 0; i < len; i++)
8525  plci->fax_connect_info_buffer[i] = nlc[1 + i];
8526  ((T30_INFO *) plci->fax_connect_info_buffer)->head_line_len = 0;
8527  i += ((T30_INFO *)&nlc[1])->head_line_len;
8528  while (i < nlc[0])
8529  plci->fax_connect_info_buffer[len++] = nlc[++i];
8530  plci->fax_connect_info_length = len;
8531  }
8532  else
8533  {
8534  nlc[0] = 14;
8535  if (b3_config->length != 16)
8536  return _B3_PARM_NOT_SUPPORTED;
8537  for (i = 0; i < 12; i++) nlc[1 + i] = b3_config->info[1 + i];
8538  if (GET_WORD(&b3_config->info[13]) != 8 && GET_WORD(&b3_config->info[13]) != 128)
8539  return _B3_PARM_NOT_SUPPORTED;
8540  nlc[13] = b3_config->info[13];
8541  if (GET_WORD(&b3_config->info[15]) >= nlc[13])
8542  return _B3_PARM_NOT_SUPPORTED;
8543  nlc[14] = b3_config->info[15];
8544  }
8545  }
8546  else
8547  {
8548  if (plci->B3_prot == 4
8549  || plci->B3_prot == 5 /*T.30 - FAX*/) return _B3_PARM_NOT_SUPPORTED;
8550  }
8551  add_p(plci, NLC, nlc);
8552  return 0;
8553 }
8554 
8555 /*----------------------------------------------------------------*/
8556 /* make the same as add_b23, but only for the modem related */
8557 /* L2 and L3 B-Chan protocol. */
8558 /* */
8559 /* Enabled L2 and L3 Configurations: */
8560 /* If L1 == Modem all negotiation */
8561 /* only L2 == Modem with full negotiation is allowed */
8562 /* If L1 == Modem async or sync */
8563 /* only L2 == Transparent is allowed */
8564 /* L3 == Modem or L3 == Transparent are allowed */
8565 /* B2 Configuration for modem: */
8566 /* word : enable/disable compression, bitoptions */
8567 /* B3 Configuration for modem: */
8568 /* empty */
8569 /*----------------------------------------------------------------*/
8570 static word add_modem_b23(PLCI *plci, API_PARSE *bp_parms)
8571 {
8572  static byte lli[12] = {1,1};
8573  static byte llc[3] = {2,0,0};
8574  static byte dlc[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
8575  API_PARSE mdm_config[2];
8576  word i;
8577  word b2_config = 0;
8578 
8579  for (i = 0; i < 2; i++) mdm_config[i].length = 0;
8580  for (i = 0; i < sizeof(dlc); i++) dlc[i] = 0;
8581 
8582  if (((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE)
8583  && (GET_WORD(bp_parms[1].info) != B2_MODEM_EC_COMPRESSION))
8584  || ((GET_WORD(bp_parms[0].info) != B1_MODEM_ALL_NEGOTIATE)
8585  && (GET_WORD(bp_parms[1].info) != B2_TRANSPARENT)))
8586  {
8587  return (_B_STACK_NOT_SUPPORTED);
8588  }
8589  if ((GET_WORD(bp_parms[2].info) != B3_MODEM)
8590  && (GET_WORD(bp_parms[2].info) != B3_TRANSPARENT))
8591  {
8592  return (_B_STACK_NOT_SUPPORTED);
8593  }
8594 
8595  plci->B2_prot = (byte) GET_WORD(bp_parms[1].info);
8596  plci->B3_prot = (byte) GET_WORD(bp_parms[2].info);
8597 
8598  if ((GET_WORD(bp_parms[1].info) == B2_MODEM_EC_COMPRESSION) && bp_parms[4].length)
8599  {
8600  if (api_parse(&bp_parms[4].info[1],
8601  (word)bp_parms[4].length, "w",
8602  mdm_config))
8603  {
8604  return (_WRONG_MESSAGE_FORMAT);
8605  }
8606  b2_config = GET_WORD(mdm_config[0].info);
8607  }
8608 
8609  /* OK, L2 is modem */
8610 
8611  lli[0] = 1;
8612  lli[1] = 1;
8613  if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL)
8614  lli[1] |= 2;
8615  if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL)
8616  lli[1] |= 4;
8617 
8618  if ((lli[1] & 0x02) && (diva_xdi_extended_features & DIVA_CAPI_USE_CMA)) {
8619  lli[1] |= 0x10;
8620  if (plci->rx_dma_descriptor <= 0) {
8621  plci->rx_dma_descriptor = diva_get_dma_descriptor(plci, &plci->rx_dma_magic);
8622  if (plci->rx_dma_descriptor >= 0)
8623  plci->rx_dma_descriptor++;
8624  }
8625  if (plci->rx_dma_descriptor > 0) {
8626  lli[1] |= 0x40;
8627  lli[0] = 6;
8628  lli[2] = (byte)(plci->rx_dma_descriptor - 1);
8629  lli[3] = (byte)plci->rx_dma_magic;
8630  lli[4] = (byte)(plci->rx_dma_magic >> 8);
8631  lli[5] = (byte)(plci->rx_dma_magic >> 16);
8632  lli[6] = (byte)(plci->rx_dma_magic >> 24);
8633  }
8634  }
8635 
8636  if (DIVA_CAPI_SUPPORTS_NO_CANCEL(plci->adapter)) {
8637  lli[1] |= 0x20;
8638  }
8639 
8640  llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ?
8641  /*V42*/ 10 : /*V42_IN*/ 9;
8642  llc[2] = 4; /* pass L3 always transparent */
8643  add_p(plci, LLI, lli);
8644  add_p(plci, LLC, llc);
8645  i = 1;
8646  PUT_WORD(&dlc[i], plci->appl->MaxDataLength);
8647  i += 2;
8648  if (GET_WORD(bp_parms[1].info) == B2_MODEM_EC_COMPRESSION)
8649  {
8650  if (bp_parms[4].length)
8651  {
8652  dbug(1, dprintf("MDM b2_config=%02x", b2_config));
8653  dlc[i++] = 3; /* Addr A */
8654  dlc[i++] = 1; /* Addr B */
8655  dlc[i++] = 7; /* modulo mode */
8656  dlc[i++] = 7; /* window size */
8657  dlc[i++] = 0; /* XID len Lo */
8658  dlc[i++] = 0; /* XID len Hi */
8659 
8660  if (b2_config & MDM_B2_DISABLE_V42bis)
8661  {
8662  dlc[i] |= DLC_MODEMPROT_DISABLE_V42_V42BIS;
8663  }
8664  if (b2_config & MDM_B2_DISABLE_MNP)
8665  {
8666  dlc[i] |= DLC_MODEMPROT_DISABLE_MNP_MNP5;
8667  }
8668  if (b2_config & MDM_B2_DISABLE_TRANS)
8669  {
8670  dlc[i] |= DLC_MODEMPROT_REQUIRE_PROTOCOL;
8671  }
8672  if (b2_config & MDM_B2_DISABLE_V42)
8673  {
8674  dlc[i] |= DLC_MODEMPROT_DISABLE_V42_DETECT;
8675  }
8676  if (b2_config & MDM_B2_DISABLE_COMP)
8677  {
8678  dlc[i] |= DLC_MODEMPROT_DISABLE_COMPRESSION;
8679  }
8680  i++;
8681  }
8682  }
8683  else
8684  {
8685  dlc[i++] = 3; /* Addr A */
8686  dlc[i++] = 1; /* Addr B */
8687  dlc[i++] = 7; /* modulo mode */
8688  dlc[i++] = 7; /* window size */
8689  dlc[i++] = 0; /* XID len Lo */
8690  dlc[i++] = 0; /* XID len Hi */
8691  dlc[i++] = DLC_MODEMPROT_DISABLE_V42_V42BIS |
8692  DLC_MODEMPROT_DISABLE_MNP_MNP5 |
8693  DLC_MODEMPROT_DISABLE_V42_DETECT |
8694  DLC_MODEMPROT_DISABLE_COMPRESSION;
8695  }
8696  dlc[0] = (byte)(i - 1);
8697 /* HexDump ("DLC", sizeof(dlc), &dlc[0]); */
8698  add_p(plci, DLC, dlc);
8699  return (0);
8700 }
8701 
8702 
8703 /*------------------------------------------------------------------*/
8704 /* send a request for the signaling entity */
8705 /*------------------------------------------------------------------*/
8706 
8707 static void sig_req(PLCI *plci, byte req, byte Id)
8708 {
8709  if (!plci) return;
8710  if (plci->adapter->adapter_disabled) return;
8711  dbug(1, dprintf("sig_req(%x)", req));
8712  if (req == REMOVE)
8713  plci->sig_remove_id = plci->Sig.Id;
8714  if (plci->req_in == plci->req_in_start) {
8715  plci->req_in += 2;
8716  plci->RBuffer[plci->req_in++] = 0;
8717  }
8718  PUT_WORD(&plci->RBuffer[plci->req_in_start], plci->req_in-plci->req_in_start - 2);
8719  plci->RBuffer[plci->req_in++] = Id; /* sig/nl flag */
8720  plci->RBuffer[plci->req_in++] = req; /* request */
8721  plci->RBuffer[plci->req_in++] = 0; /* channel */
8722  plci->req_in_start = plci->req_in;
8723 }
8724 
8725 /*------------------------------------------------------------------*/
8726 /* send a request for the network layer entity */
8727 /*------------------------------------------------------------------*/
8728 
8729 static void nl_req_ncci(PLCI *plci, byte req, byte ncci)
8730 {
8731  if (!plci) return;
8732  if (plci->adapter->adapter_disabled) return;
8733  dbug(1, dprintf("nl_req %02x %02x %02x", plci->Id, req, ncci));
8734  if (req == REMOVE)
8735  {
8736  plci->nl_remove_id = plci->NL.Id;
8737  ncci_remove(plci, 0, (byte)(ncci != 0));
8738  ncci = 0;
8739  }
8740  if (plci->req_in == plci->req_in_start) {
8741  plci->req_in += 2;
8742  plci->RBuffer[plci->req_in++] = 0;
8743  }
8744  PUT_WORD(&plci->RBuffer[plci->req_in_start], plci->req_in-plci->req_in_start - 2);
8745  plci->RBuffer[plci->req_in++] = 1; /* sig/nl flag */
8746  plci->RBuffer[plci->req_in++] = req; /* request */
8747  plci->RBuffer[plci->req_in++] = plci->adapter->ncci_ch[ncci]; /* channel */
8748  plci->req_in_start = plci->req_in;
8749 }
8750 
8751 static void send_req(PLCI *plci)
8752 {
8753  ENTITY *e;
8754  word l;
8755 /* word i; */
8756 
8757  if (!plci) return;
8758  if (plci->adapter->adapter_disabled) return;
8759  channel_xmit_xon(plci);
8760 
8761  /* if nothing to do, return */
8762  if (plci->req_in == plci->req_out) return;
8763  dbug(1, dprintf("send_req(in=%d,out=%d)", plci->req_in, plci->req_out));
8764 
8765  if (plci->nl_req || plci->sig_req) return;
8766 
8767  l = GET_WORD(&plci->RBuffer[plci->req_out]);
8768  plci->req_out += 2;
8769  plci->XData[0].P = &plci->RBuffer[plci->req_out];
8770  plci->req_out += l;
8771  if (plci->RBuffer[plci->req_out] == 1)
8772  {
8773  e = &plci->NL;
8774  plci->req_out++;
8775  e->Req = plci->nl_req = plci->RBuffer[plci->req_out++];
8776  e->ReqCh = plci->RBuffer[plci->req_out++];
8777  if (!(e->Id & 0x1f))
8778  {
8779  e->Id = NL_ID;
8780  plci->RBuffer[plci->req_out - 4] = CAI;
8781  plci->RBuffer[plci->req_out - 3] = 1;
8782  plci->RBuffer[plci->req_out - 2] = (plci->Sig.Id == 0xff) ? 0 : plci->Sig.Id;
8783  plci->RBuffer[plci->req_out - 1] = 0;
8784  l += 3;
8785  plci->nl_global_req = plci->nl_req;
8786  }
8787  dbug(1, dprintf("%x:NLREQ(%x:%x:%x)", plci->adapter->Id, e->Id, e->Req, e->ReqCh));
8788  }
8789  else
8790  {
8791  e = &plci->Sig;
8792  if (plci->RBuffer[plci->req_out])
8793  e->Id = plci->RBuffer[plci->req_out];
8794  plci->req_out++;
8795  e->Req = plci->sig_req = plci->RBuffer[plci->req_out++];
8796  e->ReqCh = plci->RBuffer[plci->req_out++];
8797  if (!(e->Id & 0x1f))
8798  plci->sig_global_req = plci->sig_req;
8799  dbug(1, dprintf("%x:SIGREQ(%x:%x:%x)", plci->adapter->Id, e->Id, e->Req, e->ReqCh));
8800  }
8801  plci->XData[0].PLength = l;
8802  e->X = plci->XData;
8803  plci->adapter->request(e);
8804  dbug(1, dprintf("send_ok"));
8805 }
8806 
8807 static void send_data(PLCI *plci)
8808 {
8809  DIVA_CAPI_ADAPTER *a;
8810  DATA_B3_DESC *data;
8811  NCCI *ncci_ptr;
8812  word ncci;
8813 
8814  if (!plci->nl_req && plci->ncci_ring_list)
8815  {
8816  a = plci->adapter;
8817  ncci = plci->ncci_ring_list;
8818  do
8819  {
8820  ncci = a->ncci_next[ncci];
8821  ncci_ptr = &(a->ncci[ncci]);
8822  if (!(a->ncci_ch[ncci]
8823  && (a->ch_flow_control[a->ncci_ch[ncci]] & N_OK_FC_PENDING)))
8824  {
8825  if (ncci_ptr->data_pending)
8826  {
8827  if ((a->ncci_state[ncci] == CONNECTED)
8828  || (a->ncci_state[ncci] == INC_ACT_PENDING)
8829  || (plci->send_disc == ncci))
8830  {
8831  data = &(ncci_ptr->DBuffer[ncci_ptr->data_out]);
8832  if ((plci->B2_prot == B2_V120_ASYNC)
8833  || (plci->B2_prot == B2_V120_ASYNC_V42BIS)
8834  || (plci->B2_prot == B2_V120_BIT_TRANSPARENT))
8835  {
8836  plci->NData[1].P = TransmitBufferGet(plci->appl, data->P);
8837  plci->NData[1].PLength = data->Length;
8838  if (data->Flags & 0x10)
8839  plci->NData[0].P = v120_break_header;
8840  else
8841  plci->NData[0].P = v120_default_header;
8842  plci->NData[0].PLength = 1;
8843  plci->NL.XNum = 2;
8844  plci->NL.Req = plci->nl_req = (byte)((data->Flags & 0x07) << 4 | N_DATA);
8845  }
8846  else
8847  {
8848  plci->NData[0].P = TransmitBufferGet(plci->appl, data->P);
8849  plci->NData[0].PLength = data->Length;
8850  if (data->Flags & 0x10)
8851  plci->NL.Req = plci->nl_req = (byte)N_UDATA;
8852 
8853  else if ((plci->B3_prot == B3_RTP) && (data->Flags & 0x01))
8854  plci->NL.Req = plci->nl_req = (byte)N_BDATA;
8855 
8856  else
8857  plci->NL.Req = plci->nl_req = (byte)((data->Flags & 0x07) << 4 | N_DATA);
8858  }
8859  plci->NL.X = plci->NData;
8860  plci->NL.ReqCh = a->ncci_ch[ncci];
8861  dbug(1, dprintf("%x:DREQ(%x:%x)", a->Id, plci->NL.Id, plci->NL.Req));
8862  plci->data_sent = true;
8863  plci->data_sent_ptr = data->P;
8864  a->request(&plci->NL);
8865  }
8866  else {
8867  cleanup_ncci_data(plci, ncci);
8868  }
8869  }
8870  else if (plci->send_disc == ncci)
8871  {
8872  /* dprintf("N_DISC"); */
8873  plci->NData[0].PLength = 0;
8874  plci->NL.ReqCh = a->ncci_ch[ncci];
8875  plci->NL.Req = plci->nl_req = N_DISC;
8876  a->request(&plci->NL);
8877  plci->command = _DISCONNECT_B3_R;
8878  plci->send_disc = 0;
8879  }
8880  }
8881  } while (!plci->nl_req && (ncci != plci->ncci_ring_list));
8882  plci->ncci_ring_list = ncci;
8883  }
8884 }
8885 
8886 static void listen_check(DIVA_CAPI_ADAPTER *a)
8887 {
8888  word i, j;
8889  PLCI *plci;
8890  byte activnotifiedcalls = 0;
8891 
8892  dbug(1, dprintf("listen_check(%d,%d)", a->listen_active, a->max_listen));
8893  if (!remove_started && !a->adapter_disabled)
8894  {
8895  for (i = 0; i < a->max_plci; i++)
8896  {
8897  plci = &(a->plci[i]);
8898  if (plci->notifiedcall) activnotifiedcalls++;
8899  }
8900  dbug(1, dprintf("listen_check(%d)", activnotifiedcalls));
8901 
8902  for (i = a->listen_active; i < ((word)(a->max_listen + activnotifiedcalls)); i++) {
8903  if ((j = get_plci(a))) {
8904  a->listen_active++;
8905  plci = &a->plci[j - 1];
8906  plci->State = LISTENING;
8907 
8908  add_p(plci, OAD, "\x01\xfd");
8909 
8910  add_p(plci, KEY, "\x04\x43\x41\x32\x30");
8911 
8912  add_p(plci, CAI, "\x01\xc0");
8913  add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
8914  add_p(plci, LLI, "\x01\xc4"); /* support Dummy CR FAC + MWI + SpoofNotify */
8915  add_p(plci, SHIFT | 6, NULL);
8916  add_p(plci, SIN, "\x02\x00\x00");
8917  plci->internal_command = LISTEN_SIG_ASSIGN_PEND; /* do indicate_req if OK */
8918  sig_req(plci, ASSIGN, DSIG_ID);
8919  send_req(plci);
8920  }
8921  }
8922  }
8923 }
8924 
8925 /*------------------------------------------------------------------*/
8926 /* functions for all parameters sent in INDs */
8927 /*------------------------------------------------------------------*/
8928 
8929 static void IndParse(PLCI *plci, word *parms_id, byte **parms, byte multiIEsize)
8930 {
8931  word ploc; /* points to current location within packet */
8932  byte w;
8933  byte wlen;
8934  byte codeset, lock;
8935  byte *in;
8936  word i;
8937  word code;
8938  word mIEindex = 0;
8939  ploc = 0;
8940  codeset = 0;
8941  lock = 0;
8942 
8943  in = plci->Sig.RBuffer->P;
8944  for (i = 0; i < parms_id[0]; i++) /* multiIE parms_id contains just the 1st */
8945  { /* element but parms array is larger */
8946  parms[i] = (byte *)"";
8947  }
8948  for (i = 0; i < multiIEsize; i++)
8949  {
8950  parms[i] = (byte *)"";
8951  }
8952 
8953  while (ploc < plci->Sig.RBuffer->length - 1) {
8954 
8955  /* read information element id and length */
8956  w = in[ploc];
8957 
8958  if (w & 0x80) {
8959 /* w &=0xf0; removed, cannot detect congestion levels */
8960 /* upper 4 bit masked with w==SHIFT now */
8961  wlen = 0;
8962  }
8963  else {
8964  wlen = (byte)(in[ploc + 1] + 1);
8965  }
8966  /* check if length valid (not exceeding end of packet) */
8967  if ((ploc + wlen) > 270) return;
8968  if (lock & 0x80) lock &= 0x7f;
8969  else codeset = lock;
8970 
8971  if ((w & 0xf0) == SHIFT) {
8972  codeset = in[ploc];
8973  if (!(codeset & 0x08)) lock = (byte)(codeset & 7);
8974  codeset &= 7;
8975  lock |= 0x80;
8976  }
8977  else {
8978  if (w == ESC && wlen >= 3) code = in[ploc + 2] | 0x800;
8979  else code = w;
8980  code |= (codeset << 8);
8981 
8982  for (i = 1; i < parms_id[0] + 1 && parms_id[i] != code; i++);
8983 
8984  if (i < parms_id[0] + 1) {
8985  if (!multiIEsize) { /* with multiIEs use next field index, */
8986  mIEindex = i - 1; /* with normal IEs use same index like parms_id */
8987  }
8988 
8989  parms[mIEindex] = &in[ploc + 1];
8990  dbug(1, dprintf("mIE[%d]=0x%x", *parms[mIEindex], in[ploc]));
8991  if (parms_id[i] == OAD
8992  || parms_id[i] == CONN_NR
8993  || parms_id[i] == CAD) {
8994  if (in[ploc + 2] & 0x80) {
8995  in[ploc + 0] = (byte)(in[ploc + 1] + 1);
8996  in[ploc + 1] = (byte)(in[ploc + 2] & 0x7f);
8997  in[ploc + 2] = 0x80;
8998  parms[mIEindex] = &in[ploc];
8999  }
9000  }
9001  mIEindex++; /* effects multiIEs only */
9002  }
9003  }
9004 
9005  ploc += (wlen + 1);
9006  }
9007  return;
9008 }
9009 
9010 /*------------------------------------------------------------------*/
9011 /* try to match a cip from received BC and HLC */
9012 /*------------------------------------------------------------------*/
9013 
9014 static byte ie_compare(byte *ie1, byte *ie2)
9015 {
9016  word i;
9017  if (!ie1 || !ie2) return false;
9018  if (!ie1[0]) return false;
9019  for (i = 0; i < (word)(ie1[0] + 1); i++) if (ie1[i] != ie2[i]) return false;
9020  return true;
9021 }
9022 
9023 static word find_cip(DIVA_CAPI_ADAPTER *a, byte *bc, byte *hlc)
9024 {
9025  word i;
9026  word j;
9027 
9028  for (i = 9; i && !ie_compare(bc, cip_bc[i][a->u_law]); i--);
9029 
9030  for (j = 16; j < 29 &&
9031  (!ie_compare(bc, cip_bc[j][a->u_law]) || !ie_compare(hlc, cip_hlc[j])); j++);
9032  if (j == 29) return i;
9033  return j;
9034 }
9035 
9036 
9037 static byte AddInfo(byte **add_i,
9038  byte **fty_i,
9039  byte *esc_chi,
9040  byte *facility)
9041 {
9042  byte i;
9043  byte j;
9044  byte k;
9045  byte flen;
9046  byte len = 0;
9047  /* facility is a nested structure */
9048  /* FTY can be more than once */
9049 
9050  if (esc_chi[0] && !(esc_chi[esc_chi[0]] & 0x7f))
9051  {
9052  add_i[0] = (byte *)"\x02\x02\x00"; /* use neither b nor d channel */
9053  }
9054 
9055  else
9056  {
9057  add_i[0] = (byte *)"";
9058  }
9059  if (!fty_i[0][0])
9060  {
9061  add_i[3] = (byte *)"";
9062  }
9063  else
9064  { /* facility array found */
9065  for (i = 0, j = 1; i < MAX_MULTI_IE && fty_i[i][0]; i++)
9066  {
9067  dbug(1, dprintf("AddIFac[%d]", fty_i[i][0]));
9068  len += fty_i[i][0];
9069  len += 2;
9070  flen = fty_i[i][0];
9071  facility[j++] = 0x1c; /* copy fac IE */
9072  for (k = 0; k <= flen; k++, j++)
9073  {
9074  facility[j] = fty_i[i][k];
9075 /* dbug(1, dprintf("%x ",facility[j])); */
9076  }
9077  }
9078  facility[0] = len;
9079  add_i[3] = facility;
9080  }
9081 /* dbug(1, dprintf("FacArrLen=%d ",len)); */
9082  len = add_i[0][0] + add_i[1][0] + add_i[2][0] + add_i[3][0];
9083  len += 4; /* calculate length of all */
9084  return (len);
9085 }
9086 
9087 /*------------------------------------------------------------------*/
9088 /* voice and codec features */
9089 /*------------------------------------------------------------------*/
9090 
9091 static void SetVoiceChannel(PLCI *plci, byte *chi, DIVA_CAPI_ADAPTER *a)
9092 {
9093  byte voice_chi[] = "\x02\x18\x01";
9094  byte channel;
9095 
9096  channel = chi[chi[0]] & 0x3;
9097  dbug(1, dprintf("ExtDevON(Ch=0x%x)", channel));
9098  voice_chi[2] = (channel) ? channel : 1;
9099  add_p(plci, FTY, "\x02\x01\x07"); /* B On, default on 1 */
9100  add_p(plci, ESC, voice_chi); /* Channel */
9101  sig_req(plci, TEL_CTRL, 0);
9102  send_req(plci);
9103  if (a->AdvSignalPLCI)
9104  {
9105  adv_voice_write_coefs(a->AdvSignalPLCI, ADV_VOICE_WRITE_ACTIVATION);
9106  }
9107 }
9108 
9109 static void VoiceChannelOff(PLCI *plci)
9110 {
9111  dbug(1, dprintf("ExtDevOFF"));
9112  add_p(plci, FTY, "\x02\x01\x08"); /* B Off */
9113  sig_req(plci, TEL_CTRL, 0);
9114  send_req(plci);
9115  if (plci->adapter->AdvSignalPLCI)
9116  {
9117  adv_voice_clear_config(plci->adapter->AdvSignalPLCI);
9118  }
9119 }
9120 
9121 
9122 static word AdvCodecSupport(DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl,
9123  byte hook_listen)
9124 {
9125  word j;
9126  PLCI *splci;
9127 
9128  /* check if hardware supports handset with hook states (adv.codec) */
9129  /* or if just a on board codec is supported */
9130  /* the advanced codec plci is just for internal use */
9131 
9132  /* diva Pro with on-board codec: */
9133  if (a->profile.Global_Options & HANDSET)
9134  {
9135  /* new call, but hook states are already signalled */
9136  if (a->AdvCodecFLAG)
9137  {
9138  if (a->AdvSignalAppl != appl || a->AdvSignalPLCI)
9139  {
9140  dbug(1, dprintf("AdvSigPlci=0x%x", a->AdvSignalPLCI));
9141  return 0x2001; /* codec in use by another application */
9142  }
9143  if (plci != NULL)
9144  {
9145  a->AdvSignalPLCI = plci;
9146  plci->tel = ADV_VOICE;
9147  }
9148  return 0; /* adv codec still used */
9149  }
9150  if ((j = get_plci(a)))
9151  {
9152  splci = &a->plci[j - 1];
9153  splci->tel = CODEC_PERMANENT;
9154  /* hook_listen indicates if a facility_req with handset/hook support */
9155  /* was sent. Otherwise if just a call on an external device was made */
9156  /* the codec will be used but the hook info will be discarded (just */
9157  /* the external controller is in use */
9158  if (hook_listen) splci->State = ADVANCED_VOICE_SIG;
9159  else
9160  {
9161  splci->State = ADVANCED_VOICE_NOSIG;
9162  if (plci)
9163  {
9164  plci->spoofed_msg = SPOOFING_REQUIRED;
9165  }
9166  /* indicate D-ch connect if */
9167  } /* codec is connected OK */
9168  if (plci != NULL)
9169  {
9170  a->AdvSignalPLCI = plci;
9171  plci->tel = ADV_VOICE;
9172  }
9173  a->AdvSignalAppl = appl;
9174  a->AdvCodecFLAG = true;
9175  a->AdvCodecPLCI = splci;
9176  add_p(splci, CAI, "\x01\x15");
9177  add_p(splci, LLI, "\x01\x00");
9178  add_p(splci, ESC, "\x02\x18\x00");
9179  add_p(splci, UID, "\x06\x43\x61\x70\x69\x32\x30");
9180  splci->internal_command = PERM_COD_ASSIGN;
9181  dbug(1, dprintf("Codec Assign"));
9182  sig_req(splci, ASSIGN, DSIG_ID);
9183  send_req(splci);
9184  }
9185  else
9186  {
9187  return 0x2001; /* wrong state, no more plcis */
9188  }
9189  }
9190  else if (a->profile.Global_Options & ON_BOARD_CODEC)
9191  {
9192  if (hook_listen) return 0x300B; /* Facility not supported */
9193  /* no hook with SCOM */
9194  if (plci != NULL) plci->tel = CODEC;
9195  dbug(1, dprintf("S/SCOM codec"));
9196  /* first time we use the scom-s codec we must shut down the internal */
9197  /* handset application of the card. This can be done by an assign with */
9198  /* a cai with the 0x80 bit set. Assign return code is 'out of resource'*/
9199  if (!a->scom_appl_disable) {
9200  if ((j = get_plci(a))) {
9201  splci = &a->plci[j - 1];
9202  add_p(splci, CAI, "\x01\x80");
9203  add_p(splci, UID, "\x06\x43\x61\x70\x69\x32\x30");
9204  sig_req(splci, ASSIGN, 0xC0); /* 0xc0 is the TEL_ID */
9205  send_req(splci);
9206  a->scom_appl_disable = true;
9207  }
9208  else{
9209  return 0x2001; /* wrong state, no more plcis */
9210  }
9211  }
9212  }
9213  else return 0x300B; /* Facility not supported */
9214 
9215  return 0;
9216 }
9217 
9218 
9219 static void CodecIdCheck(DIVA_CAPI_ADAPTER *a, PLCI *plci)
9220 {
9221 
9222  dbug(1, dprintf("CodecIdCheck"));
9223 
9224  if (a->AdvSignalPLCI == plci)
9225  {
9226  dbug(1, dprintf("PLCI owns codec"));
9227  VoiceChannelOff(a->AdvCodecPLCI);
9228  if (a->AdvCodecPLCI->State == ADVANCED_VOICE_NOSIG)
9229  {
9230  dbug(1, dprintf("remove temp codec PLCI"));
9231  plci_remove(a->AdvCodecPLCI);
9232  a->AdvCodecFLAG = 0;
9233  a->AdvCodecPLCI = NULL;
9234  a->AdvSignalAppl = NULL;
9235  }
9236  a->AdvSignalPLCI = NULL;
9237  }
9238 }
9239 
9240 /* -------------------------------------------------------------------
9241  Ask for physical address of card on PCI bus
9242  ------------------------------------------------------------------- */
9243 static void diva_ask_for_xdi_sdram_bar(DIVA_CAPI_ADAPTER *a,
9244  IDI_SYNC_REQ *preq) {
9245  a->sdram_bar = 0;
9246  if (diva_xdi_extended_features & DIVA_CAPI_XDI_PROVIDES_SDRAM_BAR) {
9247  ENTITY *e = (ENTITY *)preq;
9248 
9249  e->user[0] = a->Id - 1;
9250  preq->xdi_sdram_bar.info.bar = 0;
9251  preq->xdi_sdram_bar.Req = 0;
9252  preq->xdi_sdram_bar.Rc = IDI_SYNC_REQ_XDI_GET_ADAPTER_SDRAM_BAR;
9253 
9254  (*(a->request))(e);
9255 
9256  a->sdram_bar = preq->xdi_sdram_bar.info.bar;
9257  dbug(3, dprintf("A(%d) SDRAM BAR = %08x", a->Id, a->sdram_bar));
9258  }
9259 }
9260 
9261 /* -------------------------------------------------------------------
9262  Ask XDI about extended features
9263  ------------------------------------------------------------------- */
9264 static void diva_get_extended_adapter_features(DIVA_CAPI_ADAPTER *a) {
9265  IDI_SYNC_REQ *preq;
9266  char buffer[((sizeof(preq->xdi_extended_features) + 4) > sizeof(ENTITY)) ? (sizeof(preq->xdi_extended_features) + 4) : sizeof(ENTITY)];
9267 
9268  char features[4];
9269  preq = (IDI_SYNC_REQ *)&buffer[0];
9270 
9271  if (!diva_xdi_extended_features) {
9272  ENTITY *e = (ENTITY *)preq;
9273  diva_xdi_extended_features |= 0x80000000;
9274 
9275  e->user[0] = a->Id - 1;
9276  preq->xdi_extended_features.Req = 0;
9277  preq->xdi_extended_features.Rc = IDI_SYNC_REQ_XDI_GET_EXTENDED_FEATURES;
9278  preq->xdi_extended_features.info.buffer_length_in_bytes = sizeof(features);
9279  preq->xdi_extended_features.info.features = &features[0];
9280 
9281  (*(a->request))(e);
9282 
9283  if (features[0] & DIVA_XDI_EXTENDED_FEATURES_VALID) {
9284  /*
9285  Check features located in the byte '0'
9286  */
9287  if (features[0] & DIVA_XDI_EXTENDED_FEATURE_CMA) {
9288  diva_xdi_extended_features |= DIVA_CAPI_USE_CMA;
9289  }
9290  if (features[0] & DIVA_XDI_EXTENDED_FEATURE_RX_DMA) {
9291  diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_RX_DMA;
9292  dbug(1, dprintf("XDI provides RxDMA"));
9293  }
9294  if (features[0] & DIVA_XDI_EXTENDED_FEATURE_SDRAM_BAR) {
9295  diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_SDRAM_BAR;
9296  }
9297  if (features[0] & DIVA_XDI_EXTENDED_FEATURE_NO_CANCEL_RC) {
9298  diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_NO_CANCEL;
9299  dbug(3, dprintf("XDI provides NO_CANCEL_RC feature"));
9300  }
9301 
9302  }
9303  }
9304 
9305  diva_ask_for_xdi_sdram_bar(a, preq);
9306 }
9307 
9308 /*------------------------------------------------------------------*/
9309 /* automatic law */
9310 /*------------------------------------------------------------------*/
9311 /* called from OS specific part after init time to get the Law */
9312 /* a-law (Euro) and u-law (us,japan) use different BCs in the Setup message */
9313 void AutomaticLaw(DIVA_CAPI_ADAPTER *a)
9314 {
9315  word j;
9316  PLCI *splci;
9317 
9318  if (a->automatic_law) {
9319  return;
9320  }
9321  if ((j = get_plci(a))) {
9322  diva_get_extended_adapter_features(a);
9323  splci = &a->plci[j - 1];
9324  a->automatic_lawPLCI = splci;
9325  a->automatic_law = 1;
9326  add_p(splci, CAI, "\x01\x80");
9327  add_p(splci, UID, "\x06\x43\x61\x70\x69\x32\x30");
9328  splci->internal_command = USELAW_REQ;
9329  splci->command = 0;
9330  splci->number = 0;
9331  sig_req(splci, ASSIGN, DSIG_ID);
9332  send_req(splci);
9333  }
9334 }
9335 
9336 /* called from OS specific part if an application sends an Capi20Release */
9337 word CapiRelease(word Id)
9338 {
9339  word i, j, appls_found;
9340  PLCI *plci;
9341  APPL *this;
9342  DIVA_CAPI_ADAPTER *a;
9343 
9344  if (!Id)
9345  {
9346  dbug(0, dprintf("A: CapiRelease(Id==0)"));
9347  return (_WRONG_APPL_ID);
9348  }
9349 
9350  this = &application[Id - 1]; /* get application pointer */
9351 
9352  for (i = 0, appls_found = 0; i < max_appl; i++)
9353  {
9354  if (application[i].Id) /* an application has been found */
9355  {
9356  appls_found++;
9357  }
9358  }
9359 
9360  for (i = 0; i < max_adapter; i++) /* scan all adapters... */
9361  {
9362  a = &adapter[i];
9363  if (a->request)
9364  {
9365  a->Info_Mask[Id - 1] = 0;
9366  a->CIP_Mask[Id - 1] = 0;
9367  a->Notification_Mask[Id - 1] = 0;
9368  a->codec_listen[Id - 1] = NULL;
9369  a->requested_options_table[Id - 1] = 0;
9370  for (j = 0; j < a->max_plci; j++) /* and all PLCIs connected */
9371  { /* with this application */
9372  plci = &a->plci[j];
9373  if (plci->Id) /* if plci owns no application */
9374  { /* it may be not jet connected */
9375  if (plci->State == INC_CON_PENDING
9376  || plci->State == INC_CON_ALERT)
9377  {
9378  if (test_c_ind_mask_bit(plci, (word)(Id - 1)))
9379  {
9380  clear_c_ind_mask_bit(plci, (word)(Id - 1));
9381  if (c_ind_mask_empty(plci))
9382  {
9383  sig_req(plci, HANGUP, 0);
9384  send_req(plci);
9385  plci->State = OUTG_DIS_PENDING;
9386  }
9387  }
9388  }
9389  if (test_c_ind_mask_bit(plci, (word)(Id - 1)))
9390  {
9391  clear_c_ind_mask_bit(plci, (word)(Id - 1));
9392  if (c_ind_mask_empty(plci))
9393  {
9394  if (!plci->appl)
9395  {
9396  plci_remove(plci);
9397  plci->State = IDLE;
9398  }
9399  }
9400  }
9401  if (plci->appl == this)
9402  {
9403  plci->appl = NULL;
9404  plci_remove(plci);
9405  plci->State = IDLE;
9406  }
9407  }
9408  }
9409  listen_check(a);
9410 
9411  if (a->flag_dynamic_l1_down)
9412  {
9413  if (appls_found == 1) /* last application does a capi release */
9414  {
9415  if ((j = get_plci(a)))
9416  {
9417  plci = &a->plci[j - 1];
9418  plci->command = 0;
9419  add_p(plci, OAD, "\x01\xfd");
9420  add_p(plci, CAI, "\x01\x80");
9421  add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
9422  add_p(plci, SHIFT | 6, NULL);
9423  add_p(plci, SIN, "\x02\x00\x00");
9424  plci->internal_command = REM_L1_SIG_ASSIGN_PEND;
9425  sig_req(plci, ASSIGN, DSIG_ID);
9426  add_p(plci, FTY, "\x02\xff\x06"); /* l1 down */
9427  sig_req(plci, SIG_CTRL, 0);
9428  send_req(plci);
9429  }
9430  }
9431  }
9432  if (a->AdvSignalAppl == this)
9433  {
9434  this->NullCREnable = false;
9435  if (a->AdvCodecPLCI)
9436  {
9437  plci_remove(a->AdvCodecPLCI);
9438  a->AdvCodecPLCI->tel = 0;
9439  a->AdvCodecPLCI->adv_nl = 0;
9440  }
9441  a->AdvSignalAppl = NULL;
9442  a->AdvSignalPLCI = NULL;
9443  a->AdvCodecFLAG = 0;
9444  a->AdvCodecPLCI = NULL;
9445  }
9446  }
9447  }
9448 
9449  this->Id = 0;
9450 
9451  return GOOD;
9452 }
9453 
9454 static word plci_remove_check(PLCI *plci)
9455 {
9456  if (!plci) return true;
9457  if (!plci->NL.Id && c_ind_mask_empty(plci))
9458  {
9459  if (plci->Sig.Id == 0xff)
9460  plci->Sig.Id = 0;
9461  if (!plci->Sig.Id)
9462  {
9463  dbug(1, dprintf("plci_remove_complete(%x)", plci->Id));
9464  dbug(1, dprintf("tel=0x%x,Sig=0x%x", plci->tel, plci->Sig.Id));
9465  if (plci->Id)
9466  {
9467  CodecIdCheck(plci->adapter, plci);
9468  clear_b1_config(plci);
9469  ncci_remove(plci, 0, false);
9470  plci_free_msg_in_queue(plci);
9471  channel_flow_control_remove(plci);
9472  plci->Id = 0;
9473  plci->State = IDLE;
9474  plci->channels = 0;
9475  plci->appl = NULL;
9476  plci->notifiedcall = 0;
9477  }
9478  listen_check(plci->adapter);
9479  return true;
9480  }
9481  }
9482  return false;
9483 }
9484 
9485 
9486 /*------------------------------------------------------------------*/
9487 
9488 static byte plci_nl_busy(PLCI *plci)
9489 {
9490  /* only applicable for non-multiplexed protocols */
9491  return (plci->nl_req
9492  || (plci->ncci_ring_list
9493  && plci->adapter->ncci_ch[plci->ncci_ring_list]
9494  && (plci->adapter->ch_flow_control[plci->adapter->ncci_ch[plci->ncci_ring_list]] & N_OK_FC_PENDING)));
9495 }
9496 
9497 
9498 /*------------------------------------------------------------------*/
9499 /* DTMF facilities */
9500 /*------------------------------------------------------------------*/
9501 
9502 
9503 static struct
9504 {
9505  byte send_mask;
9506  byte listen_mask;
9507  byte character;
9508  byte code;
9509 } dtmf_digit_map[] =
9510 {
9511  { 0x01, 0x01, 0x23, DTMF_DIGIT_TONE_CODE_HASHMARK },
9512  { 0x01, 0x01, 0x2a, DTMF_DIGIT_TONE_CODE_STAR },
9513  { 0x01, 0x01, 0x30, DTMF_DIGIT_TONE_CODE_0 },
9514  { 0x01, 0x01, 0x31, DTMF_DIGIT_TONE_CODE_1 },
9515  { 0x01, 0x01, 0x32, DTMF_DIGIT_TONE_CODE_2 },
9516  { 0x01, 0x01, 0x33, DTMF_DIGIT_TONE_CODE_3 },
9517  { 0x01, 0x01, 0x34, DTMF_DIGIT_TONE_CODE_4 },
9518  { 0x01, 0x01, 0x35, DTMF_DIGIT_TONE_CODE_5 },
9519  { 0x01, 0x01, 0x36, DTMF_DIGIT_TONE_CODE_6 },
9520  { 0x01, 0x01, 0x37, DTMF_DIGIT_TONE_CODE_7 },
9521  { 0x01, 0x01, 0x38, DTMF_DIGIT_TONE_CODE_8 },
9522  { 0x01, 0x01, 0x39, DTMF_DIGIT_TONE_CODE_9 },
9523  { 0x01, 0x01, 0x41, DTMF_DIGIT_TONE_CODE_A },
9524  { 0x01, 0x01, 0x42, DTMF_DIGIT_TONE_CODE_B },
9525  { 0x01, 0x01, 0x43, DTMF_DIGIT_TONE_CODE_C },
9526  { 0x01, 0x01, 0x44, DTMF_DIGIT_TONE_CODE_D },
9527  { 0x01, 0x00, 0x61, DTMF_DIGIT_TONE_CODE_A },
9528  { 0x01, 0x00, 0x62, DTMF_DIGIT_TONE_CODE_B },
9529  { 0x01, 0x00, 0x63, DTMF_DIGIT_TONE_CODE_C },
9530  { 0x01, 0x00, 0x64, DTMF_DIGIT_TONE_CODE_D },
9531 
9532  { 0x04, 0x04, 0x80, DTMF_SIGNAL_NO_TONE },
9533  { 0x00, 0x04, 0x81, DTMF_SIGNAL_UNIDENTIFIED_TONE },
9534  { 0x04, 0x04, 0x82, DTMF_SIGNAL_DIAL_TONE },
9535  { 0x04, 0x04, 0x83, DTMF_SIGNAL_PABX_INTERNAL_DIAL_TONE },
9536  { 0x04, 0x04, 0x84, DTMF_SIGNAL_SPECIAL_DIAL_TONE },
9537  { 0x04, 0x04, 0x85, DTMF_SIGNAL_SECOND_DIAL_TONE },
9538  { 0x04, 0x04, 0x86, DTMF_SIGNAL_RINGING_TONE },
9539  { 0x04, 0x04, 0x87, DTMF_SIGNAL_SPECIAL_RINGING_TONE },
9540  { 0x04, 0x04, 0x88, DTMF_SIGNAL_BUSY_TONE },
9541  { 0x04, 0x04, 0x89, DTMF_SIGNAL_CONGESTION_TONE },
9542  { 0x04, 0x04, 0x8a, DTMF_SIGNAL_SPECIAL_INFORMATION_TONE },
9543  { 0x04, 0x04, 0x8b, DTMF_SIGNAL_COMFORT_TONE },
9544  { 0x04, 0x04, 0x8c, DTMF_SIGNAL_HOLD_TONE },
9545  { 0x04, 0x04, 0x8d, DTMF_SIGNAL_RECORD_TONE },
9546  { 0x04, 0x04, 0x8e, DTMF_SIGNAL_CALLER_WAITING_TONE },
9547  { 0x04, 0x04, 0x8f, DTMF_SIGNAL_CALL_WAITING_TONE },
9548  { 0x04, 0x04, 0x90, DTMF_SIGNAL_PAY_TONE },
9549  { 0x04, 0x04, 0x91, DTMF_SIGNAL_POSITIVE_INDICATION_TONE },
9550  { 0x04, 0x04, 0x92, DTMF_SIGNAL_NEGATIVE_INDICATION_TONE },
9551  { 0x04, 0x04, 0x93, DTMF_SIGNAL_WARNING_TONE },
9552  { 0x04, 0x04, 0x94, DTMF_SIGNAL_INTRUSION_TONE },
9553  { 0x04, 0x04, 0x95, DTMF_SIGNAL_CALLING_CARD_SERVICE_TONE },
9554  { 0x04, 0x04, 0x96, DTMF_SIGNAL_PAYPHONE_RECOGNITION_TONE },
9555  { 0x04, 0x04, 0x97, DTMF_SIGNAL_CPE_ALERTING_SIGNAL },
9556  { 0x04, 0x04, 0x98, DTMF_SIGNAL_OFF_HOOK_WARNING_TONE },
9557  { 0x04, 0x04, 0xbf, DTMF_SIGNAL_INTERCEPT_TONE },
9558  { 0x04, 0x04, 0xc0, DTMF_SIGNAL_MODEM_CALLING_TONE },
9559  { 0x04, 0x04, 0xc1, DTMF_SIGNAL_FAX_CALLING_TONE },
9560  { 0x04, 0x04, 0xc2, DTMF_SIGNAL_ANSWER_TONE },
9561  { 0x04, 0x04, 0xc3, DTMF_SIGNAL_REVERSED_ANSWER_TONE },
9562  { 0x04, 0x04, 0xc4, DTMF_SIGNAL_ANSAM_TONE },
9563  { 0x04, 0x04, 0xc5, DTMF_SIGNAL_REVERSED_ANSAM_TONE },
9564  { 0x04, 0x04, 0xc6, DTMF_SIGNAL_BELL103_ANSWER_TONE },
9565  { 0x04, 0x04, 0xc7, DTMF_SIGNAL_FAX_FLAGS },
9566  { 0x04, 0x04, 0xc8, DTMF_SIGNAL_G2_FAX_GROUP_ID },
9567  { 0x00, 0x04, 0xc9, DTMF_SIGNAL_HUMAN_SPEECH },
9568  { 0x04, 0x04, 0xca, DTMF_SIGNAL_ANSWERING_MACHINE_390 },
9569  { 0x02, 0x02, 0xf1, DTMF_MF_DIGIT_TONE_CODE_1 },
9570  { 0x02, 0x02, 0xf2, DTMF_MF_DIGIT_TONE_CODE_2 },
9571  { 0x02, 0x02, 0xf3, DTMF_MF_DIGIT_TONE_CODE_3 },
9572  { 0x02, 0x02, 0xf4, DTMF_MF_DIGIT_TONE_CODE_4 },
9573  { 0x02, 0x02, 0xf5, DTMF_MF_DIGIT_TONE_CODE_5 },
9574  { 0x02, 0x02, 0xf6, DTMF_MF_DIGIT_TONE_CODE_6 },
9575  { 0x02, 0x02, 0xf7, DTMF_MF_DIGIT_TONE_CODE_7 },
9576  { 0x02, 0x02, 0xf8, DTMF_MF_DIGIT_TONE_CODE_8 },
9577  { 0x02, 0x02, 0xf9, DTMF_MF_DIGIT_TONE_CODE_9 },
9578  { 0x02, 0x02, 0xfa, DTMF_MF_DIGIT_TONE_CODE_0 },
9579  { 0x02, 0x02, 0xfb, DTMF_MF_DIGIT_TONE_CODE_K1 },
9580  { 0x02, 0x02, 0xfc, DTMF_MF_DIGIT_TONE_CODE_K2 },
9581  { 0x02, 0x02, 0xfd, DTMF_MF_DIGIT_TONE_CODE_KP },
9582  { 0x02, 0x02, 0xfe, DTMF_MF_DIGIT_TONE_CODE_S1 },
9583  { 0x02, 0x02, 0xff, DTMF_MF_DIGIT_TONE_CODE_ST },
9584 
9585 };
9586 
9587 #define DTMF_DIGIT_MAP_ENTRIES ARRAY_SIZE(dtmf_digit_map)
9588 
9589 
9590 static void dtmf_enable_receiver(PLCI *plci, byte enable_mask)
9591 {
9592  word min_digit_duration, min_gap_duration;
9593 
9594  dbug(1, dprintf("[%06lx] %s,%d: dtmf_enable_receiver %02x",
9595  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
9596  (char *)(FILE_), __LINE__, enable_mask));
9597 
9598  if (enable_mask != 0)
9599  {
9600  min_digit_duration = (plci->dtmf_rec_pulse_ms == 0) ? 40 : plci->dtmf_rec_pulse_ms;
9601  min_gap_duration = (plci->dtmf_rec_pause_ms == 0) ? 40 : plci->dtmf_rec_pause_ms;
9602  plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_ENABLE_RECEIVER;
9603  PUT_WORD(&plci->internal_req_buffer[1], min_digit_duration);
9604  PUT_WORD(&plci->internal_req_buffer[3], min_gap_duration);
9605  plci->NData[0].PLength = 5;
9606 
9607  PUT_WORD(&plci->internal_req_buffer[5], INTERNAL_IND_BUFFER_SIZE);
9608  plci->NData[0].PLength += 2;
9609  capidtmf_recv_enable(&(plci->capidtmf_state), min_digit_duration, min_gap_duration);
9610 
9611  }
9612  else
9613  {
9614  plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_DISABLE_RECEIVER;
9615  plci->NData[0].PLength = 1;
9616 
9617  capidtmf_recv_disable(&(plci->capidtmf_state));
9618 
9619  }
9620  plci->NData[0].P = plci->internal_req_buffer;
9621  plci->NL.X = plci->NData;
9622  plci->NL.ReqCh = 0;
9623  plci->NL.Req = plci->nl_req = (byte) N_UDATA;
9624  plci->adapter->request(&plci->NL);
9625 }
9626 
9627 
9628 static void dtmf_send_digits(PLCI *plci, byte *digit_buffer, word digit_count)
9629 {
9630  word w, i;
9631 
9632  dbug(1, dprintf("[%06lx] %s,%d: dtmf_send_digits %d",
9633  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
9634  (char *)(FILE_), __LINE__, digit_count));
9635 
9636  plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_SEND_DIGITS;
9637  w = (plci->dtmf_send_pulse_ms == 0) ? 40 : plci->dtmf_send_pulse_ms;
9638  PUT_WORD(&plci->internal_req_buffer[1], w);
9639  w = (plci->dtmf_send_pause_ms == 0) ? 40 : plci->dtmf_send_pause_ms;
9640  PUT_WORD(&plci->internal_req_buffer[3], w);
9641  for (i = 0; i < digit_count; i++)
9642  {
9643  w = 0;
9644  while ((w < DTMF_DIGIT_MAP_ENTRIES)
9645  && (digit_buffer[i] != dtmf_digit_map[w].character))
9646  {
9647  w++;
9648  }
9649  plci->internal_req_buffer[5 + i] = (w < DTMF_DIGIT_MAP_ENTRIES) ?
9650  dtmf_digit_map[w].code : DTMF_DIGIT_TONE_CODE_STAR;
9651  }
9652  plci->NData[0].PLength = 5 + digit_count;
9653  plci->NData[0].P = plci->internal_req_buffer;
9654  plci->NL.X = plci->NData;
9655  plci->NL.ReqCh = 0;
9656  plci->NL.Req = plci->nl_req = (byte) N_UDATA;
9657  plci->adapter->request(&plci->NL);
9658 }
9659 
9660 
9661 static void dtmf_rec_clear_config(PLCI *plci)
9662 {
9663 
9664  dbug(1, dprintf("[%06lx] %s,%d: dtmf_rec_clear_config",
9665  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
9666  (char *)(FILE_), __LINE__));
9667 
9668  plci->dtmf_rec_active = 0;
9669  plci->dtmf_rec_pulse_ms = 0;
9670  plci->dtmf_rec_pause_ms = 0;
9671 
9672  capidtmf_init(&(plci->capidtmf_state), plci->adapter->u_law);
9673 
9674 }
9675 
9676 
9677 static void dtmf_send_clear_config(PLCI *plci)
9678 {
9679 
9680  dbug(1, dprintf("[%06lx] %s,%d: dtmf_send_clear_config",
9681  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
9682  (char *)(FILE_), __LINE__));
9683 
9684  plci->dtmf_send_requests = 0;
9685  plci->dtmf_send_pulse_ms = 0;
9686  plci->dtmf_send_pause_ms = 0;
9687 }
9688 
9689 
9690 static void dtmf_prepare_switch(dword Id, PLCI *plci)
9691 {
9692 
9693  dbug(1, dprintf("[%06lx] %s,%d: dtmf_prepare_switch",
9694  UnMapId(Id), (char *)(FILE_), __LINE__));
9695 
9696  while (plci->dtmf_send_requests != 0)
9697  dtmf_confirmation(Id, plci);
9698 }
9699 
9700 
9701 static word dtmf_save_config(dword Id, PLCI *plci, byte Rc)
9702 {
9703 
9704  dbug(1, dprintf("[%06lx] %s,%d: dtmf_save_config %02x %d",
9705  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
9706 
9707  return (GOOD);
9708 }
9709 
9710 
9711 static word dtmf_restore_config(dword Id, PLCI *plci, byte Rc)
9712 {
9713  word Info;
9714 
9715  dbug(1, dprintf("[%06lx] %s,%d: dtmf_restore_config %02x %d",
9716  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
9717 
9718  Info = GOOD;
9719  if (plci->B1_facilities & B1_FACILITY_DTMFR)
9720  {
9721  switch (plci->adjust_b_state)
9722  {
9723  case ADJUST_B_RESTORE_DTMF_1:
9724  plci->internal_command = plci->adjust_b_command;
9725  if (plci_nl_busy(plci))
9726  {
9727  plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
9728  break;
9729  }
9730  dtmf_enable_receiver(plci, plci->dtmf_rec_active);
9731  plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_2;
9732  break;
9733  case ADJUST_B_RESTORE_DTMF_2:
9734  if ((Rc != OK) && (Rc != OK_FC))
9735  {
9736  dbug(1, dprintf("[%06lx] %s,%d: Reenable DTMF receiver failed %02x",
9737  UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
9738  Info = _WRONG_STATE;
9739  break;
9740  }
9741  break;
9742  }
9743  }
9744  return (Info);
9745 }
9746 
9747 
9748 static void dtmf_command(dword Id, PLCI *plci, byte Rc)
9749 {
9750  word internal_command, Info;
9751  byte mask;
9752  byte result[4];
9753 
9754  dbug(1, dprintf("[%06lx] %s,%d: dtmf_command %02x %04x %04x %d %d %d %d",
9755  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command,
9756  plci->dtmf_cmd, plci->dtmf_rec_pulse_ms, plci->dtmf_rec_pause_ms,
9757  plci->dtmf_send_pulse_ms, plci->dtmf_send_pause_ms));
9758 
9759  Info = GOOD;
9760  result[0] = 2;
9761  PUT_WORD(&result[1], DTMF_SUCCESS);
9762  internal_command = plci->internal_command;
9763  plci->internal_command = 0;
9764  mask = 0x01;
9765  switch (plci->dtmf_cmd)
9766  {
9767 
9768  case DTMF_LISTEN_TONE_START:
9769  mask <<= 1;
9770  case DTMF_LISTEN_MF_START:
9771  mask <<= 1;
9772 
9773  case DTMF_LISTEN_START:
9774  switch (internal_command)
9775  {
9776  default:
9777  adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities |
9778  B1_FACILITY_DTMFR), DTMF_COMMAND_1);
9779  case DTMF_COMMAND_1:
9780  if (adjust_b_process(Id, plci, Rc) != GOOD)
9781  {
9782  dbug(1, dprintf("[%06lx] %s,%d: Load DTMF failed",
9783  UnMapId(Id), (char *)(FILE_), __LINE__));
9784  Info = _FACILITY_NOT_SUPPORTED;
9785  break;
9786  }
9787  if (plci->internal_command)
9788  return;
9789  case DTMF_COMMAND_2:
9790  if (plci_nl_busy(plci))
9791  {
9792  plci->internal_command = DTMF_COMMAND_2;
9793  return;
9794  }
9795  plci->internal_command = DTMF_COMMAND_3;
9796  dtmf_enable_receiver(plci, (byte)(plci->dtmf_rec_active | mask));
9797  return;
9798  case DTMF_COMMAND_3:
9799  if ((Rc != OK) && (Rc != OK_FC))
9800  {
9801  dbug(1, dprintf("[%06lx] %s,%d: Enable DTMF receiver failed %02x",
9802  UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
9803  Info = _FACILITY_NOT_SUPPORTED;
9804  break;
9805  }
9806 
9807  plci->tone_last_indication_code = DTMF_SIGNAL_NO_TONE;
9808 
9809  plci->dtmf_rec_active |= mask;
9810  break;
9811  }
9812  break;
9813 
9814 
9815  case DTMF_LISTEN_TONE_STOP:
9816  mask <<= 1;
9817  case DTMF_LISTEN_MF_STOP:
9818  mask <<= 1;
9819 
9820  case DTMF_LISTEN_STOP:
9821  switch (internal_command)
9822  {
9823  default:
9824  plci->dtmf_rec_active &= ~mask;
9825  if (plci->dtmf_rec_active)
9826  break;
9827 /*
9828  case DTMF_COMMAND_1:
9829  if (plci->dtmf_rec_active)
9830  {
9831  if (plci_nl_busy (plci))
9832  {
9833  plci->internal_command = DTMF_COMMAND_1;
9834  return;
9835  }
9836  plci->dtmf_rec_active &= ~mask;
9837  plci->internal_command = DTMF_COMMAND_2;
9838  dtmf_enable_receiver (plci, false);
9839  return;
9840  }
9841  Rc = OK;
9842  case DTMF_COMMAND_2:
9843  if ((Rc != OK) && (Rc != OK_FC))
9844  {
9845  dbug (1, dprintf("[%06lx] %s,%d: Disable DTMF receiver failed %02x",
9846  UnMapId (Id), (char far *)(FILE_), __LINE__, Rc));
9847  Info = _FACILITY_NOT_SUPPORTED;
9848  break;
9849  }
9850 */
9851  adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities &
9852  ~(B1_FACILITY_DTMFX | B1_FACILITY_DTMFR)), DTMF_COMMAND_3);
9853  case DTMF_COMMAND_3:
9854  if (adjust_b_process(Id, plci, Rc) != GOOD)
9855  {
9856  dbug(1, dprintf("[%06lx] %s,%d: Unload DTMF failed",
9857  UnMapId(Id), (char *)(FILE_), __LINE__));
9858  Info = _FACILITY_NOT_SUPPORTED;
9859  break;
9860  }
9861  if (plci->internal_command)
9862  return;
9863  break;
9864  }
9865  break;
9866 
9867 
9868  case DTMF_SEND_TONE:
9869  mask <<= 1;
9870  case DTMF_SEND_MF:
9871  mask <<= 1;
9872 
9873  case DTMF_DIGITS_SEND:
9874  switch (internal_command)
9875  {
9876  default:
9877  adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities |
9878  ((plci->dtmf_parameter_length != 0) ? B1_FACILITY_DTMFX | B1_FACILITY_DTMFR : B1_FACILITY_DTMFX)),
9879  DTMF_COMMAND_1);
9880  case DTMF_COMMAND_1:
9881  if (adjust_b_process(Id, plci, Rc) != GOOD)
9882  {
9883  dbug(1, dprintf("[%06lx] %s,%d: Load DTMF failed",
9884  UnMapId(Id), (char *)(FILE_), __LINE__));
9885  Info = _FACILITY_NOT_SUPPORTED;
9886  break;
9887  }
9888  if (plci->internal_command)
9889  return;
9890  case DTMF_COMMAND_2:
9891  if (plci_nl_busy(plci))
9892  {
9893  plci->internal_command = DTMF_COMMAND_2;
9894  return;
9895  }
9896  plci->dtmf_msg_number_queue[(plci->dtmf_send_requests)++] = plci->number;
9897  plci->internal_command = DTMF_COMMAND_3;
9898  dtmf_send_digits(plci, &plci->saved_msg.parms[3].info[1], plci->saved_msg.parms[3].length);
9899  return;
9900  case DTMF_COMMAND_3:
9901  if ((Rc != OK) && (Rc != OK_FC))
9902  {
9903  dbug(1, dprintf("[%06lx] %s,%d: Send DTMF digits failed %02x",
9904  UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
9905  if (plci->dtmf_send_requests != 0)
9906  (plci->dtmf_send_requests)--;
9907  Info = _FACILITY_NOT_SUPPORTED;
9908  break;
9909  }
9910  return;
9911  }
9912  break;
9913  }
9914  sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->number,
9915  "wws", Info, SELECTOR_DTMF, result);
9916 }
9917 
9918 
9919 static byte dtmf_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg)
9920 {
9921  word Info;
9922  word i, j;
9923  byte mask;
9924  API_PARSE dtmf_parms[5];
9925  byte result[40];
9926 
9927  dbug(1, dprintf("[%06lx] %s,%d: dtmf_request",
9928  UnMapId(Id), (char *)(FILE_), __LINE__));
9929 
9930  Info = GOOD;
9931  result[0] = 2;
9932  PUT_WORD(&result[1], DTMF_SUCCESS);
9933  if (!(a->profile.Global_Options & GL_DTMF_SUPPORTED))
9934  {
9935  dbug(1, dprintf("[%06lx] %s,%d: Facility not supported",
9936  UnMapId(Id), (char *)(FILE_), __LINE__));
9937  Info = _FACILITY_NOT_SUPPORTED;
9938  }
9939  else if (api_parse(&msg[1].info[1], msg[1].length, "w", dtmf_parms))
9940  {
9941  dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
9942  UnMapId(Id), (char *)(FILE_), __LINE__));
9943  Info = _WRONG_MESSAGE_FORMAT;
9944  }
9945 
9946  else if ((GET_WORD(dtmf_parms[0].info) == DTMF_GET_SUPPORTED_DETECT_CODES)
9947  || (GET_WORD(dtmf_parms[0].info) == DTMF_GET_SUPPORTED_SEND_CODES))
9948  {
9949  if (!((a->requested_options_table[appl->Id - 1])
9950  & (1L << PRIVATE_DTMF_TONE)))
9951  {
9952  dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x",
9953  UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(dtmf_parms[0].info)));
9954  PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST);
9955  }
9956  else
9957  {
9958  for (i = 0; i < 32; i++)
9959  result[4 + i] = 0;
9960  if (GET_WORD(dtmf_parms[0].info) == DTMF_GET_SUPPORTED_DETECT_CODES)
9961  {
9962  for (i = 0; i < DTMF_DIGIT_MAP_ENTRIES; i++)
9963  {
9964  if (dtmf_digit_map[i].listen_mask != 0)
9965  result[4 + (dtmf_digit_map[i].character >> 3)] |= (1 << (dtmf_digit_map[i].character & 0x7));
9966  }
9967  }
9968  else
9969  {
9970  for (i = 0; i < DTMF_DIGIT_MAP_ENTRIES; i++)
9971  {
9972  if (dtmf_digit_map[i].send_mask != 0)
9973  result[4 + (dtmf_digit_map[i].character >> 3)] |= (1 << (dtmf_digit_map[i].character & 0x7));
9974  }
9975  }
9976  result[0] = 3 + 32;
9977  result[3] = 32;
9978  }
9979  }
9980 
9981  else if (plci == NULL)
9982  {
9983  dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI",
9984  UnMapId(Id), (char *)(FILE_), __LINE__));
9985  Info = _WRONG_IDENTIFIER;
9986  }
9987  else
9988  {
9989  if (!plci->State
9990  || !plci->NL.Id || plci->nl_remove_id)
9991  {
9992  dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
9993  UnMapId(Id), (char *)(FILE_), __LINE__));
9994  Info = _WRONG_STATE;
9995  }
9996  else
9997  {
9998  plci->command = 0;
9999  plci->dtmf_cmd = GET_WORD(dtmf_parms[0].info);
10000  mask = 0x01;
10001  switch (plci->dtmf_cmd)
10002  {
10003 
10004  case DTMF_LISTEN_TONE_START:
10005  case DTMF_LISTEN_TONE_STOP:
10006  mask <<= 1;
10007  case DTMF_LISTEN_MF_START:
10008  case DTMF_LISTEN_MF_STOP:
10009  mask <<= 1;
10010  if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[appl->Id - 1])
10011  & (1L << PRIVATE_DTMF_TONE)))
10012  {
10013  dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x",
10014  UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(dtmf_parms[0].info)));
10015  PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST);
10016  break;
10017  }
10018 
10019  case DTMF_LISTEN_START:
10020  case DTMF_LISTEN_STOP:
10021  if (!(a->manufacturer_features & MANUFACTURER_FEATURE_HARDDTMF)
10022  && !(a->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE))
10023  {
10024  dbug(1, dprintf("[%06lx] %s,%d: Facility not supported",
10025  UnMapId(Id), (char *)(FILE_), __LINE__));
10026  Info = _FACILITY_NOT_SUPPORTED;
10027  break;
10028  }
10029  if (mask & DTMF_LISTEN_ACTIVE_FLAG)
10030  {
10031  if (api_parse(&msg[1].info[1], msg[1].length, "wwws", dtmf_parms))
10032  {
10033  plci->dtmf_rec_pulse_ms = 0;
10034  plci->dtmf_rec_pause_ms = 0;
10035  }
10036  else
10037  {
10038  plci->dtmf_rec_pulse_ms = GET_WORD(dtmf_parms[1].info);
10039  plci->dtmf_rec_pause_ms = GET_WORD(dtmf_parms[2].info);
10040  }
10041  }
10042  start_internal_command(Id, plci, dtmf_command);
10043  return (false);
10044 
10045 
10046  case DTMF_SEND_TONE:
10047  mask <<= 1;
10048  case DTMF_SEND_MF:
10049  mask <<= 1;
10050  if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[appl->Id - 1])
10051  & (1L << PRIVATE_DTMF_TONE)))
10052  {
10053  dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x",
10054  UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(dtmf_parms[0].info)));
10055  PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST);
10056  break;
10057  }
10058 
10059  case DTMF_DIGITS_SEND:
10060  if (api_parse(&msg[1].info[1], msg[1].length, "wwws", dtmf_parms))
10061  {
10062  dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
10063  UnMapId(Id), (char *)(FILE_), __LINE__));
10064  Info = _WRONG_MESSAGE_FORMAT;
10065  break;
10066  }
10067  if (mask & DTMF_LISTEN_ACTIVE_FLAG)
10068  {
10069  plci->dtmf_send_pulse_ms = GET_WORD(dtmf_parms[1].info);
10070  plci->dtmf_send_pause_ms = GET_WORD(dtmf_parms[2].info);
10071  }
10072  i = 0;
10073  j = 0;
10074  while ((i < dtmf_parms[3].length) && (j < DTMF_DIGIT_MAP_ENTRIES))
10075  {
10076  j = 0;
10077  while ((j < DTMF_DIGIT_MAP_ENTRIES)
10078  && ((dtmf_parms[3].info[i + 1] != dtmf_digit_map[j].character)
10079  || ((dtmf_digit_map[j].send_mask & mask) == 0)))
10080  {
10081  j++;
10082  }
10083  i++;
10084  }
10085  if (j == DTMF_DIGIT_MAP_ENTRIES)
10086  {
10087  dbug(1, dprintf("[%06lx] %s,%d: Incorrect DTMF digit %02x",
10088  UnMapId(Id), (char *)(FILE_), __LINE__, dtmf_parms[3].info[i]));
10089  PUT_WORD(&result[1], DTMF_INCORRECT_DIGIT);
10090  break;
10091  }
10092  if (plci->dtmf_send_requests >= ARRAY_SIZE(plci->dtmf_msg_number_queue))
10093  {
10094  dbug(1, dprintf("[%06lx] %s,%d: DTMF request overrun",
10095  UnMapId(Id), (char *)(FILE_), __LINE__));
10096  Info = _WRONG_STATE;
10097  break;
10098  }
10099  api_save_msg(dtmf_parms, "wwws", &plci->saved_msg);
10100  start_internal_command(Id, plci, dtmf_command);
10101  return (false);
10102 
10103  default:
10104  dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x",
10105  UnMapId(Id), (char *)(FILE_), __LINE__, plci->dtmf_cmd));
10106  PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST);
10107  }
10108  }
10109  }
10110  sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
10111  "wws", Info, SELECTOR_DTMF, result);
10112  return (false);
10113 }
10114 
10115 
10116 static void dtmf_confirmation(dword Id, PLCI *plci)
10117 {
10118  word i;
10119  byte result[4];
10120 
10121  dbug(1, dprintf("[%06lx] %s,%d: dtmf_confirmation",
10122  UnMapId(Id), (char *)(FILE_), __LINE__));
10123 
10124  result[0] = 2;
10125  PUT_WORD(&result[1], DTMF_SUCCESS);
10126  if (plci->dtmf_send_requests != 0)
10127  {
10128  sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->dtmf_msg_number_queue[0],
10129  "wws", GOOD, SELECTOR_DTMF, result);
10130  (plci->dtmf_send_requests)--;
10131  for (i = 0; i < plci->dtmf_send_requests; i++)
10132  plci->dtmf_msg_number_queue[i] = plci->dtmf_msg_number_queue[i + 1];
10133  }
10134 }
10135 
10136 
10137 static void dtmf_indication(dword Id, PLCI *plci, byte *msg, word length)
10138 {
10139  word i, j, n;
10140 
10141  dbug(1, dprintf("[%06lx] %s,%d: dtmf_indication",
10142  UnMapId(Id), (char *)(FILE_), __LINE__));
10143 
10144  n = 0;
10145  for (i = 1; i < length; i++)
10146  {
10147  j = 0;
10148  while ((j < DTMF_DIGIT_MAP_ENTRIES)
10149  && ((msg[i] != dtmf_digit_map[j].code)
10150  || ((dtmf_digit_map[j].listen_mask & plci->dtmf_rec_active) == 0)))
10151  {
10152  j++;
10153  }
10154  if (j < DTMF_DIGIT_MAP_ENTRIES)
10155  {
10156 
10157  if ((dtmf_digit_map[j].listen_mask & DTMF_TONE_LISTEN_ACTIVE_FLAG)
10158  && (plci->tone_last_indication_code == DTMF_SIGNAL_NO_TONE)
10159  && (dtmf_digit_map[j].character != DTMF_SIGNAL_UNIDENTIFIED_TONE))
10160  {
10161  if (n + 1 == i)
10162  {
10163  for (i = length; i > n + 1; i--)
10164  msg[i] = msg[i - 1];
10165  length++;
10166  i++;
10167  }
10168  msg[++n] = DTMF_SIGNAL_UNIDENTIFIED_TONE;
10169  }
10170  plci->tone_last_indication_code = dtmf_digit_map[j].character;
10171 
10172  msg[++n] = dtmf_digit_map[j].character;
10173  }
10174  }
10175  if (n != 0)
10176  {
10177  msg[0] = (byte) n;
10178  sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "wS", SELECTOR_DTMF, msg);
10179  }
10180 }
10181 
10182 
10183 /*------------------------------------------------------------------*/
10184 /* DTMF parameters */
10185 /*------------------------------------------------------------------*/
10186 
10187 static void dtmf_parameter_write(PLCI *plci)
10188 {
10189  word i;
10190  byte parameter_buffer[DTMF_PARAMETER_BUFFER_SIZE + 2];
10191 
10192  dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_write",
10193  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10194  (char *)(FILE_), __LINE__));
10195 
10196  parameter_buffer[0] = plci->dtmf_parameter_length + 1;
10197  parameter_buffer[1] = DSP_CTRL_SET_DTMF_PARAMETERS;
10198  for (i = 0; i < plci->dtmf_parameter_length; i++)
10199  parameter_buffer[2 + i] = plci->dtmf_parameter_buffer[i];
10200  add_p(plci, FTY, parameter_buffer);
10201  sig_req(plci, TEL_CTRL, 0);
10202  send_req(plci);
10203 }
10204 
10205 
10206 static void dtmf_parameter_clear_config(PLCI *plci)
10207 {
10208 
10209  dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_clear_config",
10210  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10211  (char *)(FILE_), __LINE__));
10212 
10213  plci->dtmf_parameter_length = 0;
10214 }
10215 
10216 
10217 static void dtmf_parameter_prepare_switch(dword Id, PLCI *plci)
10218 {
10219 
10220  dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_prepare_switch",
10221  UnMapId(Id), (char *)(FILE_), __LINE__));
10222 
10223 }
10224 
10225 
10226 static word dtmf_parameter_save_config(dword Id, PLCI *plci, byte Rc)
10227 {
10228 
10229  dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_save_config %02x %d",
10230  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
10231 
10232  return (GOOD);
10233 }
10234 
10235 
10236 static word dtmf_parameter_restore_config(dword Id, PLCI *plci, byte Rc)
10237 {
10238  word Info;
10239 
10240  dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_restore_config %02x %d",
10241  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
10242 
10243  Info = GOOD;
10244  if ((plci->B1_facilities & B1_FACILITY_DTMFR)
10245  && (plci->dtmf_parameter_length != 0))
10246  {
10247  switch (plci->adjust_b_state)
10248  {
10249  case ADJUST_B_RESTORE_DTMF_PARAMETER_1:
10250  plci->internal_command = plci->adjust_b_command;
10251  if (plci->sig_req)
10252  {
10253  plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_1;
10254  break;
10255  }
10256  dtmf_parameter_write(plci);
10257  plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_2;
10258  break;
10259  case ADJUST_B_RESTORE_DTMF_PARAMETER_2:
10260  if ((Rc != OK) && (Rc != OK_FC))
10261  {
10262  dbug(1, dprintf("[%06lx] %s,%d: Restore DTMF parameters failed %02x",
10263  UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
10264  Info = _WRONG_STATE;
10265  break;
10266  }
10267  break;
10268  }
10269  }
10270  return (Info);
10271 }
10272 
10273 
10274 /*------------------------------------------------------------------*/
10275 /* Line interconnect facilities */
10276 /*------------------------------------------------------------------*/
10277 
10278 
10279 LI_CONFIG *li_config_table;
10280 word li_total_channels;
10281 
10282 
10283 /*------------------------------------------------------------------*/
10284 /* translate a CHI information element to a channel number */
10285 /* returns 0xff - any channel */
10286 /* 0xfe - chi wrong coding */
10287 /* 0xfd - D-channel */
10288 /* 0x00 - no channel */
10289 /* else channel number / PRI: timeslot */
10290 /* if channels is provided we accept more than one channel. */
10291 /*------------------------------------------------------------------*/
10292 
10293 static byte chi_to_channel(byte *chi, dword *pchannelmap)
10294 {
10295  int p;
10296  int i;
10297  dword map;
10298  byte excl;
10299  byte ofs;
10300  byte ch;
10301 
10302  if (pchannelmap) *pchannelmap = 0;
10303  if (!chi[0]) return 0xff;
10304  excl = 0;
10305 
10306  if (chi[1] & 0x20) {
10307  if (chi[0] == 1 && chi[1] == 0xac) return 0xfd; /* exclusive d-channel */
10308  for (i = 1; i < chi[0] && !(chi[i] & 0x80); i++);
10309  if (i == chi[0] || !(chi[i] & 0x80)) return 0xfe;
10310  if ((chi[1] | 0xc8) != 0xe9) return 0xfe;
10311  if (chi[1] & 0x08) excl = 0x40;
10312 
10313  /* int. id present */
10314  if (chi[1] & 0x40) {
10315  p = i + 1;
10316  for (i = p; i < chi[0] && !(chi[i] & 0x80); i++);
10317  if (i == chi[0] || !(chi[i] & 0x80)) return 0xfe;
10318  }
10319 
10320  /* coding standard, Number/Map, Channel Type */
10321  p = i + 1;
10322  for (i = p; i < chi[0] && !(chi[i] & 0x80); i++);
10323  if (i == chi[0] || !(chi[i] & 0x80)) return 0xfe;
10324  if ((chi[p] | 0xd0) != 0xd3) return 0xfe;
10325 
10326  /* Number/Map */
10327  if (chi[p] & 0x10) {
10328 
10329  /* map */
10330  if ((chi[0] - p) == 4) ofs = 0;
10331  else if ((chi[0] - p) == 3) ofs = 1;
10332  else return 0xfe;
10333  ch = 0;
10334  map = 0;
10335  for (i = 0; i < 4 && p < chi[0]; i++) {
10336  p++;
10337  ch += 8;
10338  map <<= 8;
10339  if (chi[p]) {
10340  for (ch = 0; !(chi[p] & (1 << ch)); ch++);
10341  map |= chi[p];
10342  }
10343  }
10344  ch += ofs;
10345  map <<= ofs;
10346  }
10347  else {
10348 
10349  /* number */
10350  p = i + 1;
10351  ch = chi[p] & 0x3f;
10352  if (pchannelmap) {
10353  if ((byte)(chi[0] - p) > 30) return 0xfe;
10354  map = 0;
10355  for (i = p; i <= chi[0]; i++) {
10356  if ((chi[i] & 0x7f) > 31) return 0xfe;
10357  map |= (1L << (chi[i] & 0x7f));
10358  }
10359  }
10360  else {
10361  if (p != chi[0]) return 0xfe;
10362  if (ch > 31) return 0xfe;
10363  map = (1L << ch);
10364  }
10365  if (chi[p] & 0x40) return 0xfe;
10366  }
10367  if (pchannelmap) *pchannelmap = map;
10368  else if (map != ((dword)(1L << ch))) return 0xfe;
10369  return (byte)(excl | ch);
10370  }
10371  else { /* not PRI */
10372  for (i = 1; i < chi[0] && !(chi[i] & 0x80); i++);
10373  if (i != chi[0] || !(chi[i] & 0x80)) return 0xfe;
10374  if (chi[1] & 0x08) excl = 0x40;
10375 
10376  switch (chi[1] | 0x98) {
10377  case 0x98: return 0;
10378  case 0x99:
10379  if (pchannelmap) *pchannelmap = 2;
10380  return excl | 1;
10381  case 0x9a:
10382  if (pchannelmap) *pchannelmap = 4;
10383  return excl | 2;
10384  case 0x9b: return 0xff;
10385  case 0x9c: return 0xfd; /* d-ch */
10386  default: return 0xfe;
10387  }
10388  }
10389 }
10390 
10391 
10392 static void mixer_set_bchannel_id_esc(PLCI *plci, byte bchannel_id)
10393 {
10394  DIVA_CAPI_ADAPTER *a;
10395  PLCI *splci;
10396  byte old_id;
10397 
10398  a = plci->adapter;
10399  old_id = plci->li_bchannel_id;
10400  if (a->li_pri)
10401  {
10402  if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10403  li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10404  plci->li_bchannel_id = (bchannel_id & 0x1f) + 1;
10405  if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10406  li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10407  }
10408  else
10409  {
10410  if (((bchannel_id & 0x03) == 1) || ((bchannel_id & 0x03) == 2))
10411  {
10412  if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10413  li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10414  plci->li_bchannel_id = bchannel_id & 0x03;
10415  if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI != plci) && (a->AdvSignalPLCI->tel == ADV_VOICE))
10416  {
10417  splci = a->AdvSignalPLCI;
10418  if (li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci == NULL)
10419  {
10420  if ((splci->li_bchannel_id != 0)
10421  && (li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci == splci))
10422  {
10423  li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci = NULL;
10424  }
10425  splci->li_bchannel_id = 3 - plci->li_bchannel_id;
10426  li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci = splci;
10427  dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id_esc %d",
10428  (dword)((splci->Id << 8) | UnMapController(splci->adapter->Id)),
10429  (char *)(FILE_), __LINE__, splci->li_bchannel_id));
10430  }
10431  }
10432  if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10433  li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10434  }
10435  }
10436  if ((old_id == 0) && (plci->li_bchannel_id != 0)
10437  && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
10438  {
10439  mixer_clear_config(plci);
10440  }
10441  dbug(1, dprintf("[%06lx] %s,%d: mixer_set_bchannel_id_esc %d %d",
10442  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10443  (char *)(FILE_), __LINE__, bchannel_id, plci->li_bchannel_id));
10444 }
10445 
10446 
10447 static void mixer_set_bchannel_id(PLCI *plci, byte *chi)
10448 {
10449  DIVA_CAPI_ADAPTER *a;
10450  PLCI *splci;
10451  byte ch, old_id;
10452 
10453  a = plci->adapter;
10454  old_id = plci->li_bchannel_id;
10455  ch = chi_to_channel(chi, NULL);
10456  if (!(ch & 0x80))
10457  {
10458  if (a->li_pri)
10459  {
10460  if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10461  li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10462  plci->li_bchannel_id = (ch & 0x1f) + 1;
10463  if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10464  li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10465  }
10466  else
10467  {
10468  if (((ch & 0x1f) == 1) || ((ch & 0x1f) == 2))
10469  {
10470  if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10471  li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10472  plci->li_bchannel_id = ch & 0x1f;
10473  if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI != plci) && (a->AdvSignalPLCI->tel == ADV_VOICE))
10474  {
10475  splci = a->AdvSignalPLCI;
10476  if (li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci == NULL)
10477  {
10478  if ((splci->li_bchannel_id != 0)
10479  && (li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci == splci))
10480  {
10481  li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci = NULL;
10482  }
10483  splci->li_bchannel_id = 3 - plci->li_bchannel_id;
10484  li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci = splci;
10485  dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id %d",
10486  (dword)((splci->Id << 8) | UnMapController(splci->adapter->Id)),
10487  (char *)(FILE_), __LINE__, splci->li_bchannel_id));
10488  }
10489  }
10490  if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10491  li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10492  }
10493  }
10494  }
10495  if ((old_id == 0) && (plci->li_bchannel_id != 0)
10496  && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
10497  {
10498  mixer_clear_config(plci);
10499  }
10500  dbug(1, dprintf("[%06lx] %s,%d: mixer_set_bchannel_id %02x %d",
10501  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10502  (char *)(FILE_), __LINE__, ch, plci->li_bchannel_id));
10503 }
10504 
10505 
10506 #define MIXER_MAX_DUMP_CHANNELS 34
10507 
10508 static void mixer_calculate_coefs(DIVA_CAPI_ADAPTER *a)
10509 {
10510  static char hex_digit_table[0x10] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
10511  word n, i, j;
10512  char *p;
10513  char hex_line[2 * MIXER_MAX_DUMP_CHANNELS + MIXER_MAX_DUMP_CHANNELS / 8 + 4];
10514 
10515  dbug(1, dprintf("[%06lx] %s,%d: mixer_calculate_coefs",
10516  (dword)(UnMapController(a->Id)), (char *)(FILE_), __LINE__));
10517 
10518  for (i = 0; i < li_total_channels; i++)
10519  {
10520  li_config_table[i].channel &= LI_CHANNEL_ADDRESSES_SET;
10521  if (li_config_table[i].chflags != 0)
10522  li_config_table[i].channel |= LI_CHANNEL_INVOLVED;
10523  else
10524  {
10525  for (j = 0; j < li_total_channels; j++)
10526  {
10527  if (((li_config_table[i].flag_table[j]) != 0)
10528  || ((li_config_table[j].flag_table[i]) != 0))
10529  {
10530  li_config_table[i].channel |= LI_CHANNEL_INVOLVED;
10531  }
10532  if (((li_config_table[i].flag_table[j] & LI_FLAG_CONFERENCE) != 0)
10533  || ((li_config_table[j].flag_table[i] & LI_FLAG_CONFERENCE) != 0))
10534  {
10535  li_config_table[i].channel |= LI_CHANNEL_CONFERENCE;
10536  }
10537  }
10538  }
10539  }
10540  for (i = 0; i < li_total_channels; i++)
10541  {
10542  for (j = 0; j < li_total_channels; j++)
10543  {
10544  li_config_table[i].coef_table[j] &= ~(LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC);
10545  if (li_config_table[i].flag_table[j] & LI_FLAG_CONFERENCE)
10546  li_config_table[i].coef_table[j] |= LI_COEF_CH_CH;
10547  }
10548  }
10549  for (n = 0; n < li_total_channels; n++)
10550  {
10551  if (li_config_table[n].channel & LI_CHANNEL_CONFERENCE)
10552  {
10553  for (i = 0; i < li_total_channels; i++)
10554  {
10555  if (li_config_table[i].channel & LI_CHANNEL_CONFERENCE)
10556  {
10557  for (j = 0; j < li_total_channels; j++)
10558  {
10559  li_config_table[i].coef_table[j] |=
10560  li_config_table[i].coef_table[n] & li_config_table[n].coef_table[j];
10561  }
10562  }
10563  }
10564  }
10565  }
10566  for (i = 0; i < li_total_channels; i++)
10567  {
10568  if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10569  {
10570  li_config_table[i].coef_table[i] &= ~LI_COEF_CH_CH;
10571  for (j = 0; j < li_total_channels; j++)
10572  {
10573  if (li_config_table[i].coef_table[j] & LI_COEF_CH_CH)
10574  li_config_table[i].flag_table[j] |= LI_FLAG_CONFERENCE;
10575  }
10576  if (li_config_table[i].flag_table[i] & LI_FLAG_CONFERENCE)
10577  li_config_table[i].coef_table[i] |= LI_COEF_CH_CH;
10578  }
10579  }
10580  for (i = 0; i < li_total_channels; i++)
10581  {
10582  if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10583  {
10584  for (j = 0; j < li_total_channels; j++)
10585  {
10586  if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
10587  li_config_table[i].coef_table[j] |= LI_COEF_CH_CH;
10588  if (li_config_table[i].flag_table[j] & LI_FLAG_MONITOR)
10589  li_config_table[i].coef_table[j] |= LI_COEF_CH_PC;
10590  if (li_config_table[i].flag_table[j] & LI_FLAG_MIX)
10591  li_config_table[i].coef_table[j] |= LI_COEF_PC_CH;
10592  if (li_config_table[i].flag_table[j] & LI_FLAG_PCCONNECT)
10593  li_config_table[i].coef_table[j] |= LI_COEF_PC_PC;
10594  }
10595  if (li_config_table[i].chflags & LI_CHFLAG_MONITOR)
10596  {
10597  for (j = 0; j < li_total_channels; j++)
10598  {
10599  if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
10600  {
10601  li_config_table[i].coef_table[j] |= LI_COEF_CH_PC;
10602  if (li_config_table[j].chflags & LI_CHFLAG_MIX)
10603  li_config_table[i].coef_table[j] |= LI_COEF_PC_CH | LI_COEF_PC_PC;
10604  }
10605  }
10606  }
10607  if (li_config_table[i].chflags & LI_CHFLAG_MIX)
10608  {
10609  for (j = 0; j < li_total_channels; j++)
10610  {
10611  if (li_config_table[j].flag_table[i] & LI_FLAG_INTERCONNECT)
10612  li_config_table[j].coef_table[i] |= LI_COEF_PC_CH;
10613  }
10614  }
10615  if (li_config_table[i].chflags & LI_CHFLAG_LOOP)
10616  {
10617  for (j = 0; j < li_total_channels; j++)
10618  {
10619  if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
10620  {
10621  for (n = 0; n < li_total_channels; n++)
10622  {
10623  if (li_config_table[n].flag_table[i] & LI_FLAG_INTERCONNECT)
10624  {
10625  li_config_table[n].coef_table[j] |= LI_COEF_CH_CH;
10626  if (li_config_table[j].chflags & LI_CHFLAG_MIX)
10627  {
10628  li_config_table[n].coef_table[j] |= LI_COEF_PC_CH;
10629  if (li_config_table[n].chflags & LI_CHFLAG_MONITOR)
10630  li_config_table[n].coef_table[j] |= LI_COEF_CH_PC | LI_COEF_PC_PC;
10631  }
10632  else if (li_config_table[n].chflags & LI_CHFLAG_MONITOR)
10633  li_config_table[n].coef_table[j] |= LI_COEF_CH_PC;
10634  }
10635  }
10636  }
10637  }
10638  }
10639  }
10640  }
10641  for (i = 0; i < li_total_channels; i++)
10642  {
10643  if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10644  {
10645  if (li_config_table[i].chflags & (LI_CHFLAG_MONITOR | LI_CHFLAG_MIX | LI_CHFLAG_LOOP))
10646  li_config_table[i].channel |= LI_CHANNEL_ACTIVE;
10647  if (li_config_table[i].chflags & LI_CHFLAG_MONITOR)
10648  li_config_table[i].channel |= LI_CHANNEL_RX_DATA;
10649  if (li_config_table[i].chflags & LI_CHFLAG_MIX)
10650  li_config_table[i].channel |= LI_CHANNEL_TX_DATA;
10651  for (j = 0; j < li_total_channels; j++)
10652  {
10653  if ((li_config_table[i].flag_table[j] &
10654  (LI_FLAG_INTERCONNECT | LI_FLAG_PCCONNECT | LI_FLAG_CONFERENCE | LI_FLAG_MONITOR))
10655  || (li_config_table[j].flag_table[i] &
10656  (LI_FLAG_INTERCONNECT | LI_FLAG_PCCONNECT | LI_FLAG_CONFERENCE | LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX)))
10657  {
10658  li_config_table[i].channel |= LI_CHANNEL_ACTIVE;
10659  }
10660  if (li_config_table[i].flag_table[j] & (LI_FLAG_PCCONNECT | LI_FLAG_MONITOR))
10661  li_config_table[i].channel |= LI_CHANNEL_RX_DATA;
10662  if (li_config_table[j].flag_table[i] & (LI_FLAG_PCCONNECT | LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX))
10663  li_config_table[i].channel |= LI_CHANNEL_TX_DATA;
10664  }
10665  if (!(li_config_table[i].channel & LI_CHANNEL_ACTIVE))
10666  {
10667  li_config_table[i].coef_table[i] |= LI_COEF_PC_CH | LI_COEF_CH_PC;
10668  li_config_table[i].channel |= LI_CHANNEL_TX_DATA | LI_CHANNEL_RX_DATA;
10669  }
10670  }
10671  }
10672  for (i = 0; i < li_total_channels; i++)
10673  {
10674  if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10675  {
10676  j = 0;
10677  while ((j < li_total_channels) && !(li_config_table[i].flag_table[j] & LI_FLAG_ANNOUNCEMENT))
10678  j++;
10679  if (j < li_total_channels)
10680  {
10681  for (j = 0; j < li_total_channels; j++)
10682  {
10683  li_config_table[i].coef_table[j] &= ~(LI_COEF_CH_CH | LI_COEF_PC_CH);
10684  if (li_config_table[i].flag_table[j] & LI_FLAG_ANNOUNCEMENT)
10685  li_config_table[i].coef_table[j] |= LI_COEF_PC_CH;
10686  }
10687  }
10688  }
10689  }
10690  n = li_total_channels;
10691  if (n > MIXER_MAX_DUMP_CHANNELS)
10692  n = MIXER_MAX_DUMP_CHANNELS;
10693  p = hex_line;
10694  for (j = 0; j < n; j++)
10695  {
10696  if ((j & 0x7) == 0)
10697  *(p++) = ' ';
10698  *(p++) = hex_digit_table[li_config_table[j].curchnl >> 4];
10699  *(p++) = hex_digit_table[li_config_table[j].curchnl & 0xf];
10700  }
10701  *p = '\0';
10702  dbug(1, dprintf("[%06lx] CURRENT %s",
10703  (dword)(UnMapController(a->Id)), (char *)hex_line));
10704  p = hex_line;
10705  for (j = 0; j < n; j++)
10706  {
10707  if ((j & 0x7) == 0)
10708  *(p++) = ' ';
10709  *(p++) = hex_digit_table[li_config_table[j].channel >> 4];
10710  *(p++) = hex_digit_table[li_config_table[j].channel & 0xf];
10711  }
10712  *p = '\0';
10713  dbug(1, dprintf("[%06lx] CHANNEL %s",
10714  (dword)(UnMapController(a->Id)), (char *)hex_line));
10715  p = hex_line;
10716  for (j = 0; j < n; j++)
10717  {
10718  if ((j & 0x7) == 0)
10719  *(p++) = ' ';
10720  *(p++) = hex_digit_table[li_config_table[j].chflags >> 4];
10721  *(p++) = hex_digit_table[li_config_table[j].chflags & 0xf];
10722  }
10723  *p = '\0';
10724  dbug(1, dprintf("[%06lx] CHFLAG %s",
10725  (dword)(UnMapController(a->Id)), (char *)hex_line));
10726  for (i = 0; i < n; i++)
10727  {
10728  p = hex_line;
10729  for (j = 0; j < n; j++)
10730  {
10731  if ((j & 0x7) == 0)
10732  *(p++) = ' ';
10733  *(p++) = hex_digit_table[li_config_table[i].flag_table[j] >> 4];
10734  *(p++) = hex_digit_table[li_config_table[i].flag_table[j] & 0xf];
10735  }
10736  *p = '\0';
10737  dbug(1, dprintf("[%06lx] FLAG[%02x]%s",
10738  (dword)(UnMapController(a->Id)), i, (char *)hex_line));
10739  }
10740  for (i = 0; i < n; i++)
10741  {
10742  p = hex_line;
10743  for (j = 0; j < n; j++)
10744  {
10745  if ((j & 0x7) == 0)
10746  *(p++) = ' ';
10747  *(p++) = hex_digit_table[li_config_table[i].coef_table[j] >> 4];
10748  *(p++) = hex_digit_table[li_config_table[i].coef_table[j] & 0xf];
10749  }
10750  *p = '\0';
10751  dbug(1, dprintf("[%06lx] COEF[%02x]%s",
10752  (dword)(UnMapController(a->Id)), i, (char *)hex_line));
10753  }
10754 }
10755 
10756 
10757 static struct
10758 {
10759  byte mask;
10760  byte line_flags;
10761 } mixer_write_prog_pri[] =
10762 {
10763  { LI_COEF_CH_CH, 0 },
10764  { LI_COEF_CH_PC, MIXER_COEF_LINE_TO_PC_FLAG },
10765  { LI_COEF_PC_CH, MIXER_COEF_LINE_FROM_PC_FLAG },
10766  { LI_COEF_PC_PC, MIXER_COEF_LINE_TO_PC_FLAG | MIXER_COEF_LINE_FROM_PC_FLAG }
10767 };
10768 
10769 static struct
10770 {
10771  byte from_ch;
10772  byte to_ch;
10773  byte mask;
10774  byte xconnect_override;
10775 } mixer_write_prog_bri[] =
10776 {
10777  { 0, 0, LI_COEF_CH_CH, 0x01 }, /* B to B */
10778  { 1, 0, LI_COEF_CH_CH, 0x01 }, /* Alt B to B */
10779  { 0, 0, LI_COEF_PC_CH, 0x80 }, /* PC to B */
10780  { 1, 0, LI_COEF_PC_CH, 0x01 }, /* Alt PC to B */
10781  { 2, 0, LI_COEF_CH_CH, 0x00 }, /* IC to B */
10782  { 3, 0, LI_COEF_CH_CH, 0x00 }, /* Alt IC to B */
10783  { 0, 0, LI_COEF_CH_PC, 0x80 }, /* B to PC */
10784  { 1, 0, LI_COEF_CH_PC, 0x01 }, /* Alt B to PC */
10785  { 0, 0, LI_COEF_PC_PC, 0x01 }, /* PC to PC */
10786  { 1, 0, LI_COEF_PC_PC, 0x01 }, /* Alt PC to PC */
10787  { 2, 0, LI_COEF_CH_PC, 0x00 }, /* IC to PC */
10788  { 3, 0, LI_COEF_CH_PC, 0x00 }, /* Alt IC to PC */
10789  { 0, 2, LI_COEF_CH_CH, 0x00 }, /* B to IC */
10790  { 1, 2, LI_COEF_CH_CH, 0x00 }, /* Alt B to IC */
10791  { 0, 2, LI_COEF_PC_CH, 0x00 }, /* PC to IC */
10792  { 1, 2, LI_COEF_PC_CH, 0x00 }, /* Alt PC to IC */
10793  { 2, 2, LI_COEF_CH_CH, 0x00 }, /* IC to IC */
10794  { 3, 2, LI_COEF_CH_CH, 0x00 }, /* Alt IC to IC */
10795  { 1, 1, LI_COEF_CH_CH, 0x01 }, /* Alt B to Alt B */
10796  { 0, 1, LI_COEF_CH_CH, 0x01 }, /* B to Alt B */
10797  { 1, 1, LI_COEF_PC_CH, 0x80 }, /* Alt PC to Alt B */
10798  { 0, 1, LI_COEF_PC_CH, 0x01 }, /* PC to Alt B */
10799  { 3, 1, LI_COEF_CH_CH, 0x00 }, /* Alt IC to Alt B */
10800  { 2, 1, LI_COEF_CH_CH, 0x00 }, /* IC to Alt B */
10801  { 1, 1, LI_COEF_CH_PC, 0x80 }, /* Alt B to Alt PC */
10802  { 0, 1, LI_COEF_CH_PC, 0x01 }, /* B to Alt PC */
10803  { 1, 1, LI_COEF_PC_PC, 0x01 }, /* Alt PC to Alt PC */
10804  { 0, 1, LI_COEF_PC_PC, 0x01 }, /* PC to Alt PC */
10805  { 3, 1, LI_COEF_CH_PC, 0x00 }, /* Alt IC to Alt PC */
10806  { 2, 1, LI_COEF_CH_PC, 0x00 }, /* IC to Alt PC */
10807  { 1, 3, LI_COEF_CH_CH, 0x00 }, /* Alt B to Alt IC */
10808  { 0, 3, LI_COEF_CH_CH, 0x00 }, /* B to Alt IC */
10809  { 1, 3, LI_COEF_PC_CH, 0x00 }, /* Alt PC to Alt IC */
10810  { 0, 3, LI_COEF_PC_CH, 0x00 }, /* PC to Alt IC */
10811  { 3, 3, LI_COEF_CH_CH, 0x00 }, /* Alt IC to Alt IC */
10812  { 2, 3, LI_COEF_CH_CH, 0x00 } /* IC to Alt IC */
10813 };
10814 
10815 static byte mixer_swapped_index_bri[] =
10816 {
10817  18, /* B to B */
10818  19, /* Alt B to B */
10819  20, /* PC to B */
10820  21, /* Alt PC to B */
10821  22, /* IC to B */
10822  23, /* Alt IC to B */
10823  24, /* B to PC */
10824  25, /* Alt B to PC */
10825  26, /* PC to PC */
10826  27, /* Alt PC to PC */
10827  28, /* IC to PC */
10828  29, /* Alt IC to PC */
10829  30, /* B to IC */
10830  31, /* Alt B to IC */
10831  32, /* PC to IC */
10832  33, /* Alt PC to IC */
10833  34, /* IC to IC */
10834  35, /* Alt IC to IC */
10835  0, /* Alt B to Alt B */
10836  1, /* B to Alt B */
10837  2, /* Alt PC to Alt B */
10838  3, /* PC to Alt B */
10839  4, /* Alt IC to Alt B */
10840  5, /* IC to Alt B */
10841  6, /* Alt B to Alt PC */
10842  7, /* B to Alt PC */
10843  8, /* Alt PC to Alt PC */
10844  9, /* PC to Alt PC */
10845  10, /* Alt IC to Alt PC */
10846  11, /* IC to Alt PC */
10847  12, /* Alt B to Alt IC */
10848  13, /* B to Alt IC */
10849  14, /* Alt PC to Alt IC */
10850  15, /* PC to Alt IC */
10851  16, /* Alt IC to Alt IC */
10852  17 /* IC to Alt IC */
10853 };
10854 
10855 static struct
10856 {
10857  byte mask;
10858  byte from_pc;
10859  byte to_pc;
10860 } xconnect_write_prog[] =
10861 {
10862  { LI_COEF_CH_CH, false, false },
10863  { LI_COEF_CH_PC, false, true },
10864  { LI_COEF_PC_CH, true, false },
10865  { LI_COEF_PC_PC, true, true }
10866 };
10867 
10868 
10869 static void xconnect_query_addresses(PLCI *plci)
10870 {
10871  DIVA_CAPI_ADAPTER *a;
10872  word w, ch;
10873  byte *p;
10874 
10875  dbug(1, dprintf("[%06lx] %s,%d: xconnect_query_addresses",
10876  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10877  (char *)(FILE_), __LINE__));
10878 
10879  a = plci->adapter;
10880  if (a->li_pri && ((plci->li_bchannel_id == 0)
10881  || (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci)))
10882  {
10883  dbug(1, dprintf("[%06x] %s,%d: Channel id wiped out",
10884  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10885  (char *)(FILE_), __LINE__));
10886  return;
10887  }
10888  p = plci->internal_req_buffer;
10889  ch = (a->li_pri) ? plci->li_bchannel_id - 1 : 0;
10890  *(p++) = UDATA_REQUEST_XCONNECT_FROM;
10891  w = ch;
10892  *(p++) = (byte) w;
10893  *(p++) = (byte)(w >> 8);
10894  w = ch | XCONNECT_CHANNEL_PORT_PC;
10895  *(p++) = (byte) w;
10896  *(p++) = (byte)(w >> 8);
10897  plci->NData[0].P = plci->internal_req_buffer;
10898  plci->NData[0].PLength = p - plci->internal_req_buffer;
10899  plci->NL.X = plci->NData;
10900  plci->NL.ReqCh = 0;
10901  plci->NL.Req = plci->nl_req = (byte) N_UDATA;
10902  plci->adapter->request(&plci->NL);
10903 }
10904 
10905 
10906 static void xconnect_write_coefs(PLCI *plci, word internal_command)
10907 {
10908 
10909  dbug(1, dprintf("[%06lx] %s,%d: xconnect_write_coefs %04x",
10910  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10911  (char *)(FILE_), __LINE__, internal_command));
10912 
10913  plci->li_write_command = internal_command;
10914  plci->li_write_channel = 0;
10915 }
10916 
10917 
10918 static byte xconnect_write_coefs_process(dword Id, PLCI *plci, byte Rc)
10919 {
10920  DIVA_CAPI_ADAPTER *a;
10921  word w, n, i, j, r, s, to_ch;
10922  dword d;
10923  byte *p;
10924  struct xconnect_transfer_address_s *transfer_address;
10925  byte ch_map[MIXER_CHANNELS_BRI];
10926 
10927  dbug(1, dprintf("[%06x] %s,%d: xconnect_write_coefs_process %02x %d",
10928  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->li_write_channel));
10929 
10930  a = plci->adapter;
10931  if ((plci->li_bchannel_id == 0)
10932  || (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci))
10933  {
10934  dbug(1, dprintf("[%06x] %s,%d: Channel id wiped out",
10935  UnMapId(Id), (char *)(FILE_), __LINE__));
10936  return (true);
10937  }
10938  i = a->li_base + (plci->li_bchannel_id - 1);
10939  j = plci->li_write_channel;
10940  p = plci->internal_req_buffer;
10941  if (j != 0)
10942  {
10943  if ((Rc != OK) && (Rc != OK_FC))
10944  {
10945  dbug(1, dprintf("[%06lx] %s,%d: LI write coefs failed %02x",
10946  UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
10947  return (false);
10948  }
10949  }
10950  if (li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
10951  {
10952  r = 0;
10953  s = 0;
10954  if (j < li_total_channels)
10955  {
10956  if (li_config_table[i].channel & LI_CHANNEL_ADDRESSES_SET)
10957  {
10958  s = ((li_config_table[i].send_b.card_address.low | li_config_table[i].send_b.card_address.high) ?
10959  (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_PC | LI_COEF_PC_PC)) &
10960  ((li_config_table[i].send_pc.card_address.low | li_config_table[i].send_pc.card_address.high) ?
10961  (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_PC_CH));
10962  }
10963  r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
10964  while ((j < li_total_channels)
10965  && ((r == 0)
10966  || (!(li_config_table[j].channel & LI_CHANNEL_ADDRESSES_SET))
10967  || (!li_config_table[j].adapter->li_pri
10968  && (j >= li_config_table[j].adapter->li_base + MIXER_BCHANNELS_BRI))
10969  || (((li_config_table[j].send_b.card_address.low != li_config_table[i].send_b.card_address.low)
10970  || (li_config_table[j].send_b.card_address.high != li_config_table[i].send_b.card_address.high))
10971  && (!(a->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)
10972  || !(li_config_table[j].adapter->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)))
10973  || ((li_config_table[j].adapter->li_base != a->li_base)
10974  && !(r & s &
10975  ((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ?
10976  (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) &
10977  ((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ?
10978  (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC))))))
10979  {
10980  j++;
10981  if (j < li_total_channels)
10982  r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
10983  }
10984  }
10985  if (j < li_total_channels)
10986  {
10987  plci->internal_command = plci->li_write_command;
10988  if (plci_nl_busy(plci))
10989  return (true);
10990  to_ch = (a->li_pri) ? plci->li_bchannel_id - 1 : 0;
10991  *(p++) = UDATA_REQUEST_XCONNECT_TO;
10992  do
10993  {
10994  if (li_config_table[j].adapter->li_base != a->li_base)
10995  {
10996  r &= s &
10997  ((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ?
10998  (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) &
10999  ((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ?
11000  (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC));
11001  }
11002  n = 0;
11003  do
11004  {
11005  if (r & xconnect_write_prog[n].mask)
11006  {
11007  if (xconnect_write_prog[n].from_pc)
11008  transfer_address = &(li_config_table[j].send_pc);
11009  else
11010  transfer_address = &(li_config_table[j].send_b);
11011  d = transfer_address->card_address.low;
11012  *(p++) = (byte) d;
11013  *(p++) = (byte)(d >> 8);
11014  *(p++) = (byte)(d >> 16);
11015  *(p++) = (byte)(d >> 24);
11016  d = transfer_address->card_address.high;
11017  *(p++) = (byte) d;
11018  *(p++) = (byte)(d >> 8);
11019  *(p++) = (byte)(d >> 16);
11020  *(p++) = (byte)(d >> 24);
11021  d = transfer_address->offset;
11022  *(p++) = (byte) d;
11023  *(p++) = (byte)(d >> 8);
11024  *(p++) = (byte)(d >> 16);
11025  *(p++) = (byte)(d >> 24);
11026  w = xconnect_write_prog[n].to_pc ? to_ch | XCONNECT_CHANNEL_PORT_PC : to_ch;
11027  *(p++) = (byte) w;
11028  *(p++) = (byte)(w >> 8);
11029  w = ((li_config_table[i].coef_table[j] & xconnect_write_prog[n].mask) == 0) ? 0x01 :
11030  (li_config_table[i].adapter->u_law ?
11031  (li_config_table[j].adapter->u_law ? 0x80 : 0x86) :
11032  (li_config_table[j].adapter->u_law ? 0x7a : 0x80));
11033  *(p++) = (byte) w;
11034  *(p++) = (byte) 0;
11035  li_config_table[i].coef_table[j] ^= xconnect_write_prog[n].mask << 4;
11036  }
11037  n++;
11038  } while ((n < ARRAY_SIZE(xconnect_write_prog))
11039  && ((p - plci->internal_req_buffer) + 16 < INTERNAL_REQ_BUFFER_SIZE));
11040  if (n == ARRAY_SIZE(xconnect_write_prog))
11041  {
11042  do
11043  {
11044  j++;
11045  if (j < li_total_channels)
11046  r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
11047  } while ((j < li_total_channels)
11048  && ((r == 0)
11049  || (!(li_config_table[j].channel & LI_CHANNEL_ADDRESSES_SET))
11050  || (!li_config_table[j].adapter->li_pri
11051  && (j >= li_config_table[j].adapter->li_base + MIXER_BCHANNELS_BRI))
11052  || (((li_config_table[j].send_b.card_address.low != li_config_table[i].send_b.card_address.low)
11053  || (li_config_table[j].send_b.card_address.high != li_config_table[i].send_b.card_address.high))
11054  && (!(a->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)
11055  || !(li_config_table[j].adapter->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)))
11056  || ((li_config_table[j].adapter->li_base != a->li_base)
11057  && !(r & s &
11058  ((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ?
11059  (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) &
11060  ((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ?
11061  (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC))))));
11062  }
11063  } while ((j < li_total_channels)
11064  && ((p - plci->internal_req_buffer) + 16 < INTERNAL_REQ_BUFFER_SIZE));
11065  }
11066  else if (j == li_total_channels)
11067  {
11068  plci->internal_command = plci->li_write_command;
11069  if (plci_nl_busy(plci))
11070  return (true);
11071  if (a->li_pri)
11072  {
11073  *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_PRI_SYNC;
11074  w = 0;
11075  if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
11076  w |= MIXER_FEATURE_ENABLE_TX_DATA;
11077  if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
11078  w |= MIXER_FEATURE_ENABLE_RX_DATA;
11079  *(p++) = (byte) w;
11080  *(p++) = (byte)(w >> 8);
11081  }
11082  else
11083  {
11084  *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_BRI;
11085  w = 0;
11086  if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI)
11087  && (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length))
11088  {
11089  w = GET_WORD(a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE);
11090  }
11091  if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
11092  w |= MIXER_FEATURE_ENABLE_TX_DATA;
11093  if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
11094  w |= MIXER_FEATURE_ENABLE_RX_DATA;
11095  *(p++) = (byte) w;
11096  *(p++) = (byte)(w >> 8);
11097  for (j = 0; j < sizeof(ch_map); j += 2)
11098  {
11099  if (plci->li_bchannel_id == 2)
11100  {
11101  ch_map[j] = (byte)(j + 1);
11102  ch_map[j + 1] = (byte) j;
11103  }
11104  else
11105  {
11106  ch_map[j] = (byte) j;
11107  ch_map[j + 1] = (byte)(j + 1);
11108  }
11109  }
11110  for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++)
11111  {
11112  i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch];
11113  j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch];
11114  if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED)
11115  {
11116  *p = (mixer_write_prog_bri[n].xconnect_override != 0) ?
11117  mixer_write_prog_bri[n].xconnect_override :
11118  ((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01);
11119  if ((i >= a->li_base + MIXER_BCHANNELS_BRI) || (j >= a->li_base + MIXER_BCHANNELS_BRI))
11120  {
11121  w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
11122  li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4;
11123  }
11124  }
11125  else
11126  {
11127  *p = 0x00;
11128  if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI->tel == ADV_VOICE))
11129  {
11130  w = (plci == a->AdvSignalPLCI) ? n : mixer_swapped_index_bri[n];
11131  if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w < a->adv_voice_coef_length)
11132  *p = a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w];
11133  }
11134  }
11135  p++;
11136  }
11137  }
11138  j = li_total_channels + 1;
11139  }
11140  }
11141  else
11142  {
11143  if (j <= li_total_channels)
11144  {
11145  plci->internal_command = plci->li_write_command;
11146  if (plci_nl_busy(plci))
11147  return (true);
11148  if (j < a->li_base)
11149  j = a->li_base;
11150  if (a->li_pri)
11151  {
11152  *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_PRI_SYNC;
11153  w = 0;
11154  if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
11155  w |= MIXER_FEATURE_ENABLE_TX_DATA;
11156  if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
11157  w |= MIXER_FEATURE_ENABLE_RX_DATA;
11158  *(p++) = (byte) w;
11159  *(p++) = (byte)(w >> 8);
11160  for (n = 0; n < ARRAY_SIZE(mixer_write_prog_pri); n++)
11161  {
11162  *(p++) = (byte)((plci->li_bchannel_id - 1) | mixer_write_prog_pri[n].line_flags);
11163  for (j = a->li_base; j < a->li_base + MIXER_CHANNELS_PRI; j++)
11164  {
11165  w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
11166  if (w & mixer_write_prog_pri[n].mask)
11167  {
11168  *(p++) = (li_config_table[i].coef_table[j] & mixer_write_prog_pri[n].mask) ? 0x80 : 0x01;
11169  li_config_table[i].coef_table[j] ^= mixer_write_prog_pri[n].mask << 4;
11170  }
11171  else
11172  *(p++) = 0x00;
11173  }
11174  *(p++) = (byte)((plci->li_bchannel_id - 1) | MIXER_COEF_LINE_ROW_FLAG | mixer_write_prog_pri[n].line_flags);
11175  for (j = a->li_base; j < a->li_base + MIXER_CHANNELS_PRI; j++)
11176  {
11177  w = ((li_config_table[j].coef_table[i] & 0xf) ^ (li_config_table[j].coef_table[i] >> 4));
11178  if (w & mixer_write_prog_pri[n].mask)
11179  {
11180  *(p++) = (li_config_table[j].coef_table[i] & mixer_write_prog_pri[n].mask) ? 0x80 : 0x01;
11181  li_config_table[j].coef_table[i] ^= mixer_write_prog_pri[n].mask << 4;
11182  }
11183  else
11184  *(p++) = 0x00;
11185  }
11186  }
11187  }
11188  else
11189  {
11190  *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_BRI;
11191  w = 0;
11192  if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI)
11193  && (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length))
11194  {
11195  w = GET_WORD(a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE);
11196  }
11197  if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
11198  w |= MIXER_FEATURE_ENABLE_TX_DATA;
11199  if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
11200  w |= MIXER_FEATURE_ENABLE_RX_DATA;
11201  *(p++) = (byte) w;
11202  *(p++) = (byte)(w >> 8);
11203  for (j = 0; j < sizeof(ch_map); j += 2)
11204  {
11205  if (plci->li_bchannel_id == 2)
11206  {
11207  ch_map[j] = (byte)(j + 1);
11208  ch_map[j + 1] = (byte) j;
11209  }
11210  else
11211  {
11212  ch_map[j] = (byte) j;
11213  ch_map[j + 1] = (byte)(j + 1);
11214  }
11215  }
11216  for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++)
11217  {
11218  i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch];
11219  j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch];
11220  if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED)
11221  {
11222  *p = ((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01);
11223  w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
11224  li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4;
11225  }
11226  else
11227  {
11228  *p = 0x00;
11229  if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI->tel == ADV_VOICE))
11230  {
11231  w = (plci == a->AdvSignalPLCI) ? n : mixer_swapped_index_bri[n];
11232  if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w < a->adv_voice_coef_length)
11233  *p = a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w];
11234  }
11235  }
11236  p++;
11237  }
11238  }
11239  j = li_total_channels + 1;
11240  }
11241  }
11242  plci->li_write_channel = j;
11243  if (p != plci->internal_req_buffer)
11244  {
11245  plci->NData[0].P = plci->internal_req_buffer;
11246  plci->NData[0].PLength = p - plci->internal_req_buffer;
11247  plci->NL.X = plci->NData;
11248  plci->NL.ReqCh = 0;
11249  plci->NL.Req = plci->nl_req = (byte) N_UDATA;
11250  plci->adapter->request(&plci->NL);
11251  }
11252  return (true);
11253 }
11254 
11255 
11256 static void mixer_notify_update(PLCI *plci, byte others)
11257 {
11258  DIVA_CAPI_ADAPTER *a;
11259  word i, w;
11260  PLCI *notify_plci;
11261  byte msg[sizeof(CAPI_MSG_HEADER) + 6];
11262 
11263  dbug(1, dprintf("[%06lx] %s,%d: mixer_notify_update %d",
11264  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
11265  (char *)(FILE_), __LINE__, others));
11266 
11267  a = plci->adapter;
11268  if (a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED)
11269  {
11270  if (others)
11271  plci->li_notify_update = true;
11272  i = 0;
11273  do
11274  {
11275  notify_plci = NULL;
11276  if (others)
11277  {
11278  while ((i < li_total_channels) && (li_config_table[i].plci == NULL))
11279  i++;
11280  if (i < li_total_channels)
11281  notify_plci = li_config_table[i++].plci;
11282  }
11283  else
11284  {
11285  if ((plci->li_bchannel_id != 0)
11286  && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11287  {
11288  notify_plci = plci;
11289  }
11290  }
11291  if ((notify_plci != NULL)
11292  && !notify_plci->li_notify_update
11293  && (notify_plci->appl != NULL)
11294  && (notify_plci->State)
11295  && notify_plci->NL.Id && !notify_plci->nl_remove_id)
11296  {
11297  notify_plci->li_notify_update = true;
11298  ((CAPI_MSG *) msg)->header.length = 18;
11299  ((CAPI_MSG *) msg)->header.appl_id = notify_plci->appl->Id;
11300  ((CAPI_MSG *) msg)->header.command = _FACILITY_R;
11301  ((CAPI_MSG *) msg)->header.number = 0;
11302  ((CAPI_MSG *) msg)->header.controller = notify_plci->adapter->Id;
11303  ((CAPI_MSG *) msg)->header.plci = notify_plci->Id;
11304  ((CAPI_MSG *) msg)->header.ncci = 0;
11305  ((CAPI_MSG *) msg)->info.facility_req.Selector = SELECTOR_LINE_INTERCONNECT;
11306  ((CAPI_MSG *) msg)->info.facility_req.structs[0] = 3;
11307  PUT_WORD(&(((CAPI_MSG *) msg)->info.facility_req.structs[1]), LI_REQ_SILENT_UPDATE);
11308  ((CAPI_MSG *) msg)->info.facility_req.structs[3] = 0;
11309  w = api_put(notify_plci->appl, (CAPI_MSG *) msg);
11310  if (w != _QUEUE_FULL)
11311  {
11312  if (w != 0)
11313  {
11314  dbug(1, dprintf("[%06lx] %s,%d: Interconnect notify failed %06x %d",
11315  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
11316  (char *)(FILE_), __LINE__,
11317  (dword)((notify_plci->Id << 8) | UnMapController(notify_plci->adapter->Id)), w));
11318  }
11319  notify_plci->li_notify_update = false;
11320  }
11321  }
11322  } while (others && (notify_plci != NULL));
11323  if (others)
11324  plci->li_notify_update = false;
11325  }
11326 }
11327 
11328 
11329 static void mixer_clear_config(PLCI *plci)
11330 {
11331  DIVA_CAPI_ADAPTER *a;
11332  word i, j;
11333 
11334  dbug(1, dprintf("[%06lx] %s,%d: mixer_clear_config",
11335  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
11336  (char *)(FILE_), __LINE__));
11337 
11338  plci->li_notify_update = false;
11339  plci->li_plci_b_write_pos = 0;
11340  plci->li_plci_b_read_pos = 0;
11341  plci->li_plci_b_req_pos = 0;
11342  a = plci->adapter;
11343  if ((plci->li_bchannel_id != 0)
11344  && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11345  {
11346  i = a->li_base + (plci->li_bchannel_id - 1);
11347  li_config_table[i].curchnl = 0;
11348  li_config_table[i].channel = 0;
11349  li_config_table[i].chflags = 0;
11350  for (j = 0; j < li_total_channels; j++)
11351  {
11352  li_config_table[j].flag_table[i] = 0;
11353  li_config_table[i].flag_table[j] = 0;
11354  li_config_table[i].coef_table[j] = 0;
11355  li_config_table[j].coef_table[i] = 0;
11356  }
11357  if (!a->li_pri)
11358  {
11359  li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET;
11360  if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
11361  {
11362  i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
11363  li_config_table[i].curchnl = 0;
11364  li_config_table[i].channel = 0;
11365  li_config_table[i].chflags = 0;
11366  for (j = 0; j < li_total_channels; j++)
11367  {
11368  li_config_table[i].flag_table[j] = 0;
11369  li_config_table[j].flag_table[i] = 0;
11370  li_config_table[i].coef_table[j] = 0;
11371  li_config_table[j].coef_table[i] = 0;
11372  }
11373  if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
11374  {
11375  i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
11376  li_config_table[i].curchnl = 0;
11377  li_config_table[i].channel = 0;
11378  li_config_table[i].chflags = 0;
11379  for (j = 0; j < li_total_channels; j++)
11380  {
11381  li_config_table[i].flag_table[j] = 0;
11382  li_config_table[j].flag_table[i] = 0;
11383  li_config_table[i].coef_table[j] = 0;
11384  li_config_table[j].coef_table[i] = 0;
11385  }
11386  }
11387  }
11388  }
11389  }
11390 }
11391 
11392 
11393 static void mixer_prepare_switch(dword Id, PLCI *plci)
11394 {
11395 
11396  dbug(1, dprintf("[%06lx] %s,%d: mixer_prepare_switch",
11397  UnMapId(Id), (char *)(FILE_), __LINE__));
11398 
11399  do
11400  {
11401  mixer_indication_coefs_set(Id, plci);
11402  } while (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos);
11403 }
11404 
11405 
11406 static word mixer_save_config(dword Id, PLCI *plci, byte Rc)
11407 {
11408  DIVA_CAPI_ADAPTER *a;
11409  word i, j;
11410 
11411  dbug(1, dprintf("[%06lx] %s,%d: mixer_save_config %02x %d",
11412  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
11413 
11414  a = plci->adapter;
11415  if ((plci->li_bchannel_id != 0)
11416  && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11417  {
11418  i = a->li_base + (plci->li_bchannel_id - 1);
11419  for (j = 0; j < li_total_channels; j++)
11420  {
11421  li_config_table[i].coef_table[j] &= 0xf;
11422  li_config_table[j].coef_table[i] &= 0xf;
11423  }
11424  if (!a->li_pri)
11425  li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET;
11426  }
11427  return (GOOD);
11428 }
11429 
11430 
11431 static word mixer_restore_config(dword Id, PLCI *plci, byte Rc)
11432 {
11433  DIVA_CAPI_ADAPTER *a;
11434  word Info;
11435 
11436  dbug(1, dprintf("[%06lx] %s,%d: mixer_restore_config %02x %d",
11437  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
11438 
11439  Info = GOOD;
11440  a = plci->adapter;
11441  if ((plci->B1_facilities & B1_FACILITY_MIXER)
11442  && (plci->li_bchannel_id != 0)
11443  && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11444  {
11445  switch (plci->adjust_b_state)
11446  {
11447  case ADJUST_B_RESTORE_MIXER_1:
11448  if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
11449  {
11450  plci->internal_command = plci->adjust_b_command;
11451  if (plci_nl_busy(plci))
11452  {
11453  plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_1;
11454  break;
11455  }
11456  xconnect_query_addresses(plci);
11457  plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_2;
11458  break;
11459  }
11460  plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5;
11461  Rc = OK;
11462  case ADJUST_B_RESTORE_MIXER_2:
11463  case ADJUST_B_RESTORE_MIXER_3:
11464  case ADJUST_B_RESTORE_MIXER_4:
11465  if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0))
11466  {
11467  dbug(1, dprintf("[%06lx] %s,%d: Adjust B query addresses failed %02x",
11468  UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
11469  Info = _WRONG_STATE;
11470  break;
11471  }
11472  if (Rc == OK)
11473  {
11474  if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2)
11475  plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_3;
11476  else if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_4)
11477  plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5;
11478  }
11479  else if (Rc == 0)
11480  {
11481  if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2)
11482  plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_4;
11483  else if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_3)
11484  plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5;
11485  }
11486  if (plci->adjust_b_state != ADJUST_B_RESTORE_MIXER_5)
11487  {
11488  plci->internal_command = plci->adjust_b_command;
11489  break;
11490  }
11491  case ADJUST_B_RESTORE_MIXER_5:
11492  xconnect_write_coefs(plci, plci->adjust_b_command);
11493  plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_6;
11494  Rc = OK;
11495  case ADJUST_B_RESTORE_MIXER_6:
11496  if (!xconnect_write_coefs_process(Id, plci, Rc))
11497  {
11498  dbug(1, dprintf("[%06lx] %s,%d: Write mixer coefs failed",
11499  UnMapId(Id), (char *)(FILE_), __LINE__));
11500  Info = _FACILITY_NOT_SUPPORTED;
11501  break;
11502  }
11503  if (plci->internal_command)
11504  break;
11505  plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_7;
11506  case ADJUST_B_RESTORE_MIXER_7:
11507  break;
11508  }
11509  }
11510  return (Info);
11511 }
11512 
11513 
11514 static void mixer_command(dword Id, PLCI *plci, byte Rc)
11515 {
11516  DIVA_CAPI_ADAPTER *a;
11517  word i, internal_command;
11518 
11519  dbug(1, dprintf("[%06lx] %s,%d: mixer_command %02x %04x %04x",
11520  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command,
11521  plci->li_cmd));
11522 
11523  a = plci->adapter;
11524  internal_command = plci->internal_command;
11525  plci->internal_command = 0;
11526  switch (plci->li_cmd)
11527  {
11528  case LI_REQ_CONNECT:
11529  case LI_REQ_DISCONNECT:
11530  case LI_REQ_SILENT_UPDATE:
11531  switch (internal_command)
11532  {
11533  default:
11534  if (plci->li_channel_bits & LI_CHANNEL_INVOLVED)
11535  {
11536  adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities |
11537  B1_FACILITY_MIXER), MIXER_COMMAND_1);
11538  }
11539  case MIXER_COMMAND_1:
11540  if (plci->li_channel_bits & LI_CHANNEL_INVOLVED)
11541  {
11542  if (adjust_b_process(Id, plci, Rc) != GOOD)
11543  {
11544  dbug(1, dprintf("[%06lx] %s,%d: Load mixer failed",
11545  UnMapId(Id), (char *)(FILE_), __LINE__));
11546  break;
11547  }
11548  if (plci->internal_command)
11549  return;
11550  }
11551  plci->li_plci_b_req_pos = plci->li_plci_b_write_pos;
11552  if ((plci->li_channel_bits & LI_CHANNEL_INVOLVED)
11553  || ((get_b1_facilities(plci, plci->B1_resource) & B1_FACILITY_MIXER)
11554  && (add_b1_facilities(plci, plci->B1_resource, (word)(plci->B1_facilities &
11555  ~B1_FACILITY_MIXER)) == plci->B1_resource)))
11556  {
11557  xconnect_write_coefs(plci, MIXER_COMMAND_2);
11558  }
11559  else
11560  {
11561  do
11562  {
11563  mixer_indication_coefs_set(Id, plci);
11564  } while (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos);
11565  }
11566  case MIXER_COMMAND_2:
11567  if ((plci->li_channel_bits & LI_CHANNEL_INVOLVED)
11568  || ((get_b1_facilities(plci, plci->B1_resource) & B1_FACILITY_MIXER)
11569  && (add_b1_facilities(plci, plci->B1_resource, (word)(plci->B1_facilities &
11570  ~B1_FACILITY_MIXER)) == plci->B1_resource)))
11571  {
11572  if (!xconnect_write_coefs_process(Id, plci, Rc))
11573  {
11574  dbug(1, dprintf("[%06lx] %s,%d: Write mixer coefs failed",
11575  UnMapId(Id), (char *)(FILE_), __LINE__));
11576  if (plci->li_plci_b_write_pos != plci->li_plci_b_req_pos)
11577  {
11578  do
11579  {
11580  plci->li_plci_b_write_pos = (plci->li_plci_b_write_pos == 0) ?
11581  LI_PLCI_B_QUEUE_ENTRIES - 1 : plci->li_plci_b_write_pos - 1;
11582  i = (plci->li_plci_b_write_pos == 0) ?
11583  LI_PLCI_B_QUEUE_ENTRIES - 1 : plci->li_plci_b_write_pos - 1;
11584  } while ((plci->li_plci_b_write_pos != plci->li_plci_b_req_pos)
11585  && !(plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG));
11586  }
11587  break;
11588  }
11589  if (plci->internal_command)
11590  return;
11591  }
11592  if (!(plci->li_channel_bits & LI_CHANNEL_INVOLVED))
11593  {
11594  adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities &
11595  ~B1_FACILITY_MIXER), MIXER_COMMAND_3);
11596  }
11597  case MIXER_COMMAND_3:
11598  if (!(plci->li_channel_bits & LI_CHANNEL_INVOLVED))
11599  {
11600  if (adjust_b_process(Id, plci, Rc) != GOOD)
11601  {
11602  dbug(1, dprintf("[%06lx] %s,%d: Unload mixer failed",
11603  UnMapId(Id), (char *)(FILE_), __LINE__));
11604  break;
11605  }
11606  if (plci->internal_command)
11607  return;
11608  }
11609  break;
11610  }
11611  break;
11612  }
11613  if ((plci->li_bchannel_id == 0)
11614  || (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci))
11615  {
11616  dbug(1, dprintf("[%06x] %s,%d: Channel id wiped out %d",
11617  UnMapId(Id), (char *)(FILE_), __LINE__, (int)(plci->li_bchannel_id)));
11618  }
11619  else
11620  {
11621  i = a->li_base + (plci->li_bchannel_id - 1);
11622  li_config_table[i].curchnl = plci->li_channel_bits;
11623  if (!a->li_pri && (plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
11624  {
11625  i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
11626  li_config_table[i].curchnl = plci->li_channel_bits;
11627  if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
11628  {
11629  i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
11630  li_config_table[i].curchnl = plci->li_channel_bits;
11631  }
11632  }
11633  }
11634 }
11635 
11636 
11637 static void li_update_connect(dword Id, DIVA_CAPI_ADAPTER *a, PLCI *plci,
11638  dword plci_b_id, byte connect, dword li_flags)
11639 {
11640  word i, ch_a, ch_a_v, ch_a_s, ch_b, ch_b_v, ch_b_s;
11641  PLCI *plci_b;
11642  DIVA_CAPI_ADAPTER *a_b;
11643 
11644  a_b = &(adapter[MapController((byte)(plci_b_id & 0x7f)) - 1]);
11645  plci_b = &(a_b->plci[((plci_b_id >> 8) & 0xff) - 1]);
11646  ch_a = a->li_base + (plci->li_bchannel_id - 1);
11647  if (!a->li_pri && (plci->tel == ADV_VOICE)
11648  && (plci == a->AdvSignalPLCI) && (Id & EXT_CONTROLLER))
11649  {
11650  ch_a_v = ch_a + MIXER_IC_CHANNEL_BASE;
11651  ch_a_s = (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11652  a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id) : ch_a_v;
11653  }
11654  else
11655  {
11656  ch_a_v = ch_a;
11657  ch_a_s = ch_a;
11658  }
11659  ch_b = a_b->li_base + (plci_b->li_bchannel_id - 1);
11660  if (!a_b->li_pri && (plci_b->tel == ADV_VOICE)
11661  && (plci_b == a_b->AdvSignalPLCI) && (plci_b_id & EXT_CONTROLLER))
11662  {
11663  ch_b_v = ch_b + MIXER_IC_CHANNEL_BASE;
11664  ch_b_s = (a_b->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11665  a_b->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci_b->li_bchannel_id) : ch_b_v;
11666  }
11667  else
11668  {
11669  ch_b_v = ch_b;
11670  ch_b_s = ch_b;
11671  }
11672  if (connect)
11673  {
11674  li_config_table[ch_a].flag_table[ch_a_v] &= ~LI_FLAG_MONITOR;
11675  li_config_table[ch_a].flag_table[ch_a_s] &= ~LI_FLAG_MONITOR;
11676  li_config_table[ch_a_v].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11677  li_config_table[ch_a_s].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11678  }
11679  li_config_table[ch_a].flag_table[ch_b_v] &= ~LI_FLAG_MONITOR;
11680  li_config_table[ch_a].flag_table[ch_b_s] &= ~LI_FLAG_MONITOR;
11681  li_config_table[ch_b_v].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11682  li_config_table[ch_b_s].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11683  if (ch_a_v == ch_b_v)
11684  {
11685  li_config_table[ch_a_v].flag_table[ch_b_v] &= ~LI_FLAG_CONFERENCE;
11686  li_config_table[ch_a_s].flag_table[ch_b_s] &= ~LI_FLAG_CONFERENCE;
11687  }
11688  else
11689  {
11690  if (li_config_table[ch_a_v].flag_table[ch_b_v] & LI_FLAG_CONFERENCE)
11691  {
11692  for (i = 0; i < li_total_channels; i++)
11693  {
11694  if (i != ch_a_v)
11695  li_config_table[ch_a_v].flag_table[i] &= ~LI_FLAG_CONFERENCE;
11696  }
11697  }
11698  if (li_config_table[ch_a_s].flag_table[ch_b_v] & LI_FLAG_CONFERENCE)
11699  {
11700  for (i = 0; i < li_total_channels; i++)
11701  {
11702  if (i != ch_a_s)
11703  li_config_table[ch_a_s].flag_table[i] &= ~LI_FLAG_CONFERENCE;
11704  }
11705  }
11706  if (li_config_table[ch_b_v].flag_table[ch_a_v] & LI_FLAG_CONFERENCE)
11707  {
11708  for (i = 0; i < li_total_channels; i++)
11709  {
11710  if (i != ch_a_v)
11711  li_config_table[i].flag_table[ch_a_v] &= ~LI_FLAG_CONFERENCE;
11712  }
11713  }
11714  if (li_config_table[ch_b_v].flag_table[ch_a_s] & LI_FLAG_CONFERENCE)
11715  {
11716  for (i = 0; i < li_total_channels; i++)
11717  {
11718  if (i != ch_a_s)
11719  li_config_table[i].flag_table[ch_a_s] &= ~LI_FLAG_CONFERENCE;
11720  }
11721  }
11722  }
11723  if (li_flags & LI_FLAG_CONFERENCE_A_B)
11724  {
11725  li_config_table[ch_b_v].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11726  li_config_table[ch_b_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11727  li_config_table[ch_b_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11728  li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11729  }
11730  if (li_flags & LI_FLAG_CONFERENCE_B_A)
11731  {
11732  li_config_table[ch_a_v].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11733  li_config_table[ch_a_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11734  li_config_table[ch_a_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11735  li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11736  }
11737  if (li_flags & LI_FLAG_MONITOR_A)
11738  {
11739  li_config_table[ch_a].flag_table[ch_a_v] |= LI_FLAG_MONITOR;
11740  li_config_table[ch_a].flag_table[ch_a_s] |= LI_FLAG_MONITOR;
11741  }
11742  if (li_flags & LI_FLAG_MONITOR_B)
11743  {
11744  li_config_table[ch_a].flag_table[ch_b_v] |= LI_FLAG_MONITOR;
11745  li_config_table[ch_a].flag_table[ch_b_s] |= LI_FLAG_MONITOR;
11746  }
11747  if (li_flags & LI_FLAG_ANNOUNCEMENT_A)
11748  {
11749  li_config_table[ch_a_v].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11750  li_config_table[ch_a_s].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11751  }
11752  if (li_flags & LI_FLAG_ANNOUNCEMENT_B)
11753  {
11754  li_config_table[ch_b_v].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11755  li_config_table[ch_b_s].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11756  }
11757  if (li_flags & LI_FLAG_MIX_A)
11758  {
11759  li_config_table[ch_a_v].flag_table[ch_a] |= LI_FLAG_MIX;
11760  li_config_table[ch_a_s].flag_table[ch_a] |= LI_FLAG_MIX;
11761  }
11762  if (li_flags & LI_FLAG_MIX_B)
11763  {
11764  li_config_table[ch_b_v].flag_table[ch_a] |= LI_FLAG_MIX;
11765  li_config_table[ch_b_s].flag_table[ch_a] |= LI_FLAG_MIX;
11766  }
11767  if (ch_a_v != ch_a_s)
11768  {
11769  li_config_table[ch_a_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11770  li_config_table[ch_a_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11771  }
11772  if (ch_b_v != ch_b_s)
11773  {
11774  li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11775  li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11776  }
11777 }
11778 
11779 
11780 static void li2_update_connect(dword Id, DIVA_CAPI_ADAPTER *a, PLCI *plci,
11781  dword plci_b_id, byte connect, dword li_flags)
11782 {
11783  word ch_a, ch_a_v, ch_a_s, ch_b, ch_b_v, ch_b_s;
11784  PLCI *plci_b;
11785  DIVA_CAPI_ADAPTER *a_b;
11786 
11787  a_b = &(adapter[MapController((byte)(plci_b_id & 0x7f)) - 1]);
11788  plci_b = &(a_b->plci[((plci_b_id >> 8) & 0xff) - 1]);
11789  ch_a = a->li_base + (plci->li_bchannel_id - 1);
11790  if (!a->li_pri && (plci->tel == ADV_VOICE)
11791  && (plci == a->AdvSignalPLCI) && (Id & EXT_CONTROLLER))
11792  {
11793  ch_a_v = ch_a + MIXER_IC_CHANNEL_BASE;
11794  ch_a_s = (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11795  a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id) : ch_a_v;
11796  }
11797  else
11798  {
11799  ch_a_v = ch_a;
11800  ch_a_s = ch_a;
11801  }
11802  ch_b = a_b->li_base + (plci_b->li_bchannel_id - 1);
11803  if (!a_b->li_pri && (plci_b->tel == ADV_VOICE)
11804  && (plci_b == a_b->AdvSignalPLCI) && (plci_b_id & EXT_CONTROLLER))
11805  {
11806  ch_b_v = ch_b + MIXER_IC_CHANNEL_BASE;
11807  ch_b_s = (a_b->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11808  a_b->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci_b->li_bchannel_id) : ch_b_v;
11809  }
11810  else
11811  {
11812  ch_b_v = ch_b;
11813  ch_b_s = ch_b;
11814  }
11815  if (connect)
11816  {
11817  li_config_table[ch_b].flag_table[ch_b_v] &= ~LI_FLAG_MONITOR;
11818  li_config_table[ch_b].flag_table[ch_b_s] &= ~LI_FLAG_MONITOR;
11819  li_config_table[ch_b_v].flag_table[ch_b] &= ~LI_FLAG_MIX;
11820  li_config_table[ch_b_s].flag_table[ch_b] &= ~LI_FLAG_MIX;
11821  li_config_table[ch_b].flag_table[ch_b] &= ~LI_FLAG_PCCONNECT;
11822  li_config_table[ch_b].chflags &= ~(LI_CHFLAG_MONITOR | LI_CHFLAG_MIX | LI_CHFLAG_LOOP);
11823  }
11824  li_config_table[ch_b_v].flag_table[ch_a_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11825  li_config_table[ch_b_s].flag_table[ch_a_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11826  li_config_table[ch_b_v].flag_table[ch_a_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11827  li_config_table[ch_b_s].flag_table[ch_a_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11828  li_config_table[ch_a_v].flag_table[ch_b_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11829  li_config_table[ch_a_v].flag_table[ch_b_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11830  li_config_table[ch_a_s].flag_table[ch_b_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11831  li_config_table[ch_a_s].flag_table[ch_b_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11832  if (li_flags & LI2_FLAG_INTERCONNECT_A_B)
11833  {
11834  li_config_table[ch_b_v].flag_table[ch_a_v] |= LI_FLAG_INTERCONNECT;
11835  li_config_table[ch_b_s].flag_table[ch_a_v] |= LI_FLAG_INTERCONNECT;
11836  li_config_table[ch_b_v].flag_table[ch_a_s] |= LI_FLAG_INTERCONNECT;
11837  li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_INTERCONNECT;
11838  }
11839  if (li_flags & LI2_FLAG_INTERCONNECT_B_A)
11840  {
11841  li_config_table[ch_a_v].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11842  li_config_table[ch_a_v].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11843  li_config_table[ch_a_s].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11844  li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11845  }
11846  if (li_flags & LI2_FLAG_MONITOR_B)
11847  {
11848  li_config_table[ch_b].flag_table[ch_b_v] |= LI_FLAG_MONITOR;
11849  li_config_table[ch_b].flag_table[ch_b_s] |= LI_FLAG_MONITOR;
11850  }
11851  if (li_flags & LI2_FLAG_MIX_B)
11852  {
11853  li_config_table[ch_b_v].flag_table[ch_b] |= LI_FLAG_MIX;
11854  li_config_table[ch_b_s].flag_table[ch_b] |= LI_FLAG_MIX;
11855  }
11856  if (li_flags & LI2_FLAG_MONITOR_X)
11857  li_config_table[ch_b].chflags |= LI_CHFLAG_MONITOR;
11858  if (li_flags & LI2_FLAG_MIX_X)
11859  li_config_table[ch_b].chflags |= LI_CHFLAG_MIX;
11860  if (li_flags & LI2_FLAG_LOOP_B)
11861  {
11862  li_config_table[ch_b_v].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11863  li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11864  li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11865  li_config_table[ch_b_s].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11866  }
11867  if (li_flags & LI2_FLAG_LOOP_PC)
11868  li_config_table[ch_b].flag_table[ch_b] |= LI_FLAG_PCCONNECT;
11869  if (li_flags & LI2_FLAG_LOOP_X)
11870  li_config_table[ch_b].chflags |= LI_CHFLAG_LOOP;
11871  if (li_flags & LI2_FLAG_PCCONNECT_A_B)
11872  li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_PCCONNECT;
11873  if (li_flags & LI2_FLAG_PCCONNECT_B_A)
11874  li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_PCCONNECT;
11875  if (ch_a_v != ch_a_s)
11876  {
11877  li_config_table[ch_a_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11878  li_config_table[ch_a_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11879  }
11880  if (ch_b_v != ch_b_s)
11881  {
11882  li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11883  li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11884  }
11885 }
11886 
11887 
11888 static word li_check_main_plci(dword Id, PLCI *plci)
11889 {
11890  if (plci == NULL)
11891  {
11892  dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI",
11893  UnMapId(Id), (char *)(FILE_), __LINE__));
11894  return (_WRONG_IDENTIFIER);
11895  }
11896  if (!plci->State
11897  || !plci->NL.Id || plci->nl_remove_id
11898  || (plci->li_bchannel_id == 0))
11899  {
11900  dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
11901  UnMapId(Id), (char *)(FILE_), __LINE__));
11902  return (_WRONG_STATE);
11903  }
11904  li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci = plci;
11905  return (GOOD);
11906 }
11907 
11908 
11909 static PLCI *li_check_plci_b(dword Id, PLCI *plci,
11910  dword plci_b_id, word plci_b_write_pos, byte *p_result)
11911 {
11912  byte ctlr_b;
11913  PLCI *plci_b;
11914 
11915  if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
11916  LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2)
11917  {
11918  dbug(1, dprintf("[%06lx] %s,%d: LI request overrun",
11919  UnMapId(Id), (char *)(FILE_), __LINE__));
11920  PUT_WORD(p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE);
11921  return (NULL);
11922  }
11923  ctlr_b = 0;
11924  if ((plci_b_id & 0x7f) != 0)
11925  {
11926  ctlr_b = MapController((byte)(plci_b_id & 0x7f));
11927  if ((ctlr_b > max_adapter) || ((ctlr_b != 0) && (adapter[ctlr_b - 1].request == NULL)))
11928  ctlr_b = 0;
11929  }
11930  if ((ctlr_b == 0)
11931  || (((plci_b_id >> 8) & 0xff) == 0)
11932  || (((plci_b_id >> 8) & 0xff) > adapter[ctlr_b - 1].max_plci))
11933  {
11934  dbug(1, dprintf("[%06lx] %s,%d: LI invalid second PLCI %08lx",
11935  UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
11936  PUT_WORD(p_result, _WRONG_IDENTIFIER);
11937  return (NULL);
11938  }
11939  plci_b = &(adapter[ctlr_b - 1].plci[((plci_b_id >> 8) & 0xff) - 1]);
11940  if (!plci_b->State
11941  || !plci_b->NL.Id || plci_b->nl_remove_id
11942  || (plci_b->li_bchannel_id == 0))
11943  {
11944  dbug(1, dprintf("[%06lx] %s,%d: LI peer in wrong state %08lx",
11945  UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
11946  PUT_WORD(p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE);
11947  return (NULL);
11948  }
11949  li_config_table[plci_b->adapter->li_base + (plci_b->li_bchannel_id - 1)].plci = plci_b;
11950  if (((byte)(plci_b_id & ~EXT_CONTROLLER)) !=
11951  ((byte)(UnMapController(plci->adapter->Id) & ~EXT_CONTROLLER))
11952  && (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
11953  || !(plci_b->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)))
11954  {
11955  dbug(1, dprintf("[%06lx] %s,%d: LI not on same ctrl %08lx",
11956  UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
11957  PUT_WORD(p_result, _WRONG_IDENTIFIER);
11958  return (NULL);
11959  }
11960  if (!(get_b1_facilities(plci_b, add_b1_facilities(plci_b, plci_b->B1_resource,
11961  (word)(plci_b->B1_facilities | B1_FACILITY_MIXER))) & B1_FACILITY_MIXER))
11962  {
11963  dbug(1, dprintf("[%06lx] %s,%d: Interconnect peer cannot mix %d",
11964  UnMapId(Id), (char *)(FILE_), __LINE__, plci_b->B1_resource));
11965  PUT_WORD(p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE);
11966  return (NULL);
11967  }
11968  return (plci_b);
11969 }
11970 
11971 
11972 static PLCI *li2_check_plci_b(dword Id, PLCI *plci,
11973  dword plci_b_id, word plci_b_write_pos, byte *p_result)
11974 {
11975  byte ctlr_b;
11976  PLCI *plci_b;
11977 
11978  if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
11979  LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2)
11980  {
11981  dbug(1, dprintf("[%06lx] %s,%d: LI request overrun",
11982  UnMapId(Id), (char *)(FILE_), __LINE__));
11983  PUT_WORD(p_result, _WRONG_STATE);
11984  return (NULL);
11985  }
11986  ctlr_b = 0;
11987  if ((plci_b_id & 0x7f) != 0)
11988  {
11989  ctlr_b = MapController((byte)(plci_b_id & 0x7f));
11990  if ((ctlr_b > max_adapter) || ((ctlr_b != 0) && (adapter[ctlr_b - 1].request == NULL)))
11991  ctlr_b = 0;
11992  }
11993  if ((ctlr_b == 0)
11994  || (((plci_b_id >> 8) & 0xff) == 0)
11995  || (((plci_b_id >> 8) & 0xff) > adapter[ctlr_b - 1].max_plci))
11996  {
11997  dbug(1, dprintf("[%06lx] %s,%d: LI invalid second PLCI %08lx",
11998  UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
11999  PUT_WORD(p_result, _WRONG_IDENTIFIER);
12000  return (NULL);
12001  }
12002  plci_b = &(adapter[ctlr_b - 1].plci[((plci_b_id >> 8) & 0xff) - 1]);
12003  if (!plci_b->State
12004  || !plci_b->NL.Id || plci_b->nl_remove_id
12005  || (plci_b->li_bchannel_id == 0)
12006  || (li_config_table[plci_b->adapter->li_base + (plci_b->li_bchannel_id - 1)].plci != plci_b))
12007  {
12008  dbug(1, dprintf("[%06lx] %s,%d: LI peer in wrong state %08lx",
12009  UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
12010  PUT_WORD(p_result, _WRONG_STATE);
12011  return (NULL);
12012  }
12013  if (((byte)(plci_b_id & ~EXT_CONTROLLER)) !=
12014  ((byte)(UnMapController(plci->adapter->Id) & ~EXT_CONTROLLER))
12015  && (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12016  || !(plci_b->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)))
12017  {
12018  dbug(1, dprintf("[%06lx] %s,%d: LI not on same ctrl %08lx",
12019  UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
12020  PUT_WORD(p_result, _WRONG_IDENTIFIER);
12021  return (NULL);
12022  }
12023  if (!(get_b1_facilities(plci_b, add_b1_facilities(plci_b, plci_b->B1_resource,
12024  (word)(plci_b->B1_facilities | B1_FACILITY_MIXER))) & B1_FACILITY_MIXER))
12025  {
12026  dbug(1, dprintf("[%06lx] %s,%d: Interconnect peer cannot mix %d",
12027  UnMapId(Id), (char *)(FILE_), __LINE__, plci_b->B1_resource));
12028  PUT_WORD(p_result, _WRONG_STATE);
12029  return (NULL);
12030  }
12031  return (plci_b);
12032 }
12033 
12034 
12035 static byte mixer_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg)
12036 {
12037  word Info;
12038  word i;
12039  dword d, li_flags, plci_b_id;
12040  PLCI *plci_b;
12041  API_PARSE li_parms[3];
12042  API_PARSE li_req_parms[3];
12043  API_PARSE li_participant_struct[2];
12044  API_PARSE li_participant_parms[3];
12045  word participant_parms_pos;
12046  byte result_buffer[32];
12047  byte *result;
12048  word result_pos;
12049  word plci_b_write_pos;
12050 
12051  dbug(1, dprintf("[%06lx] %s,%d: mixer_request",
12052  UnMapId(Id), (char *)(FILE_), __LINE__));
12053 
12054  Info = GOOD;
12055  result = result_buffer;
12056  result_buffer[0] = 0;
12057  if (!(a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED))
12058  {
12059  dbug(1, dprintf("[%06lx] %s,%d: Facility not supported",
12060  UnMapId(Id), (char *)(FILE_), __LINE__));
12061  Info = _FACILITY_NOT_SUPPORTED;
12062  }
12063  else if (api_parse(&msg[1].info[1], msg[1].length, "ws", li_parms))
12064  {
12065  dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12066  UnMapId(Id), (char *)(FILE_), __LINE__));
12067  Info = _WRONG_MESSAGE_FORMAT;
12068  }
12069  else
12070  {
12071  result_buffer[0] = 3;
12072  PUT_WORD(&result_buffer[1], GET_WORD(li_parms[0].info));
12073  result_buffer[3] = 0;
12074  switch (GET_WORD(li_parms[0].info))
12075  {
12076  case LI_GET_SUPPORTED_SERVICES:
12077  if (appl->appl_flags & APPL_FLAG_OLD_LI_SPEC)
12078  {
12079  result_buffer[0] = 17;
12080  result_buffer[3] = 14;
12081  PUT_WORD(&result_buffer[4], GOOD);
12082  d = 0;
12083  if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_CH)
12084  d |= LI_CONFERENCING_SUPPORTED;
12085  if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_PC)
12086  d |= LI_MONITORING_SUPPORTED;
12087  if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_CH)
12088  d |= LI_ANNOUNCEMENTS_SUPPORTED | LI_MIXING_SUPPORTED;
12089  if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12090  d |= LI_CROSS_CONTROLLER_SUPPORTED;
12091  PUT_DWORD(&result_buffer[6], d);
12092  if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12093  {
12094  d = 0;
12095  for (i = 0; i < li_total_channels; i++)
12096  {
12097  if ((li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12098  && (li_config_table[i].adapter->li_pri
12099  || (i < li_config_table[i].adapter->li_base + MIXER_BCHANNELS_BRI)))
12100  {
12101  d++;
12102  }
12103  }
12104  }
12105  else
12106  {
12107  d = a->li_pri ? a->li_channels : MIXER_BCHANNELS_BRI;
12108  }
12109  PUT_DWORD(&result_buffer[10], d / 2);
12110  PUT_DWORD(&result_buffer[14], d);
12111  }
12112  else
12113  {
12114  result_buffer[0] = 25;
12115  result_buffer[3] = 22;
12116  PUT_WORD(&result_buffer[4], GOOD);
12117  d = LI2_ASYMMETRIC_SUPPORTED | LI2_B_LOOPING_SUPPORTED | LI2_X_LOOPING_SUPPORTED;
12118  if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_PC)
12119  d |= LI2_MONITORING_SUPPORTED | LI2_REMOTE_MONITORING_SUPPORTED;
12120  if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_CH)
12121  d |= LI2_MIXING_SUPPORTED | LI2_REMOTE_MIXING_SUPPORTED;
12122  if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_PC)
12123  d |= LI2_PC_LOOPING_SUPPORTED;
12124  if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12125  d |= LI2_CROSS_CONTROLLER_SUPPORTED;
12126  PUT_DWORD(&result_buffer[6], d);
12127  d = a->li_pri ? a->li_channels : MIXER_BCHANNELS_BRI;
12128  PUT_DWORD(&result_buffer[10], d / 2);
12129  PUT_DWORD(&result_buffer[14], d - 1);
12130  if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12131  {
12132  d = 0;
12133  for (i = 0; i < li_total_channels; i++)
12134  {
12135  if ((li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12136  && (li_config_table[i].adapter->li_pri
12137  || (i < li_config_table[i].adapter->li_base + MIXER_BCHANNELS_BRI)))
12138  {
12139  d++;
12140  }
12141  }
12142  }
12143  PUT_DWORD(&result_buffer[18], d / 2);
12144  PUT_DWORD(&result_buffer[22], d - 1);
12145  }
12146  break;
12147 
12148  case LI_REQ_CONNECT:
12149  if (li_parms[1].length == 8)
12150  {
12151  appl->appl_flags |= APPL_FLAG_OLD_LI_SPEC;
12152  if (api_parse(&li_parms[1].info[1], li_parms[1].length, "dd", li_req_parms))
12153  {
12154  dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12155  UnMapId(Id), (char *)(FILE_), __LINE__));
12156  Info = _WRONG_MESSAGE_FORMAT;
12157  break;
12158  }
12159  plci_b_id = GET_DWORD(li_req_parms[0].info) & 0xffff;
12160  li_flags = GET_DWORD(li_req_parms[1].info);
12161  Info = li_check_main_plci(Id, plci);
12162  result_buffer[0] = 9;
12163  result_buffer[3] = 6;
12164  PUT_DWORD(&result_buffer[4], plci_b_id);
12165  PUT_WORD(&result_buffer[8], GOOD);
12166  if (Info != GOOD)
12167  break;
12168  result = plci->saved_msg.info;
12169  for (i = 0; i <= result_buffer[0]; i++)
12170  result[i] = result_buffer[i];
12171  plci_b_write_pos = plci->li_plci_b_write_pos;
12172  plci_b = li_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[8]);
12173  if (plci_b == NULL)
12174  break;
12175  li_update_connect(Id, a, plci, plci_b_id, true, li_flags);
12176  plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_LAST_FLAG;
12177  plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12178  plci->li_plci_b_write_pos = plci_b_write_pos;
12179  }
12180  else
12181  {
12182  appl->appl_flags &= ~APPL_FLAG_OLD_LI_SPEC;
12183  if (api_parse(&li_parms[1].info[1], li_parms[1].length, "ds", li_req_parms))
12184  {
12185  dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12186  UnMapId(Id), (char *)(FILE_), __LINE__));
12187  Info = _WRONG_MESSAGE_FORMAT;
12188  break;
12189  }
12190  li_flags = GET_DWORD(li_req_parms[0].info) & ~(LI2_FLAG_INTERCONNECT_A_B | LI2_FLAG_INTERCONNECT_B_A);
12191  Info = li_check_main_plci(Id, plci);
12192  result_buffer[0] = 7;
12193  result_buffer[3] = 4;
12194  PUT_WORD(&result_buffer[4], Info);
12195  result_buffer[6] = 0;
12196  if (Info != GOOD)
12197  break;
12198  result = plci->saved_msg.info;
12199  for (i = 0; i <= result_buffer[0]; i++)
12200  result[i] = result_buffer[i];
12201  plci_b_write_pos = plci->li_plci_b_write_pos;
12202  participant_parms_pos = 0;
12203  result_pos = 7;
12204  li2_update_connect(Id, a, plci, UnMapId(Id), true, li_flags);
12205  while (participant_parms_pos < li_req_parms[1].length)
12206  {
12207  result[result_pos] = 6;
12208  result_pos += 7;
12209  PUT_DWORD(&result[result_pos - 6], 0);
12210  PUT_WORD(&result[result_pos - 2], GOOD);
12211  if (api_parse(&li_req_parms[1].info[1 + participant_parms_pos],
12212  (word)(li_parms[1].length - participant_parms_pos), "s", li_participant_struct))
12213  {
12214  dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12215  UnMapId(Id), (char *)(FILE_), __LINE__));
12216  PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12217  break;
12218  }
12219  if (api_parse(&li_participant_struct[0].info[1],
12220  li_participant_struct[0].length, "dd", li_participant_parms))
12221  {
12222  dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12223  UnMapId(Id), (char *)(FILE_), __LINE__));
12224  PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12225  break;
12226  }
12227  plci_b_id = GET_DWORD(li_participant_parms[0].info) & 0xffff;
12228  li_flags = GET_DWORD(li_participant_parms[1].info);
12229  PUT_DWORD(&result[result_pos - 6], plci_b_id);
12230  if (sizeof(result) - result_pos < 7)
12231  {
12232  dbug(1, dprintf("[%06lx] %s,%d: LI result overrun",
12233  UnMapId(Id), (char *)(FILE_), __LINE__));
12234  PUT_WORD(&result[result_pos - 2], _WRONG_STATE);
12235  break;
12236  }
12237  plci_b = li2_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[result_pos - 2]);
12238  if (plci_b != NULL)
12239  {
12240  li2_update_connect(Id, a, plci, plci_b_id, true, li_flags);
12241  plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id |
12242  ((li_flags & (LI2_FLAG_INTERCONNECT_A_B | LI2_FLAG_INTERCONNECT_B_A |
12243  LI2_FLAG_PCCONNECT_A_B | LI2_FLAG_PCCONNECT_B_A)) ? 0 : LI_PLCI_B_DISC_FLAG);
12244  plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12245  }
12246  participant_parms_pos = (word)((&li_participant_struct[0].info[1 + li_participant_struct[0].length]) -
12247  (&li_req_parms[1].info[1]));
12248  }
12249  result[0] = (byte)(result_pos - 1);
12250  result[3] = (byte)(result_pos - 4);
12251  result[6] = (byte)(result_pos - 7);
12252  i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES - 1 : plci_b_write_pos - 1;
12253  if ((plci_b_write_pos == plci->li_plci_b_read_pos)
12254  || (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG))
12255  {
12256  plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_FLAG | LI_PLCI_B_LAST_FLAG;
12257  plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12258  }
12259  else
12260  plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG;
12261  plci->li_plci_b_write_pos = plci_b_write_pos;
12262  }
12263  mixer_calculate_coefs(a);
12264  plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel;
12265  mixer_notify_update(plci, true);
12266  sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
12267  "wwS", Info, SELECTOR_LINE_INTERCONNECT, result);
12268  plci->command = 0;
12269  plci->li_cmd = GET_WORD(li_parms[0].info);
12270  start_internal_command(Id, plci, mixer_command);
12271  return (false);
12272 
12273  case LI_REQ_DISCONNECT:
12274  if (li_parms[1].length == 4)
12275  {
12276  appl->appl_flags |= APPL_FLAG_OLD_LI_SPEC;
12277  if (api_parse(&li_parms[1].info[1], li_parms[1].length, "d", li_req_parms))
12278  {
12279  dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12280  UnMapId(Id), (char *)(FILE_), __LINE__));
12281  Info = _WRONG_MESSAGE_FORMAT;
12282  break;
12283  }
12284  plci_b_id = GET_DWORD(li_req_parms[0].info) & 0xffff;
12285  Info = li_check_main_plci(Id, plci);
12286  result_buffer[0] = 9;
12287  result_buffer[3] = 6;
12288  PUT_DWORD(&result_buffer[4], GET_DWORD(li_req_parms[0].info));
12289  PUT_WORD(&result_buffer[8], GOOD);
12290  if (Info != GOOD)
12291  break;
12292  result = plci->saved_msg.info;
12293  for (i = 0; i <= result_buffer[0]; i++)
12294  result[i] = result_buffer[i];
12295  plci_b_write_pos = plci->li_plci_b_write_pos;
12296  plci_b = li_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[8]);
12297  if (plci_b == NULL)
12298  break;
12299  li_update_connect(Id, a, plci, plci_b_id, false, 0);
12300  plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG | LI_PLCI_B_LAST_FLAG;
12301  plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12302  plci->li_plci_b_write_pos = plci_b_write_pos;
12303  }
12304  else
12305  {
12306  appl->appl_flags &= ~APPL_FLAG_OLD_LI_SPEC;
12307  if (api_parse(&li_parms[1].info[1], li_parms[1].length, "s", li_req_parms))
12308  {
12309  dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12310  UnMapId(Id), (char *)(FILE_), __LINE__));
12311  Info = _WRONG_MESSAGE_FORMAT;
12312  break;
12313  }
12314  Info = li_check_main_plci(Id, plci);
12315  result_buffer[0] = 7;
12316  result_buffer[3] = 4;
12317  PUT_WORD(&result_buffer[4], Info);
12318  result_buffer[6] = 0;
12319  if (Info != GOOD)
12320  break;
12321  result = plci->saved_msg.info;
12322  for (i = 0; i <= result_buffer[0]; i++)
12323  result[i] = result_buffer[i];
12324  plci_b_write_pos = plci->li_plci_b_write_pos;
12325  participant_parms_pos = 0;
12326  result_pos = 7;
12327  while (participant_parms_pos < li_req_parms[0].length)
12328  {
12329  result[result_pos] = 6;
12330  result_pos += 7;
12331  PUT_DWORD(&result[result_pos - 6], 0);
12332  PUT_WORD(&result[result_pos - 2], GOOD);
12333  if (api_parse(&li_req_parms[0].info[1 + participant_parms_pos],
12334  (word)(li_parms[1].length - participant_parms_pos), "s", li_participant_struct))
12335  {
12336  dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12337  UnMapId(Id), (char *)(FILE_), __LINE__));
12338  PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12339  break;
12340  }
12341  if (api_parse(&li_participant_struct[0].info[1],
12342  li_participant_struct[0].length, "d", li_participant_parms))
12343  {
12344  dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12345  UnMapId(Id), (char *)(FILE_), __LINE__));
12346  PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12347  break;
12348  }
12349  plci_b_id = GET_DWORD(li_participant_parms[0].info) & 0xffff;
12350  PUT_DWORD(&result[result_pos - 6], plci_b_id);
12351  if (sizeof(result) - result_pos < 7)
12352  {
12353  dbug(1, dprintf("[%06lx] %s,%d: LI result overrun",
12354  UnMapId(Id), (char *)(FILE_), __LINE__));
12355  PUT_WORD(&result[result_pos - 2], _WRONG_STATE);
12356  break;
12357  }
12358  plci_b = li2_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[result_pos - 2]);
12359  if (plci_b != NULL)
12360  {
12361  li2_update_connect(Id, a, plci, plci_b_id, false, 0);
12362  plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG;
12363  plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12364  }
12365  participant_parms_pos = (word)((&li_participant_struct[0].info[1 + li_participant_struct[0].length]) -
12366  (&li_req_parms[0].info[1]));
12367  }
12368  result[0] = (byte)(result_pos - 1);
12369  result[3] = (byte)(result_pos - 4);
12370  result[6] = (byte)(result_pos - 7);
12371  i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES - 1 : plci_b_write_pos - 1;
12372  if ((plci_b_write_pos == plci->li_plci_b_read_pos)
12373  || (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG))
12374  {
12375  plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_FLAG | LI_PLCI_B_LAST_FLAG;
12376  plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12377  }
12378  else
12379  plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG;
12380  plci->li_plci_b_write_pos = plci_b_write_pos;
12381  }
12382  mixer_calculate_coefs(a);
12383  plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel;
12384  mixer_notify_update(plci, true);
12385  sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
12386  "wwS", Info, SELECTOR_LINE_INTERCONNECT, result);
12387  plci->command = 0;
12388  plci->li_cmd = GET_WORD(li_parms[0].info);
12389  start_internal_command(Id, plci, mixer_command);
12390  return (false);
12391 
12392  case LI_REQ_SILENT_UPDATE:
12393  if (!plci || !plci->State
12394  || !plci->NL.Id || plci->nl_remove_id
12395  || (plci->li_bchannel_id == 0)
12396  || (li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci != plci))
12397  {
12398  dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
12399  UnMapId(Id), (char *)(FILE_), __LINE__));
12400  return (false);
12401  }
12402  plci_b_write_pos = plci->li_plci_b_write_pos;
12403  if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
12404  LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2)
12405  {
12406  dbug(1, dprintf("[%06lx] %s,%d: LI request overrun",
12407  UnMapId(Id), (char *)(FILE_), __LINE__));
12408  return (false);
12409  }
12410  i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES - 1 : plci_b_write_pos - 1;
12411  if ((plci_b_write_pos == plci->li_plci_b_read_pos)
12412  || (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG))
12413  {
12414  plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_FLAG | LI_PLCI_B_LAST_FLAG;
12415  plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12416  }
12417  else
12418  plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG;
12419  plci->li_plci_b_write_pos = plci_b_write_pos;
12420  plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel;
12421  plci->command = 0;
12422  plci->li_cmd = GET_WORD(li_parms[0].info);
12423  start_internal_command(Id, plci, mixer_command);
12424  return (false);
12425 
12426  default:
12427  dbug(1, dprintf("[%06lx] %s,%d: LI unknown request %04x",
12428  UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(li_parms[0].info)));
12429  Info = _FACILITY_NOT_SUPPORTED;
12430  }
12431  }
12432  sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
12433  "wwS", Info, SELECTOR_LINE_INTERCONNECT, result);
12434  return (false);
12435 }
12436 
12437 
12438 static void mixer_indication_coefs_set(dword Id, PLCI *plci)
12439 {
12440  dword d;
12441  byte result[12];
12442 
12443  dbug(1, dprintf("[%06lx] %s,%d: mixer_indication_coefs_set",
12444  UnMapId(Id), (char *)(FILE_), __LINE__));
12445 
12446  if (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos)
12447  {
12448  do
12449  {
12450  d = plci->li_plci_b_queue[plci->li_plci_b_read_pos];
12451  if (!(d & LI_PLCI_B_SKIP_FLAG))
12452  {
12453  if (plci->appl->appl_flags & APPL_FLAG_OLD_LI_SPEC)
12454  {
12455  if (d & LI_PLCI_B_DISC_FLAG)
12456  {
12457  result[0] = 5;
12458  PUT_WORD(&result[1], LI_IND_DISCONNECT);
12459  result[3] = 2;
12460  PUT_WORD(&result[4], _LI_USER_INITIATED);
12461  }
12462  else
12463  {
12464  result[0] = 7;
12465  PUT_WORD(&result[1], LI_IND_CONNECT_ACTIVE);
12466  result[3] = 4;
12467  PUT_DWORD(&result[4], d & ~LI_PLCI_B_FLAG_MASK);
12468  }
12469  }
12470  else
12471  {
12472  if (d & LI_PLCI_B_DISC_FLAG)
12473  {
12474  result[0] = 9;
12475  PUT_WORD(&result[1], LI_IND_DISCONNECT);
12476  result[3] = 6;
12477  PUT_DWORD(&result[4], d & ~LI_PLCI_B_FLAG_MASK);
12478  PUT_WORD(&result[8], _LI_USER_INITIATED);
12479  }
12480  else
12481  {
12482  result[0] = 7;
12483  PUT_WORD(&result[1], LI_IND_CONNECT_ACTIVE);
12484  result[3] = 4;
12485  PUT_DWORD(&result[4], d & ~LI_PLCI_B_FLAG_MASK);
12486  }
12487  }
12488  sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0,
12489  "ws", SELECTOR_LINE_INTERCONNECT, result);
12490  }
12491  plci->li_plci_b_read_pos = (plci->li_plci_b_read_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ?
12492  0 : plci->li_plci_b_read_pos + 1;
12493  } while (!(d & LI_PLCI_B_LAST_FLAG) && (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos));
12494  }
12495 }
12496 
12497 
12498 static void mixer_indication_xconnect_from(dword Id, PLCI *plci, byte *msg, word length)
12499 {
12500  word i, j, ch;
12501  struct xconnect_transfer_address_s s, *p;
12502  DIVA_CAPI_ADAPTER *a;
12503 
12504  dbug(1, dprintf("[%06lx] %s,%d: mixer_indication_xconnect_from %d",
12505  UnMapId(Id), (char *)(FILE_), __LINE__, (int)length));
12506 
12507  a = plci->adapter;
12508  i = 1;
12509  for (i = 1; i < length; i += 16)
12510  {
12511  s.card_address.low = msg[i] | (msg[i + 1] << 8) | (((dword)(msg[i + 2])) << 16) | (((dword)(msg[i + 3])) << 24);
12512  s.card_address.high = msg[i + 4] | (msg[i + 5] << 8) | (((dword)(msg[i + 6])) << 16) | (((dword)(msg[i + 7])) << 24);
12513  s.offset = msg[i + 8] | (msg[i + 9] << 8) | (((dword)(msg[i + 10])) << 16) | (((dword)(msg[i + 11])) << 24);
12514  ch = msg[i + 12] | (msg[i + 13] << 8);
12515  j = ch & XCONNECT_CHANNEL_NUMBER_MASK;
12516  if (!a->li_pri && (plci->li_bchannel_id == 2))
12517  j = 1 - j;
12518  j += a->li_base;
12519  if (ch & XCONNECT_CHANNEL_PORT_PC)
12520  p = &(li_config_table[j].send_pc);
12521  else
12522  p = &(li_config_table[j].send_b);
12523  p->card_address.low = s.card_address.low;
12524  p->card_address.high = s.card_address.high;
12525  p->offset = s.offset;
12526  li_config_table[j].channel |= LI_CHANNEL_ADDRESSES_SET;
12527  }
12528  if (plci->internal_command_queue[0]
12529  && ((plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2)
12530  || (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_3)
12531  || (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_4)))
12532  {
12533  (*(plci->internal_command_queue[0]))(Id, plci, 0);
12534  if (!plci->internal_command)
12535  next_internal_command(Id, plci);
12536  }
12537  mixer_notify_update(plci, true);
12538 }
12539 
12540 
12541 static void mixer_indication_xconnect_to(dword Id, PLCI *plci, byte *msg, word length)
12542 {
12543 
12544  dbug(1, dprintf("[%06lx] %s,%d: mixer_indication_xconnect_to %d",
12545  UnMapId(Id), (char *)(FILE_), __LINE__, (int) length));
12546 
12547 }
12548 
12549 
12550 static byte mixer_notify_source_removed(PLCI *plci, dword plci_b_id)
12551 {
12552  word plci_b_write_pos;
12553 
12554  plci_b_write_pos = plci->li_plci_b_write_pos;
12555  if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
12556  LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 1)
12557  {
12558  dbug(1, dprintf("[%06lx] %s,%d: LI request overrun",
12559  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
12560  (char *)(FILE_), __LINE__));
12561  return (false);
12562  }
12563  plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG;
12564  plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12565  plci->li_plci_b_write_pos = plci_b_write_pos;
12566  return (true);
12567 }
12568 
12569 
12570 static void mixer_remove(PLCI *plci)
12571 {
12572  DIVA_CAPI_ADAPTER *a;
12573  PLCI *notify_plci;
12574  dword plci_b_id;
12575  word i, j;
12576 
12577  dbug(1, dprintf("[%06lx] %s,%d: mixer_remove",
12578  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
12579  (char *)(FILE_), __LINE__));
12580 
12581  a = plci->adapter;
12582  plci_b_id = (plci->Id << 8) | UnMapController(plci->adapter->Id);
12583  if (a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED)
12584  {
12585  if ((plci->li_bchannel_id != 0)
12586  && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
12587  {
12588  i = a->li_base + (plci->li_bchannel_id - 1);
12589  if ((li_config_table[i].curchnl | li_config_table[i].channel) & LI_CHANNEL_INVOLVED)
12590  {
12591  for (j = 0; j < li_total_channels; j++)
12592  {
12593  if ((li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
12594  || (li_config_table[j].flag_table[i] & LI_FLAG_INTERCONNECT))
12595  {
12596  notify_plci = li_config_table[j].plci;
12597  if ((notify_plci != NULL)
12598  && (notify_plci != plci)
12599  && (notify_plci->appl != NULL)
12600  && !(notify_plci->appl->appl_flags & APPL_FLAG_OLD_LI_SPEC)
12601  && (notify_plci->State)
12602  && notify_plci->NL.Id && !notify_plci->nl_remove_id)
12603  {
12604  mixer_notify_source_removed(notify_plci, plci_b_id);
12605  }
12606  }
12607  }
12608  mixer_clear_config(plci);
12609  mixer_calculate_coefs(a);
12610  mixer_notify_update(plci, true);
12611  }
12612  li_config_table[i].plci = NULL;
12613  plci->li_bchannel_id = 0;
12614  }
12615  }
12616 }
12617 
12618 
12619 /*------------------------------------------------------------------*/
12620 /* Echo canceller facilities */
12621 /*------------------------------------------------------------------*/
12622 
12623 
12624 static void ec_write_parameters(PLCI *plci)
12625 {
12626  word w;
12627  byte parameter_buffer[6];
12628 
12629  dbug(1, dprintf("[%06lx] %s,%d: ec_write_parameters",
12630  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
12631  (char *)(FILE_), __LINE__));
12632 
12633  parameter_buffer[0] = 5;
12634  parameter_buffer[1] = DSP_CTRL_SET_LEC_PARAMETERS;
12635  PUT_WORD(&parameter_buffer[2], plci->ec_idi_options);
12636  plci->ec_idi_options &= ~LEC_RESET_COEFFICIENTS;
12637  w = (plci->ec_tail_length == 0) ? 128 : plci->ec_tail_length;
12638  PUT_WORD(&parameter_buffer[4], w);
12639  add_p(plci, FTY, parameter_buffer);
12640  sig_req(plci, TEL_CTRL, 0);
12641  send_req(plci);
12642 }
12643 
12644 
12645 static void ec_clear_config(PLCI *plci)
12646 {
12647 
12648  dbug(1, dprintf("[%06lx] %s,%d: ec_clear_config",
12649  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
12650  (char *)(FILE_), __LINE__));
12651 
12652  plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER |
12653  LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING;
12654  plci->ec_tail_length = 0;
12655 }
12656 
12657 
12658 static void ec_prepare_switch(dword Id, PLCI *plci)
12659 {
12660 
12661  dbug(1, dprintf("[%06lx] %s,%d: ec_prepare_switch",
12662  UnMapId(Id), (char *)(FILE_), __LINE__));
12663 
12664 }
12665 
12666 
12667 static word ec_save_config(dword Id, PLCI *plci, byte Rc)
12668 {
12669 
12670  dbug(1, dprintf("[%06lx] %s,%d: ec_save_config %02x %d",
12671  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
12672 
12673  return (GOOD);
12674 }
12675 
12676 
12677 static word ec_restore_config(dword Id, PLCI *plci, byte Rc)
12678 {
12679  word Info;
12680 
12681  dbug(1, dprintf("[%06lx] %s,%d: ec_restore_config %02x %d",
12682  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
12683 
12684  Info = GOOD;
12685  if (plci->B1_facilities & B1_FACILITY_EC)
12686  {
12687  switch (plci->adjust_b_state)
12688  {
12689  case ADJUST_B_RESTORE_EC_1:
12690  plci->internal_command = plci->adjust_b_command;
12691  if (plci->sig_req)
12692  {
12693  plci->adjust_b_state = ADJUST_B_RESTORE_EC_1;
12694  break;
12695  }
12696  ec_write_parameters(plci);
12697  plci->adjust_b_state = ADJUST_B_RESTORE_EC_2;
12698  break;
12699  case ADJUST_B_RESTORE_EC_2:
12700  if ((Rc != OK) && (Rc != OK_FC))
12701  {
12702  dbug(1, dprintf("[%06lx] %s,%d: Restore EC failed %02x",
12703  UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
12704  Info = _WRONG_STATE;
12705  break;
12706  }
12707  break;
12708  }
12709  }
12710  return (Info);
12711 }
12712 
12713 
12714 static void ec_command(dword Id, PLCI *plci, byte Rc)
12715 {
12716  word internal_command, Info;
12717  byte result[8];
12718 
12719  dbug(1, dprintf("[%06lx] %s,%d: ec_command %02x %04x %04x %04x %d",
12720  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command,
12721  plci->ec_cmd, plci->ec_idi_options, plci->ec_tail_length));
12722 
12723  Info = GOOD;
12724  if (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC)
12725  {
12726  result[0] = 2;
12727  PUT_WORD(&result[1], EC_SUCCESS);
12728  }
12729  else
12730  {
12731  result[0] = 5;
12732  PUT_WORD(&result[1], plci->ec_cmd);
12733  result[3] = 2;
12734  PUT_WORD(&result[4], GOOD);
12735  }
12736  internal_command = plci->internal_command;
12737  plci->internal_command = 0;
12738  switch (plci->ec_cmd)
12739  {
12740  case EC_ENABLE_OPERATION:
12741  case EC_FREEZE_COEFFICIENTS:
12742  case EC_RESUME_COEFFICIENT_UPDATE:
12743  case EC_RESET_COEFFICIENTS:
12744  switch (internal_command)
12745  {
12746  default:
12747  adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities |
12748  B1_FACILITY_EC), EC_COMMAND_1);
12749  case EC_COMMAND_1:
12750  if (adjust_b_process(Id, plci, Rc) != GOOD)
12751  {
12752  dbug(1, dprintf("[%06lx] %s,%d: Load EC failed",
12753  UnMapId(Id), (char *)(FILE_), __LINE__));
12754  Info = _FACILITY_NOT_SUPPORTED;
12755  break;
12756  }
12757  if (plci->internal_command)
12758  return;
12759  case EC_COMMAND_2:
12760  if (plci->sig_req)
12761  {
12762  plci->internal_command = EC_COMMAND_2;
12763  return;
12764  }
12765  plci->internal_command = EC_COMMAND_3;
12766  ec_write_parameters(plci);
12767  return;
12768  case EC_COMMAND_3:
12769  if ((Rc != OK) && (Rc != OK_FC))
12770  {
12771  dbug(1, dprintf("[%06lx] %s,%d: Enable EC failed %02x",
12772  UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
12773  Info = _FACILITY_NOT_SUPPORTED;
12774  break;
12775  }
12776  break;
12777  }
12778  break;
12779 
12780  case EC_DISABLE_OPERATION:
12781  switch (internal_command)
12782  {
12783  default:
12784  case EC_COMMAND_1:
12785  if (plci->B1_facilities & B1_FACILITY_EC)
12786  {
12787  if (plci->sig_req)
12788  {
12789  plci->internal_command = EC_COMMAND_1;
12790  return;
12791  }
12792  plci->internal_command = EC_COMMAND_2;
12793  ec_write_parameters(plci);
12794  return;
12795  }
12796  Rc = OK;
12797  case EC_COMMAND_2:
12798  if ((Rc != OK) && (Rc != OK_FC))
12799  {
12800  dbug(1, dprintf("[%06lx] %s,%d: Disable EC failed %02x",
12801  UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
12802  Info = _FACILITY_NOT_SUPPORTED;
12803  break;
12804  }
12805  adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities &
12806  ~B1_FACILITY_EC), EC_COMMAND_3);
12807  case EC_COMMAND_3:
12808  if (adjust_b_process(Id, plci, Rc) != GOOD)
12809  {
12810  dbug(1, dprintf("[%06lx] %s,%d: Unload EC failed",
12811  UnMapId(Id), (char *)(FILE_), __LINE__));
12812  Info = _FACILITY_NOT_SUPPORTED;
12813  break;
12814  }
12815  if (plci->internal_command)
12816  return;
12817  break;
12818  }
12819  break;
12820  }
12821  sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->number,
12822  "wws", Info, (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ?
12823  PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result);
12824 }
12825 
12826 
12827 static byte ec_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg)
12828 {
12829  word Info;
12830  word opt;
12831  API_PARSE ec_parms[3];
12832  byte result[16];
12833 
12834  dbug(1, dprintf("[%06lx] %s,%d: ec_request",
12835  UnMapId(Id), (char *)(FILE_), __LINE__));
12836 
12837  Info = GOOD;
12838  result[0] = 0;
12839  if (!(a->man_profile.private_options & (1L << PRIVATE_ECHO_CANCELLER)))
12840  {
12841  dbug(1, dprintf("[%06lx] %s,%d: Facility not supported",
12842  UnMapId(Id), (char *)(FILE_), __LINE__));
12843  Info = _FACILITY_NOT_SUPPORTED;
12844  }
12845  else
12846  {
12847  if (appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC)
12848  {
12849  if (api_parse(&msg[1].info[1], msg[1].length, "w", ec_parms))
12850  {
12851  dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12852  UnMapId(Id), (char *)(FILE_), __LINE__));
12853  Info = _WRONG_MESSAGE_FORMAT;
12854  }
12855  else
12856  {
12857  if (plci == NULL)
12858  {
12859  dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI",
12860  UnMapId(Id), (char *)(FILE_), __LINE__));
12861  Info = _WRONG_IDENTIFIER;
12862  }
12863  else if (!plci->State || !plci->NL.Id || plci->nl_remove_id)
12864  {
12865  dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
12866  UnMapId(Id), (char *)(FILE_), __LINE__));
12867  Info = _WRONG_STATE;
12868  }
12869  else
12870  {
12871  plci->command = 0;
12872  plci->ec_cmd = GET_WORD(ec_parms[0].info);
12873  plci->ec_idi_options &= ~(LEC_MANUAL_DISABLE | LEC_RESET_COEFFICIENTS);
12874  result[0] = 2;
12875  PUT_WORD(&result[1], EC_SUCCESS);
12876  if (msg[1].length >= 4)
12877  {
12878  opt = GET_WORD(&ec_parms[0].info[2]);
12879  plci->ec_idi_options &= ~(LEC_ENABLE_NONLINEAR_PROCESSING |
12880  LEC_ENABLE_2100HZ_DETECTOR | LEC_REQUIRE_2100HZ_REVERSALS);
12881  if (!(opt & EC_DISABLE_NON_LINEAR_PROCESSING))
12882  plci->ec_idi_options |= LEC_ENABLE_NONLINEAR_PROCESSING;
12883  if (opt & EC_DETECT_DISABLE_TONE)
12884  plci->ec_idi_options |= LEC_ENABLE_2100HZ_DETECTOR;
12885  if (!(opt & EC_DO_NOT_REQUIRE_REVERSALS))
12886  plci->ec_idi_options |= LEC_REQUIRE_2100HZ_REVERSALS;
12887  if (msg[1].length >= 6)
12888  {
12889  plci->ec_tail_length = GET_WORD(&ec_parms[0].info[4]);
12890  }
12891  }
12892  switch (plci->ec_cmd)
12893  {
12894  case EC_ENABLE_OPERATION:
12895  plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS;
12896  start_internal_command(Id, plci, ec_command);
12897  return (false);
12898 
12899  case EC_DISABLE_OPERATION:
12900  plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER |
12901  LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING |
12902  LEC_RESET_COEFFICIENTS;
12903  start_internal_command(Id, plci, ec_command);
12904  return (false);
12905 
12906  case EC_FREEZE_COEFFICIENTS:
12907  plci->ec_idi_options |= LEC_FREEZE_COEFFICIENTS;
12908  start_internal_command(Id, plci, ec_command);
12909  return (false);
12910 
12911  case EC_RESUME_COEFFICIENT_UPDATE:
12912  plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS;
12913  start_internal_command(Id, plci, ec_command);
12914  return (false);
12915 
12916  case EC_RESET_COEFFICIENTS:
12917  plci->ec_idi_options |= LEC_RESET_COEFFICIENTS;
12918  start_internal_command(Id, plci, ec_command);
12919  return (false);
12920 
12921  default:
12922  dbug(1, dprintf("[%06lx] %s,%d: EC unknown request %04x",
12923  UnMapId(Id), (char *)(FILE_), __LINE__, plci->ec_cmd));
12924  PUT_WORD(&result[1], EC_UNSUPPORTED_OPERATION);
12925  }
12926  }
12927  }
12928  }
12929  else
12930  {
12931  if (api_parse(&msg[1].info[1], msg[1].length, "ws", ec_parms))
12932  {
12933  dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12934  UnMapId(Id), (char *)(FILE_), __LINE__));
12935  Info = _WRONG_MESSAGE_FORMAT;
12936  }
12937  else
12938  {
12939  if (GET_WORD(ec_parms[0].info) == EC_GET_SUPPORTED_SERVICES)
12940  {
12941  result[0] = 11;
12942  PUT_WORD(&result[1], EC_GET_SUPPORTED_SERVICES);
12943  result[3] = 8;
12944  PUT_WORD(&result[4], GOOD);
12945  PUT_WORD(&result[6], 0x0007);
12946  PUT_WORD(&result[8], LEC_MAX_SUPPORTED_TAIL_LENGTH);
12947  PUT_WORD(&result[10], 0);
12948  }
12949  else if (plci == NULL)
12950  {
12951  dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI",
12952  UnMapId(Id), (char *)(FILE_), __LINE__));
12953  Info = _WRONG_IDENTIFIER;
12954  }
12955  else if (!plci->State || !plci->NL.Id || plci->nl_remove_id)
12956  {
12957  dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
12958  UnMapId(Id), (char *)(FILE_), __LINE__));
12959  Info = _WRONG_STATE;
12960  }
12961  else
12962  {
12963  plci->command = 0;
12964  plci->ec_cmd = GET_WORD(ec_parms[0].info);
12965  plci->ec_idi_options &= ~(LEC_MANUAL_DISABLE | LEC_RESET_COEFFICIENTS);
12966  result[0] = 5;
12967  PUT_WORD(&result[1], plci->ec_cmd);
12968  result[3] = 2;
12969  PUT_WORD(&result[4], GOOD);
12970  plci->ec_idi_options &= ~(LEC_ENABLE_NONLINEAR_PROCESSING |
12971  LEC_ENABLE_2100HZ_DETECTOR | LEC_REQUIRE_2100HZ_REVERSALS);
12972  plci->ec_tail_length = 0;
12973  if (ec_parms[1].length >= 2)
12974  {
12975  opt = GET_WORD(&ec_parms[1].info[1]);
12976  if (opt & EC_ENABLE_NON_LINEAR_PROCESSING)
12977  plci->ec_idi_options |= LEC_ENABLE_NONLINEAR_PROCESSING;
12978  if (opt & EC_DETECT_DISABLE_TONE)
12979  plci->ec_idi_options |= LEC_ENABLE_2100HZ_DETECTOR;
12980  if (!(opt & EC_DO_NOT_REQUIRE_REVERSALS))
12981  plci->ec_idi_options |= LEC_REQUIRE_2100HZ_REVERSALS;
12982  if (ec_parms[1].length >= 4)
12983  {
12984  plci->ec_tail_length = GET_WORD(&ec_parms[1].info[3]);
12985  }
12986  }
12987  switch (plci->ec_cmd)
12988  {
12989  case EC_ENABLE_OPERATION:
12990  plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS;
12991  start_internal_command(Id, plci, ec_command);
12992  return (false);
12993 
12994  case EC_DISABLE_OPERATION:
12995  plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER |
12996  LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING |
12997  LEC_RESET_COEFFICIENTS;
12998  start_internal_command(Id, plci, ec_command);
12999  return (false);
13000 
13001  default:
13002  dbug(1, dprintf("[%06lx] %s,%d: EC unknown request %04x",
13003  UnMapId(Id), (char *)(FILE_), __LINE__, plci->ec_cmd));
13004  PUT_WORD(&result[4], _FACILITY_SPECIFIC_FUNCTION_NOT_SUPP);
13005  }
13006  }
13007  }
13008  }
13009  }
13010  sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
13011  "wws", Info, (appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ?
13012  PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result);
13013  return (false);
13014 }
13015 
13016 
13017 static void ec_indication(dword Id, PLCI *plci, byte *msg, word length)
13018 {
13019  byte result[8];
13020 
13021  dbug(1, dprintf("[%06lx] %s,%d: ec_indication",
13022  UnMapId(Id), (char *)(FILE_), __LINE__));
13023 
13024  if (!(plci->ec_idi_options & LEC_MANUAL_DISABLE))
13025  {
13026  if (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC)
13027  {
13028  result[0] = 2;
13029  PUT_WORD(&result[1], 0);
13030  switch (msg[1])
13031  {
13032  case LEC_DISABLE_TYPE_CONTIGNUOUS_2100HZ:
13033  PUT_WORD(&result[1], EC_BYPASS_DUE_TO_CONTINUOUS_2100HZ);
13034  break;
13035  case LEC_DISABLE_TYPE_REVERSED_2100HZ:
13036  PUT_WORD(&result[1], EC_BYPASS_DUE_TO_REVERSED_2100HZ);
13037  break;
13038  case LEC_DISABLE_RELEASED:
13039  PUT_WORD(&result[1], EC_BYPASS_RELEASED);
13040  break;
13041  }
13042  }
13043  else
13044  {
13045  result[0] = 5;
13046  PUT_WORD(&result[1], EC_BYPASS_INDICATION);
13047  result[3] = 2;
13048  PUT_WORD(&result[4], 0);
13049  switch (msg[1])
13050  {
13051  case LEC_DISABLE_TYPE_CONTIGNUOUS_2100HZ:
13052  PUT_WORD(&result[4], EC_BYPASS_DUE_TO_CONTINUOUS_2100HZ);
13053  break;
13054  case LEC_DISABLE_TYPE_REVERSED_2100HZ:
13055  PUT_WORD(&result[4], EC_BYPASS_DUE_TO_REVERSED_2100HZ);
13056  break;
13057  case LEC_DISABLE_RELEASED:
13058  PUT_WORD(&result[4], EC_BYPASS_RELEASED);
13059  break;
13060  }
13061  }
13062  sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ?
13063  PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result);
13064  }
13065 }
13066 
13067 
13068 
13069 /*------------------------------------------------------------------*/
13070 /* Advanced voice */
13071 /*------------------------------------------------------------------*/
13072 
13073 static void adv_voice_write_coefs(PLCI *plci, word write_command)
13074 {
13075  DIVA_CAPI_ADAPTER *a;
13076  word i;
13077  byte *p;
13078 
13079  word w, n, j, k;
13080  byte ch_map[MIXER_CHANNELS_BRI];
13081 
13082  byte coef_buffer[ADV_VOICE_COEF_BUFFER_SIZE + 2];
13083 
13084  dbug(1, dprintf("[%06lx] %s,%d: adv_voice_write_coefs %d",
13085  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13086  (char *)(FILE_), __LINE__, write_command));
13087 
13088  a = plci->adapter;
13089  p = coef_buffer + 1;
13090  *(p++) = DSP_CTRL_OLD_SET_MIXER_COEFFICIENTS;
13091  i = 0;
13092  while (i + sizeof(word) <= a->adv_voice_coef_length)
13093  {
13094  PUT_WORD(p, GET_WORD(a->adv_voice_coef_buffer + i));
13095  p += 2;
13096  i += 2;
13097  }
13098  while (i < ADV_VOICE_OLD_COEF_COUNT * sizeof(word))
13099  {
13100  PUT_WORD(p, 0x8000);
13101  p += 2;
13102  i += 2;
13103  }
13104 
13105  if (!a->li_pri && (plci->li_bchannel_id == 0))
13106  {
13107  if ((li_config_table[a->li_base].plci == NULL) && (li_config_table[a->li_base + 1].plci != NULL))
13108  {
13109  plci->li_bchannel_id = 1;
13110  li_config_table[a->li_base].plci = plci;
13111  dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id %d",
13112  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13113  (char *)(FILE_), __LINE__, plci->li_bchannel_id));
13114  }
13115  else if ((li_config_table[a->li_base].plci != NULL) && (li_config_table[a->li_base + 1].plci == NULL))
13116  {
13117  plci->li_bchannel_id = 2;
13118  li_config_table[a->li_base + 1].plci = plci;
13119  dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id %d",
13120  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13121  (char *)(FILE_), __LINE__, plci->li_bchannel_id));
13122  }
13123  }
13124  if (!a->li_pri && (plci->li_bchannel_id != 0)
13125  && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
13126  {
13127  i = a->li_base + (plci->li_bchannel_id - 1);
13128  switch (write_command)
13129  {
13130  case ADV_VOICE_WRITE_ACTIVATION:
13131  j = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
13132  k = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
13133  if (!(plci->B1_facilities & B1_FACILITY_MIXER))
13134  {
13135  li_config_table[j].flag_table[i] |= LI_FLAG_CONFERENCE | LI_FLAG_MIX;
13136  li_config_table[i].flag_table[j] |= LI_FLAG_CONFERENCE | LI_FLAG_MONITOR;
13137  }
13138  if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13139  {
13140  li_config_table[k].flag_table[i] |= LI_FLAG_CONFERENCE | LI_FLAG_MIX;
13141  li_config_table[i].flag_table[k] |= LI_FLAG_CONFERENCE | LI_FLAG_MONITOR;
13142  li_config_table[k].flag_table[j] |= LI_FLAG_CONFERENCE;
13143  li_config_table[j].flag_table[k] |= LI_FLAG_CONFERENCE;
13144  }
13145  mixer_calculate_coefs(a);
13146  li_config_table[i].curchnl = li_config_table[i].channel;
13147  li_config_table[j].curchnl = li_config_table[j].channel;
13148  if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13149  li_config_table[k].curchnl = li_config_table[k].channel;
13150  break;
13151 
13152  case ADV_VOICE_WRITE_DEACTIVATION:
13153  for (j = 0; j < li_total_channels; j++)
13154  {
13155  li_config_table[i].flag_table[j] = 0;
13156  li_config_table[j].flag_table[i] = 0;
13157  }
13158  k = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
13159  for (j = 0; j < li_total_channels; j++)
13160  {
13161  li_config_table[k].flag_table[j] = 0;
13162  li_config_table[j].flag_table[k] = 0;
13163  }
13164  if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13165  {
13166  k = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
13167  for (j = 0; j < li_total_channels; j++)
13168  {
13169  li_config_table[k].flag_table[j] = 0;
13170  li_config_table[j].flag_table[k] = 0;
13171  }
13172  }
13173  mixer_calculate_coefs(a);
13174  break;
13175  }
13176  if (plci->B1_facilities & B1_FACILITY_MIXER)
13177  {
13178  w = 0;
13179  if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length)
13180  w = GET_WORD(a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE);
13181  if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
13182  w |= MIXER_FEATURE_ENABLE_TX_DATA;
13183  if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
13184  w |= MIXER_FEATURE_ENABLE_RX_DATA;
13185  *(p++) = (byte) w;
13186  *(p++) = (byte)(w >> 8);
13187  for (j = 0; j < sizeof(ch_map); j += 2)
13188  {
13189  ch_map[j] = (byte)(j + (plci->li_bchannel_id - 1));
13190  ch_map[j + 1] = (byte)(j + (2 - plci->li_bchannel_id));
13191  }
13192  for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++)
13193  {
13194  i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch];
13195  j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch];
13196  if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED)
13197  {
13198  *(p++) = ((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01);
13199  w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
13200  li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4;
13201  }
13202  else
13203  {
13204  *(p++) = (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + n < a->adv_voice_coef_length) ?
13205  a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + n] : 0x00;
13206  }
13207  }
13208  }
13209  else
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  }
13215  else
13216 
13217  {
13218  for (i = ADV_VOICE_NEW_COEF_BASE; i < a->adv_voice_coef_length; i++)
13219  *(p++) = a->adv_voice_coef_buffer[i];
13220  }
13221  coef_buffer[0] = (p - coef_buffer) - 1;
13222  add_p(plci, FTY, coef_buffer);
13223  sig_req(plci, TEL_CTRL, 0);
13224  send_req(plci);
13225 }
13226 
13227 
13228 static void adv_voice_clear_config(PLCI *plci)
13229 {
13230  DIVA_CAPI_ADAPTER *a;
13231 
13232  word i, j;
13233 
13234 
13235  dbug(1, dprintf("[%06lx] %s,%d: adv_voice_clear_config",
13236  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13237  (char *)(FILE_), __LINE__));
13238 
13239  a = plci->adapter;
13240  if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
13241  {
13242  a->adv_voice_coef_length = 0;
13243 
13244  if (!a->li_pri && (plci->li_bchannel_id != 0)
13245  && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
13246  {
13247  i = a->li_base + (plci->li_bchannel_id - 1);
13248  li_config_table[i].curchnl = 0;
13249  li_config_table[i].channel = 0;
13250  li_config_table[i].chflags = 0;
13251  for (j = 0; j < li_total_channels; j++)
13252  {
13253  li_config_table[i].flag_table[j] = 0;
13254  li_config_table[j].flag_table[i] = 0;
13255  li_config_table[i].coef_table[j] = 0;
13256  li_config_table[j].coef_table[i] = 0;
13257  }
13258  li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET;
13259  i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
13260  li_config_table[i].curchnl = 0;
13261  li_config_table[i].channel = 0;
13262  li_config_table[i].chflags = 0;
13263  for (j = 0; j < li_total_channels; j++)
13264  {
13265  li_config_table[i].flag_table[j] = 0;
13266  li_config_table[j].flag_table[i] = 0;
13267  li_config_table[i].coef_table[j] = 0;
13268  li_config_table[j].coef_table[i] = 0;
13269  }
13270  if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13271  {
13272  i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
13273  li_config_table[i].curchnl = 0;
13274  li_config_table[i].channel = 0;
13275  li_config_table[i].chflags = 0;
13276  for (j = 0; j < li_total_channels; j++)
13277  {
13278  li_config_table[i].flag_table[j] = 0;
13279  li_config_table[j].flag_table[i] = 0;
13280  li_config_table[i].coef_table[j] = 0;
13281  li_config_table[j].coef_table[i] = 0;
13282  }
13283  }
13284  }
13285 
13286  }
13287 }
13288 
13289 
13290 static void adv_voice_prepare_switch(dword Id, PLCI *plci)
13291 {
13292 
13293  dbug(1, dprintf("[%06lx] %s,%d: adv_voice_prepare_switch",
13294  UnMapId(Id), (char *)(FILE_), __LINE__));
13295 
13296 }
13297 
13298 
13299 static word adv_voice_save_config(dword Id, PLCI *plci, byte Rc)
13300 {
13301 
13302  dbug(1, dprintf("[%06lx] %s,%d: adv_voice_save_config %02x %d",
13303  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
13304 
13305  return (GOOD);
13306 }
13307 
13308 
13309 static word adv_voice_restore_config(dword Id, PLCI *plci, byte Rc)
13310 {
13311  DIVA_CAPI_ADAPTER *a;
13312  word Info;
13313 
13314  dbug(1, dprintf("[%06lx] %s,%d: adv_voice_restore_config %02x %d",
13315  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
13316 
13317  Info = GOOD;
13318  a = plci->adapter;
13319  if ((plci->B1_facilities & B1_FACILITY_VOICE)
13320  && (plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
13321  {
13322  switch (plci->adjust_b_state)
13323  {
13324  case ADJUST_B_RESTORE_VOICE_1:
13325  plci->internal_command = plci->adjust_b_command;
13326  if (plci->sig_req)
13327  {
13328  plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_1;
13329  break;
13330  }
13331  adv_voice_write_coefs(plci, ADV_VOICE_WRITE_UPDATE);
13332  plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_2;
13333  break;
13334  case ADJUST_B_RESTORE_VOICE_2:
13335  if ((Rc != OK) && (Rc != OK_FC))
13336  {
13337  dbug(1, dprintf("[%06lx] %s,%d: Restore voice config failed %02x",
13338  UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
13339  Info = _WRONG_STATE;
13340  break;
13341  }
13342  break;
13343  }
13344  }
13345  return (Info);
13346 }
13347 
13348 
13349 
13350 
13351 /*------------------------------------------------------------------*/
13352 /* B1 resource switching */
13353 /*------------------------------------------------------------------*/
13354 
13355 static byte b1_facilities_table[] =
13356 {
13357  0x00, /* 0 No bchannel resources */
13358  0x00, /* 1 Codec (automatic law) */
13359  0x00, /* 2 Codec (A-law) */
13360  0x00, /* 3 Codec (y-law) */
13361  0x00, /* 4 HDLC for X.21 */
13362  0x00, /* 5 HDLC */
13363  0x00, /* 6 External Device 0 */
13364  0x00, /* 7 External Device 1 */
13365  0x00, /* 8 HDLC 56k */
13366  0x00, /* 9 Transparent */
13367  0x00, /* 10 Loopback to network */
13368  0x00, /* 11 Test pattern to net */
13369  0x00, /* 12 Rate adaptation sync */
13370  0x00, /* 13 Rate adaptation async */
13371  0x00, /* 14 R-Interface */
13372  0x00, /* 15 HDLC 128k leased line */
13373  0x00, /* 16 FAX */
13374  0x00, /* 17 Modem async */
13375  0x00, /* 18 Modem sync HDLC */
13376  0x00, /* 19 V.110 async HDLC */
13377  0x12, /* 20 Adv voice (Trans,mixer) */
13378  0x00, /* 21 Codec connected to IC */
13379  0x0c, /* 22 Trans,DTMF */
13380  0x1e, /* 23 Trans,DTMF+mixer */
13381  0x1f, /* 24 Trans,DTMF+mixer+local */
13382  0x13, /* 25 Trans,mixer+local */
13383  0x12, /* 26 HDLC,mixer */
13384  0x12, /* 27 HDLC 56k,mixer */
13385  0x2c, /* 28 Trans,LEC+DTMF */
13386  0x3e, /* 29 Trans,LEC+DTMF+mixer */
13387  0x3f, /* 30 Trans,LEC+DTMF+mixer+local */
13388  0x2c, /* 31 RTP,LEC+DTMF */
13389  0x3e, /* 32 RTP,LEC+DTMF+mixer */
13390  0x3f, /* 33 RTP,LEC+DTMF+mixer+local */
13391  0x00, /* 34 Signaling task */
13392  0x00, /* 35 PIAFS */
13393  0x0c, /* 36 Trans,DTMF+TONE */
13394  0x1e, /* 37 Trans,DTMF+TONE+mixer */
13395  0x1f /* 38 Trans,DTMF+TONE+mixer+local*/
13396 };
13397 
13398 
13399 static word get_b1_facilities(PLCI *plci, byte b1_resource)
13400 {
13401  word b1_facilities;
13402 
13403  b1_facilities = b1_facilities_table[b1_resource];
13404  if ((b1_resource == 9) || (b1_resource == 20) || (b1_resource == 25))
13405  {
13406 
13407  if (!(((plci->requested_options_conn | plci->requested_options) & (1L << PRIVATE_DTMF_TONE))
13408  || (plci->appl && (plci->adapter->requested_options_table[plci->appl->Id - 1] & (1L << PRIVATE_DTMF_TONE)))))
13409 
13410  {
13411  if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_SEND)
13412  b1_facilities |= B1_FACILITY_DTMFX;
13413  if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE)
13414  b1_facilities |= B1_FACILITY_DTMFR;
13415  }
13416  }
13417  if ((b1_resource == 17) || (b1_resource == 18))
13418  {
13419  if (plci->adapter->manufacturer_features & (MANUFACTURER_FEATURE_V18 | MANUFACTURER_FEATURE_VOWN))
13420  b1_facilities |= B1_FACILITY_DTMFX | B1_FACILITY_DTMFR;
13421  }
13422 /*
13423  dbug (1, dprintf("[%06lx] %s,%d: get_b1_facilities %d %04x",
13424  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13425  (char far *)(FILE_), __LINE__, b1_resource, b1_facilites));
13426 */
13427  return (b1_facilities);
13428 }
13429 
13430 
13431 static byte add_b1_facilities(PLCI *plci, byte b1_resource, word b1_facilities)
13432 {
13433  byte b;
13434 
13435  switch (b1_resource)
13436  {
13437  case 5:
13438  case 26:
13439  if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13440  b = 26;
13441  else
13442  b = 5;
13443  break;
13444 
13445  case 8:
13446  case 27:
13447  if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13448  b = 27;
13449  else
13450  b = 8;
13451  break;
13452 
13453  case 9:
13454  case 20:
13455  case 22:
13456  case 23:
13457  case 24:
13458  case 25:
13459  case 28:
13460  case 29:
13461  case 30:
13462  case 36:
13463  case 37:
13464  case 38:
13465  if (b1_facilities & B1_FACILITY_EC)
13466  {
13467  if (b1_facilities & B1_FACILITY_LOCAL)
13468  b = 30;
13469  else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13470  b = 29;
13471  else
13472  b = 28;
13473  }
13474 
13475  else if ((b1_facilities & (B1_FACILITY_DTMFX | B1_FACILITY_DTMFR | B1_FACILITY_MIXER))
13476  && (((plci->requested_options_conn | plci->requested_options) & (1L << PRIVATE_DTMF_TONE))
13477  || (plci->appl && (plci->adapter->requested_options_table[plci->appl->Id - 1] & (1L << PRIVATE_DTMF_TONE)))))
13478  {
13479  if (b1_facilities & B1_FACILITY_LOCAL)
13480  b = 38;
13481  else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13482  b = 37;
13483  else
13484  b = 36;
13485  }
13486 
13487  else if (((plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_HARDDTMF)
13488  && !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE))
13489  || ((b1_facilities & B1_FACILITY_DTMFR)
13490  && ((b1_facilities & B1_FACILITY_MIXER)
13491  || !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE)))
13492  || ((b1_facilities & B1_FACILITY_DTMFX)
13493  && ((b1_facilities & B1_FACILITY_MIXER)
13494  || !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_SEND))))
13495  {
13496  if (b1_facilities & B1_FACILITY_LOCAL)
13497  b = 24;
13498  else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13499  b = 23;
13500  else
13501  b = 22;
13502  }
13503  else
13504  {
13505  if (b1_facilities & B1_FACILITY_LOCAL)
13506  b = 25;
13507  else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13508  b = 20;
13509  else
13510  b = 9;
13511  }
13512  break;
13513 
13514  case 31:
13515  case 32:
13516  case 33:
13517  if (b1_facilities & B1_FACILITY_LOCAL)
13518  b = 33;
13519  else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13520  b = 32;
13521  else
13522  b = 31;
13523  break;
13524 
13525  default:
13526  b = b1_resource;
13527  }
13528  dbug(1, dprintf("[%06lx] %s,%d: add_b1_facilities %d %04x %d %04x",
13529  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13530  (char *)(FILE_), __LINE__,
13531  b1_resource, b1_facilities, b, get_b1_facilities(plci, b)));
13532  return (b);
13533 }
13534 
13535 
13536 static void adjust_b1_facilities(PLCI *plci, byte new_b1_resource, word new_b1_facilities)
13537 {
13538  word removed_facilities;
13539 
13540  dbug(1, dprintf("[%06lx] %s,%d: adjust_b1_facilities %d %04x %04x",
13541  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13542  (char *)(FILE_), __LINE__, new_b1_resource, new_b1_facilities,
13543  new_b1_facilities & get_b1_facilities(plci, new_b1_resource)));
13544 
13545  new_b1_facilities &= get_b1_facilities(plci, new_b1_resource);
13546  removed_facilities = plci->B1_facilities & ~new_b1_facilities;
13547 
13548  if (removed_facilities & B1_FACILITY_EC)
13549  ec_clear_config(plci);
13550 
13551 
13552  if (removed_facilities & B1_FACILITY_DTMFR)
13553  {
13554  dtmf_rec_clear_config(plci);
13555  dtmf_parameter_clear_config(plci);
13556  }
13557  if (removed_facilities & B1_FACILITY_DTMFX)
13558  dtmf_send_clear_config(plci);
13559 
13560 
13561  if (removed_facilities & B1_FACILITY_MIXER)
13562  mixer_clear_config(plci);
13563 
13564  if (removed_facilities & B1_FACILITY_VOICE)
13565  adv_voice_clear_config(plci);
13566  plci->B1_facilities = new_b1_facilities;
13567 }
13568 
13569 
13570 static void adjust_b_clear(PLCI *plci)
13571 {
13572 
13573  dbug(1, dprintf("[%06lx] %s,%d: adjust_b_clear",
13574  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13575  (char *)(FILE_), __LINE__));
13576 
13577  plci->adjust_b_restore = false;
13578 }
13579 
13580 
13581 static word adjust_b_process(dword Id, PLCI *plci, byte Rc)
13582 {
13583  word Info;
13584  byte b1_resource;
13585  NCCI *ncci_ptr;
13586  API_PARSE bp[2];
13587 
13588  dbug(1, dprintf("[%06lx] %s,%d: adjust_b_process %02x %d",
13589  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
13590 
13591  Info = GOOD;
13592  switch (plci->adjust_b_state)
13593  {
13594  case ADJUST_B_START:
13595  if ((plci->adjust_b_parms_msg == NULL)
13596  && (plci->adjust_b_mode & ADJUST_B_MODE_SWITCH_L1)
13597  && ((plci->adjust_b_mode & ~(ADJUST_B_MODE_SAVE | ADJUST_B_MODE_SWITCH_L1 |
13598  ADJUST_B_MODE_NO_RESOURCE | ADJUST_B_MODE_RESTORE)) == 0))
13599  {
13600  b1_resource = (plci->adjust_b_mode == ADJUST_B_MODE_NO_RESOURCE) ?
13601  0 : add_b1_facilities(plci, plci->B1_resource, plci->adjust_b_facilities);
13602  if (b1_resource == plci->B1_resource)
13603  {
13604  adjust_b1_facilities(plci, b1_resource, plci->adjust_b_facilities);
13605  break;
13606  }
13607  if (plci->adjust_b_facilities & ~get_b1_facilities(plci, b1_resource))
13608  {
13609  dbug(1, dprintf("[%06lx] %s,%d: Adjust B nonsupported facilities %d %d %04x",
13610  UnMapId(Id), (char *)(FILE_), __LINE__,
13611  plci->B1_resource, b1_resource, plci->adjust_b_facilities));
13612  Info = _WRONG_STATE;
13613  break;
13614  }
13615  }
13616  if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13617  {
13618 
13619  mixer_prepare_switch(Id, plci);
13620 
13621 
13622  dtmf_prepare_switch(Id, plci);
13623  dtmf_parameter_prepare_switch(Id, plci);
13624 
13625 
13626  ec_prepare_switch(Id, plci);
13627 
13628  adv_voice_prepare_switch(Id, plci);
13629  }
13630  plci->adjust_b_state = ADJUST_B_SAVE_MIXER_1;
13631  Rc = OK;
13632  case ADJUST_B_SAVE_MIXER_1:
13633  if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13634  {
13635 
13636  Info = mixer_save_config(Id, plci, Rc);
13637  if ((Info != GOOD) || plci->internal_command)
13638  break;
13639 
13640  }
13641  plci->adjust_b_state = ADJUST_B_SAVE_DTMF_1;
13642  Rc = OK;
13643  case ADJUST_B_SAVE_DTMF_1:
13644  if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13645  {
13646 
13647  Info = dtmf_save_config(Id, plci, Rc);
13648  if ((Info != GOOD) || plci->internal_command)
13649  break;
13650 
13651  }
13652  plci->adjust_b_state = ADJUST_B_REMOVE_L23_1;
13653  case ADJUST_B_REMOVE_L23_1:
13654  if ((plci->adjust_b_mode & ADJUST_B_MODE_REMOVE_L23)
13655  && plci->NL.Id && !plci->nl_remove_id)
13656  {
13657  plci->internal_command = plci->adjust_b_command;
13658  if (plci->adjust_b_ncci != 0)
13659  {
13660  ncci_ptr = &(plci->adapter->ncci[plci->adjust_b_ncci]);
13661  while (ncci_ptr->data_pending)
13662  {
13663  plci->data_sent_ptr = ncci_ptr->DBuffer[ncci_ptr->data_out].P;
13664  data_rc(plci, plci->adapter->ncci_ch[plci->adjust_b_ncci]);
13665  }
13666  while (ncci_ptr->data_ack_pending)
13667  data_ack(plci, plci->adapter->ncci_ch[plci->adjust_b_ncci]);
13668  }
13669  nl_req_ncci(plci, REMOVE,
13670  (byte)((plci->adjust_b_mode & ADJUST_B_MODE_CONNECT) ? plci->adjust_b_ncci : 0));
13671  send_req(plci);
13672  plci->adjust_b_state = ADJUST_B_REMOVE_L23_2;
13673  break;
13674  }
13675  plci->adjust_b_state = ADJUST_B_REMOVE_L23_2;
13676  Rc = OK;
13677  case ADJUST_B_REMOVE_L23_2:
13678  if ((Rc != OK) && (Rc != OK_FC))
13679  {
13680  dbug(1, dprintf("[%06lx] %s,%d: Adjust B remove failed %02x",
13681  UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
13682  Info = _WRONG_STATE;
13683  break;
13684  }
13685  if (plci->adjust_b_mode & ADJUST_B_MODE_REMOVE_L23)
13686  {
13687  if (plci_nl_busy(plci))
13688  {
13689  plci->internal_command = plci->adjust_b_command;
13690  break;
13691  }
13692  }
13693  plci->adjust_b_state = ADJUST_B_SAVE_EC_1;
13694  Rc = OK;
13695  case ADJUST_B_SAVE_EC_1:
13696  if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13697  {
13698 
13699  Info = ec_save_config(Id, plci, Rc);
13700  if ((Info != GOOD) || plci->internal_command)
13701  break;
13702 
13703  }
13704  plci->adjust_b_state = ADJUST_B_SAVE_DTMF_PARAMETER_1;
13705  Rc = OK;
13706  case ADJUST_B_SAVE_DTMF_PARAMETER_1:
13707  if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13708  {
13709 
13710  Info = dtmf_parameter_save_config(Id, plci, Rc);
13711  if ((Info != GOOD) || plci->internal_command)
13712  break;
13713 
13714  }
13715  plci->adjust_b_state = ADJUST_B_SAVE_VOICE_1;
13716  Rc = OK;
13717  case ADJUST_B_SAVE_VOICE_1:
13718  if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13719  {
13720  Info = adv_voice_save_config(Id, plci, Rc);
13721  if ((Info != GOOD) || plci->internal_command)
13722  break;
13723  }
13724  plci->adjust_b_state = ADJUST_B_SWITCH_L1_1;
13725  case ADJUST_B_SWITCH_L1_1:
13726  if (plci->adjust_b_mode & ADJUST_B_MODE_SWITCH_L1)
13727  {
13728  if (plci->sig_req)
13729  {
13730  plci->internal_command = plci->adjust_b_command;
13731  break;
13732  }
13733  if (plci->adjust_b_parms_msg != NULL)
13734  api_load_msg(plci->adjust_b_parms_msg, bp);
13735  else
13736  api_load_msg(&plci->B_protocol, bp);
13737  Info = add_b1(plci, bp,
13738  (word)((plci->adjust_b_mode & ADJUST_B_MODE_NO_RESOURCE) ? 2 : 0),
13739  plci->adjust_b_facilities);
13740  if (Info != GOOD)
13741  {
13742  dbug(1, dprintf("[%06lx] %s,%d: Adjust B invalid L1 parameters %d %04x",
13743  UnMapId(Id), (char *)(FILE_), __LINE__,
13744  plci->B1_resource, plci->adjust_b_facilities));
13745  break;
13746  }
13747  plci->internal_command = plci->adjust_b_command;
13748  sig_req(plci, RESOURCES, 0);
13749  send_req(plci);
13750  plci->adjust_b_state = ADJUST_B_SWITCH_L1_2;
13751  break;
13752  }
13753  plci->adjust_b_state = ADJUST_B_SWITCH_L1_2;
13754  Rc = OK;
13755  case ADJUST_B_SWITCH_L1_2:
13756  if ((Rc != OK) && (Rc != OK_FC))
13757  {
13758  dbug(1, dprintf("[%06lx] %s,%d: Adjust B switch failed %02x %d %04x",
13759  UnMapId(Id), (char *)(FILE_), __LINE__,
13760  Rc, plci->B1_resource, plci->adjust_b_facilities));
13761  Info = _WRONG_STATE;
13762  break;
13763  }
13764  plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_1;
13765  Rc = OK;
13766  case ADJUST_B_RESTORE_VOICE_1:
13767  case ADJUST_B_RESTORE_VOICE_2:
13768  if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13769  {
13770  Info = adv_voice_restore_config(Id, plci, Rc);
13771  if ((Info != GOOD) || plci->internal_command)
13772  break;
13773  }
13774  plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_1;
13775  Rc = OK;
13776  case ADJUST_B_RESTORE_DTMF_PARAMETER_1:
13777  case ADJUST_B_RESTORE_DTMF_PARAMETER_2:
13778  if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13779  {
13780 
13781  Info = dtmf_parameter_restore_config(Id, plci, Rc);
13782  if ((Info != GOOD) || plci->internal_command)
13783  break;
13784 
13785  }
13786  plci->adjust_b_state = ADJUST_B_RESTORE_EC_1;
13787  Rc = OK;
13788  case ADJUST_B_RESTORE_EC_1:
13789  case ADJUST_B_RESTORE_EC_2:
13790  if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13791  {
13792 
13793  Info = ec_restore_config(Id, plci, Rc);
13794  if ((Info != GOOD) || plci->internal_command)
13795  break;
13796 
13797  }
13798  plci->adjust_b_state = ADJUST_B_ASSIGN_L23_1;
13799  case ADJUST_B_ASSIGN_L23_1:
13800  if (plci->adjust_b_mode & ADJUST_B_MODE_ASSIGN_L23)
13801  {
13802  if (plci_nl_busy(plci))
13803  {
13804  plci->internal_command = plci->adjust_b_command;
13805  break;
13806  }
13807  if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT)
13808  plci->call_dir |= CALL_DIR_FORCE_OUTG_NL;
13809  if (plci->adjust_b_parms_msg != NULL)
13810  api_load_msg(plci->adjust_b_parms_msg, bp);
13811  else
13812  api_load_msg(&plci->B_protocol, bp);
13813  Info = add_b23(plci, bp);
13814  if (Info != GOOD)
13815  {
13816  dbug(1, dprintf("[%06lx] %s,%d: Adjust B invalid L23 parameters %04x",
13817  UnMapId(Id), (char *)(FILE_), __LINE__, Info));
13818  break;
13819  }
13820  plci->internal_command = plci->adjust_b_command;
13821  nl_req_ncci(plci, ASSIGN, 0);
13822  send_req(plci);
13823  plci->adjust_b_state = ADJUST_B_ASSIGN_L23_2;
13824  break;
13825  }
13826  plci->adjust_b_state = ADJUST_B_ASSIGN_L23_2;
13827  Rc = ASSIGN_OK;
13828  case ADJUST_B_ASSIGN_L23_2:
13829  if ((Rc != OK) && (Rc != OK_FC) && (Rc != ASSIGN_OK))
13830  {
13831  dbug(1, dprintf("[%06lx] %s,%d: Adjust B assign failed %02x",
13832  UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
13833  Info = _WRONG_STATE;
13834  break;
13835  }
13836  if (plci->adjust_b_mode & ADJUST_B_MODE_ASSIGN_L23)
13837  {
13838  if (Rc != ASSIGN_OK)
13839  {
13840  plci->internal_command = plci->adjust_b_command;
13841  break;
13842  }
13843  }
13844  if (plci->adjust_b_mode & ADJUST_B_MODE_USER_CONNECT)
13845  {
13846  plci->adjust_b_restore = true;
13847  break;
13848  }
13849  plci->adjust_b_state = ADJUST_B_CONNECT_1;
13850  case ADJUST_B_CONNECT_1:
13851  if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT)
13852  {
13853  plci->internal_command = plci->adjust_b_command;
13854  if (plci_nl_busy(plci))
13855  break;
13856  nl_req_ncci(plci, N_CONNECT, 0);
13857  send_req(plci);
13858  plci->adjust_b_state = ADJUST_B_CONNECT_2;
13859  break;
13860  }
13861  plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
13862  Rc = OK;
13863  case ADJUST_B_CONNECT_2:
13864  case ADJUST_B_CONNECT_3:
13865  case ADJUST_B_CONNECT_4:
13866  if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0))
13867  {
13868  dbug(1, dprintf("[%06lx] %s,%d: Adjust B connect failed %02x",
13869  UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
13870  Info = _WRONG_STATE;
13871  break;
13872  }
13873  if (Rc == OK)
13874  {
13875  if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT)
13876  {
13877  get_ncci(plci, (byte)(Id >> 16), plci->adjust_b_ncci);
13878  Id = (Id & 0xffff) | (((dword)(plci->adjust_b_ncci)) << 16);
13879  }
13880  if (plci->adjust_b_state == ADJUST_B_CONNECT_2)
13881  plci->adjust_b_state = ADJUST_B_CONNECT_3;
13882  else if (plci->adjust_b_state == ADJUST_B_CONNECT_4)
13883  plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
13884  }
13885  else if (Rc == 0)
13886  {
13887  if (plci->adjust_b_state == ADJUST_B_CONNECT_2)
13888  plci->adjust_b_state = ADJUST_B_CONNECT_4;
13889  else if (plci->adjust_b_state == ADJUST_B_CONNECT_3)
13890  plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
13891  }
13892  if (plci->adjust_b_state != ADJUST_B_RESTORE_DTMF_1)
13893  {
13894  plci->internal_command = plci->adjust_b_command;
13895  break;
13896  }
13897  Rc = OK;
13898  case ADJUST_B_RESTORE_DTMF_1:
13899  case ADJUST_B_RESTORE_DTMF_2:
13900  if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13901  {
13902 
13903  Info = dtmf_restore_config(Id, plci, Rc);
13904  if ((Info != GOOD) || plci->internal_command)
13905  break;
13906 
13907  }
13908  plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_1;
13909  Rc = OK;
13910  case ADJUST_B_RESTORE_MIXER_1:
13911  case ADJUST_B_RESTORE_MIXER_2:
13912  case ADJUST_B_RESTORE_MIXER_3:
13913  case ADJUST_B_RESTORE_MIXER_4:
13914  case ADJUST_B_RESTORE_MIXER_5:
13915  case ADJUST_B_RESTORE_MIXER_6:
13916  case ADJUST_B_RESTORE_MIXER_7:
13917  if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13918  {
13919 
13920  Info = mixer_restore_config(Id, plci, Rc);
13921  if ((Info != GOOD) || plci->internal_command)
13922  break;
13923 
13924  }
13925  plci->adjust_b_state = ADJUST_B_END;
13926  case ADJUST_B_END:
13927  break;
13928  }
13929  return (Info);
13930 }
13931 
13932 
13933 static void adjust_b1_resource(dword Id, PLCI *plci, API_SAVE *bp_msg, word b1_facilities, word internal_command)
13934 {
13935 
13936  dbug(1, dprintf("[%06lx] %s,%d: adjust_b1_resource %d %04x",
13937  UnMapId(Id), (char *)(FILE_), __LINE__,
13938  plci->B1_resource, b1_facilities));
13939 
13940  plci->adjust_b_parms_msg = bp_msg;
13941  plci->adjust_b_facilities = b1_facilities;
13942  plci->adjust_b_command = internal_command;
13943  plci->adjust_b_ncci = (word)(Id >> 16);
13944  if ((bp_msg == NULL) && (plci->B1_resource == 0))
13945  plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_NO_RESOURCE | ADJUST_B_MODE_SWITCH_L1;
13946  else
13947  plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_SWITCH_L1 | ADJUST_B_MODE_RESTORE;
13948  plci->adjust_b_state = ADJUST_B_START;
13949  dbug(1, dprintf("[%06lx] %s,%d: Adjust B1 resource %d %04x...",
13950  UnMapId(Id), (char *)(FILE_), __LINE__,
13951  plci->B1_resource, b1_facilities));
13952 }
13953 
13954 
13955 static void adjust_b_restore(dword Id, PLCI *plci, byte Rc)
13956 {
13957  word internal_command;
13958 
13959  dbug(1, dprintf("[%06lx] %s,%d: adjust_b_restore %02x %04x",
13960  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
13961 
13962  internal_command = plci->internal_command;
13963  plci->internal_command = 0;
13964  switch (internal_command)
13965  {
13966  default:
13967  plci->command = 0;
13968  if (plci->req_in != 0)
13969  {
13970  plci->internal_command = ADJUST_B_RESTORE_1;
13971  break;
13972  }
13973  Rc = OK;
13974  case ADJUST_B_RESTORE_1:
13975  if ((Rc != OK) && (Rc != OK_FC))
13976  {
13977  dbug(1, dprintf("[%06lx] %s,%d: Adjust B enqueued failed %02x",
13978  UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
13979  }
13980  plci->adjust_b_parms_msg = NULL;
13981  plci->adjust_b_facilities = plci->B1_facilities;
13982  plci->adjust_b_command = ADJUST_B_RESTORE_2;
13983  plci->adjust_b_ncci = (word)(Id >> 16);
13984  plci->adjust_b_mode = ADJUST_B_MODE_RESTORE;
13985  plci->adjust_b_state = ADJUST_B_START;
13986  dbug(1, dprintf("[%06lx] %s,%d: Adjust B restore...",
13987  UnMapId(Id), (char *)(FILE_), __LINE__));
13988  case ADJUST_B_RESTORE_2:
13989  if (adjust_b_process(Id, plci, Rc) != GOOD)
13990  {
13991  dbug(1, dprintf("[%06lx] %s,%d: Adjust B restore failed",
13992  UnMapId(Id), (char *)(FILE_), __LINE__));
13993  }
13994  if (plci->internal_command)
13995  break;
13996  break;
13997  }
13998 }
13999 
14000 
14001 static void reset_b3_command(dword Id, PLCI *plci, byte Rc)
14002 {
14003  word Info;
14004  word internal_command;
14005 
14006  dbug(1, dprintf("[%06lx] %s,%d: reset_b3_command %02x %04x",
14007  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14008 
14009  Info = GOOD;
14010  internal_command = plci->internal_command;
14011  plci->internal_command = 0;
14012  switch (internal_command)
14013  {
14014  default:
14015  plci->command = 0;
14016  plci->adjust_b_parms_msg = NULL;
14017  plci->adjust_b_facilities = plci->B1_facilities;
14018  plci->adjust_b_command = RESET_B3_COMMAND_1;
14019  plci->adjust_b_ncci = (word)(Id >> 16);
14020  plci->adjust_b_mode = ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_CONNECT;
14021  plci->adjust_b_state = ADJUST_B_START;
14022  dbug(1, dprintf("[%06lx] %s,%d: Reset B3...",
14023  UnMapId(Id), (char *)(FILE_), __LINE__));
14024  case RESET_B3_COMMAND_1:
14025  Info = adjust_b_process(Id, plci, Rc);
14026  if (Info != GOOD)
14027  {
14028  dbug(1, dprintf("[%06lx] %s,%d: Reset failed",
14029  UnMapId(Id), (char *)(FILE_), __LINE__));
14030  break;
14031  }
14032  if (plci->internal_command)
14033  return;
14034  break;
14035  }
14036 /* sendf (plci->appl, _RESET_B3_R | CONFIRM, Id, plci->number, "w", Info);*/
14037  sendf(plci->appl, _RESET_B3_I, Id, 0, "s", "");
14038 }
14039 
14040 
14041 static void select_b_command(dword Id, PLCI *plci, byte Rc)
14042 {
14043  word Info;
14044  word internal_command;
14045  byte esc_chi[3];
14046 
14047  dbug(1, dprintf("[%06lx] %s,%d: select_b_command %02x %04x",
14048  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14049 
14050  Info = GOOD;
14051  internal_command = plci->internal_command;
14052  plci->internal_command = 0;
14053  switch (internal_command)
14054  {
14055  default:
14056  plci->command = 0;
14057  plci->adjust_b_parms_msg = &plci->saved_msg;
14058  if ((plci->tel == ADV_VOICE) && (plci == plci->adapter->AdvSignalPLCI))
14059  plci->adjust_b_facilities = plci->B1_facilities | B1_FACILITY_VOICE;
14060  else
14061  plci->adjust_b_facilities = plci->B1_facilities & ~B1_FACILITY_VOICE;
14062  plci->adjust_b_command = SELECT_B_COMMAND_1;
14063  plci->adjust_b_ncci = (word)(Id >> 16);
14064  if (plci->saved_msg.parms[0].length == 0)
14065  {
14066  plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_SWITCH_L1 |
14067  ADJUST_B_MODE_NO_RESOURCE;
14068  }
14069  else
14070  {
14071  plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_SWITCH_L1 |
14072  ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_USER_CONNECT | ADJUST_B_MODE_RESTORE;
14073  }
14074  plci->adjust_b_state = ADJUST_B_START;
14075  dbug(1, dprintf("[%06lx] %s,%d: Select B protocol...",
14076  UnMapId(Id), (char *)(FILE_), __LINE__));
14077  case SELECT_B_COMMAND_1:
14078  Info = adjust_b_process(Id, plci, Rc);
14079  if (Info != GOOD)
14080  {
14081  dbug(1, dprintf("[%06lx] %s,%d: Select B protocol failed",
14082  UnMapId(Id), (char *)(FILE_), __LINE__));
14083  break;
14084  }
14085  if (plci->internal_command)
14086  return;
14087  if (plci->tel == ADV_VOICE)
14088  {
14089  esc_chi[0] = 0x02;
14090  esc_chi[1] = 0x18;
14091  esc_chi[2] = plci->b_channel;
14092  SetVoiceChannel(plci->adapter->AdvCodecPLCI, esc_chi, plci->adapter);
14093  }
14094  break;
14095  }
14096  sendf(plci->appl, _SELECT_B_REQ | CONFIRM, Id, plci->number, "w", Info);
14097 }
14098 
14099 
14100 static void fax_connect_ack_command(dword Id, PLCI *plci, byte Rc)
14101 {
14102  word internal_command;
14103 
14104  dbug(1, dprintf("[%06lx] %s,%d: fax_connect_ack_command %02x %04x",
14105  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14106 
14107  internal_command = plci->internal_command;
14108  plci->internal_command = 0;
14109  switch (internal_command)
14110  {
14111  default:
14112  plci->command = 0;
14113  case FAX_CONNECT_ACK_COMMAND_1:
14114  if (plci_nl_busy(plci))
14115  {
14116  plci->internal_command = FAX_CONNECT_ACK_COMMAND_1;
14117  return;
14118  }
14119  plci->internal_command = FAX_CONNECT_ACK_COMMAND_2;
14120  plci->NData[0].P = plci->fax_connect_info_buffer;
14121  plci->NData[0].PLength = plci->fax_connect_info_length;
14122  plci->NL.X = plci->NData;
14123  plci->NL.ReqCh = 0;
14124  plci->NL.Req = plci->nl_req = (byte) N_CONNECT_ACK;
14125  plci->adapter->request(&plci->NL);
14126  return;
14127  case FAX_CONNECT_ACK_COMMAND_2:
14128  if ((Rc != OK) && (Rc != OK_FC))
14129  {
14130  dbug(1, dprintf("[%06lx] %s,%d: FAX issue CONNECT ACK failed %02x",
14131  UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14132  break;
14133  }
14134  }
14135  if ((plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
14136  && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
14137  {
14138  if (plci->B3_prot == 4)
14139  sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
14140  else
14141  sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
14142  plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
14143  }
14144 }
14145 
14146 
14147 static void fax_edata_ack_command(dword Id, PLCI *plci, byte Rc)
14148 {
14149  word internal_command;
14150 
14151  dbug(1, dprintf("[%06lx] %s,%d: fax_edata_ack_command %02x %04x",
14152  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14153 
14154  internal_command = plci->internal_command;
14155  plci->internal_command = 0;
14156  switch (internal_command)
14157  {
14158  default:
14159  plci->command = 0;
14160  case FAX_EDATA_ACK_COMMAND_1:
14161  if (plci_nl_busy(plci))
14162  {
14163  plci->internal_command = FAX_EDATA_ACK_COMMAND_1;
14164  return;
14165  }
14166  plci->internal_command = FAX_EDATA_ACK_COMMAND_2;
14167  plci->NData[0].P = plci->fax_connect_info_buffer;
14168  plci->NData[0].PLength = plci->fax_edata_ack_length;
14169  plci->NL.X = plci->NData;
14170  plci->NL.ReqCh = 0;
14171  plci->NL.Req = plci->nl_req = (byte) N_EDATA;
14172  plci->adapter->request(&plci->NL);
14173  return;
14174  case FAX_EDATA_ACK_COMMAND_2:
14175  if ((Rc != OK) && (Rc != OK_FC))
14176  {
14177  dbug(1, dprintf("[%06lx] %s,%d: FAX issue EDATA ACK failed %02x",
14178  UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14179  break;
14180  }
14181  }
14182 }
14183 
14184 
14185 static void fax_connect_info_command(dword Id, PLCI *plci, byte Rc)
14186 {
14187  word Info;
14188  word internal_command;
14189 
14190  dbug(1, dprintf("[%06lx] %s,%d: fax_connect_info_command %02x %04x",
14191  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14192 
14193  Info = GOOD;
14194  internal_command = plci->internal_command;
14195  plci->internal_command = 0;
14196  switch (internal_command)
14197  {
14198  default:
14199  plci->command = 0;
14200  case FAX_CONNECT_INFO_COMMAND_1:
14201  if (plci_nl_busy(plci))
14202  {
14203  plci->internal_command = FAX_CONNECT_INFO_COMMAND_1;
14204  return;
14205  }
14206  plci->internal_command = FAX_CONNECT_INFO_COMMAND_2;
14207  plci->NData[0].P = plci->fax_connect_info_buffer;
14208  plci->NData[0].PLength = plci->fax_connect_info_length;
14209  plci->NL.X = plci->NData;
14210  plci->NL.ReqCh = 0;
14211  plci->NL.Req = plci->nl_req = (byte) N_EDATA;
14212  plci->adapter->request(&plci->NL);
14213  return;
14214  case FAX_CONNECT_INFO_COMMAND_2:
14215  if ((Rc != OK) && (Rc != OK_FC))
14216  {
14217  dbug(1, dprintf("[%06lx] %s,%d: FAX setting connect info failed %02x",
14218  UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14219  Info = _WRONG_STATE;
14220  break;
14221  }
14222  if (plci_nl_busy(plci))
14223  {
14224  plci->internal_command = FAX_CONNECT_INFO_COMMAND_2;
14225  return;
14226  }
14227  plci->command = _CONNECT_B3_R;
14228  nl_req_ncci(plci, N_CONNECT, 0);
14229  send_req(plci);
14230  return;
14231  }
14232  sendf(plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info);
14233 }
14234 
14235 
14236 static void fax_adjust_b23_command(dword Id, PLCI *plci, byte Rc)
14237 {
14238  word Info;
14239  word internal_command;
14240 
14241  dbug(1, dprintf("[%06lx] %s,%d: fax_adjust_b23_command %02x %04x",
14242  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14243 
14244  Info = GOOD;
14245  internal_command = plci->internal_command;
14246  plci->internal_command = 0;
14247  switch (internal_command)
14248  {
14249  default:
14250  plci->command = 0;
14251  plci->adjust_b_parms_msg = NULL;
14252  plci->adjust_b_facilities = plci->B1_facilities;
14253  plci->adjust_b_command = FAX_ADJUST_B23_COMMAND_1;
14254  plci->adjust_b_ncci = (word)(Id >> 16);
14255  plci->adjust_b_mode = ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_ASSIGN_L23;
14256  plci->adjust_b_state = ADJUST_B_START;
14257  dbug(1, dprintf("[%06lx] %s,%d: FAX adjust B23...",
14258  UnMapId(Id), (char *)(FILE_), __LINE__));
14259  case FAX_ADJUST_B23_COMMAND_1:
14260  Info = adjust_b_process(Id, plci, Rc);
14261  if (Info != GOOD)
14262  {
14263  dbug(1, dprintf("[%06lx] %s,%d: FAX adjust failed",
14264  UnMapId(Id), (char *)(FILE_), __LINE__));
14265  break;
14266  }
14267  if (plci->internal_command)
14268  return;
14269  case FAX_ADJUST_B23_COMMAND_2:
14270  if (plci_nl_busy(plci))
14271  {
14272  plci->internal_command = FAX_ADJUST_B23_COMMAND_2;
14273  return;
14274  }
14275  plci->command = _CONNECT_B3_R;
14276  nl_req_ncci(plci, N_CONNECT, 0);
14277  send_req(plci);
14278  return;
14279  }
14280  sendf(plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info);
14281 }
14282 
14283 
14284 static void fax_disconnect_command(dword Id, PLCI *plci, byte Rc)
14285 {
14286  word internal_command;
14287 
14288  dbug(1, dprintf("[%06lx] %s,%d: fax_disconnect_command %02x %04x",
14289  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14290 
14291  internal_command = plci->internal_command;
14292  plci->internal_command = 0;
14293  switch (internal_command)
14294  {
14295  default:
14296  plci->command = 0;
14297  plci->internal_command = FAX_DISCONNECT_COMMAND_1;
14298  return;
14299  case FAX_DISCONNECT_COMMAND_1:
14300  case FAX_DISCONNECT_COMMAND_2:
14301  case FAX_DISCONNECT_COMMAND_3:
14302  if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0))
14303  {
14304  dbug(1, dprintf("[%06lx] %s,%d: FAX disconnect EDATA failed %02x",
14305  UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14306  break;
14307  }
14308  if (Rc == OK)
14309  {
14310  if ((internal_command == FAX_DISCONNECT_COMMAND_1)
14311  || (internal_command == FAX_DISCONNECT_COMMAND_2))
14312  {
14313  plci->internal_command = FAX_DISCONNECT_COMMAND_2;
14314  }
14315  }
14316  else if (Rc == 0)
14317  {
14318  if (internal_command == FAX_DISCONNECT_COMMAND_1)
14319  plci->internal_command = FAX_DISCONNECT_COMMAND_3;
14320  }
14321  return;
14322  }
14323 }
14324 
14325 
14326 
14327 static void rtp_connect_b3_req_command(dword Id, PLCI *plci, byte Rc)
14328 {
14329  word Info;
14330  word internal_command;
14331 
14332  dbug(1, dprintf("[%06lx] %s,%d: rtp_connect_b3_req_command %02x %04x",
14333  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14334 
14335  Info = GOOD;
14336  internal_command = plci->internal_command;
14337  plci->internal_command = 0;
14338  switch (internal_command)
14339  {
14340  default:
14341  plci->command = 0;
14342  case RTP_CONNECT_B3_REQ_COMMAND_1:
14343  if (plci_nl_busy(plci))
14344  {
14345  plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_1;
14346  return;
14347  }
14348  plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_2;
14349  nl_req_ncci(plci, N_CONNECT, 0);
14350  send_req(plci);
14351  return;
14352  case RTP_CONNECT_B3_REQ_COMMAND_2:
14353  if ((Rc != OK) && (Rc != OK_FC))
14354  {
14355  dbug(1, dprintf("[%06lx] %s,%d: RTP setting connect info failed %02x",
14356  UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14357  Info = _WRONG_STATE;
14358  break;
14359  }
14360  if (plci_nl_busy(plci))
14361  {
14362  plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_2;
14363  return;
14364  }
14365  plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_3;
14366  plci->NData[0].PLength = plci->internal_req_buffer[0];
14367  plci->NData[0].P = plci->internal_req_buffer + 1;
14368  plci->NL.X = plci->NData;
14369  plci->NL.ReqCh = 0;
14370  plci->NL.Req = plci->nl_req = (byte) N_UDATA;
14371  plci->adapter->request(&plci->NL);
14372  break;
14373  case RTP_CONNECT_B3_REQ_COMMAND_3:
14374  return;
14375  }
14376  sendf(plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info);
14377 }
14378 
14379 
14380 static void rtp_connect_b3_res_command(dword Id, PLCI *plci, byte Rc)
14381 {
14382  word internal_command;
14383 
14384  dbug(1, dprintf("[%06lx] %s,%d: rtp_connect_b3_res_command %02x %04x",
14385  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14386 
14387  internal_command = plci->internal_command;
14388  plci->internal_command = 0;
14389  switch (internal_command)
14390  {
14391  default:
14392  plci->command = 0;
14393  case RTP_CONNECT_B3_RES_COMMAND_1:
14394  if (plci_nl_busy(plci))
14395  {
14396  plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_1;
14397  return;
14398  }
14399  plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_2;
14400  nl_req_ncci(plci, N_CONNECT_ACK, (byte)(Id >> 16));
14401  send_req(plci);
14402  return;
14403  case RTP_CONNECT_B3_RES_COMMAND_2:
14404  if ((Rc != OK) && (Rc != OK_FC))
14405  {
14406  dbug(1, dprintf("[%06lx] %s,%d: RTP setting connect resp info failed %02x",
14407  UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14408  break;
14409  }
14410  if (plci_nl_busy(plci))
14411  {
14412  plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_2;
14413  return;
14414  }
14415  sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
14416  plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_3;
14417  plci->NData[0].PLength = plci->internal_req_buffer[0];
14418  plci->NData[0].P = plci->internal_req_buffer + 1;
14419  plci->NL.X = plci->NData;
14420  plci->NL.ReqCh = 0;
14421  plci->NL.Req = plci->nl_req = (byte) N_UDATA;
14422  plci->adapter->request(&plci->NL);
14423  return;
14424  case RTP_CONNECT_B3_RES_COMMAND_3:
14425  return;
14426  }
14427 }
14428 
14429 
14430 
14431 static void hold_save_command(dword Id, PLCI *plci, byte Rc)
14432 {
14433  byte SS_Ind[] = "\x05\x02\x00\x02\x00\x00"; /* Hold_Ind struct*/
14434  word Info;
14435  word internal_command;
14436 
14437  dbug(1, dprintf("[%06lx] %s,%d: hold_save_command %02x %04x",
14438  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14439 
14440  Info = GOOD;
14441  internal_command = plci->internal_command;
14442  plci->internal_command = 0;
14443  switch (internal_command)
14444  {
14445  default:
14446  if (!plci->NL.Id)
14447  break;
14448  plci->command = 0;
14449  plci->adjust_b_parms_msg = NULL;
14450  plci->adjust_b_facilities = plci->B1_facilities;
14451  plci->adjust_b_command = HOLD_SAVE_COMMAND_1;
14452  plci->adjust_b_ncci = (word)(Id >> 16);
14453  plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23;
14454  plci->adjust_b_state = ADJUST_B_START;
14455  dbug(1, dprintf("[%06lx] %s,%d: HOLD save...",
14456  UnMapId(Id), (char *)(FILE_), __LINE__));
14457  case HOLD_SAVE_COMMAND_1:
14458  Info = adjust_b_process(Id, plci, Rc);
14459  if (Info != GOOD)
14460  {
14461  dbug(1, dprintf("[%06lx] %s,%d: HOLD save failed",
14462  UnMapId(Id), (char *)(FILE_), __LINE__));
14463  break;
14464  }
14465  if (plci->internal_command)
14466  return;
14467  }
14468  sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", 3, SS_Ind);
14469 }
14470 
14471 
14472 static void retrieve_restore_command(dword Id, PLCI *plci, byte Rc)
14473 {
14474  byte SS_Ind[] = "\x05\x03\x00\x02\x00\x00"; /* Retrieve_Ind struct*/
14475  word Info;
14476  word internal_command;
14477 
14478  dbug(1, dprintf("[%06lx] %s,%d: retrieve_restore_command %02x %04x",
14479  UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14480 
14481  Info = GOOD;
14482  internal_command = plci->internal_command;
14483  plci->internal_command = 0;
14484  switch (internal_command)
14485  {
14486  default:
14487  plci->command = 0;
14488  plci->adjust_b_parms_msg = NULL;
14489  plci->adjust_b_facilities = plci->B1_facilities;
14490  plci->adjust_b_command = RETRIEVE_RESTORE_COMMAND_1;
14491  plci->adjust_b_ncci = (word)(Id >> 16);
14492  plci->adjust_b_mode = ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_USER_CONNECT | ADJUST_B_MODE_RESTORE;
14493  plci->adjust_b_state = ADJUST_B_START;
14494  dbug(1, dprintf("[%06lx] %s,%d: RETRIEVE restore...",
14495  UnMapId(Id), (char *)(FILE_), __LINE__));
14496  case RETRIEVE_RESTORE_COMMAND_1:
14497  Info = adjust_b_process(Id, plci, Rc);
14498  if (Info != GOOD)
14499  {
14500  dbug(1, dprintf("[%06lx] %s,%d: RETRIEVE restore failed",
14501  UnMapId(Id), (char *)(FILE_), __LINE__));
14502  break;
14503  }
14504  if (plci->internal_command)
14505  return;
14506  }
14507  sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", 3, SS_Ind);
14508 }
14509 
14510 
14511 static void init_b1_config(PLCI *plci)
14512 {
14513 
14514  dbug(1, dprintf("[%06lx] %s,%d: init_b1_config",
14515  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
14516  (char *)(FILE_), __LINE__));
14517 
14518  plci->B1_resource = 0;
14519  plci->B1_facilities = 0;
14520 
14521  plci->li_bchannel_id = 0;
14522  mixer_clear_config(plci);
14523 
14524 
14525  ec_clear_config(plci);
14526 
14527 
14528  dtmf_rec_clear_config(plci);
14529  dtmf_send_clear_config(plci);
14530  dtmf_parameter_clear_config(plci);
14531 
14532  adv_voice_clear_config(plci);
14533  adjust_b_clear(plci);
14534 }
14535 
14536 
14537 static void clear_b1_config(PLCI *plci)
14538 {
14539 
14540  dbug(1, dprintf("[%06lx] %s,%d: clear_b1_config",
14541  (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
14542  (char *)(FILE_), __LINE__));
14543 
14544  adv_voice_clear_config(plci);
14545  adjust_b_clear(plci);
14546 
14547  ec_clear_config(plci);
14548 
14549 
14550  dtmf_rec_clear_config(plci);
14551  dtmf_send_clear_config(plci);
14552  dtmf_parameter_clear_config(plci);
14553 
14554 
14555  if ((plci->li_bchannel_id != 0)
14556  && (li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci == plci))
14557  {
14558  mixer_clear_config(plci);
14559  li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci = NULL;
14560  plci->li_bchannel_id = 0;
14561  }
14562 
14563  plci->B1_resource = 0;
14564  plci->B1_facilities = 0;
14565 }
14566 
14567 
14568 /* -----------------------------------------------------------------
14569  XON protocol local helpers
14570  ----------------------------------------------------------------- */
14571 static void channel_flow_control_remove(PLCI *plci) {
14572  DIVA_CAPI_ADAPTER *a = plci->adapter;
14573  word i;
14574  for (i = 1; i < MAX_NL_CHANNEL + 1; i++) {
14575  if (a->ch_flow_plci[i] == plci->Id) {
14576  a->ch_flow_plci[i] = 0;
14577  a->ch_flow_control[i] = 0;
14578  }
14579  }
14580 }
14581 
14582 static void channel_x_on(PLCI *plci, byte ch) {
14583  DIVA_CAPI_ADAPTER *a = plci->adapter;
14584  if (a->ch_flow_control[ch] & N_XON_SENT) {
14585  a->ch_flow_control[ch] &= ~N_XON_SENT;
14586  }
14587 }
14588 
14589 static void channel_x_off(PLCI *plci, byte ch, byte flag) {
14590  DIVA_CAPI_ADAPTER *a = plci->adapter;
14591  if ((a->ch_flow_control[ch] & N_RX_FLOW_CONTROL_MASK) == 0) {
14592  a->ch_flow_control[ch] |= (N_CH_XOFF | flag);
14593  a->ch_flow_plci[ch] = plci->Id;
14594  a->ch_flow_control_pending++;
14595  }
14596 }
14597 
14598 static void channel_request_xon(PLCI *plci, byte ch) {
14599  DIVA_CAPI_ADAPTER *a = plci->adapter;
14600 
14601  if (a->ch_flow_control[ch] & N_CH_XOFF) {
14602  a->ch_flow_control[ch] |= N_XON_REQ;
14603  a->ch_flow_control[ch] &= ~N_CH_XOFF;
14604  a->ch_flow_control[ch] &= ~N_XON_CONNECT_IND;
14605  }
14606 }
14607 
14608 static void channel_xmit_extended_xon(PLCI *plci) {
14609  DIVA_CAPI_ADAPTER *a;
14610  int max_ch = ARRAY_SIZE(a->ch_flow_control);
14611  int i, one_requested = 0;
14612 
14613  if ((!plci) || (!plci->Id) || ((a = plci->adapter) == NULL)) {
14614  return;
14615  }
14616 
14617  for (i = 0; i < max_ch; i++) {
14618  if ((a->ch_flow_control[i] & N_CH_XOFF) &&
14619  (a->ch_flow_control[i] & N_XON_CONNECT_IND) &&
14620  (plci->Id == a->ch_flow_plci[i])) {
14621  channel_request_xon(plci, (byte)i);
14622  one_requested = 1;
14623  }
14624  }
14625 
14626  if (one_requested) {
14627  channel_xmit_xon(plci);
14628  }
14629 }
14630 
14631 /*
14632  Try to xmit next X_ON
14633 */
14634 static int find_channel_with_pending_x_on(DIVA_CAPI_ADAPTER *a, PLCI *plci) {
14635  int max_ch = ARRAY_SIZE(a->ch_flow_control);
14636  int i;
14637 
14638  if (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL)) {
14639  return (0);
14640  }
14641 
14642  if (a->last_flow_control_ch >= max_ch) {
14643  a->last_flow_control_ch = 1;
14644  }
14645  for (i = a->last_flow_control_ch; i < max_ch; i++) {
14646  if ((a->ch_flow_control[i] & N_XON_REQ) &&
14647  (plci->Id == a->ch_flow_plci[i])) {
14648  a->last_flow_control_ch = i + 1;
14649  return (i);
14650  }
14651  }
14652 
14653  for (i = 1; i < a->last_flow_control_ch; i++) {
14654  if ((a->ch_flow_control[i] & N_XON_REQ) &&
14655  (plci->Id == a->ch_flow_plci[i])) {
14656  a->last_flow_control_ch = i + 1;
14657  return (i);
14658  }
14659  }
14660 
14661  return (0);
14662 }
14663 
14664 static void channel_xmit_xon(PLCI *plci) {
14665  DIVA_CAPI_ADAPTER *a = plci->adapter;
14666  byte ch;
14667 
14668  if (plci->nl_req || !plci->NL.Id || plci->nl_remove_id) {
14669  return;
14670  }
14671  if ((ch = (byte)find_channel_with_pending_x_on(a, plci)) == 0) {
14672  return;
14673  }
14674  a->ch_flow_control[ch] &= ~N_XON_REQ;
14675  a->ch_flow_control[ch] |= N_XON_SENT;
14676 
14677  plci->NL.Req = plci->nl_req = (byte)N_XON;
14678  plci->NL.ReqCh = ch;
14679  plci->NL.X = plci->NData;
14680  plci->NL.XNum = 1;
14681  plci->NData[0].P = &plci->RBuffer[0];
14682  plci->NData[0].PLength = 0;
14683 
14684  plci->adapter->request(&plci->NL);
14685 }
14686 
14687 static int channel_can_xon(PLCI *plci, byte ch) {
14688  APPL *APPLptr;
14689  DIVA_CAPI_ADAPTER *a;
14690  word NCCIcode;
14691  dword count;
14692  word Num;
14693  word i;
14694 
14695  APPLptr = plci->appl;
14696  a = plci->adapter;
14697 
14698  if (!APPLptr)
14699  return (0);
14700 
14701  NCCIcode = a->ch_ncci[ch] | (((word) a->Id) << 8);
14702 
14703  /* count all buffers within the Application pool */
14704  /* belonging to the same NCCI. XON if a first is */
14705  /* used. */
14706  count = 0;
14707  Num = 0xffff;
14708  for (i = 0; i < APPLptr->MaxBuffer; i++) {
14709  if (NCCIcode == APPLptr->DataNCCI[i]) count++;
14710  if (!APPLptr->DataNCCI[i] && Num == 0xffff) Num = i;
14711  }
14712  if ((count > 2) || (Num == 0xffff)) {
14713  return (0);
14714  }
14715  return (1);
14716 }
14717 
14718 
14719 /*------------------------------------------------------------------*/
14720 
14721 static word CPN_filter_ok(byte *cpn, DIVA_CAPI_ADAPTER *a, word offset)
14722 {
14723  return 1;
14724 }
14725 
14726 
14727 
14728 /**********************************************************************************/
14729 /* function groups the listening applications according to the CIP mask and the */
14730 /* Info_Mask. Each group gets just one Connect_Ind. Some application manufacturer */
14731 /* are not multi-instance capable, so they start e.g. 30 applications what causes */
14732 /* big problems on application level (one call, 30 Connect_Ind, ect). The */
14733 /* function must be enabled by setting "a->group_optimization_enabled" from the */
14734 /* OS specific part (per adapter). */
14735 /**********************************************************************************/
14736 static void group_optimization(DIVA_CAPI_ADAPTER *a, PLCI *plci)
14737 {
14738  word i, j, k, busy, group_found;
14739  dword info_mask_group[MAX_CIP_TYPES];
14740  dword cip_mask_group[MAX_CIP_TYPES];
14741  word appl_number_group_type[MAX_APPL];
14742  PLCI *auxplci;
14743 
14744  set_group_ind_mask(plci); /* all APPLs within this inc. call are allowed to dial in */
14745 
14746  if (!a->group_optimization_enabled)
14747  {
14748  dbug(1, dprintf("No group optimization"));
14749  return;
14750  }
14751 
14752  dbug(1, dprintf("Group optimization = 0x%x...", a->group_optimization_enabled));
14753 
14754  for (i = 0; i < MAX_CIP_TYPES; i++)
14755  {
14756  info_mask_group[i] = 0;
14757  cip_mask_group[i] = 0;
14758  }
14759  for (i = 0; i < MAX_APPL; i++)
14760  {
14761  appl_number_group_type[i] = 0;
14762  }
14763  for (i = 0; i < max_appl; i++) /* check if any multi instance capable application is present */
14764  { /* group_optimization set to 1 means not to optimize multi-instance capable applications (default) */
14765  if (application[i].Id && (application[i].MaxNCCI) > 1 && (a->CIP_Mask[i]) && (a->group_optimization_enabled == 1))
14766  {
14767  dbug(1, dprintf("Multi-Instance capable, no optimization required"));
14768  return; /* allow good application unfiltered access */
14769  }
14770  }
14771  for (i = 0; i < max_appl; i++) /* Build CIP Groups */
14772  {
14773  if (application[i].Id && a->CIP_Mask[i])
14774  {
14775  for (k = 0, busy = false; k < a->max_plci; k++)
14776  {
14777  if (a->plci[k].Id)
14778  {
14779  auxplci = &a->plci[k];
14780  if (auxplci->appl == &application[i]) /* application has a busy PLCI */
14781  {
14782  busy = true;
14783  dbug(1, dprintf("Appl 0x%x is busy", i + 1));
14784  }
14785  else if (test_c_ind_mask_bit(auxplci, i)) /* application has an incoming call pending */
14786  {
14787  busy = true;
14788  dbug(1, dprintf("Appl 0x%x has inc. call pending", i + 1));
14789  }
14790  }
14791  }
14792 
14793  for (j = 0, group_found = 0; j <= (MAX_CIP_TYPES) && !busy && !group_found; j++) /* build groups with free applications only */
14794  {
14795  if (j == MAX_CIP_TYPES) /* all groups are in use but group still not found */
14796  { /* the MAX_CIP_TYPES group enables all calls because of field overflow */
14797  appl_number_group_type[i] = MAX_CIP_TYPES;
14798  group_found = true;
14799  dbug(1, dprintf("Field overflow appl 0x%x", i + 1));
14800  }
14801  else if ((info_mask_group[j] == a->CIP_Mask[i]) && (cip_mask_group[j] == a->Info_Mask[i]))
14802  { /* is group already present ? */
14803  appl_number_group_type[i] = j | 0x80; /* store the group number for each application */
14804  group_found = true;
14805  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]));
14806  }
14807  else if (!info_mask_group[j])
14808  { /* establish a new group */
14809  appl_number_group_type[i] = j | 0x80; /* store the group number for each application */
14810  info_mask_group[j] = a->CIP_Mask[i]; /* store the new CIP mask for the new group */
14811  cip_mask_group[j] = a->Info_Mask[i]; /* store the new Info_Mask for this new group */
14812  group_found = true;
14813  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]));
14814  }
14815  }
14816  }
14817  }
14818 
14819  for (i = 0; i < max_appl; i++) /* Build group_optimization_mask_table */
14820  {
14821  if (appl_number_group_type[i]) /* application is free, has listens and is member of a group */
14822  {
14823  if (appl_number_group_type[i] == MAX_CIP_TYPES)
14824  {
14825  dbug(1, dprintf("OverflowGroup 0x%x, valid appl = 0x%x, call enabled", appl_number_group_type[i], i + 1));
14826  }
14827  else
14828  {
14829  dbug(1, dprintf("Group 0x%x, valid appl = 0x%x", appl_number_group_type[i], i + 1));
14830  for (j = i + 1; j < max_appl; j++) /* search other group members and mark them as busy */
14831  {
14832  if (appl_number_group_type[i] == appl_number_group_type[j])
14833  {
14834  dbug(1, dprintf("Appl 0x%x is member of group 0x%x, no call", j + 1, appl_number_group_type[j]));
14835  clear_group_ind_mask_bit(plci, j); /* disable call on other group members */
14836  appl_number_group_type[j] = 0; /* remove disabled group member from group list */
14837  }
14838  }
14839  }
14840  }
14841  else /* application should not get a call */
14842  {
14843  clear_group_ind_mask_bit(plci, i);
14844  }
14845  }
14846 
14847 }
14848 
14849 
14850 
14851 /* OS notifies the driver about a application Capi_Register */
14852 word CapiRegister(word id)
14853 {
14854  word i, j, appls_found;
14855 
14856  PLCI *plci;
14857  DIVA_CAPI_ADAPTER *a;
14858 
14859  for (i = 0, appls_found = 0; i < max_appl; i++)
14860  {
14861  if (application[i].Id && (application[i].Id != id))
14862  {
14863  appls_found++; /* an application has been found */
14864  }
14865  }
14866 
14867  if (appls_found) return true;
14868  for (i = 0; i < max_adapter; i++) /* scan all adapters... */
14869  {
14870  a = &adapter[i];
14871  if (a->request)
14872  {
14873  if (a->flag_dynamic_l1_down) /* remove adapter from L1 tristate (Huntgroup) */
14874  {
14875  if (!appls_found) /* first application does a capi register */
14876  {
14877  if ((j = get_plci(a))) /* activate L1 of all adapters */
14878  {
14879  plci = &a->plci[j - 1];
14880  plci->command = 0;
14881  add_p(plci, OAD, "\x01\xfd");
14882  add_p(plci, CAI, "\x01\x80");
14883  add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
14884  add_p(plci, SHIFT | 6, NULL);
14885  add_p(plci, SIN, "\x02\x00\x00");
14886  plci->internal_command = START_L1_SIG_ASSIGN_PEND;
14887  sig_req(plci, ASSIGN, DSIG_ID);
14888  add_p(plci, FTY, "\x02\xff\x07"); /* l1 start */
14889  sig_req(plci, SIG_CTRL, 0);
14890  send_req(plci);
14891  }
14892  }
14893  }
14894  }
14895  }
14896  return false;
14897 }
14898 
14899 /*------------------------------------------------------------------*/
14900 
14901 /* Functions for virtual Switching e.g. Transfer by join, Conference */
14902 
14903 static void VSwitchReqInd(PLCI *plci, dword Id, byte **parms)
14904 {
14905  word i;
14906  /* Format of vswitch_t:
14907  0 byte length
14908  1 byte VSWITCHIE
14909  2 byte VSWITCH_REQ/VSWITCH_IND
14910  3 byte reserved
14911  4 word VSwitchcommand
14912  6 word returnerror
14913  8... Params
14914  */
14915  if (!plci ||
14916  !plci->appl ||
14917  !plci->State ||
14918  plci->Sig.Ind == NCR_FACILITY
14919  )
14920  return;
14921 
14922  for (i = 0; i < MAX_MULTI_IE; i++)
14923  {
14924  if (!parms[i][0]) continue;
14925  if (parms[i][0] < 7)
14926  {
14927  parms[i][0] = 0; /* kill it */
14928  continue;
14929  }
14930  dbug(1, dprintf("VSwitchReqInd(%d)", parms[i][4]));
14931  switch (parms[i][4])
14932  {
14933  case VSJOIN:
14934  if (!plci->relatedPTYPLCI ||
14935  (plci->ptyState != S_ECT && plci->relatedPTYPLCI->ptyState != S_ECT))
14936  { /* Error */
14937  break;
14938  }
14939  /* remember all necessary informations */
14940  if (parms[i][0] != 11 || parms[i][8] != 3) /* Length Test */
14941  {
14942  break;
14943  }
14944  if (parms[i][2] == VSWITCH_IND && parms[i][9] == 1)
14945  { /* first indication after ECT-Request on Consultation Call */
14946  plci->vswitchstate = parms[i][9];
14947  parms[i][9] = 2; /* State */
14948  /* now ask first Call to join */
14949  }
14950  else if (parms[i][2] == VSWITCH_REQ && parms[i][9] == 3)
14951  { /* Answer of VSWITCH_REQ from first Call */
14952  plci->vswitchstate = parms[i][9];
14953  /* tell consultation call to join
14954  and the protocol capabilities of the first call */
14955  }
14956  else
14957  { /* Error */
14958  break;
14959  }
14960  plci->vsprot = parms[i][10]; /* protocol */
14961  plci->vsprotdialect = parms[i][11]; /* protocoldialect */
14962  /* send join request to related PLCI */
14963  parms[i][1] = VSWITCHIE;
14964  parms[i][2] = VSWITCH_REQ;
14965 
14966  plci->relatedPTYPLCI->command = 0;
14967  plci->relatedPTYPLCI->internal_command = VSWITCH_REQ_PEND;
14968  add_p(plci->relatedPTYPLCI, ESC, &parms[i][0]);
14969  sig_req(plci->relatedPTYPLCI, VSWITCH_REQ, 0);
14970  send_req(plci->relatedPTYPLCI);
14971  break;
14972  case VSTRANSPORT:
14973  default:
14974  if (plci->relatedPTYPLCI &&
14975  plci->vswitchstate == 3 &&
14976  plci->relatedPTYPLCI->vswitchstate == 3)
14977  {
14978  add_p(plci->relatedPTYPLCI, ESC, &parms[i][0]);
14979  sig_req(plci->relatedPTYPLCI, VSWITCH_REQ, 0);
14980  send_req(plci->relatedPTYPLCI);
14981  }
14982  break;
14983  }
14984  parms[i][0] = 0; /* kill it */
14985  }
14986 }
14987 
14988 
14989 /*------------------------------------------------------------------*/
14990 
14991 static int diva_get_dma_descriptor(PLCI *plci, dword *dma_magic) {
14992  ENTITY e;
14993  IDI_SYNC_REQ *pReq = (IDI_SYNC_REQ *)&e;
14994 
14995  if (!(diva_xdi_extended_features & DIVA_CAPI_XDI_PROVIDES_RX_DMA)) {
14996  return (-1);
14997  }
14998 
14999  pReq->xdi_dma_descriptor_operation.Req = 0;
15000  pReq->xdi_dma_descriptor_operation.Rc = IDI_SYNC_REQ_DMA_DESCRIPTOR_OPERATION;
15001 
15002  pReq->xdi_dma_descriptor_operation.info.operation = IDI_SYNC_REQ_DMA_DESCRIPTOR_ALLOC;
15003  pReq->xdi_dma_descriptor_operation.info.descriptor_number = -1;
15004  pReq->xdi_dma_descriptor_operation.info.descriptor_address = NULL;
15005  pReq->xdi_dma_descriptor_operation.info.descriptor_magic = 0;
15006 
15007  e.user[0] = plci->adapter->Id - 1;
15008  plci->adapter->request((ENTITY *)pReq);
15009 
15010  if (!pReq->xdi_dma_descriptor_operation.info.operation &&
15011  (pReq->xdi_dma_descriptor_operation.info.descriptor_number >= 0) &&
15012  pReq->xdi_dma_descriptor_operation.info.descriptor_magic) {
15013  *dma_magic = pReq->xdi_dma_descriptor_operation.info.descriptor_magic;
15014  dbug(3, dprintf("dma_alloc, a:%d (%d-%08x)",
15015  plci->adapter->Id,
15016  pReq->xdi_dma_descriptor_operation.info.descriptor_number,
15017  *dma_magic));
15018  return (pReq->xdi_dma_descriptor_operation.info.descriptor_number);
15019  } else {
15020  dbug(1, dprintf("dma_alloc failed"));
15021  return (-1);
15022  }
15023 }
15024 
15025 static void diva_free_dma_descriptor(PLCI *plci, int nr) {
15026  ENTITY e;
15027  IDI_SYNC_REQ *pReq = (IDI_SYNC_REQ *)&e;
15028 
15029  if (nr < 0) {
15030  return;
15031  }
15032 
15033  pReq->xdi_dma_descriptor_operation.Req = 0;
15034  pReq->xdi_dma_descriptor_operation.Rc = IDI_SYNC_REQ_DMA_DESCRIPTOR_OPERATION;
15035 
15036  pReq->xdi_dma_descriptor_operation.info.operation = IDI_SYNC_REQ_DMA_DESCRIPTOR_FREE;
15037  pReq->xdi_dma_descriptor_operation.info.descriptor_number = nr;
15038  pReq->xdi_dma_descriptor_operation.info.descriptor_address = NULL;
15039  pReq->xdi_dma_descriptor_operation.info.descriptor_magic = 0;
15040 
15041  e.user[0] = plci->adapter->Id - 1;
15042  plci->adapter->request((ENTITY *)pReq);
15043 
15044  if (!pReq->xdi_dma_descriptor_operation.info.operation) {
15045  dbug(1, dprintf("dma_free(%d)", nr));
15046  } else {
15047  dbug(1, dprintf("dma_free failed (%d)", nr));
15048  }
15049 }
15050 
15051 /*------------------------------------------------------------------*/
Generated on Thu Jan 10 2013 13:41:35 for Linux Kernel by   doxygen 1.8.2