?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update checkpatch.pl to version 0.05
[pv_ops_mirror.git] / drivers / isdn / hardware / eicon / message.c
blobccd35d047ec8c314dc337e827ca3ad58b45ae767
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;
555 i<(sizeof(ftable)/sizeof(struct _ftable));
556 i++) {
557
558 if(ftable[i].command==msg->header.command) {
559 /* break loop if the message is correct, otherwise continue scan */
560 /* (for example: CONNECT_B3_T90_ACT_RES has two specifications) */
561 if(!api_parse(msg->info.b,(word)(msg->header.length-12),ftable[i].format,msg_parms)) {
562 ret = 0;
563 break;
564 }
565 for(j=0;j<MAX_MSG_PARMS+1;j++) msg_parms[j].length = 0;
566 }
567 }
568 if(ret) {
569 dbug(1,dprintf("BAD_MSG"));
570 if(plci) plci->command = 0;
571 return ret;
572 }
573
574
575 c = ftable[i].function(GET_DWORD(&msg->header.controller),
576 msg->header.number,
577 a,
578 plci,
579 appl,
580 msg_parms);
581
582 channel_xmit_extended_xon (plci);
583
584 if(c==1) send_req(plci);
585 if(c==2 && plci) plci->req_in = plci->req_in_start = plci->req_out = 0;
586 if(plci && !plci->req_in) plci->command = 0;
587 return 0;
588 }
589
590
591 /*------------------------------------------------------------------*/
592 /* api_parse function, check the format of api messages */
593 /*------------------------------------------------------------------*/
594
595 word api_parse(byte * msg, word length, byte * format, API_PARSE * parms)
596 {
597 word i;
598 word p;
599
600 for(i=0,p=0; format[i]; i++) {
601 if(parms)
602 {
603 parms[i].info = &msg[p];
604 }
605 switch(format[i]) {
606 case 'b':
607 p +=1;
608 break;
609 case 'w':
610 p +=2;
611 break;
612 case 'd':
613 p +=4;
614 break;
615 case 's':
616 if(msg[p]==0xff) {
617 parms[i].info +=2;
618 parms[i].length = msg[p+1] + (msg[p+2]<<8);
619 p +=(parms[i].length +3);
620 }
621 else {
622 parms[i].length = msg[p];
623 p +=(parms[i].length +1);
624 }
625 break;
626 }
627
628 if(p>length) return true;
629 }
630 if(parms) parms[i].info = NULL;
631 return false;
632 }
633
634 void api_save_msg(API_PARSE *in, byte *format, API_SAVE *out)
635 {
636 word i, j, n = 0;
637 byte *p;
638
639 p = out->info;
640 for (i = 0; format[i] != '\0'; i++)
641 {
642 out->parms[i].info = p;
643 out->parms[i].length = in[i].length;
644 switch (format[i])
645 {
646 case 'b':
647 n = 1;
648 break;
649 case 'w':
650 n = 2;
651 break;
652 case 'd':
653 n = 4;
654 break;
655 case 's':
656 n = in[i].length + 1;
657 break;
658 }
659 for (j = 0; j < n; j++)
660 *(p++) = in[i].info[j];
661 }
662 out->parms[i].info = NULL;
663 out->parms[i].length = 0;
664 }
665
666 void api_load_msg(API_SAVE *in, API_PARSE *out)
667 {
668 word i;
669
670 i = 0;
671 do
672 {
673 out[i].info = in->parms[i].info;
674 out[i].length = in->parms[i].length;
675 } while (in->parms[i++].info);
676 }
677
678
679 /*------------------------------------------------------------------*/
680 /* CAPI remove function */
681 /*------------------------------------------------------------------*/
682
683 word api_remove_start(void)
684 {
685 word i;
686 word j;
687
688 if(!remove_started) {
689 remove_started = true;
690 for(i=0;i<max_adapter;i++) {
691 if(adapter[i].request) {
692 for(j=0;j<adapter[i].max_plci;j++) {
693 if(adapter[i].plci[j].Sig.Id) plci_remove(&adapter[i].plci[j]);
694 }
695 }
696 }
697 return 1;
698 }
699 else {
700 for(i=0;i<max_adapter;i++) {
701 if(adapter[i].request) {
702 for(j=0;j<adapter[i].max_plci;j++) {
703 if(adapter[i].plci[j].Sig.Id) return 1;
704 }
705 }
706 }
707 }
708 api_remove_complete();
709 return 0;
710 }
711
712
713 /*------------------------------------------------------------------*/
714 /* internal command queue */
715 /*------------------------------------------------------------------*/
716
717 static void init_internal_command_queue (PLCI *plci)
718 {
719 word i;
720
721 dbug (1, dprintf ("%s,%d: init_internal_command_queue",
722 (char *)(FILE_), __LINE__));
723
724 plci->internal_command = 0;
725 for (i = 0; i < MAX_INTERNAL_COMMAND_LEVELS; i++)
726 plci->internal_command_queue[i] = NULL;
727 }
728
729
730 static void start_internal_command (dword Id, PLCI *plci, t_std_internal_command command_function)
731 {
732 word i;
733
734 dbug (1, dprintf ("[%06lx] %s,%d: start_internal_command",
735 UnMapId (Id), (char *)(FILE_), __LINE__));
736
737 if (plci->internal_command == 0)
738 {
739 plci->internal_command_queue[0] = command_function;
740 (* command_function)(Id, plci, OK);
741 }
742 else
743 {
744 i = 1;
745 while (plci->internal_command_queue[i] != 0)
746 i++;
747 plci->internal_command_queue[i] = command_function;
748 }
749 }
750
751
752 static void next_internal_command (dword Id, PLCI *plci)
753 {
754 word i;
755
756 dbug (1, dprintf ("[%06lx] %s,%d: next_internal_command",
757 UnMapId (Id), (char *)(FILE_), __LINE__));
758
759 plci->internal_command = 0;
760 plci->internal_command_queue[0] = NULL;
761 while (plci->internal_command_queue[1] != 0)
762 {
763 for (i = 0; i < MAX_INTERNAL_COMMAND_LEVELS - 1; i++)
764 plci->internal_command_queue[i] = plci->internal_command_queue[i+1];
765 plci->internal_command_queue[MAX_INTERNAL_COMMAND_LEVELS - 1] = NULL;
766 (*(plci->internal_command_queue[0]))(Id, plci, OK);
767 if (plci->internal_command != 0)
768 return;
769 plci->internal_command_queue[0] = NULL;
770 }
771 }
772
773
774 /*------------------------------------------------------------------*/
775 /* NCCI allocate/remove function */
776 /*------------------------------------------------------------------*/
777
778 static dword ncci_mapping_bug = 0;
779
780 static word get_ncci (PLCI *plci, byte ch, word force_ncci)
781 {
782 DIVA_CAPI_ADAPTER *a;
783 word ncci, i, j, k;
784
785 a = plci->adapter;
786 if (!ch || a->ch_ncci[ch])
787 {
788 ncci_mapping_bug++;
789 dbug(1,dprintf("NCCI mapping exists %ld %02x %02x %02x-%02x",
790 ncci_mapping_bug, ch, force_ncci, a->ncci_ch[a->ch_ncci[ch]], a->ch_ncci[ch]));
791 ncci = ch;
792 }
793 else
794 {
795 if (force_ncci)
796 ncci = force_ncci;
797 else
798 {
799 if ((ch < MAX_NCCI+1) && !a->ncci_ch[ch])
800 ncci = ch;
801 else
802 {
803 ncci = 1;
804 while ((ncci < MAX_NCCI+1) && a->ncci_ch[ncci])
805 ncci++;
806 if (ncci == MAX_NCCI+1)
807 {
808 ncci_mapping_bug++;
809 i = 1;
810 do
811 {
812 j = 1;
813 while ((j < MAX_NCCI+1) && (a->ncci_ch[j] != i))
814 j++;
815 k = j;
816 if (j < MAX_NCCI+1)
817 {
818 do
819 {
820 j++;
821 } while ((j < MAX_NCCI+1) && (a->ncci_ch[j] != i));
822 }
823 } while ((i < MAX_NL_CHANNEL+1) && (j < MAX_NCCI+1));
824 if (i < MAX_NL_CHANNEL+1)
825 {
826 dbug(1,dprintf("NCCI mapping overflow %ld %02x %02x %02x-%02x-%02x",
827 ncci_mapping_bug, ch, force_ncci, i, k, j));
828 }
829 else
830 {
831 dbug(1,dprintf("NCCI mapping overflow %ld %02x %02x",
832 ncci_mapping_bug, ch, force_ncci));
833 }
834 ncci = ch;
835 }
836 }
837 a->ncci_plci[ncci] = plci->Id;
838 a->ncci_state[ncci] = IDLE;
839 if (!plci->ncci_ring_list)
840 plci->ncci_ring_list = ncci;
841 else
842 a->ncci_next[ncci] = a->ncci_next[plci->ncci_ring_list];
843 a->ncci_next[plci->ncci_ring_list] = (byte) ncci;
844 }
845 a->ncci_ch[ncci] = ch;
846 a->ch_ncci[ch] = (byte) ncci;
847 dbug(1,dprintf("NCCI mapping established %ld %02x %02x %02x-%02x",
848 ncci_mapping_bug, ch, force_ncci, ch, ncci));
849 }
850 return (ncci);
851 }
852
853
854 static void ncci_free_receive_buffers (PLCI *plci, word ncci)
855 {
856 DIVA_CAPI_ADAPTER *a;
857 APPL *appl;
858 word i, ncci_code;
859 dword Id;
860
861 a = plci->adapter;
862 Id = (((dword) ncci) << 16) | (((word)(plci->Id)) << 8) | a->Id;
863 if (ncci)
864 {
865 if (a->ncci_plci[ncci] == plci->Id)
866 {
867 if (!plci->appl)
868 {
869 ncci_mapping_bug++;
870 dbug(1,dprintf("NCCI mapping appl expected %ld %08lx",
871 ncci_mapping_bug, Id));
872 }
873 else
874 {
875 appl = plci->appl;
876 ncci_code = ncci | (((word) a->Id) << 8);
877 for (i = 0; i < appl->MaxBuffer; i++)
878 {
879 if ((appl->DataNCCI[i] == ncci_code)
880 && (((byte)(appl->DataFlags[i] >> 8)) == plci->Id))
881 {
882 appl->DataNCCI[i] = 0;
883 }
884 }
885 }
886 }
887 }
888 else
889 {
890 for (ncci = 1; ncci < MAX_NCCI+1; ncci++)
891 {
892 if (a->ncci_plci[ncci] == plci->Id)
893 {
894 if (!plci->appl)
895 {
896 ncci_mapping_bug++;
897 dbug(1,dprintf("NCCI mapping no appl %ld %08lx",
898 ncci_mapping_bug, Id));
899 }
900 else
901 {
902 appl = plci->appl;
903 ncci_code = ncci | (((word) a->Id) << 8);
904 for (i = 0; i < appl->MaxBuffer; i++)
905 {
906 if ((appl->DataNCCI[i] == ncci_code)
907 && (((byte)(appl->DataFlags[i] >> 8)) == plci->Id))
908 {
909 appl->DataNCCI[i] = 0;
910 }
911 }
912 }
913 }
914 }
915 }
916 }
917
918
919 static void cleanup_ncci_data (PLCI *plci, word ncci)
920 {
921 NCCI *ncci_ptr;
922
923 if (ncci && (plci->adapter->ncci_plci[ncci] == plci->Id))
924 {
925 ncci_ptr = &(plci->adapter->ncci[ncci]);
926 if (plci->appl)
927 {
928 while (ncci_ptr->data_pending != 0)
929 {
930 if (!plci->data_sent || (ncci_ptr->DBuffer[ncci_ptr->data_out].P != plci->data_sent_ptr))
931 TransmitBufferFree (plci->appl, ncci_ptr->DBuffer[ncci_ptr->data_out].P);
932 (ncci_ptr->data_out)++;
933 if (ncci_ptr->data_out == MAX_DATA_B3)
934 ncci_ptr->data_out = 0;
935 (ncci_ptr->data_pending)--;
936 }
937 }
938 ncci_ptr->data_out = 0;
939 ncci_ptr->data_pending = 0;
940 ncci_ptr->data_ack_out = 0;
941 ncci_ptr->data_ack_pending = 0;
942 }
943 }
944
945
946 static void ncci_remove (PLCI *plci, word ncci, byte preserve_ncci)
947 {
948 DIVA_CAPI_ADAPTER *a;
949 dword Id;
950 word i;
951
952 a = plci->adapter;
953 Id = (((dword) ncci) << 16) | (((word)(plci->Id)) << 8) | a->Id;
954 if (!preserve_ncci)
955 ncci_free_receive_buffers (plci, ncci);
956 if (ncci)
957 {
958 if (a->ncci_plci[ncci] != plci->Id)
959 {
960 ncci_mapping_bug++;
961 dbug(1,dprintf("NCCI mapping doesn't exist %ld %08lx %02x",
962 ncci_mapping_bug, Id, preserve_ncci));
963 }
964 else
965 {
966 cleanup_ncci_data (plci, ncci);
967 dbug(1,dprintf("NCCI mapping released %ld %08lx %02x %02x-%02x",
968 ncci_mapping_bug, Id, preserve_ncci, a->ncci_ch[ncci], ncci));
969 a->ch_ncci[a->ncci_ch[ncci]] = 0;
970 if (!preserve_ncci)
971 {
972 a->ncci_ch[ncci] = 0;
973 a->ncci_plci[ncci] = 0;
974 a->ncci_state[ncci] = IDLE;
975 i = plci->ncci_ring_list;
976 while ((i != 0) && (a->ncci_next[i] != plci->ncci_ring_list) && (a->ncci_next[i] != ncci))
977 i = a->ncci_next[i];
978 if ((i != 0) && (a->ncci_next[i] == ncci))
979 {
980 if (i == ncci)
981 plci->ncci_ring_list = 0;
982 else if (plci->ncci_ring_list == ncci)
983 plci->ncci_ring_list = i;
984 a->ncci_next[i] = a->ncci_next[ncci];
985 }
986 a->ncci_next[ncci] = 0;
987 }
988 }
989 }
990 else
991 {
992 for (ncci = 1; ncci < MAX_NCCI+1; ncci++)
993 {
994 if (a->ncci_plci[ncci] == plci->Id)
995 {
996 cleanup_ncci_data (plci, ncci);
997 dbug(1,dprintf("NCCI mapping released %ld %08lx %02x %02x-%02x",
998 ncci_mapping_bug, Id, preserve_ncci, a->ncci_ch[ncci], ncci));
999 a->ch_ncci[a->ncci_ch[ncci]] = 0;
1000 if (!preserve_ncci)
1001 {
1002 a->ncci_ch[ncci] = 0;
1003 a->ncci_plci[ncci] = 0;
1004 a->ncci_state[ncci] = IDLE;
1005 a->ncci_next[ncci] = 0;
1006 }
1007 }
1008 }
1009 if (!preserve_ncci)
1010 plci->ncci_ring_list = 0;
1011 }
1012 }
1013
1014
1015 /*------------------------------------------------------------------*/
1016 /* PLCI remove function */
1017 /*------------------------------------------------------------------*/
1018
1019 static void plci_free_msg_in_queue (PLCI *plci)
1020 {
1021 word i;
1022
1023 if (plci->appl)
1024 {
1025 i = plci->msg_in_read_pos;
1026 while (i != plci->msg_in_write_pos)
1027 {
1028 if (i == plci->msg_in_wrap_pos)
1029 i = 0;
1030 if (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[i]))->header.command == _DATA_B3_R)
1031 {
1032
1033 TransmitBufferFree (plci->appl,
1034 (byte *)(long)(((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[i]))->info.data_b3_req.Data));
1035
1036 }
1037
1038 i += (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[i]))->header.length +
1039 MSG_IN_OVERHEAD + 3) & 0xfffc;
1040
1041 }
1042 }
1043 plci->msg_in_write_pos = MSG_IN_QUEUE_SIZE;
1044 plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
1045 plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
1046 }
1047
1048
1049 static void plci_remove(PLCI * plci)
1050 {
1051
1052 if(!plci) {
1053 dbug(1,dprintf("plci_remove(no plci)"));
1054 return;
1055 }
1056 init_internal_command_queue (plci);
1057 dbug(1,dprintf("plci_remove(%x,tel=%x)",plci->Id,plci->tel));
1058 if(plci_remove_check(plci))
1059 {
1060 return;
1061 }
1062 if (plci->Sig.Id == 0xff)
1063 {
1064 dbug(1,dprintf("D-channel X.25 plci->NL.Id:%0x", plci->NL.Id));
1065 if (plci->NL.Id && !plci->nl_remove_id)
1066 {
1067 nl_req_ncci(plci,REMOVE,0);
1068 send_req(plci);
1069 }
1070 }
1071 else
1072 {
1073 if (!plci->sig_remove_id
1074 && (plci->Sig.Id
1075 || (plci->req_in!=plci->req_out)
1076 || (plci->nl_req || plci->sig_req)))
1077 {
1078 sig_req(plci,HANGUP,0);
1079 send_req(plci);
1080 }
1081 }
1082 ncci_remove (plci, 0, false);
1083 plci_free_msg_in_queue (plci);
1084
1085 plci->channels = 0;
1086 plci->appl = NULL;
1087 if ((plci->State == INC_CON_PENDING) || (plci->State == INC_CON_ALERT))
1088 plci->State = OUTG_DIS_PENDING;
1089 }
1090
1091 /*------------------------------------------------------------------*/
1092 /* Application Group function helpers */
1093 /*------------------------------------------------------------------*/
1094
1095 static void set_group_ind_mask (PLCI *plci)
1096 {
1097 word i;
1098
1099 for (i = 0; i < C_IND_MASK_DWORDS; i++)
1100 plci->group_optimization_mask_table[i] = 0xffffffffL;
1101 }
1102
1103 static void clear_group_ind_mask_bit (PLCI *plci, word b)
1104 {
1105 plci->group_optimization_mask_table[b >> 5] &= ~(1L << (b & 0x1f));
1106 }
1107
1108 static byte test_group_ind_mask_bit (PLCI *plci, word b)
1109 {
1110 return ((plci->group_optimization_mask_table[b >> 5] & (1L << (b & 0x1f))) != 0);
1111 }
1112
1113 /*------------------------------------------------------------------*/
1114 /* c_ind_mask operations for arbitrary MAX_APPL */
1115 /*------------------------------------------------------------------*/
1116
1117 static void clear_c_ind_mask (PLCI *plci)
1118 {
1119 word i;
1120
1121 for (i = 0; i < C_IND_MASK_DWORDS; i++)
1122 plci->c_ind_mask_table[i] = 0;
1123 }
1124
1125 static byte c_ind_mask_empty (PLCI *plci)
1126 {
1127 word i;
1128
1129 i = 0;
1130 while ((i < C_IND_MASK_DWORDS) && (plci->c_ind_mask_table[i] == 0))
1131 i++;
1132 return (i == C_IND_MASK_DWORDS);
1133 }
1134
1135 static void set_c_ind_mask_bit (PLCI *plci, word b)
1136 {
1137 plci->c_ind_mask_table[b >> 5] |= (1L << (b & 0x1f));
1138 }
1139
1140 static void clear_c_ind_mask_bit (PLCI *plci, word b)
1141 {
1142 plci->c_ind_mask_table[b >> 5] &= ~(1L << (b & 0x1f));
1143 }
1144
1145 static byte test_c_ind_mask_bit (PLCI *plci, word b)
1146 {
1147 return ((plci->c_ind_mask_table[b >> 5] & (1L << (b & 0x1f))) != 0);
1148 }
1149
1150 static void dump_c_ind_mask (PLCI *plci)
1151 {
1152 static char hex_digit_table[0x10] =
1153 {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
1154 word i, j, k;
1155 dword d;
1156 char *p;
1157 char buf[40];
1158
1159 for (i = 0; i < C_IND_MASK_DWORDS; i += 4)
1160 {
1161 p = buf + 36;
1162 *p = '\0';
1163 for (j = 0; j < 4; j++)
1164 {
1165 if (i+j < C_IND_MASK_DWORDS)
1166 {
1167 d = plci->c_ind_mask_table[i+j];
1168 for (k = 0; k < 8; k++)
1169 {
1170 *(--p) = hex_digit_table[d & 0xf];
1171 d >>= 4;
1172 }
1173 }
1174 else if (i != 0)
1175 {
1176 for (k = 0; k < 8; k++)
1177 *(--p) = ' ';
1178 }
1179 *(--p) = ' ';
1180 }
1181 dbug(1,dprintf ("c_ind_mask =%s", (char *) p));
1182 }
1183 }
1184
1185
1186
1187
1188
1189 #define dump_plcis(a)
1190
1191
1192
1193 /*------------------------------------------------------------------*/
1194 /* translation function for each message */
1195 /*------------------------------------------------------------------*/
1196
1197 byte connect_req(dword Id, word Number, DIVA_CAPI_ADAPTER * a, PLCI * plci, APPL * appl, API_PARSE * parms)
1198 {
1199 word ch;
1200 word i;
1201 word Info;
1202 word CIP;
1203 byte LinkLayer;
1204 API_PARSE * ai;
1205 API_PARSE * bp;
1206 API_PARSE ai_parms[5];
1207 word channel = 0;
1208 dword ch_mask;
1209 byte m;
1210 static byte esc_chi[35] = {0x02,0x18,0x01};
1211 static byte lli[2] = {0x01,0x00};
1212 byte noCh = 0;
1213 word dir = 0;
1214 byte *p_chi = "";
1215
1216 for(i=0;i<5;i++) ai_parms[i].length = 0;
1217
1218 dbug(1,dprintf("connect_req(%d)",parms->length));
1219 Info = _WRONG_IDENTIFIER;
1220 if(a)
1221 {
1222 if(a->adapter_disabled)
1223 {
1224 dbug(1,dprintf("adapter disabled"));
1225 Id = ((word)1<<8)|a->Id;
1226 sendf(appl,_CONNECT_R|CONFIRM,Id,Number,"w",0);
1227 sendf(appl, _DISCONNECT_I, Id, 0, "w", _L1_ERROR);
1228 return false;
1229 }
1230 Info = _OUT_OF_PLCI;
1231 if((i=get_plci(a)))
1232 {
1233 Info = 0;
1234 plci = &a->plci[i-1];
1235 plci->appl = appl;
1236 plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
1237 /* check 'external controller' bit for codec support */
1238 if(Id & EXT_CONTROLLER)
1239 {
1240 if(AdvCodecSupport(a, plci, appl, 0) )
1241 {
1242 plci->Id = 0;
1243 sendf(appl, _CONNECT_R|CONFIRM, Id, Number, "w", _WRONG_IDENTIFIER);
1244 return 2;
1245 }
1246 }
1247 ai = &parms[9];
1248 bp = &parms[5];
1249 ch = 0;
1250 if(bp->length)LinkLayer = bp->info[3];
1251 else LinkLayer = 0;
1252 if(ai->length)
1253 {
1254 ch=0xffff;
1255 if(!api_parse(&ai->info[1],(word)ai->length,"ssss",ai_parms))
1256 {
1257 ch = 0;
1258 if(ai_parms[0].length)
1259 {
1260 ch = GET_WORD(ai_parms[0].info+1);
1261 if(ch>4) ch=0; /* safety -> ignore ChannelID */
1262 if(ch==4) /* explizit CHI in message */
1263 {
1264 /* check length of B-CH struct */
1265 if((ai_parms[0].info)[3]>=1)
1266 {
1267 if((ai_parms[0].info)[4]==CHI)
1268 {
1269 p_chi = &((ai_parms[0].info)[5]);
1270 }
1271 else
1272 {
1273 p_chi = &((ai_parms[0].info)[3]);
1274 }
1275 if(p_chi[0]>35) /* check length of channel ID */
1276 {
1277 Info = _WRONG_MESSAGE_FORMAT;
1278 }
1279 }
1280 else Info = _WRONG_MESSAGE_FORMAT;
1281 }
1282
1283 if(ch==3 && ai_parms[0].length>=7 && ai_parms[0].length<=36)
1284 {
1285 dir = GET_WORD(ai_parms[0].info+3);
1286 ch_mask = 0;
1287 m = 0x3f;
1288 for(i=0; i+5<=ai_parms[0].length; i++)
1289 {
1290 if(ai_parms[0].info[i+5]!=0)
1291 {
1292 if((ai_parms[0].info[i+5] | m) != 0xff)
1293 Info = _WRONG_MESSAGE_FORMAT;
1294 else
1295 {
1296 if (ch_mask == 0)
1297 channel = i;
1298 ch_mask |= 1L << i;
1299 }
1300 }
1301 m = 0;
1302 }
1303 if (ch_mask == 0)
1304 Info = _WRONG_MESSAGE_FORMAT;
1305 if (!Info)
1306 {
1307 if ((ai_parms[0].length == 36) || (ch_mask != ((dword)(1L << channel))))
1308 {
1309 esc_chi[0] = (byte)(ai_parms[0].length - 2);
1310 for(i=0; i+5<=ai_parms[0].length; i++)
1311 esc_chi[i+3] = ai_parms[0].info[i+5];
1312 }
1313 else
1314 esc_chi[0] = 2;
1315 esc_chi[2] = (byte)channel;
1316 plci->b_channel = (byte)channel; /* not correct for ETSI ch 17..31 */
1317 add_p(plci,LLI,lli);
1318 add_p(plci,ESC,esc_chi);
1319 plci->State = LOCAL_CONNECT;
1320 if(!dir) plci->call_dir |= CALL_DIR_FORCE_OUTG_NL; /* dir 0=DTE, 1=DCE */
1321 }
1322 }
1323 }
1324 }
1325 else Info = _WRONG_MESSAGE_FORMAT;
1326 }
1327
1328 dbug(1,dprintf("ch=%x,dir=%x,p_ch=%d",ch,dir,channel));
1329 plci->command = _CONNECT_R;
1330 plci->number = Number;
1331 /* x.31 or D-ch free SAPI in LinkLayer? */
1332 if(ch==1 && LinkLayer!=3 && LinkLayer!=12) noCh = true;
1333 if((ch==0 || ch==2 || noCh || ch==3 || ch==4) && !Info)
1334 {
1335 /* B-channel used for B3 connections (ch==0), or no B channel */
1336 /* is used (ch==2) or perm. connection (3) is used do a CALL */
1337 if(noCh) Info = add_b1(plci,&parms[5],2,0); /* no resource */
1338 else Info = add_b1(plci,&parms[5],ch,0);
1339 add_s(plci,OAD,&parms[2]);
1340 add_s(plci,OSA,&parms[4]);
1341 add_s(plci,BC,&parms[6]);
1342 add_s(plci,LLC,&parms[7]);
1343 add_s(plci,HLC,&parms[8]);
1344 CIP = GET_WORD(parms[0].info);
1345 if (a->Info_Mask[appl->Id-1] & 0x200)
1346 {
1347 /* early B3 connect (CIP mask bit 9) no release after a disc */
1348 add_p(plci,LLI,"\x01\x01");
1349 }
1350 if(GET_WORD(parms[0].info)<29) {
1351 add_p(plci,BC,cip_bc[GET_WORD(parms[0].info)][a->u_law]);
1352 add_p(plci,HLC,cip_hlc[GET_WORD(parms[0].info)]);
1353 }
1354 add_p(plci,UID,"\x06\x43\x61\x70\x69\x32\x30");
1355 sig_req(plci,ASSIGN,DSIG_ID);
1356 }
1357 else if(ch==1) {
1358
1359 /* D-Channel used for B3 connections */
1360 plci->Sig.Id = 0xff;
1361 Info = 0;
1362 }
1363
1364 if(!Info && ch!=2 && !noCh ) {
1365 Info = add_b23(plci,&parms[5]);
1366 if(!Info) {
1367 if(!(plci->tel && !plci->adv_nl))nl_req_ncci(plci,ASSIGN,0);
1368 }
1369 }
1370
1371 if(!Info)
1372 {
1373 if(ch==0 || ch==2 || ch==3 || noCh || ch==4)
1374 {
1375 if(plci->spoofed_msg==SPOOFING_REQUIRED)
1376 {
1377 api_save_msg(parms, "wsssssssss", &plci->saved_msg);
1378 plci->spoofed_msg = CALL_REQ;
1379 plci->internal_command = BLOCK_PLCI;
1380 plci->command = 0;
1381 dbug(1,dprintf("Spoof"));
1382 send_req(plci);
1383 return false;
1384 }
1385 if(ch==4)add_p(plci,CHI,p_chi);
1386 add_s(plci,CPN,&parms[1]);
1387 add_s(plci,DSA,&parms[3]);
1388 if(noCh) add_p(plci,ESC,"\x02\x18\xfd"); /* D-channel, no B-L3 */
1389 add_ai(plci,&parms[9]);
1390 if(!dir)sig_req(plci,CALL_REQ,0);
1391 else
1392 {
1393 plci->command = PERM_LIST_REQ;
1394 plci->appl = appl;
1395 sig_req(plci,LISTEN_REQ,0);
1396 send_req(plci);
1397 return false;
1398 }
1399 }
1400 send_req(plci);
1401 return false;
1402 }
1403 plci->Id = 0;
1404 }
1405 }
1406 sendf(appl,
1407 _CONNECT_R|CONFIRM,
1408 Id,
1409 Number,
1410 "w",Info);
1411 return 2;
1412 }
1413
1414 byte connect_res(dword Id, word Number, DIVA_CAPI_ADAPTER * a, PLCI * plci, APPL * appl, API_PARSE * parms)
1415 {
1416 word i, Info;
1417 word Reject;
1418 static byte cau_t[] = {0,0,0x90,0x91,0xac,0x9d,0x86,0xd8,0x9b};
1419 static byte esc_t[] = {0x03,0x08,0x00,0x00};
1420 API_PARSE * ai;
1421 API_PARSE ai_parms[5];
1422 word ch=0;
1423
1424 if(!plci) {
1425 dbug(1,dprintf("connect_res(no plci)"));
1426 return 0; /* no plci, no send */
1427 }
1428
1429 dbug(1,dprintf("connect_res(State=0x%x)",plci->State));
1430 for(i=0;i<5;i++) ai_parms[i].length = 0;
1431 ai = &parms[5];
1432 dbug(1,dprintf("ai->length=%d",ai->length));
1433
1434 if(ai->length)
1435 {
1436 if(!api_parse(&ai->info[1],(word)ai->length,"ssss",ai_parms))
1437 {
1438 dbug(1,dprintf("ai_parms[0].length=%d/0x%x",ai_parms[0].length,GET_WORD(ai_parms[0].info+1)));
1439 ch = 0;
1440 if(ai_parms[0].length)
1441 {
1442 ch = GET_WORD(ai_parms[0].info+1);
1443 dbug(1,dprintf("BCH-I=0x%x",ch));
1444 }
1445 }
1446 }
1447
1448 if(plci->State==INC_CON_CONNECTED_ALERT)
1449 {
1450 dbug(1,dprintf("Connected Alert Call_Res"));
1451 if (a->Info_Mask[appl->Id-1] & 0x200)
1452 {
1453 /* early B3 connect (CIP mask bit 9) no release after a disc */
1454 add_p(plci,LLI,"\x01\x01");
1455 }
1456 add_s(plci, CONN_NR, &parms[2]);
1457 add_s(plci, LLC, &parms[4]);
1458 add_ai(plci, &parms[5]);
1459 plci->State = INC_CON_ACCEPT;
1460 sig_req(plci, CALL_RES,0);
1461 return 1;
1462 }
1463 else if(plci->State==INC_CON_PENDING || plci->State==INC_CON_ALERT) {
1464 clear_c_ind_mask_bit (plci, (word)(appl->Id-1));
1465 dump_c_ind_mask (plci);
1466 Reject = GET_WORD(parms[0].info);
1467 dbug(1,dprintf("Reject=0x%x",Reject));
1468 if(Reject)
1469 {
1470 if(c_ind_mask_empty (plci))
1471 {
1472 if((Reject&0xff00)==0x3400)
1473 {
1474 esc_t[2] = ((byte)(Reject&0x00ff)) | 0x80;
1475 add_p(plci,ESC,esc_t);
1476 add_ai(plci, &parms[5]);
1477 sig_req(plci,REJECT,0);
1478 }
1479 else if(Reject==1 || Reject>9)
1480 {
1481 add_ai(plci, &parms[5]);
1482 sig_req(plci,HANGUP,0);
1483 }
1484 else
1485 {
1486 esc_t[2] = cau_t[(Reject&0x000f)];
1487 add_p(plci,ESC,esc_t);
1488 add_ai(plci, &parms[5]);
1489 sig_req(plci,REJECT,0);
1490 }
1491 plci->appl = appl;
1492 }
1493 else
1494 {
1495 sendf(appl, _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED);
1496 }
1497 }
1498 else {
1499 plci->appl = appl;
1500 if(Id & EXT_CONTROLLER){
1501 if(AdvCodecSupport(a, plci, appl, 0)){
1502 dbug(1,dprintf("connect_res(error from AdvCodecSupport)"));
1503 sig_req(plci,HANGUP,0);
1504 return 1;
1505 }
1506 if(plci->tel == ADV_VOICE && a->AdvCodecPLCI)
1507 {
1508 Info = add_b23(plci, &parms[1]);
1509 if (Info)
1510 {
1511 dbug(1,dprintf("connect_res(error from add_b23)"));
1512 sig_req(plci,HANGUP,0);
1513 return 1;
1514 }
1515 if(plci->adv_nl)
1516 {
1517 nl_req_ncci(plci, ASSIGN, 0);
1518 }
1519 }
1520 }
1521 else
1522 {
1523 plci->tel = 0;
1524 if(ch!=2)
1525 {
1526 Info = add_b23(plci, &parms[1]);
1527 if (Info)
1528 {
1529 dbug(1,dprintf("connect_res(error from add_b23 2)"));
1530 sig_req(plci,HANGUP,0);
1531 return 1;
1532 }
1533 }
1534 nl_req_ncci(plci, ASSIGN, 0);
1535 }
1536
1537 if(plci->spoofed_msg==SPOOFING_REQUIRED)
1538 {
1539 api_save_msg(parms, "wsssss", &plci->saved_msg);
1540 plci->spoofed_msg = CALL_RES;
1541 plci->internal_command = BLOCK_PLCI;
1542 plci->command = 0;
1543 dbug(1,dprintf("Spoof"));
1544 }
1545 else
1546 {
1547 add_b1 (plci, &parms[1], ch, plci->B1_facilities);
1548 if (a->Info_Mask[appl->Id-1] & 0x200)
1549 {
1550 /* early B3 connect (CIP mask bit 9) no release after a disc */
1551 add_p(plci,LLI,"\x01\x01");
1552 }
1553 add_s(plci, CONN_NR, &parms[2]);
1554 add_s(plci, LLC, &parms[4]);
1555 add_ai(plci, &parms[5]);
1556 plci->State = INC_CON_ACCEPT;
1557 sig_req(plci, CALL_RES,0);
1558 }
1559
1560 for(i=0; i<max_appl; i++) {
1561 if(test_c_ind_mask_bit (plci, i)) {
1562 sendf(&application[i], _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED);
1563 }
1564 }
1565 }
1566 }
1567 return 1;
1568 }
1569
1570 byte connect_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER * a, PLCI * plci, APPL * appl, API_PARSE * msg)
1571 {
1572 dbug(1,dprintf("connect_a_res"));
1573 return false;
1574 }
1575
1576 byte disconnect_req(dword Id, word Number, DIVA_CAPI_ADAPTER * a, 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 byte disconnect_res(dword Id, word Number, DIVA_CAPI_ADAPTER * a, PLCI * plci, APPL * appl, API_PARSE * msg)
1632 {
1633 dbug(1,dprintf("disconnect_res"));
1634 if(plci)
1635 {
1636 /* clear ind mask bit, just in case of collsion of */
1637 /* DISCONNECT_IND and CONNECT_RES */
1638 clear_c_ind_mask_bit (plci, (word)(appl->Id-1));
1639 ncci_free_receive_buffers (plci, 0);
1640 if(plci_remove_check(plci))
1641 {
1642 return 0;
1643 }
1644 if(plci->State==INC_DIS_PENDING
1645 || plci->State==SUSPENDING) {
1646 if(c_ind_mask_empty (plci)) {
1647 if(plci->State!=SUSPENDING)plci->State = IDLE;
1648 dbug(1,dprintf("chs=%d",plci->channels));
1649 if(!plci->channels) {
1650 plci_remove(plci);
1651 }
1652 }
1653 }
1654 }
1655 return 0;
1656 }
1657
1658 byte listen_req(dword Id, word Number, DIVA_CAPI_ADAPTER * a, PLCI * plci, APPL * appl, API_PARSE * parms)
1659 {
1660 word Info;
1661 byte i;
1662
1663 dbug(1,dprintf("listen_req(Appl=0x%x)",appl->Id));
1664
1665 Info = _WRONG_IDENTIFIER;
1666 if(a) {
1667 Info = 0;
1668 a->Info_Mask[appl->Id-1] = GET_DWORD(parms[0].info);
1669 a->CIP_Mask[appl->Id-1] = GET_DWORD(parms[1].info);
1670 dbug(1,dprintf("CIP_MASK=0x%lx",GET_DWORD(parms[1].info)));
1671 if (a->Info_Mask[appl->Id-1] & 0x200){ /* early B3 connect provides */
1672 a->Info_Mask[appl->Id-1] |= 0x10; /* call progression infos */
1673 }
1674
1675 /* check if external controller listen and switch listen on or off*/
1676 if(Id&EXT_CONTROLLER && GET_DWORD(parms[1].info)){
1677 if(a->profile.Global_Options & ON_BOARD_CODEC) {
1678 dummy_plci.State = IDLE;
1679 a->codec_listen[appl->Id-1] = &dummy_plci;
1680 a->TelOAD[0] = (byte)(parms[3].length);
1681 for(i=1;parms[3].length>=i && i<22;i++) {
1682 a->TelOAD[i] = parms[3].info[i];
1683 }
1684 a->TelOAD[i] = 0;
1685 a->TelOSA[0] = (byte)(parms[4].length);
1686 for(i=1;parms[4].length>=i && i<22;i++) {
1687 a->TelOSA[i] = parms[4].info[i];
1688 }
1689 a->TelOSA[i] = 0;
1690 }
1691 else Info = 0x2002; /* wrong controller, codec not supported */
1692 }
1693 else{ /* clear listen */
1694 a->codec_listen[appl->Id-1] = (PLCI *)0;
1695 }
1696 }
1697 sendf(appl,
1698 _LISTEN_R|CONFIRM,
1699 Id,
1700 Number,
1701 "w",Info);
1702
1703 if (a) listen_check(a);
1704 return false;
1705 }
1706
1707 byte info_req(dword Id, word Number, DIVA_CAPI_ADAPTER * a, PLCI * plci, APPL * appl, API_PARSE * msg)
1708 {
1709 word i;
1710 API_PARSE * ai;
1711 PLCI * rc_plci = NULL;
1712 API_PARSE ai_parms[5];
1713 word Info = 0;
1714
1715 dbug(1,dprintf("info_req"));
1716 for(i=0;i<5;i++) ai_parms[i].length = 0;
1717
1718 ai = &msg[1];
1719
1720 if(ai->length)
1721 {
1722 if(api_parse(&ai->info[1],(word)ai->length,"ssss",ai_parms))
1723 {
1724 dbug(1,dprintf("AddInfo wrong"));
1725 Info = _WRONG_MESSAGE_FORMAT;
1726 }
1727 }
1728 if(!a) Info = _WRONG_STATE;
1729
1730 if(!Info && plci)
1731 { /* no fac, with CPN, or KEY */
1732 rc_plci = plci;
1733 if(!ai_parms[3].length && plci->State && (msg[0].length || ai_parms[1].length) )
1734 {
1735 /* overlap sending option */
1736 dbug(1,dprintf("OvlSnd"));
1737 add_s(plci,CPN,&msg[0]);
1738 add_s(plci,KEY,&ai_parms[1]);
1739 sig_req(plci,INFO_REQ,0);
1740 send_req(plci);
1741 return false;
1742 }
1743
1744 if(plci->State && ai_parms[2].length)
1745 {
1746 /* User_Info option */
1747 dbug(1,dprintf("UUI"));
1748 add_s(plci,UUI,&ai_parms[2]);
1749 sig_req(plci,USER_DATA,0);
1750 }
1751 else if(plci->State && ai_parms[3].length)
1752 {
1753 /* Facility option */
1754 dbug(1,dprintf("FAC"));
1755 add_s(plci,CPN,&msg[0]);
1756 add_ai(plci, &msg[1]);
1757 sig_req(plci,FACILITY_REQ,0);
1758 }
1759 else
1760 {
1761 Info = _WRONG_STATE;
1762 }
1763 }
1764 else if((ai_parms[1].length || ai_parms[2].length || ai_parms[3].length) && !Info)
1765 {
1766 /* NCR_Facility option -> send UUI and Keypad too */
1767 dbug(1,dprintf("NCR_FAC"));
1768 if((i=get_plci(a)))
1769 {
1770 rc_plci = &a->plci[i-1];
1771 appl->NullCREnable = true;
1772 rc_plci->internal_command = C_NCR_FAC_REQ;
1773 rc_plci->appl = appl;
1774 add_p(rc_plci,CAI,"\x01\x80");
1775 add_p(rc_plci,UID,"\x06\x43\x61\x70\x69\x32\x30");
1776 sig_req(rc_plci,ASSIGN,DSIG_ID);
1777 send_req(rc_plci);
1778 }
1779 else
1780 {
1781 Info = _OUT_OF_PLCI;
1782 }
1783
1784 if(!Info)
1785 {
1786 add_s(rc_plci,CPN,&msg[0]);
1787 add_ai(rc_plci, &msg[1]);
1788 sig_req(rc_plci,NCR_FACILITY,0);
1789 send_req(rc_plci);
1790 return false;
1791 /* for application controlled supplementary services */
1792 }
1793 }
1794
1795 if (!rc_plci)
1796 {
1797 Info = _WRONG_MESSAGE_FORMAT;
1798 }
1799
1800 if(!Info)
1801 {
1802 send_req(rc_plci);
1803 }
1804 else
1805 { /* appl is not assigned to a PLCI or error condition */
1806 dbug(1,dprintf("localInfoCon"));
1807 sendf(appl,
1808 _INFO_R|CONFIRM,
1809 Id,
1810 Number,
1811 "w",Info);
1812 }
1813 return false;
1814 }
1815
1816 byte info_res(dword Id, word Number, DIVA_CAPI_ADAPTER * a, PLCI * plci, APPL * appl, API_PARSE * msg)
1817 {
1818 dbug(1,dprintf("info_res"));
1819 return false;
1820 }
1821
1822 byte alert_req(dword Id, word Number, DIVA_CAPI_ADAPTER * a, PLCI * plci, APPL * appl, API_PARSE * msg)
1823 {
1824 word Info;
1825 byte ret;
1826
1827 dbug(1,dprintf("alert_req"));
1828
1829 Info = _WRONG_IDENTIFIER;
1830 ret = false;
1831 if(plci) {
1832 Info = _ALERT_IGNORED;
1833 if(plci->State!=INC_CON_ALERT) {
1834 Info = _WRONG_STATE;
1835 if(plci->State==INC_CON_PENDING) {
1836 Info = 0;
1837 plci->State=INC_CON_ALERT;
1838 add_ai(plci, &msg[0]);
1839 sig_req(plci,CALL_ALERT,0);
1840 ret = 1;
1841 }
1842 }
1843 }
1844 sendf(appl,
1845 _ALERT_R|CONFIRM,
1846 Id,
1847 Number,
1848 "w",Info);
1849 return ret;
1850 }
1851
1852 byte facility_req(dword Id, word Number, DIVA_CAPI_ADAPTER * a, PLCI * plci, APPL * appl, API_PARSE * msg)
1853 {
1854 word Info = 0;
1855 word i = 0;
1856
1857 word selector;
1858 word SSreq;
1859 long relatedPLCIvalue;
1860 DIVA_CAPI_ADAPTER * relatedadapter;
1861 byte * SSparms = "";
1862 byte RCparms[] = "\x05\x00\x00\x02\x00\x00";
1863 byte SSstruct[] = "\x09\x00\x00\x06\x00\x00\x00\x00\x00\x00";
1864 API_PARSE * parms;
1865 API_PARSE ss_parms[11];
1866 PLCI *rplci;
1867 byte cai[15];
1868 dword d;
1869 API_PARSE dummy;
1870
1871 dbug(1,dprintf("facility_req"));
1872 for(i=0;i<9;i++) ss_parms[i].length = 0;
1873
1874 parms = &msg[1];
1875
1876 if(!a)
1877 {
1878 dbug(1,dprintf("wrong Ctrl"));
1879 Info = _WRONG_IDENTIFIER;
1880 }
1881
1882 selector = GET_WORD(msg[0].info);
1883
1884 if(!Info)
1885 {
1886 switch(selector)
1887 {
1888 case SELECTOR_HANDSET:
1889 Info = AdvCodecSupport(a, plci, appl, HOOK_SUPPORT);
1890 break;
1891
1892 case SELECTOR_SU_SERV:
1893 if(!msg[1].length)
1894 {
1895 Info = _WRONG_MESSAGE_FORMAT;
1896 break;
1897 }
1898 SSreq = GET_WORD(&(msg[1].info[1]));
1899 PUT_WORD(&RCparms[1],SSreq);
1900 SSparms = RCparms;
1901 switch(SSreq)
1902 {
1903 case S_GET_SUPPORTED_SERVICES:
1904 if((i=get_plci(a)))
1905 {
1906 rplci = &a->plci[i-1];
1907 rplci->appl = appl;
1908 add_p(rplci,CAI,"\x01\x80");
1909 add_p(rplci,UID,"\x06\x43\x61\x70\x69\x32\x30");
1910 sig_req(rplci,ASSIGN,DSIG_ID);
1911 send_req(rplci);
1912 }
1913 else
1914 {
1915 PUT_DWORD(&SSstruct[6], MASK_TERMINAL_PORTABILITY);
1916 SSparms = (byte *)SSstruct;
1917 break;
1918 }
1919 rplci->internal_command = GETSERV_REQ_PEND;
1920 rplci->number = Number;
1921 rplci->appl = appl;
1922 sig_req(rplci,S_SUPPORTED,0);
1923 send_req(rplci);
1924 return false;
1925 break;
1926
1927 case S_LISTEN:
1928 if(parms->length==7)
1929 {
1930 if(api_parse(&parms->info[1],(word)parms->length,"wbd",ss_parms))
1931 {
1932 dbug(1,dprintf("format wrong"));
1933 Info = _WRONG_MESSAGE_FORMAT;
1934 break;
1935 }
1936 }
1937 else
1938 {
1939 Info = _WRONG_MESSAGE_FORMAT;
1940 break;
1941 }
1942 a->Notification_Mask[appl->Id-1] = GET_DWORD(ss_parms[2].info);
1943 if(a->Notification_Mask[appl->Id-1] & SMASK_MWI) /* MWI active? */
1944 {
1945 if((i=get_plci(a)))
1946 {
1947 rplci = &a->plci[i-1];
1948 rplci->appl = appl;
1949 add_p(rplci,CAI,"\x01\x80");
1950 add_p(rplci,UID,"\x06\x43\x61\x70\x69\x32\x30");
1951 sig_req(rplci,ASSIGN,DSIG_ID);
1952 send_req(rplci);
1953 }
1954 else
1955 {
1956 break;
1957 }
1958 rplci->internal_command = GET_MWI_STATE;
1959 rplci->number = Number;
1960 sig_req(rplci,MWI_POLL,0);
1961 send_req(rplci);
1962 }
1963 break;
1964
1965 case S_HOLD:
1966 api_parse(&parms->info[1],(word)parms->length,"ws",ss_parms);
1967 if(plci && plci->State && plci->SuppState==IDLE)
1968 {
1969 plci->SuppState = HOLD_REQUEST;
1970 plci->command = C_HOLD_REQ;
1971 add_s(plci,CAI,&ss_parms[1]);
1972 sig_req(plci,CALL_HOLD,0);
1973 send_req(plci);
1974 return false;
1975 }
1976 else Info = 0x3010; /* wrong state */
1977 break;
1978 case S_RETRIEVE:
1979 if(plci && plci->State && plci->SuppState==CALL_HELD)
1980 {
1981 if(Id & EXT_CONTROLLER)
1982 {
1983 if(AdvCodecSupport(a, plci, appl, 0))
1984 {
1985 Info = 0x3010; /* wrong state */
1986 break;
1987 }
1988 }
1989 else plci->tel = 0;
1990
1991 plci->SuppState = RETRIEVE_REQUEST;
1992 plci->command = C_RETRIEVE_REQ;
1993 if(plci->spoofed_msg==SPOOFING_REQUIRED)
1994 {
1995 plci->spoofed_msg = CALL_RETRIEVE;
1996 plci->internal_command = BLOCK_PLCI;
1997 plci->command = 0;
1998 dbug(1,dprintf("Spoof"));
1999 return false;
2000 }
2001 else
2002 {
2003 sig_req(plci,CALL_RETRIEVE,0);
2004 send_req(plci);
2005 return false;
2006 }
2007 }
2008 else Info = 0x3010; /* wrong state */
2009 break;
2010 case S_SUSPEND:
2011 if(parms->length)
2012 {
2013 if(api_parse(&parms->info[1],(word)parms->length,"wbs",ss_parms))
2014 {
2015 dbug(1,dprintf("format wrong"));
2016 Info = _WRONG_MESSAGE_FORMAT;
2017 break;
2018 }
2019 }
2020 if(plci && plci->State)
2021 {
2022 add_s(plci,CAI,&ss_parms[2]);
2023 plci->command = SUSPEND_REQ;
2024 sig_req(plci,SUSPEND,0);
2025 plci->State = SUSPENDING;
2026 send_req(plci);
2027 }
2028 else Info = 0x3010; /* wrong state */
2029 break;
2030
2031 case S_RESUME:
2032 if(!(i=get_plci(a)) )
2033 {
2034 Info = _OUT_OF_PLCI;
2035 break;
2036 }
2037 rplci = &a->plci[i-1];
2038 rplci->appl = appl;
2039 rplci->number = Number;
2040 rplci->tel = 0;
2041 rplci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
2042 /* check 'external controller' bit for codec support */
2043 if(Id & EXT_CONTROLLER)
2044 {
2045 if(AdvCodecSupport(a, rplci, appl, 0) )
2046 {
2047 rplci->Id = 0;
2048 Info = 0x300A;
2049 break;
2050 }
2051 }
2052 if(parms->length)
2053 {
2054 if(api_parse(&parms->info[1],(word)parms->length,"wbs",ss_parms))
2055 {
2056 dbug(1,dprintf("format wrong"));
2057 rplci->Id = 0;
2058 Info = _WRONG_MESSAGE_FORMAT;
2059 break;
2060 }
2061 }
2062 dummy.length = 0;
2063 dummy.info = "\x00";
2064 add_b1(rplci, &dummy, 0, 0);
2065 if (a->Info_Mask[appl->Id-1] & 0x200)
2066 {
2067 /* early B3 connect (CIP mask bit 9) no release after a disc */
2068 add_p(rplci,LLI,"\x01\x01");
2069 }
2070 add_p(rplci,UID,"\x06\x43\x61\x70\x69\x32\x30");
2071 sig_req(rplci,ASSIGN,DSIG_ID);
2072 send_req(rplci);
2073 add_s(rplci,CAI,&ss_parms[2]);
2074 rplci->command = RESUME_REQ;
2075 sig_req(rplci,RESUME,0);
2076 rplci->State = RESUMING;
2077 send_req(rplci);
2078 break;
2079
2080 case S_CONF_BEGIN: /* Request */
2081 case S_CONF_DROP:
2082 case S_CONF_ISOLATE:
2083 case S_CONF_REATTACH:
2084 if(api_parse(&parms->info[1],(word)parms->length,"wbd",ss_parms))
2085 {
2086 dbug(1,dprintf("format wrong"));
2087 Info = _WRONG_MESSAGE_FORMAT;
2088 break;
2089 }
2090 if(plci && plci->State && ((plci->SuppState==IDLE)||(plci->SuppState==CALL_HELD)))
2091 {
2092 d = GET_DWORD(ss_parms[2].info);
2093 if(d>=0x80)
2094 {
2095 dbug(1,dprintf("format wrong"));
2096 Info = _WRONG_MESSAGE_FORMAT;
2097 break;
2098 }
2099 plci->ptyState = (byte)SSreq;
2100 plci->command = 0;
2101 cai[0] = 2;
2102 switch(SSreq)
2103 {
2104 case S_CONF_BEGIN:
2105 cai[1] = CONF_BEGIN;
2106 plci->internal_command = CONF_BEGIN_REQ_PEND;
2107 break;
2108 case S_CONF_DROP:
2109 cai[1] = CONF_DROP;
2110 plci->internal_command = CONF_DROP_REQ_PEND;
2111 break;
2112 case S_CONF_ISOLATE:
2113 cai[1] = CONF_ISOLATE;
2114 plci->internal_command = CONF_ISOLATE_REQ_PEND;
2115 break;
2116 case S_CONF_REATTACH:
2117 cai[1] = CONF_REATTACH;
2118 plci->internal_command = CONF_REATTACH_REQ_PEND;
2119 break;
2120 }
2121 cai[2] = (byte)d; /* Conference Size resp. PartyId */
2122 add_p(plci,CAI,cai);
2123 sig_req(plci,S_SERVICE,0);
2124 send_req(plci);
2125 return false;
2126 }
2127 else Info = 0x3010; /* wrong state */
2128 break;
2129
2130 case S_ECT:
2131 case S_3PTY_BEGIN:
2132 case S_3PTY_END:
2133 case S_CONF_ADD:
2134 if(parms->length==7)
2135 {
2136 if(api_parse(&parms->info[1],(word)parms->length,"wbd",ss_parms))
2137 {
2138 dbug(1,dprintf("format wrong"));
2139 Info = _WRONG_MESSAGE_FORMAT;
2140 break;
2141 }
2142 }
2143 else if(parms->length==8) /* workaround for the T-View-S */
2144 {
2145 if(api_parse(&parms->info[1],(word)parms->length,"wbdb",ss_parms))
2146 {
2147 dbug(1,dprintf("format wrong"));
2148 Info = _WRONG_MESSAGE_FORMAT;
2149 break;
2150 }
2151 }
2152 else
2153 {
2154 Info = _WRONG_MESSAGE_FORMAT;
2155 break;
2156 }
2157 if(!msg[1].length)
2158 {
2159 Info = _WRONG_MESSAGE_FORMAT;
2160 break;
2161 }
2162 if (!plci)
2163 {
2164 Info = _WRONG_IDENTIFIER;
2165 break;
2166 }
2167 relatedPLCIvalue = GET_DWORD(ss_parms[2].info);
2168 relatedPLCIvalue &= 0x0000FFFF;
2169 dbug(1,dprintf("PTY/ECT/addCONF,relPLCI=%lx",relatedPLCIvalue));
2170 /* controller starts with 0 up to (max_adapter - 1) */
2171 if (((relatedPLCIvalue & 0x7f) == 0)
2172 || (MapController ((byte)(relatedPLCIvalue & 0x7f)) == 0)
2173 || (MapController ((byte)(relatedPLCIvalue & 0x7f)) > max_adapter))
2174 {
2175 if(SSreq==S_3PTY_END)
2176 {
2177 dbug(1, dprintf("wrong Controller use 2nd PLCI=PLCI"));
2178 rplci = plci;
2179 }
2180 else
2181 {
2182 Info = 0x3010; /* wrong state */
2183 break;
2184 }
2185 }
2186 else
2187 {
2188 relatedadapter = &adapter[MapController ((byte)(relatedPLCIvalue & 0x7f))-1];
2189 relatedPLCIvalue >>=8;
2190 /* find PLCI PTR*/
2191 for(i=0,rplci=NULL;i<relatedadapter->max_plci;i++)
2192 {
2193 if(relatedadapter->plci[i].Id == (byte)relatedPLCIvalue)
2194 {
2195 rplci = &relatedadapter->plci[i];
2196 }
2197 }
2198 if(!rplci || !relatedPLCIvalue)
2199 {
2200 if(SSreq==S_3PTY_END)
2201 {
2202 dbug(1, dprintf("use 2nd PLCI=PLCI"));
2203 rplci = plci;
2204 }
2205 else
2206 {
2207 Info = 0x3010; /* wrong state */
2208 break;
2209 }
2210 }
2211 }
2212 /*
2213 dbug(1,dprintf("rplci:%x",rplci));
2214 dbug(1,dprintf("plci:%x",plci));
2215 dbug(1,dprintf("rplci->ptyState:%x",rplci->ptyState));
2216 dbug(1,dprintf("plci->ptyState:%x",plci->ptyState));
2217 dbug(1,dprintf("SSreq:%x",SSreq));
2218 dbug(1,dprintf("rplci->internal_command:%x",rplci->internal_command));
2219 dbug(1,dprintf("rplci->appl:%x",rplci->appl));
2220 dbug(1,dprintf("rplci->Id:%x",rplci->Id));
2221 */
2222 /* send PTY/ECT req, cannot check all states because of US stuff */
2223 if( !rplci->internal_command && rplci->appl )
2224 {
2225 plci->command = 0;
2226 rplci->relatedPTYPLCI = plci;
2227 plci->relatedPTYPLCI = rplci;
2228 rplci->ptyState = (byte)SSreq;
2229 if(SSreq==S_ECT)
2230 {
2231 rplci->internal_command = ECT_REQ_PEND;
2232 cai[1] = ECT_EXECUTE;
2233
2234 rplci->vswitchstate=0;
2235 rplci->vsprot=0;
2236 rplci->vsprotdialect=0;
2237 plci->vswitchstate=0;
2238 plci->vsprot=0;
2239 plci->vsprotdialect=0;
2240
2241 }
2242 else if(SSreq==S_CONF_ADD)
2243 {
2244 rplci->internal_command = CONF_ADD_REQ_PEND;
2245 cai[1] = CONF_ADD;
2246 }
2247 else
2248 {
2249 rplci->internal_command = PTY_REQ_PEND;
2250 cai[1] = (byte)(SSreq-3);
2251 }
2252 rplci->number = Number;
2253 if(plci!=rplci) /* explicit invocation */
2254 {
2255 cai[0] = 2;
2256 cai[2] = plci->Sig.Id;
2257 dbug(1,dprintf("explicit invocation"));
2258 }
2259 else
2260 {
2261 dbug(1,dprintf("implicit invocation"));
2262 cai[0] = 1;
2263 }
2264 add_p(rplci,CAI,cai);
2265 sig_req(rplci,S_SERVICE,0);
2266 send_req(rplci);
2267 return false;
2268 }
2269 else
2270 {
2271 dbug(0,dprintf("Wrong line"));
2272 Info = 0x3010; /* wrong state */
2273 break;
2274 }
2275 break;
2276
2277 case S_CALL_DEFLECTION:
2278 if(api_parse(&parms->info[1],(word)parms->length,"wbwss",ss_parms))
2279 {
2280 dbug(1,dprintf("format wrong"));
2281 Info = _WRONG_MESSAGE_FORMAT;
2282 break;
2283 }
2284 if (!plci)
2285 {
2286 Info = _WRONG_IDENTIFIER;
2287 break;
2288 }
2289 /* reuse unused screening indicator */
2290 ss_parms[3].info[3] = (byte)GET_WORD(&(ss_parms[2].info[0]));
2291 plci->command = 0;
2292 plci->internal_command = CD_REQ_PEND;
2293 appl->CDEnable = true;
2294 cai[0] = 1;
2295 cai[1] = CALL_DEFLECTION;
2296 add_p(plci,CAI,cai);
2297 add_p(plci,CPN,ss_parms[3].info);
2298 sig_req(plci,S_SERVICE,0);
2299 send_req(plci);
2300 return false;
2301 break;
2302
2303 case S_CALL_FORWARDING_START:
2304 if(api_parse(&parms->info[1],(word)parms->length,"wbdwwsss",ss_parms))
2305 {
2306 dbug(1,dprintf("format wrong"));
2307 Info = _WRONG_MESSAGE_FORMAT;
2308 break;
2309 }
2310
2311 if((i=get_plci(a)))
2312 {
2313 rplci = &a->plci[i-1];
2314 rplci->appl = appl;
2315 add_p(rplci,CAI,"\x01\x80");
2316 add_p(rplci,UID,"\x06\x43\x61\x70\x69\x32\x30");
2317 sig_req(rplci,ASSIGN,DSIG_ID);
2318 send_req(rplci);
2319 }
2320 else
2321 {
2322 Info = _OUT_OF_PLCI;
2323 break;
2324 }
2325
2326 /* reuse unused screening indicator */
2327 rplci->internal_command = CF_START_PEND;
2328 rplci->appl = appl;
2329 rplci->number = Number;
2330 appl->S_Handle = GET_DWORD(&(ss_parms[2].info[0]));
2331 cai[0] = 2;
2332 cai[1] = 0x70|(byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */
2333 cai[2] = (byte)GET_WORD(&(ss_parms[4].info[0])); /* Basic Service */
2334 add_p(rplci,CAI,cai);
2335 add_p(rplci,OAD,ss_parms[5].info);
2336 add_p(rplci,CPN,ss_parms[6].info);
2337 sig_req(rplci,S_SERVICE,0);
2338 send_req(rplci);
2339 return false;
2340 break;
2341
2342 case S_INTERROGATE_DIVERSION:
2343 case S_INTERROGATE_NUMBERS:
2344 case S_CALL_FORWARDING_STOP:
2345 case S_CCBS_REQUEST:
2346 case S_CCBS_DEACTIVATE:
2347 case S_CCBS_INTERROGATE:
2348 switch(SSreq)
2349 {
2350 case S_INTERROGATE_NUMBERS:
2351 if(api_parse(&parms->info[1],(word)parms->length,"wbd",ss_parms))
2352 {
2353 dbug(0,dprintf("format wrong"));
2354 Info = _WRONG_MESSAGE_FORMAT;
2355 }
2356 break;
2357 case S_CCBS_REQUEST:
2358 case S_CCBS_DEACTIVATE:
2359 if(api_parse(&parms->info[1],(word)parms->length,"wbdw",ss_parms))
2360 {
2361 dbug(0,dprintf("format wrong"));
2362 Info = _WRONG_MESSAGE_FORMAT;
2363 }
2364 break;
2365 case S_CCBS_INTERROGATE:
2366 if(api_parse(&parms->info[1],(word)parms->length,"wbdws",ss_parms))
2367 {
2368 dbug(0,dprintf("format wrong"));
2369 Info = _WRONG_MESSAGE_FORMAT;
2370 }
2371 break;
2372 default:
2373 if(api_parse(&parms->info[1],(word)parms->length,"wbdwws",ss_parms))
2374 {
2375 dbug(0,dprintf("format wrong"));
2376 Info = _WRONG_MESSAGE_FORMAT;
2377 break;
2378 }
2379 break;
2380 }
2381
2382 if(Info) break;
2383 if((i=get_plci(a)))
2384 {
2385 rplci = &a->plci[i-1];
2386 switch(SSreq)
2387 {
2388 case S_INTERROGATE_DIVERSION: /* use cai with S_SERVICE below */
2389 cai[1] = 0x60|(byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */
2390 rplci->internal_command = INTERR_DIVERSION_REQ_PEND; /* move to rplci if assigned */
2391 break;
2392 case S_INTERROGATE_NUMBERS: /* use cai with S_SERVICE below */
2393 cai[1] = DIVERSION_INTERROGATE_NUM; /* Function */
2394 rplci->internal_command = INTERR_NUMBERS_REQ_PEND; /* move to rplci if assigned */
2395 break;
2396 case S_CALL_FORWARDING_STOP:
2397 rplci->internal_command = CF_STOP_PEND;
2398 cai[1] = 0x80|(byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */
2399 break;
2400 case S_CCBS_REQUEST:
2401 cai[1] = CCBS_REQUEST;
2402 rplci->internal_command = CCBS_REQUEST_REQ_PEND;
2403 break;
2404 case S_CCBS_DEACTIVATE:
2405 cai[1] = CCBS_DEACTIVATE;
2406 rplci->internal_command = CCBS_DEACTIVATE_REQ_PEND;
2407 break;
2408 case S_CCBS_INTERROGATE:
2409 cai[1] = CCBS_INTERROGATE;
2410 rplci->internal_command = CCBS_INTERROGATE_REQ_PEND;
2411 break;
2412 default:
2413 cai[1] = 0;
2414 break;
2415 }
2416 rplci->appl = appl;
2417 rplci->number = Number;
2418 add_p(rplci,CAI,"\x01\x80");
2419 add_p(rplci,UID,"\x06\x43\x61\x70\x69\x32\x30");
2420 sig_req(rplci,ASSIGN,DSIG_ID);
2421 send_req(rplci);
2422 }
2423 else
2424 {
2425 Info = _OUT_OF_PLCI;
2426 break;
2427 }
2428
2429 appl->S_Handle = GET_DWORD(&(ss_parms[2].info[0]));
2430 switch(SSreq)
2431 {
2432 case S_INTERROGATE_NUMBERS:
2433 cai[0] = 1;
2434 add_p(rplci,CAI,cai);
2435 break;
2436 case S_CCBS_REQUEST:
2437 case S_CCBS_DEACTIVATE:
2438 cai[0] = 3;
2439 PUT_WORD(&cai[2],GET_WORD(&(ss_parms[3].info[0])));
2440 add_p(rplci,CAI,cai);
2441 break;
2442 case S_CCBS_INTERROGATE:
2443 cai[0] = 3;
2444 PUT_WORD(&cai[2],GET_WORD(&(ss_parms[3].info[0])));
2445 add_p(rplci,CAI,cai);
2446 add_p(rplci,OAD,ss_parms[4].info);
2447 break;
2448 default:
2449 cai[0] = 2;
2450 cai[2] = (byte)GET_WORD(&(ss_parms[4].info[0])); /* Basic Service */
2451 add_p(rplci,CAI,cai);
2452 add_p(rplci,OAD,ss_parms[5].info);
2453 break;
2454 }
2455
2456 sig_req(rplci,S_SERVICE,0);
2457 send_req(rplci);
2458 return false;
2459 break;
2460
2461 case S_MWI_ACTIVATE:
2462 if(api_parse(&parms->info[1],(word)parms->length,"wbwdwwwssss",ss_parms))
2463 {
2464 dbug(1,dprintf("format wrong"));
2465 Info = _WRONG_MESSAGE_FORMAT;
2466 break;
2467 }
2468 if(!plci)
2469 {
2470 if((i=get_plci(a)))
2471 {
2472 rplci = &a->plci[i-1];
2473 rplci->appl = appl;
2474 rplci->cr_enquiry=true;
2475 add_p(rplci,CAI,"\x01\x80");
2476 add_p(rplci,UID,"\x06\x43\x61\x70\x69\x32\x30");
2477 sig_req(rplci,ASSIGN,DSIG_ID);
2478 send_req(rplci);
2479 }
2480 else
2481 {
2482 Info = _OUT_OF_PLCI;
2483 break;
2484 }
2485 }
2486 else
2487 {
2488 rplci = plci;
2489 rplci->cr_enquiry=false;
2490 }
2491
2492 rplci->command = 0;
2493 rplci->internal_command = MWI_ACTIVATE_REQ_PEND;
2494 rplci->appl = appl;
2495 rplci->number = Number;
2496
2497 cai[0] = 13;
2498 cai[1] = ACTIVATION_MWI; /* Function */
2499 PUT_WORD(&cai[2],GET_WORD(&(ss_parms[2].info[0]))); /* Basic Service */
2500 PUT_DWORD(&cai[4],GET_DWORD(&(ss_parms[3].info[0]))); /* Number of Messages */
2501 PUT_WORD(&cai[8],GET_WORD(&(ss_parms[4].info[0]))); /* Message Status */
2502 PUT_WORD(&cai[10],GET_WORD(&(ss_parms[5].info[0]))); /* Message Reference */
2503 PUT_WORD(&cai[12],GET_WORD(&(ss_parms[6].info[0]))); /* Invocation Mode */
2504 add_p(rplci,CAI,cai);
2505 add_p(rplci,CPN,ss_parms[7].info); /* Receiving User Number */
2506 add_p(rplci,OAD,ss_parms[8].info); /* Controlling User Number */
2507 add_p(rplci,OSA,ss_parms[9].info); /* Controlling User Provided Number */
2508 add_p(rplci,UID,ss_parms[10].info); /* Time */
2509 sig_req(rplci,S_SERVICE,0);
2510 send_req(rplci);
2511 return false;
2512
2513 case S_MWI_DEACTIVATE:
2514 if(api_parse(&parms->info[1],(word)parms->length,"wbwwss",ss_parms))
2515 {
2516 dbug(1,dprintf("format wrong"));
2517 Info = _WRONG_MESSAGE_FORMAT;
2518 break;
2519 }
2520 if(!plci)
2521 {
2522 if((i=get_plci(a)))
2523 {
2524 rplci = &a->plci[i-1];
2525 rplci->appl = appl;
2526 rplci->cr_enquiry=true;
2527 add_p(rplci,CAI,"\x01\x80");
2528 add_p(rplci,UID,"\x06\x43\x61\x70\x69\x32\x30");
2529 sig_req(rplci,ASSIGN,DSIG_ID);
2530 send_req(rplci);
2531 }
2532 else
2533 {
2534 Info = _OUT_OF_PLCI;
2535 break;
2536 }
2537 }
2538 else
2539 {
2540 rplci = plci;
2541 rplci->cr_enquiry=false;
2542 }
2543
2544 rplci->command = 0;
2545 rplci->internal_command = MWI_DEACTIVATE_REQ_PEND;
2546 rplci->appl = appl;
2547 rplci->number = Number;
2548
2549 cai[0] = 5;
2550 cai[1] = DEACTIVATION_MWI; /* Function */
2551 PUT_WORD(&cai[2],GET_WORD(&(ss_parms[2].info[0]))); /* Basic Service */
2552 PUT_WORD(&cai[4],GET_WORD(&(ss_parms[3].info[0]))); /* Invocation Mode */
2553 add_p(rplci,CAI,cai);
2554 add_p(rplci,CPN,ss_parms[4].info); /* Receiving User Number */
2555 add_p(rplci,OAD,ss_parms[5].info); /* Controlling User Number */
2556 sig_req(rplci,S_SERVICE,0);
2557 send_req(rplci);
2558 return false;
2559
2560 default:
2561 Info = 0x300E; /* not supported */
2562 break;
2563 }
2564 break; /* case SELECTOR_SU_SERV: end */
2565
2566
2567 case SELECTOR_DTMF:
2568 return (dtmf_request (Id, Number, a, plci, appl, msg));
2569
2570
2571
2572 case SELECTOR_LINE_INTERCONNECT:
2573 return (mixer_request (Id, Number, a, plci, appl, msg));
2574
2575
2576
2577 case PRIV_SELECTOR_ECHO_CANCELLER:
2578 appl->appl_flags |= APPL_FLAG_PRIV_EC_SPEC;
2579 return (ec_request (Id, Number, a, plci, appl, msg));
2580
2581 case SELECTOR_ECHO_CANCELLER:
2582 appl->appl_flags &= ~APPL_FLAG_PRIV_EC_SPEC;
2583 return (ec_request (Id, Number, a, plci, appl, msg));
2584
2585
2586 case SELECTOR_V42BIS:
2587 default:
2588 Info = _FACILITY_NOT_SUPPORTED;
2589 break;
2590 } /* end of switch(selector) */
2591 }
2592
2593 dbug(1,dprintf("SendFacRc"));
2594 sendf(appl,
2595 _FACILITY_R|CONFIRM,
2596 Id,
2597 Number,
2598 "wws",Info,selector,SSparms);
2599 return false;
2600 }
2601
2602 byte facility_res(dword Id, word Number, DIVA_CAPI_ADAPTER * a, PLCI * plci, APPL * appl, API_PARSE * msg)
2603 {
2604 dbug(1,dprintf("facility_res"));
2605 return false;
2606 }
2607
2608 byte connect_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER * a, PLCI * plci, APPL * appl, API_PARSE * parms)
2609 {
2610 word Info = 0;
2611 byte req;
2612 byte len;
2613 word w;
2614 word fax_control_bits, fax_feature_bits, fax_info_change;
2615 API_PARSE * ncpi;
2616 byte pvc[2];
2617
2618 API_PARSE fax_parms[9];
2619 word i;
2620
2621
2622 dbug(1,dprintf("connect_b3_req"));
2623 if(plci)
2624 {
2625 if ((plci->State == IDLE) || (plci->State == OUTG_DIS_PENDING)
2626 || (plci->State == INC_DIS_PENDING) || (plci->SuppState != IDLE))
2627 {
2628 Info = _WRONG_STATE;
2629 }
2630 else
2631 {
2632 /* local reply if assign unsuccessfull
2633 or B3 protocol allows only one layer 3 connection
2634 and already connected
2635 or B2 protocol not any LAPD
2636 and connect_b3_req contradicts originate/answer direction */
2637 if (!plci->NL.Id
2638 || (((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE))
2639 && ((plci->channels != 0)
2640 || (((plci->B2_prot != B2_SDLC) && (plci->B2_prot != B2_LAPD) && (plci->B2_prot != B2_LAPD_FREE_SAPI_SEL))
2641 && ((plci->call_dir & CALL_DIR_ANSWER) && !(plci->call_dir & CALL_DIR_FORCE_OUTG_NL))))))
2642 {
2643 dbug(1,dprintf("B3 already connected=%d or no NL.Id=0x%x, dir=%d sstate=0x%x",
2644 plci->channels,plci->NL.Id,plci->call_dir,plci->SuppState));
2645 Info = _WRONG_STATE;
2646 sendf(appl,
2647 _CONNECT_B3_R|CONFIRM,
2648 Id,
2649 Number,
2650 "w",Info);
2651 return false;
2652 }
2653 plci->requested_options_conn = 0;
2654
2655 req = N_CONNECT;
2656 ncpi = &parms[0];
2657 if(plci->B3_prot==2 || plci->B3_prot==3)
2658 {
2659 if(ncpi->length>2)
2660 {
2661 /* check for PVC */
2662 if(ncpi->info[2] || ncpi->info[3])
2663 {
2664 pvc[0] = ncpi->info[3];
2665 pvc[1] = ncpi->info[2];
2666 add_d(plci,2,pvc);
2667 req = N_RESET;
2668 }
2669 else
2670 {
2671 if(ncpi->info[1] &1) req = N_CONNECT | N_D_BIT;
2672 add_d(plci,(word)(ncpi->length-3),&ncpi->info[4]);
2673 }
2674 }
2675 }
2676 else if(plci->B3_prot==5)
2677 {
2678 if (plci->NL.Id && !plci->nl_remove_id)
2679 {
2680 fax_control_bits = GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low);
2681 fax_feature_bits = GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->feature_bits_low);
2682 if (!(fax_control_bits & T30_CONTROL_BIT_MORE_DOCUMENTS)
2683 || (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS))
2684 {
2685 len = (byte)(&(((T30_INFO *) 0)->universal_6));
2686 fax_info_change = false;
2687 if (ncpi->length >= 4)
2688 {
2689 w = GET_WORD(&ncpi->info[3]);
2690 if ((w & 0x0001) != ((word)(((T30_INFO *)(plci->fax_connect_info_buffer))->resolution & 0x0001)))
2691 {
2692 ((T30_INFO *)(plci->fax_connect_info_buffer))->resolution =
2693 (byte)((((T30_INFO *)(plci->fax_connect_info_buffer))->resolution & ~T30_RESOLUTION_R8_0770_OR_200) |
2694 ((w & 0x0001) ? T30_RESOLUTION_R8_0770_OR_200 : 0));
2695 fax_info_change = true;
2696 }
2697 fax_control_bits &= ~(T30_CONTROL_BIT_REQUEST_POLLING | T30_CONTROL_BIT_MORE_DOCUMENTS);
2698 if (w & 0x0002) /* Fax-polling request */
2699 fax_control_bits |= T30_CONTROL_BIT_REQUEST_POLLING;
2700 if ((w & 0x0004) /* Request to send / poll another document */
2701 && (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_MORE_DOCUMENTS))
2702 {
2703 fax_control_bits |= T30_CONTROL_BIT_MORE_DOCUMENTS;
2704 }
2705 if (ncpi->length >= 6)
2706 {
2707 w = GET_WORD(&ncpi->info[5]);
2708 if (((byte) w) != ((T30_INFO *)(plci->fax_connect_info_buffer))->data_format)
2709 {
2710 ((T30_INFO *)(plci->fax_connect_info_buffer))->data_format = (byte) w;
2711 fax_info_change = true;
2712 }
2713
2714 if ((a->man_profile.private_options & (1L << PRIVATE_FAX_SUB_SEP_PWD))
2715 && (GET_WORD(&ncpi->info[5]) & 0x8000)) /* Private SEP/SUB/PWD enable */
2716 {
2717 plci->requested_options_conn |= (1L << PRIVATE_FAX_SUB_SEP_PWD);
2718 }
2719 if ((a->man_profile.private_options & (1L << PRIVATE_FAX_NONSTANDARD))
2720 && (GET_WORD(&ncpi->info[5]) & 0x4000)) /* Private non-standard facilities enable */
2721 {
2722 plci->requested_options_conn |= (1L << PRIVATE_FAX_NONSTANDARD);
2723 }
2724 fax_control_bits &= ~(T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_SEL_POLLING |
2725 T30_CONTROL_BIT_ACCEPT_PASSWORD);
2726 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id-1])
2727 & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
2728 {
2729 if (api_parse (&ncpi->info[1], ncpi->length, "wwwwsss", fax_parms))
2730 Info = _WRONG_MESSAGE_FORMAT;
2731 else
2732 {
2733 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id-1])
2734 & (1L << PRIVATE_FAX_SUB_SEP_PWD))
2735 {
2736 fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_PASSWORD;
2737 if (fax_control_bits & T30_CONTROL_BIT_ACCEPT_POLLING)
2738 fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SEL_POLLING;
2739 }
2740 w = fax_parms[4].length;
2741 if (w > 20)
2742 w = 20;
2743 ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id_len = (byte) w;
2744 for (i = 0; i < w; i++)
2745 ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id[i] = fax_parms[4].info[1+i];
2746 ((T30_INFO *)(plci->fax_connect_info_buffer))->head_line_len = 0;
2747 len = (byte)(((T30_INFO *) 0)->station_id + 20);
2748 w = fax_parms[5].length;
2749 if (w > 20)
2750 w = 20;
2751 plci->fax_connect_info_buffer[len++] = (byte) w;
2752 for (i = 0; i < w; i++)
2753 plci->fax_connect_info_buffer[len++] = fax_parms[5].info[1+i];
2754 w = fax_parms[6].length;
2755 if (w > 20)
2756 w = 20;
2757 plci->fax_connect_info_buffer[len++] = (byte) w;
2758 for (i = 0; i < w; i++)
2759 plci->fax_connect_info_buffer[len++] = fax_parms[6].info[1+i];
2760 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id-1])
2761 & (1L << PRIVATE_FAX_NONSTANDARD))
2762 {
2763 if (api_parse (&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms))
2764 {
2765 dbug(1,dprintf("non-standard facilities info missing or wrong format"));
2766 plci->fax_connect_info_buffer[len++] = 0;
2767 }
2768 else
2769 {
2770 if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2))
2771 plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]);
2772 plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length);
2773 for (i = 0; i < fax_parms[7].length; i++)
2774 plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1+i];
2775 }
2776 }
2777 }
2778 }
2779 else
2780 {
2781 len = (byte)(&(((T30_INFO *) 0)->universal_6));
2782 }
2783 fax_info_change = true;
2784
2785 }
2786 if (fax_control_bits != GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low))
2787 {
2788 PUT_WORD (&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low, fax_control_bits);
2789 fax_info_change = true;
2790 }
2791 }
2792 if (Info == GOOD)
2793 {
2794 plci->fax_connect_info_length = len;
2795 if (fax_info_change)
2796 {
2797 if (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS)
2798 {
2799 start_internal_command (Id, plci, fax_connect_info_command);
2800 return false;
2801 }
2802 else
2803 {
2804 start_internal_command (Id, plci, fax_adjust_b23_command);
2805 return false;
2806 }
2807 }
2808 }
2809 }
2810 else Info = _WRONG_STATE;
2811 }
2812 else Info = _WRONG_STATE;
2813 }
2814
2815 else if (plci->B3_prot == B3_RTP)
2816 {
2817 plci->internal_req_buffer[0] = ncpi->length + 1;
2818 plci->internal_req_buffer[1] = UDATA_REQUEST_RTP_RECONFIGURE;
2819 for (w = 0; w < ncpi->length; w++)
2820 plci->internal_req_buffer[2+w] = ncpi->info[1+w];
2821 start_internal_command (Id, plci, rtp_connect_b3_req_command);
2822 return false;
2823 }
2824
2825 if(!Info)
2826 {
2827 nl_req_ncci(plci,req,0);
2828 return 1;
2829 }
2830 }
2831 }
2832 else Info = _WRONG_IDENTIFIER;
2833
2834 sendf(appl,
2835 _CONNECT_B3_R|CONFIRM,
2836 Id,
2837 Number,
2838 "w",Info);
2839 return false;
2840 }
2841
2842 byte connect_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER * a, PLCI * plci, APPL * appl, API_PARSE * parms)
2843 {
2844 word ncci;
2845 API_PARSE * ncpi;
2846 byte req;
2847
2848 word w;
2849
2850
2851 API_PARSE fax_parms[9];
2852 word i;
2853 byte len;
2854
2855
2856 dbug(1,dprintf("connect_b3_res"));
2857
2858 ncci = (word)(Id>>16);
2859 if(plci && ncci) {
2860 if(a->ncci_state[ncci]==INC_CON_PENDING) {
2861 if (GET_WORD (&parms[0].info[0]) != 0)
2862 {
2863 a->ncci_state[ncci] = OUTG_REJ_PENDING;
2864 channel_request_xon (plci, a->ncci_ch[ncci]);
2865 channel_xmit_xon (plci);
2866 cleanup_ncci_data (plci, ncci);
2867 nl_req_ncci(plci,N_DISC,(byte)ncci);
2868 return 1;
2869 }
2870 a->ncci_state[ncci] = INC_ACT_PENDING;
2871
2872 req = N_CONNECT_ACK;
2873 ncpi = &parms[1];
2874 if ((plci->B3_prot == 4) || (plci->B3_prot == 5) || (plci->B3_prot == 7))
2875 {
2876
2877 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id-1])
2878 & (1L << PRIVATE_FAX_NONSTANDARD))
2879 {
2880 if (((plci->B3_prot == 4) || (plci->B3_prot == 5))
2881 && (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF)
2882 && (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP))
2883 {
2884 len = ((byte)(((T30_INFO *) 0)->station_id + 20));
2885 if (plci->fax_connect_info_length < len)
2886 {
2887 ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id_len = 0;
2888 ((T30_INFO *)(plci->fax_connect_info_buffer))->head_line_len = 0;
2889 }
2890 if (api_parse (&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms))
2891 {
2892 dbug(1,dprintf("non-standard facilities info missing or wrong format"));
2893 }
2894 else
2895 {
2896 if (plci->fax_connect_info_length <= len)
2897 plci->fax_connect_info_buffer[len] = 0;
2898 len += 1 + plci->fax_connect_info_buffer[len];
2899 if (plci->fax_connect_info_length <= len)
2900 plci->fax_connect_info_buffer[len] = 0;
2901 len += 1 + plci->fax_connect_info_buffer[len];
2902 if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2))
2903 plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]);
2904 plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length);
2905 for (i = 0; i < fax_parms[7].length; i++)
2906 plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1+i];
2907 }
2908 plci->fax_connect_info_length = len;
2909 ((T30_INFO *)(plci->fax_connect_info_buffer))->code = 0;
2910 start_internal_command (Id, plci, fax_connect_ack_command);
2911 return false;
2912 }
2913 }
2914
2915 nl_req_ncci(plci,req,(byte)ncci);
2916 if ((plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
2917 && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
2918 {
2919 if (plci->B3_prot == 4)
2920 sendf(appl,_CONNECT_B3_ACTIVE_I,Id,0,"s","");
2921 else
2922 sendf(appl,_CONNECT_B3_ACTIVE_I,Id,0,"S",plci->ncpi_buffer);
2923 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
2924 }
2925 }
2926
2927 else if (plci->B3_prot == B3_RTP)
2928 {
2929 plci->internal_req_buffer[0] = ncpi->length + 1;
2930 plci->internal_req_buffer[1] = UDATA_REQUEST_RTP_RECONFIGURE;
2931 for (w = 0; w < ncpi->length; w++)
2932 plci->internal_req_buffer[2+w] = ncpi->info[1+w];
2933 start_internal_command (Id, plci, rtp_connect_b3_res_command);
2934 return false;
2935 }
2936
2937 else
2938 {
2939 if(ncpi->length>2) {
2940 if(ncpi->info[1] &1) req = N_CONNECT_ACK | N_D_BIT;
2941 add_d(plci,(word)(ncpi->length-3),&ncpi->info[4]);
2942 }
2943 nl_req_ncci(plci,req,(byte)ncci);
2944 sendf(appl,_CONNECT_B3_ACTIVE_I,Id,0,"s","");
2945 if (plci->adjust_b_restore)
2946 {
2947 plci->adjust_b_restore = false;
2948 start_internal_command (Id, plci, adjust_b_restore);
2949 }
2950 }
2951 return 1;
2952 }
2953 }
2954 return false;
2955 }
2956
2957 byte connect_b3_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER * a, PLCI * plci, APPL * appl, API_PARSE * parms)
2958 {
2959 word ncci;
2960
2961 ncci = (word)(Id>>16);
2962 dbug(1,dprintf("connect_b3_a_res(ncci=0x%x)",ncci));
2963
2964 if (plci && ncci && (plci->State != IDLE) && (plci->State != INC_DIS_PENDING)
2965 && (plci->State != OUTG_DIS_PENDING))
2966 {
2967 if(a->ncci_state[ncci]==INC_ACT_PENDING) {
2968 a->ncci_state[ncci] = CONNECTED;
2969 if(plci->State!=INC_CON_CONNECTED_ALERT) plci->State = CONNECTED;
2970 channel_request_xon (plci, a->ncci_ch[ncci]);
2971 channel_xmit_xon (plci);
2972 }
2973 }
2974 return false;
2975 }
2976
2977 byte disconnect_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER * a, PLCI * plci, APPL * appl, API_PARSE * parms)
2978 {
2979 word Info;
2980 word ncci;
2981 API_PARSE * ncpi;
2982
2983 dbug(1,dprintf("disconnect_b3_req"));
2984
2985 Info = _WRONG_IDENTIFIER;
2986 ncci = (word)(Id>>16);
2987 if (plci && ncci)
2988 {
2989 Info = _WRONG_STATE;
2990 if ((a->ncci_state[ncci] == CONNECTED)
2991 || (a->ncci_state[ncci] == OUTG_CON_PENDING)
2992 || (a->ncci_state[ncci] == INC_CON_PENDING)
2993 || (a->ncci_state[ncci] == INC_ACT_PENDING))
2994 {
2995 a->ncci_state[ncci] = OUTG_DIS_PENDING;
2996 channel_request_xon (plci, a->ncci_ch[ncci]);
2997 channel_xmit_xon (plci);
2998
2999 if (a->ncci[ncci].data_pending
3000 && ((plci->B3_prot == B3_TRANSPARENT)
3001 || (plci->B3_prot == B3_T30)
3002 || (plci->B3_prot == B3_T30_WITH_EXTENSIONS)))
3003 {
3004 plci->send_disc = (byte)ncci;
3005 plci->command = 0;
3006 return false;
3007 }
3008 else
3009 {
3010 cleanup_ncci_data (plci, ncci);
3011
3012 if(plci->B3_prot==2 || plci->B3_prot==3)
3013 {
3014 ncpi = &parms[0];
3015 if(ncpi->length>3)
3016 {
3017 add_d(plci, (word)(ncpi->length - 3) ,(byte *)&(ncpi->info[4]));
3018 }
3019 }
3020 nl_req_ncci(plci,N_DISC,(byte)ncci);
3021 }
3022 return 1;
3023 }
3024 }
3025 sendf(appl,
3026 _DISCONNECT_B3_R|CONFIRM,
3027 Id,
3028 Number,
3029 "w",Info);
3030 return false;
3031 }
3032
3033 byte disconnect_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER * a, PLCI * plci, APPL * appl, API_PARSE * parms)
3034 {
3035 word ncci;
3036 word i;
3037
3038 ncci = (word)(Id>>16);
3039 dbug(1,dprintf("disconnect_b3_res(ncci=0x%x",ncci));
3040 if(plci && ncci) {
3041 plci->requested_options_conn = 0;
3042 plci->fax_connect_info_length = 0;
3043 plci->ncpi_state = 0x00;
3044 if (((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE))
3045 && ((plci->B2_prot != B2_LAPD) && (plci->B2_prot != B2_LAPD_FREE_SAPI_SEL)))
3046 {
3047 plci->call_dir |= CALL_DIR_FORCE_OUTG_NL;
3048 }
3049 for(i=0; i<MAX_CHANNELS_PER_PLCI && plci->inc_dis_ncci_table[i]!=(byte)ncci; i++);
3050 if(i<MAX_CHANNELS_PER_PLCI) {
3051 if(plci->channels)plci->channels--;
3052 for(; i<MAX_CHANNELS_PER_PLCI-1; i++) plci->inc_dis_ncci_table[i] = plci->inc_dis_ncci_table[i+1];
3053 plci->inc_dis_ncci_table[MAX_CHANNELS_PER_PLCI-1] = 0;
3054
3055 ncci_free_receive_buffers (plci, ncci);
3056
3057 if((plci->State==IDLE || plci->State==SUSPENDING) && !plci->channels){
3058 if(plci->State == SUSPENDING){
3059 sendf(plci->appl,
3060 _FACILITY_I,
3061 Id & 0xffffL,
3062 0,
3063 "ws", (word)3, "\x03\x04\x00\x00");
3064 sendf(plci->appl, _DISCONNECT_I, Id & 0xffffL, 0, "w", 0);
3065 }
3066 plci_remove(plci);
3067 plci->State=IDLE;
3068 }
3069 }
3070 else
3071 {
3072 if ((a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
3073 && ((plci->B3_prot == 4) || (plci->B3_prot == 5))
3074 && (a->ncci_state[ncci] == INC_DIS_PENDING))
3075 {
3076 ncci_free_receive_buffers (plci, ncci);
3077
3078 nl_req_ncci(plci,N_EDATA,(byte)ncci);
3079
3080 plci->adapter->ncci_state[ncci] = IDLE;
3081 start_internal_command (Id, plci, fax_disconnect_command);
3082 return 1;
3083 }
3084 }
3085 }
3086 return false;
3087 }
3088
3089 byte data_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER * a, PLCI * plci, APPL * appl, API_PARSE * parms)
3090 {
3091 NCCI *ncci_ptr;
3092 DATA_B3_DESC *data;
3093 word Info;
3094 word ncci;
3095 word i;
3096
3097 dbug(1,dprintf("data_b3_req"));
3098
3099 Info = _WRONG_IDENTIFIER;
3100 ncci = (word)(Id>>16);
3101 dbug(1,dprintf("ncci=0x%x, plci=0x%x",ncci,plci));
3102
3103 if (plci && ncci)
3104 {
3105 Info = _WRONG_STATE;
3106 if ((a->ncci_state[ncci] == CONNECTED)
3107 || (a->ncci_state[ncci] == INC_ACT_PENDING))
3108 {
3109 /* queue data */
3110 ncci_ptr = &(a->ncci[ncci]);
3111 i = ncci_ptr->data_out + ncci_ptr->data_pending;
3112 if (i >= MAX_DATA_B3)
3113 i -= MAX_DATA_B3;
3114 data = &(ncci_ptr->DBuffer[i]);
3115 data->Number = Number;
3116 if ((((byte *)(parms[0].info)) >= ((byte *)(plci->msg_in_queue)))
3117 && (((byte *)(parms[0].info)) < ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
3118 {
3119
3120 data->P = (byte *)(long)(*((dword *)(parms[0].info)));
3121
3122 }
3123 else
3124 data->P = TransmitBufferSet(appl,*(dword *)parms[0].info);
3125 data->Length = GET_WORD(parms[1].info);
3126 data->Handle = GET_WORD(parms[2].info);
3127 data->Flags = GET_WORD(parms[3].info);
3128 (ncci_ptr->data_pending)++;
3129
3130 /* check for delivery confirmation */
3131 if (data->Flags & 0x0004)
3132 {
3133 i = ncci_ptr->data_ack_out + ncci_ptr->data_ack_pending;
3134 if (i >= MAX_DATA_ACK)
3135 i -= MAX_DATA_ACK;
3136 ncci_ptr->DataAck[i].Number = data->Number;
3137 ncci_ptr->DataAck[i].Handle = data->Handle;
3138 (ncci_ptr->data_ack_pending)++;
3139 }
3140
3141 send_data(plci);
3142 return false;
3143 }
3144 }
3145 if (appl)
3146 {
3147 if (plci)
3148 {
3149 if ((((byte *)(parms[0].info)) >= ((byte *)(plci->msg_in_queue)))
3150 && (((byte *)(parms[0].info)) < ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
3151 {
3152
3153 TransmitBufferFree (appl, (byte *)(long)(*((dword *)(parms[0].info))));
3154
3155 }
3156 }
3157 sendf(appl,
3158 _DATA_B3_R|CONFIRM,
3159 Id,
3160 Number,
3161 "ww",GET_WORD(parms[2].info),Info);
3162 }
3163 return false;
3164 }
3165
3166 byte data_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER * a, PLCI * plci, APPL * appl, API_PARSE * parms)
3167 {
3168 word n;
3169 word ncci;
3170 word NCCIcode;
3171
3172 dbug(1,dprintf("data_b3_res"));
3173
3174 ncci = (word)(Id>>16);
3175 if(plci && ncci) {
3176 n = GET_WORD(parms[0].info);
3177 dbug(1,dprintf("free(%d)",n));
3178 NCCIcode = ncci | (((word) a->Id) << 8);
3179 if(n<appl->MaxBuffer &&
3180 appl->DataNCCI[n]==NCCIcode &&
3181 (byte)(appl->DataFlags[n]>>8)==plci->Id) {
3182 dbug(1,dprintf("found"));
3183 appl->DataNCCI[n] = 0;
3184
3185 if (channel_can_xon (plci, a->ncci_ch[ncci])) {
3186 channel_request_xon (plci, a->ncci_ch[ncci]);
3187 }
3188 channel_xmit_xon (plci);
3189
3190 if(appl->DataFlags[n] &4) {
3191 nl_req_ncci(plci,N_DATA_ACK,(byte)ncci);
3192 return 1;
3193 }
3194 }
3195 }
3196 return false;
3197 }
3198
3199 byte reset_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER * a, PLCI * plci, APPL * appl, API_PARSE * parms)
3200 {
3201 word Info;
3202 word ncci;
3203
3204 dbug(1,dprintf("reset_b3_req"));
3205
3206 Info = _WRONG_IDENTIFIER;
3207 ncci = (word)(Id>>16);
3208 if(plci && ncci)
3209 {
3210 Info = _WRONG_STATE;
3211 switch (plci->B3_prot)
3212 {
3213 case B3_ISO8208:
3214 case B3_X25_DCE:
3215 if(a->ncci_state[ncci]==CONNECTED)
3216 {
3217 nl_req_ncci(plci,N_RESET,(byte)ncci);
3218 send_req(plci);
3219 Info = GOOD;
3220 }
3221 break;
3222 case B3_TRANSPARENT:
3223 if(a->ncci_state[ncci]==CONNECTED)
3224 {
3225 start_internal_command (Id, plci, reset_b3_command);
3226 Info = GOOD;
3227 }
3228 break;
3229 }
3230 }
3231 /* reset_b3 must result in a reset_b3_con & reset_b3_Ind */
3232 sendf(appl,
3233 _RESET_B3_R|CONFIRM,
3234 Id,
3235 Number,
3236 "w",Info);
3237 return false;
3238 }
3239
3240 byte reset_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER * a, PLCI * plci, APPL * appl, API_PARSE * parms)
3241 {
3242 word ncci;
3243
3244 dbug(1,dprintf("reset_b3_res"));
3245
3246 ncci = (word)(Id>>16);
3247 if(plci && ncci) {
3248 switch (plci->B3_prot)
3249 {
3250 case B3_ISO8208:
3251 case B3_X25_DCE:
3252 if(a->ncci_state[ncci]==INC_RES_PENDING)
3253 {
3254 a->ncci_state[ncci] = CONNECTED;
3255 nl_req_ncci(plci,N_RESET_ACK,(byte)ncci);
3256 return true;
3257 }
3258 break;
3259 }
3260 }
3261 return false;
3262 }
3263
3264 byte connect_b3_t90_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER * a, PLCI * plci, APPL * appl, API_PARSE * parms)
3265 {
3266 word ncci;
3267 API_PARSE * ncpi;
3268 byte req;
3269
3270 dbug(1,dprintf("connect_b3_t90_a_res"));
3271
3272 ncci = (word)(Id>>16);
3273 if(plci && ncci) {
3274 if(a->ncci_state[ncci]==INC_ACT_PENDING) {
3275 a->ncci_state[ncci] = CONNECTED;
3276 }
3277 else if(a->ncci_state[ncci]==INC_CON_PENDING) {
3278 a->ncci_state[ncci] = CONNECTED;
3279
3280 req = N_CONNECT_ACK;
3281
3282 /* parms[0]==0 for CAPI original message definition! */
3283 if(parms[0].info) {
3284 ncpi = &parms[1];
3285 if(ncpi->length>2) {
3286 if(ncpi->info[1] &1) req = N_CONNECT_ACK | N_D_BIT;
3287 add_d(plci,(word)(ncpi->length-3),&ncpi->info[4]);
3288 }
3289 }
3290 nl_req_ncci(plci,req,(byte)ncci);
3291 return 1;
3292 }
3293 }
3294 return false;
3295 }
3296
3297
3298 byte select_b_req(dword Id, word Number, DIVA_CAPI_ADAPTER * a, PLCI * plci, APPL * appl, API_PARSE * msg)
3299 {
3300 word Info=0;
3301 word i;
3302 byte tel;
3303 API_PARSE bp_parms[7];
3304
3305 if(!plci || !msg)
3306 {
3307 Info = _WRONG_IDENTIFIER;
3308 }
3309 else
3310 {
3311 dbug(1,dprintf("select_b_req[%d],PLCI=0x%x,Tel=0x%x,NL=0x%x,appl=0x%x,sstate=0x%x",
3312 msg->length,plci->Id,plci->tel,plci->NL.Id,plci->appl,plci->SuppState));
3313 dbug(1,dprintf("PlciState=0x%x",plci->State));
3314 for(i=0;i<7;i++) bp_parms[i].length = 0;
3315
3316 /* check if no channel is open, no B3 connected only */
3317 if((plci->State == IDLE) || (plci->State == OUTG_DIS_PENDING) || (plci->State == INC_DIS_PENDING)
3318 || (plci->SuppState != IDLE) || plci->channels || plci->nl_remove_id)
3319 {
3320 Info = _WRONG_STATE;
3321 }
3322 /* check message format and fill bp_parms pointer */
3323 else if(msg->length && api_parse(&msg->info[1], (word)msg->length, "wwwsss", bp_parms))
3324 {
3325 Info = _WRONG_MESSAGE_FORMAT;
3326 }
3327 else
3328 {
3329 if((plci->State==INC_CON_PENDING) || (plci->State==INC_CON_ALERT)) /* send alert tone inband to the network, */
3330 { /* e.g. Qsig or RBS or Cornet-N or xess PRI */
3331 if(Id & EXT_CONTROLLER)
3332 {
3333 sendf(appl, _SELECT_B_REQ|CONFIRM, Id, Number, "w", 0x2002); /* wrong controller */
3334 return 0;
3335 }
3336 plci->State=INC_CON_CONNECTED_ALERT;
3337 plci->appl = appl;
3338 clear_c_ind_mask_bit (plci, (word)(appl->Id-1));
3339 dump_c_ind_mask (plci);
3340 for(i=0; i<max_appl; i++) /* disconnect the other appls */
3341 { /* its quasi a connect */
3342 if(test_c_ind_mask_bit (plci, i))
3343 sendf(&application[i], _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED);
3344 }
3345 }
3346
3347 api_save_msg(msg, "s", &plci->saved_msg);
3348 tel = plci->tel;
3349 if(Id & EXT_CONTROLLER)
3350 {
3351 if(tel) /* external controller in use by this PLCI */
3352 {
3353 if(a->AdvSignalAppl && a->AdvSignalAppl!=appl)
3354 {
3355 dbug(1,dprintf("Ext_Ctrl in use 1"));
3356 Info = _WRONG_STATE;
3357 }
3358 }
3359 else /* external controller NOT in use by this PLCI ? */
3360 {
3361 if(a->AdvSignalPLCI)
3362 {
3363 dbug(1,dprintf("Ext_Ctrl in use 2"));
3364 Info = _WRONG_STATE;
3365 }
3366 else /* activate the codec */
3367 {
3368 dbug(1,dprintf("Ext_Ctrl start"));
3369 if(AdvCodecSupport(a, plci, appl, 0) )
3370 {
3371 dbug(1,dprintf("Error in codec procedures"));
3372 Info = _WRONG_STATE;
3373 }
3374 else if(plci->spoofed_msg==SPOOFING_REQUIRED) /* wait until codec is active */
3375 {
3376 plci->spoofed_msg = AWAITING_SELECT_B;
3377 plci->internal_command = BLOCK_PLCI; /* lock other commands */
3378 plci->command = 0;
3379 dbug(1,dprintf("continue if codec loaded"));
3380 return false;
3381 }
3382 }
3383 }
3384 }
3385 else /* external controller bit is OFF */
3386 {
3387 if(tel) /* external controller in use, need to switch off */
3388 {
3389 if(a->AdvSignalAppl==appl)
3390 {
3391 CodecIdCheck(a, plci);
3392 plci->tel = 0;
3393 plci->adv_nl = 0;
3394 dbug(1,dprintf("Ext_Ctrl disable"));
3395 }
3396 else
3397 {
3398 dbug(1,dprintf("Ext_Ctrl not requested"));
3399 }
3400 }
3401 }
3402 if (!Info)
3403 {
3404 if (plci->call_dir & CALL_DIR_OUT)
3405 plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
3406 else if (plci->call_dir & CALL_DIR_IN)
3407 plci->call_dir = CALL_DIR_IN | CALL_DIR_ANSWER;
3408 start_internal_command (Id, plci, select_b_command);
3409 return false;
3410 }
3411 }
3412 }
3413 sendf(appl, _SELECT_B_REQ|CONFIRM, Id, Number, "w", Info);
3414 return false;
3415 }
3416
3417 byte manufacturer_req(dword Id, word Number, DIVA_CAPI_ADAPTER * a, PLCI * plci, APPL * appl, API_PARSE * parms)
3418 {
3419 word command;
3420 word i;
3421 word ncci;
3422 API_PARSE * m;
3423 API_PARSE m_parms[5];
3424 word codec;
3425 byte req;
3426 byte ch;
3427 byte dir;
3428 static byte chi[2] = {0x01,0x00};
3429 static byte lli[2] = {0x01,0x00};
3430 static byte codec_cai[2] = {0x01,0x01};
3431 static byte null_msg = {0};
3432 static API_PARSE null_parms = { 0, &null_msg };
3433 PLCI * v_plci;
3434 word Info=0;
3435
3436 dbug(1,dprintf("manufacturer_req"));
3437 for(i=0;i<5;i++) m_parms[i].length = 0;
3438
3439 if(GET_DWORD(parms[0].info)!=_DI_MANU_ID) {
3440 Info = _WRONG_MESSAGE_FORMAT;
3441 }
3442 command = GET_WORD(parms[1].info);
3443 m = &parms[2];
3444 if (!Info)
3445 {
3446 switch(command) {
3447 case _DI_ASSIGN_PLCI:
3448 if(api_parse(&m->info[1],(word)m->length,"wbbs",m_parms)) {
3449 Info = _WRONG_MESSAGE_FORMAT;
3450 break;
3451 }
3452 codec = GET_WORD(m_parms[0].info);
3453 ch = m_parms[1].info[0];
3454 dir = m_parms[2].info[0];
3455 if((i=get_plci(a))) {
3456 plci = &a->plci[i-1];
3457 plci->appl = appl;
3458 plci->command = _MANUFACTURER_R;
3459 plci->m_command = command;
3460 plci->number = Number;
3461 plci->State = LOCAL_CONNECT;
3462 Id = ( ((word)plci->Id<<8)|plci->adapter->Id|0x80);
3463 dbug(1,dprintf("ManCMD,plci=0x%x",Id));
3464
3465 if((ch==1 || ch==2) && (dir<=2)) {
3466 chi[1] = (byte)(0x80|ch);
3467 lli[1] = 0;
3468 plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
3469 switch(codec)
3470 {
3471 case 0:
3472 Info = add_b1(plci,&m_parms[3],0,0);
3473 break;
3474 case 1:
3475 add_p(plci,CAI,codec_cai);
3476 break;
3477 /* manual 'swich on' to the codec support without signalling */
3478 /* first 'assign plci' with this function, then use */
3479 case 2:
3480 if(AdvCodecSupport(a, plci, appl, 0) ) {
3481 Info = _RESOURCE_ERROR;
3482 }
3483 else {
3484 Info = add_b1(plci,&null_parms,0,B1_FACILITY_LOCAL);
3485 lli[1] = 0x10; /* local call codec stream */
3486 }
3487 break;
3488 }
3489
3490 plci->State = LOCAL_CONNECT;
3491 plci->manufacturer = true;
3492 plci->command = _MANUFACTURER_R;
3493 plci->m_command = command;
3494 plci->number = Number;
3495
3496 if(!Info)
3497 {
3498 add_p(plci,LLI,lli);
3499 add_p(plci,CHI,chi);
3500 add_p(plci,UID,"\x06\x43\x61\x70\x69\x32\x30");
3501 sig_req(plci,ASSIGN,DSIG_ID);
3502
3503 if(!codec)
3504 {
3505 Info = add_b23(plci,&m_parms[3]);
3506 if(!Info)
3507 {
3508 nl_req_ncci(plci,ASSIGN,0);
3509 send_req(plci);
3510 }
3511 }
3512 if(!Info)
3513 {
3514 dbug(1,dprintf("dir=0x%x,spoof=0x%x",dir,plci->spoofed_msg));
3515 if (plci->spoofed_msg==SPOOFING_REQUIRED)
3516 {
3517 api_save_msg (m_parms, "wbbs", &plci->saved_msg);
3518 plci->spoofed_msg = AWAITING_MANUF_CON;
3519 plci->internal_command = BLOCK_PLCI; /* reject other req meanwhile */
3520 plci->command = 0;
3521 send_req(plci);
3522 return false;
3523 }
3524 if(dir==1) {
3525 sig_req(plci,CALL_REQ,0);
3526 }
3527 else if(!dir){
3528 sig_req(plci,LISTEN_REQ,0);
3529 }
3530 send_req(plci);
3531 }
3532 else
3533 {
3534 sendf(appl,
3535 _MANUFACTURER_R|CONFIRM,
3536 Id,
3537 Number,
3538 "dww",_DI_MANU_ID,command,Info);
3539 return 2;
3540 }
3541 }
3542 }
3543 }
3544 else Info = _OUT_OF_PLCI;
3545 break;
3546
3547 case _DI_IDI_CTRL:
3548 if(!plci)
3549 {
3550 Info = _WRONG_IDENTIFIER;
3551 break;
3552 }
3553 if(api_parse(&m->info[1],(word)m->length,"bs",m_parms)) {
3554 Info = _WRONG_MESSAGE_FORMAT;
3555 break;
3556 }
3557 req = m_parms[0].info[0];
3558 plci->command = _MANUFACTURER_R;
3559 plci->m_command = command;
3560 plci->number = Number;
3561 if(req==CALL_REQ)
3562 {
3563 plci->b_channel = getChannel(&m_parms[1]);
3564 mixer_set_bchannel_id_esc (plci, plci->b_channel);
3565 if(plci->spoofed_msg==SPOOFING_REQUIRED)
3566 {
3567 plci->spoofed_msg = CALL_REQ | AWAITING_MANUF_CON;
3568 plci->internal_command = BLOCK_PLCI; /* reject other req meanwhile */
3569 plci->command = 0;
3570 break;
3571 }
3572 }
3573 else if(req==LAW_REQ)
3574 {
3575 plci->cr_enquiry = true;
3576 }
3577 add_ss(plci,FTY,&m_parms[1]);
3578 sig_req(plci,req,0);
3579 send_req(plci);
3580 if(req==HANGUP)
3581 {
3582 if (plci->NL.Id && !plci->nl_remove_id)
3583 {
3584 if (plci->channels)
3585 {
3586 for (ncci = 1; ncci < MAX_NCCI+1; ncci++)
3587 {
3588 if ((a->ncci_plci[ncci] == plci->Id) && (a->ncci_state[ncci] == CONNECTED))
3589 {
3590 a->ncci_state[ncci] = OUTG_DIS_PENDING;
3591 cleanup_ncci_data (plci, ncci);
3592 nl_req_ncci(plci,N_DISC,(byte)ncci);
3593 }
3594 }
3595 }
3596 mixer_remove (plci);
3597 nl_req_ncci(plci,REMOVE,0);
3598 send_req(plci);
3599 }
3600 }
3601 break;
3602
3603 case _DI_SIG_CTRL:
3604 /* signalling control for loop activation B-channel */
3605 if(!plci)
3606 {
3607 Info = _WRONG_IDENTIFIER;
3608 break;
3609 }
3610 if(m->length){
3611 plci->command = _MANUFACTURER_R;
3612 plci->number = Number;
3613 add_ss(plci,FTY,m);
3614 sig_req(plci,SIG_CTRL,0);
3615 send_req(plci);
3616 }
3617 else Info = _WRONG_MESSAGE_FORMAT;
3618 break;
3619
3620 case _DI_RXT_CTRL:
3621 /* activation control for receiver/transmitter B-channel */
3622 if(!plci)
3623 {
3624 Info = _WRONG_IDENTIFIER;
3625 break;
3626 }
3627 if(m->length){
3628 plci->command = _MANUFACTURER_R;
3629 plci->number = Number;
3630 add_ss(plci,FTY,m);
3631 sig_req(plci,DSP_CTRL,0);
3632 send_req(plci);
3633 }
3634 else Info = _WRONG_MESSAGE_FORMAT;
3635 break;
3636
3637 case _DI_ADV_CODEC:
3638 case _DI_DSP_CTRL:
3639 /* TEL_CTRL commands to support non standard adjustments: */
3640 /* Ring on/off, Handset micro volume, external micro vol. */
3641 /* handset+external speaker volume, receiver+transm. gain,*/
3642 /* handsfree on (hookinfo off), set mixer command */
3643
3644 if(command == _DI_ADV_CODEC)
3645 {
3646 if(!a->AdvCodecPLCI) {
3647 Info = _WRONG_STATE;
3648 break;
3649 }
3650 v_plci = a->AdvCodecPLCI;
3651 }
3652 else
3653 {
3654 if (plci
3655 && (m->length >= 3)
3656 && (m->info[1] == 0x1c)
3657 && (m->info[2] >= 1))
3658 {
3659 if (m->info[3] == DSP_CTRL_OLD_SET_MIXER_COEFFICIENTS)
3660 {
3661 if ((plci->tel != ADV_VOICE) || (plci != a->AdvSignalPLCI))
3662 {
3663 Info = _WRONG_STATE;
3664 break;
3665 }
3666 a->adv_voice_coef_length = m->info[2] - 1;
3667 if (a->adv_voice_coef_length > m->length - 3)
3668 a->adv_voice_coef_length = (byte)(m->length - 3);
3669 if (a->adv_voice_coef_length > ADV_VOICE_COEF_BUFFER_SIZE)
3670 a->adv_voice_coef_length = ADV_VOICE_COEF_BUFFER_SIZE;
3671 for (i = 0; i < a->adv_voice_coef_length; i++)
3672 a->adv_voice_coef_buffer[i] = m->info[4 + i];
3673 if (plci->B1_facilities & B1_FACILITY_VOICE)
3674 adv_voice_write_coefs (plci, ADV_VOICE_WRITE_UPDATE);
3675 break;
3676 }
3677 else if (m->info[3] == DSP_CTRL_SET_DTMF_PARAMETERS)
3678 {
3679 if (!(a->manufacturer_features & MANUFACTURER_FEATURE_DTMF_PARAMETERS))
3680 {
3681 Info = _FACILITY_NOT_SUPPORTED;
3682 break;
3683 }
3684
3685 plci->dtmf_parameter_length = m->info[2] - 1;
3686 if (plci->dtmf_parameter_length > m->length - 3)
3687 plci->dtmf_parameter_length = (byte)(m->length - 3);
3688 if (plci->dtmf_parameter_length > DTMF_PARAMETER_BUFFER_SIZE)
3689 plci->dtmf_parameter_length = DTMF_PARAMETER_BUFFER_SIZE;
3690 for (i = 0; i < plci->dtmf_parameter_length; i++)
3691 plci->dtmf_parameter_buffer[i] = m->info[4+i];
3692 if (plci->B1_facilities & B1_FACILITY_DTMFR)
3693 dtmf_parameter_write (plci);
3694 break;
3695
3696 }
3697 }
3698 v_plci = plci;
3699 }
3700
3701 if(!v_plci)
3702 {
3703 Info = _WRONG_IDENTIFIER;
3704 break;
3705 }
3706 if(m->length){
3707 add_ss(v_plci,FTY,m);
3708 sig_req(v_plci,TEL_CTRL,0);
3709 send_req(v_plci);
3710 }
3711 else Info = _WRONG_MESSAGE_FORMAT;
3712
3713 break;
3714
3715 case _DI_OPTIONS_REQUEST:
3716 if(api_parse(&m->info[1],(word)m->length,"d",m_parms)) {
3717 Info = _WRONG_MESSAGE_FORMAT;
3718 break;
3719 }
3720 if (GET_DWORD (m_parms[0].info) & ~a->man_profile.private_options)
3721 {
3722 Info = _FACILITY_NOT_SUPPORTED;
3723 break;
3724 }
3725 a->requested_options_table[appl->Id-1] = GET_DWORD (m_parms[0].info);
3726 break;
3727
3728
3729
3730 default:
3731 Info = _WRONG_MESSAGE_FORMAT;
3732 break;
3733 }
3734 }
3735
3736 sendf(appl,
3737 _MANUFACTURER_R|CONFIRM,
3738 Id,
3739 Number,
3740 "dww",_DI_MANU_ID,command,Info);
3741 return false;
3742 }
3743
3744
3745 byte manufacturer_res(dword Id, word Number, DIVA_CAPI_ADAPTER * a, PLCI * plci, APPL * appl, API_PARSE * msg)
3746 {
3747 word indication;
3748
3749 API_PARSE m_parms[3];
3750 API_PARSE *ncpi;
3751 API_PARSE fax_parms[9];
3752 word i;
3753 byte len;
3754
3755
3756 dbug(1,dprintf("manufacturer_res"));
3757
3758 if ((msg[0].length == 0)
3759 || (msg[1].length == 0)
3760 || (GET_DWORD(msg[0].info)!=_DI_MANU_ID))
3761 {
3762 return false;
3763 }
3764 indication = GET_WORD(msg[1].info);
3765 switch (indication)
3766 {
3767
3768 case _DI_NEGOTIATE_B3:
3769 if(!plci)
3770 break;
3771 if (((plci->B3_prot != 4) && (plci->B3_prot != 5))
3772 || !(plci->ncpi_state & NCPI_NEGOTIATE_B3_SENT))
3773 {
3774 dbug(1,dprintf("wrong state for NEGOTIATE_B3 parameters"));
3775 break;
3776 }
3777 if (api_parse (&msg[2].info[1], msg[2].length, "ws", m_parms))
3778 {
3779 dbug(1,dprintf("wrong format in NEGOTIATE_B3 parameters"));
3780 break;
3781 }
3782 ncpi = &m_parms[1];
3783 len = ((byte)(((T30_INFO *) 0)->station_id + 20));
3784 if (plci->fax_connect_info_length < len)
3785 {
3786 ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id_len = 0;
3787 ((T30_INFO *)(plci->fax_connect_info_buffer))->head_line_len = 0;
3788 }
3789 if (api_parse (&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms))
3790 {
3791 dbug(1,dprintf("non-standard facilities info missing or wrong format"));
3792 }
3793 else
3794 {
3795 if (plci->fax_connect_info_length <= len)
3796 plci->fax_connect_info_buffer[len] = 0;
3797 len += 1 + plci->fax_connect_info_buffer[len];
3798 if (plci->fax_connect_info_length <= len)
3799 plci->fax_connect_info_buffer[len] = 0;
3800 len += 1 + plci->fax_connect_info_buffer[len];
3801 if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2))
3802 plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]);
3803 plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length);
3804 for (i = 0; i < fax_parms[7].length; i++)
3805 plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1+i];
3806 }
3807 plci->fax_connect_info_length = len;
3808 plci->fax_edata_ack_length = plci->fax_connect_info_length;
3809 start_internal_command (Id, plci, fax_edata_ack_command);
3810 break;
3811
3812 }
3813 return false;
3814 }
3815
3816 /*------------------------------------------------------------------*/
3817 /* IDI callback function */
3818 /*------------------------------------------------------------------*/
3819
3820 void callback(ENTITY * e)
3821 {
3822 DIVA_CAPI_ADAPTER * a;
3823 APPL * appl;
3824 PLCI * plci;
3825 CAPI_MSG *m;
3826 word i, j;
3827 byte rc;
3828 byte ch;
3829 byte req;
3830 byte global_req;
3831 int no_cancel_rc;
3832
3833 dbug(1,dprintf("%x:CB(%x:Req=%x,Rc=%x,Ind=%x)",
3834 (e->user[0]+1)&0x7fff,e->Id,e->Req,e->Rc,e->Ind));
3835
3836 a = &(adapter[(byte)e->user[0]]);
3837 plci = &(a->plci[e->user[1]]);
3838 no_cancel_rc = DIVA_CAPI_SUPPORTS_NO_CANCEL(a);
3839
3840 /*
3841 If new protocol code and new XDI is used then CAPI should work
3842 fully in accordance with IDI cpec an look on callback field instead
3843 of Rc field for return codes.
3844 */
3845 if (((e->complete == 0xff) && no_cancel_rc) ||
3846 (e->Rc && !no_cancel_rc)) {
3847 rc = e->Rc;
3848 ch = e->RcCh;
3849 req = e->Req;
3850 e->Rc = 0;
3851
3852 if (e->user[0] & 0x8000)
3853 {
3854 /*
3855 If REMOVE request was sent then we have to wait until
3856 return code with Id set to zero arrives.
3857 All other return codes should be ignored.
3858 */
3859 if (req == REMOVE)
3860 {
3861 if (e->Id)
3862 {
3863 dbug(1,dprintf("cancel RC in REMOVE state"));
3864 return;
3865 }
3866 channel_flow_control_remove (plci);
3867 for (i = 0; i < 256; i++)
3868 {
3869 if (a->FlowControlIdTable[i] == plci->nl_remove_id)
3870 a->FlowControlIdTable[i] = 0;
3871 }
3872 plci->nl_remove_id = 0;
3873 if (plci->rx_dma_descriptor > 0) {
3874 diva_free_dma_descriptor (plci, plci->rx_dma_descriptor - 1);
3875 plci->rx_dma_descriptor = 0;
3876 }
3877 }
3878 if (rc == OK_FC)
3879 {
3880 a->FlowControlIdTable[ch] = e->Id;
3881 a->FlowControlSkipTable[ch] = 0;
3882
3883 a->ch_flow_control[ch] |= N_OK_FC_PENDING;
3884 a->ch_flow_plci[ch] = plci->Id;
3885 plci->nl_req = 0;
3886 }
3887 else
3888 {
3889 /*
3890 Cancel return codes self, if feature was requested
3891 */
3892 if (no_cancel_rc && (a->FlowControlIdTable[ch] == e->Id) && e->Id) {
3893 a->FlowControlIdTable[ch] = 0;
3894 if ((rc == OK) && a->FlowControlSkipTable[ch]) {
3895 dbug(3,dprintf ("XDI CAPI: RC cancelled Id:0x02, Ch:%02x", e->Id, ch));
3896 return;
3897 }
3898 }
3899
3900 if (a->ch_flow_control[ch] & N_OK_FC_PENDING)
3901 {
3902 a->ch_flow_control[ch] &= ~N_OK_FC_PENDING;
3903 if (ch == e->ReqCh)
3904 plci->nl_req = 0;
3905 }
3906 else
3907 plci->nl_req = 0;
3908 }
3909 if (plci->nl_req)
3910 control_rc (plci, 0, rc, ch, 0, true);
3911 else
3912 {
3913 if (req == N_XON)
3914 {
3915 channel_x_on (plci, ch);
3916 if (plci->internal_command)
3917 control_rc (plci, req, rc, ch, 0, true);
3918 }
3919 else
3920 {
3921 if (plci->nl_global_req)
3922 {
3923 global_req = plci->nl_global_req;
3924 plci->nl_global_req = 0;
3925 if (rc != ASSIGN_OK) {
3926 e->Id = 0;
3927 if (plci->rx_dma_descriptor > 0) {
3928 diva_free_dma_descriptor (plci, plci->rx_dma_descriptor - 1);
3929 plci->rx_dma_descriptor = 0;
3930 }
3931 }
3932 channel_xmit_xon (plci);
3933 control_rc (plci, 0, rc, ch, global_req, true);
3934 }
3935 else if (plci->data_sent)
3936 {
3937 channel_xmit_xon (plci);
3938 plci->data_sent = false;
3939 plci->NL.XNum = 1;
3940 data_rc (plci, ch);
3941 if (plci->internal_command)
3942 control_rc (plci, req, rc, ch, 0, true);
3943 }
3944 else
3945 {
3946 channel_xmit_xon (plci);
3947 control_rc (plci, req, rc, ch, 0, true);
3948 }
3949 }
3950 }
3951 }
3952 else
3953 {
3954 /*
3955 If REMOVE request was sent then we have to wait until
3956 return code with Id set to zero arrives.
3957 All other return codes should be ignored.
3958 */
3959 if (req == REMOVE)
3960 {
3961 if (e->Id)
3962 {
3963 dbug(1,dprintf("cancel RC in REMOVE state"));
3964 return;
3965 }
3966 plci->sig_remove_id = 0;
3967 }
3968 plci->sig_req = 0;
3969 if (plci->sig_global_req)
3970 {
3971 global_req = plci->sig_global_req;
3972 plci->sig_global_req = 0;
3973 if (rc != ASSIGN_OK)
3974 e->Id = 0;
3975 channel_xmit_xon (plci);
3976 control_rc (plci, 0, rc, ch, global_req, false);
3977 }
3978 else
3979 {
3980 channel_xmit_xon (plci);
3981 control_rc (plci, req, rc, ch, 0, false);
3982 }
3983 }
3984 /*
3985 Again: in accordance with IDI spec Rc and Ind can't be delivered in the
3986 same callback. Also if new XDI and protocol code used then jump
3987 direct to finish.
3988 */
3989 if (no_cancel_rc) {
3990 channel_xmit_xon(plci);
3991 goto capi_callback_suffix;
3992 }
3993 }
3994
3995 channel_xmit_xon(plci);
3996
3997 if (e->Ind) {
3998 if (e->user[0] &0x8000) {
3999 byte Ind = e->Ind & 0x0f;
4000 byte Ch = e->IndCh;
4001 if (((Ind==N_DISC) || (Ind==N_DISC_ACK)) &&
4002 (a->ch_flow_plci[Ch] == plci->Id)) {
4003 if (a->ch_flow_control[Ch] & N_RX_FLOW_CONTROL_MASK) {
4004 dbug(3,dprintf ("XDI CAPI: I: pending N-XON Ch:%02x", Ch));
4005 }
4006 a->ch_flow_control[Ch] &= ~N_RX_FLOW_CONTROL_MASK;
4007 }
4008 nl_ind(plci);
4009 if ((e->RNR != 1) &&
4010 (a->ch_flow_plci[Ch] == plci->Id) &&
4011 (a->ch_flow_control[Ch] & N_RX_FLOW_CONTROL_MASK)) {
4012 a->ch_flow_control[Ch] &= ~N_RX_FLOW_CONTROL_MASK;
4013 dbug(3,dprintf ("XDI CAPI: I: remove faked N-XON Ch:%02x", Ch));
4014 }
4015 } else {
4016 sig_ind(plci);
4017 }
4018 e->Ind = 0;
4019 }
4020
4021 capi_callback_suffix:
4022
4023 while (!plci->req_in
4024 && !plci->internal_command
4025 && (plci->msg_in_write_pos != plci->msg_in_read_pos))
4026 {
4027 j = (plci->msg_in_read_pos == plci->msg_in_wrap_pos) ? 0 : plci->msg_in_read_pos;
4028
4029 i = (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[j]))->header.length + 3) & 0xfffc;
4030
4031 m = (CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[j]);
4032 appl = *((APPL * *)(&((byte *)(plci->msg_in_queue))[j+i]));
4033 dbug(1,dprintf("dequeue msg(0x%04x) - write=%d read=%d wrap=%d",
4034 m->header.command, plci->msg_in_write_pos, plci->msg_in_read_pos, plci->msg_in_wrap_pos));
4035 if (plci->msg_in_read_pos == plci->msg_in_wrap_pos)
4036 {
4037 plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
4038 plci->msg_in_read_pos = i + MSG_IN_OVERHEAD;
4039 }
4040 else
4041 {
4042 plci->msg_in_read_pos = j + i + MSG_IN_OVERHEAD;
4043 }
4044 if (plci->msg_in_read_pos == plci->msg_in_write_pos)
4045 {
4046 plci->msg_in_write_pos = MSG_IN_QUEUE_SIZE;
4047 plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
4048 }
4049 else if (plci->msg_in_read_pos == plci->msg_in_wrap_pos)
4050 {
4051 plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
4052 plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
4053 }
4054 i = api_put (appl, m);
4055 if (i != 0)
4056 {
4057 if (m->header.command == _DATA_B3_R)
4058
4059 TransmitBufferFree (appl, (byte *)(long)(m->info.data_b3_req.Data));
4060
4061 dbug(1,dprintf("Error 0x%04x from msg(0x%04x)", i, m->header.command));
4062 break;
4063 }
4064
4065 if (plci->li_notify_update)
4066 {
4067 plci->li_notify_update = false;
4068 mixer_notify_update (plci, false);
4069 }
4070
4071 }
4072 send_data(plci);
4073 send_req(plci);
4074 }
4075
4076
4077 void control_rc(PLCI * plci, byte req, byte rc, byte ch, byte global_req, byte nl_rc)
4078 {
4079 dword Id;
4080 dword rId;
4081 word Number;
4082 word Info=0;
4083 word i;
4084 word ncci;
4085 DIVA_CAPI_ADAPTER * a;
4086 APPL * appl;
4087 PLCI * rplci;
4088 byte SSparms[] = "\x05\x00\x00\x02\x00\x00";
4089 byte SSstruct[] = "\x09\x00\x00\x06\x00\x00\x00\x00\x00\x00";
4090
4091 if (!plci) {
4092 dbug(0,dprintf("A: control_rc, no plci %02x:%02x:%02x:%02x:%02x", req, rc, ch, global_req, nl_rc));
4093 return;
4094 }
4095 dbug(1,dprintf("req0_in/out=%d/%d",plci->req_in,plci->req_out));
4096 if(plci->req_in!=plci->req_out)
4097 {
4098 if (nl_rc || (global_req != ASSIGN) || (rc == ASSIGN_OK))
4099 {
4100 dbug(1,dprintf("req_1return"));
4101 return;
4102 }
4103 /* cancel outstanding request on the PLCI after SIG ASSIGN failure */
4104 }
4105 plci->req_in = plci->req_in_start = plci->req_out = 0;
4106 dbug(1,dprintf("control_rc"));
4107
4108 appl = plci->appl;
4109 a = plci->adapter;
4110 ncci = a->ch_ncci[ch];
4111 if(appl)
4112 {
4113 Id = (((dword)(ncci ? ncci : ch)) << 16) | ((word)plci->Id << 8) | a->Id;
4114 if(plci->tel && plci->SuppState!=CALL_HELD) Id|=EXT_CONTROLLER;
4115 Number = plci->number;
4116 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));
4117 dbug(1,dprintf("channels=0x%x",plci->channels));
4118 if (plci_remove_check(plci))
4119 return;
4120 if(req==REMOVE && rc==ASSIGN_OK)
4121 {
4122 sig_req(plci,HANGUP,0);
4123 sig_req(plci,REMOVE,0);
4124 send_req(plci);
4125 }
4126 if(plci->command)
4127 {
4128 switch(plci->command)
4129 {
4130 case C_HOLD_REQ:
4131 dbug(1,dprintf("HoldRC=0x%x",rc));
4132 SSparms[1] = (byte)S_HOLD;
4133 if(rc!=OK)
4134 {
4135 plci->SuppState = IDLE;
4136 Info = 0x2001;
4137 }
4138 sendf(appl,_FACILITY_R|CONFIRM,Id,Number,"wws",Info,3,SSparms);
4139 break;
4140
4141 case C_RETRIEVE_REQ:
4142 dbug(1,dprintf("RetrieveRC=0x%x",rc));
4143 SSparms[1] = (byte)S_RETRIEVE;
4144 if(rc!=OK)
4145 {
4146 plci->SuppState = CALL_HELD;
4147 Info = 0x2001;
4148 }
4149 sendf(appl,_FACILITY_R|CONFIRM,Id,Number,"wws",Info,3,SSparms);
4150 break;
4151
4152 case _INFO_R:
4153 dbug(1,dprintf("InfoRC=0x%x",rc));
4154 if(rc!=OK) Info=_WRONG_STATE;
4155 sendf(appl,_INFO_R|CONFIRM,Id,Number,"w",Info);
4156 break;
4157
4158 case _CONNECT_R:
4159 dbug(1,dprintf("Connect_R=0x%x/0x%x/0x%x/0x%x",req,rc,global_req,nl_rc));
4160 if (plci->State == INC_DIS_PENDING)
4161 break;
4162 if(plci->Sig.Id!=0xff)
4163 {
4164 if (((global_req == ASSIGN) && (rc != ASSIGN_OK))
4165 || (!nl_rc && (req == CALL_REQ) && (rc != OK)))
4166 {
4167 dbug(1,dprintf("No more IDs/Call_Req failed"));
4168 sendf(appl,_CONNECT_R|CONFIRM,Id&0xffL,Number,"w",_OUT_OF_PLCI);
4169 plci_remove(plci);
4170 plci->State = IDLE;
4171 break;
4172 }
4173 if(plci->State!=LOCAL_CONNECT)plci->State = OUTG_CON_PENDING;
4174 sendf(appl,_CONNECT_R|CONFIRM,Id,Number,"w",0);
4175 }
4176 else /* D-ch activation */
4177 {
4178 if (rc != ASSIGN_OK)
4179 {
4180 dbug(1,dprintf("No more IDs/X.25 Call_Req failed"));
4181 sendf(appl,_CONNECT_R|CONFIRM,Id&0xffL,Number,"w",_OUT_OF_PLCI);
4182 plci_remove(plci);
4183 plci->State = IDLE;
4184 break;
4185 }
4186 sendf(appl,_CONNECT_R|CONFIRM,Id,Number,"w",0);
4187 sendf(plci->appl,_CONNECT_ACTIVE_I,Id,0,"sss","","","");
4188 plci->State = INC_ACT_PENDING;
4189 }
4190 break;
4191
4192 case _CONNECT_I|RESPONSE:
4193 if (plci->State != INC_DIS_PENDING)
4194 plci->State = INC_CON_ACCEPT;
4195 break;
4196
4197 case _DISCONNECT_R:
4198 if (plci->State == INC_DIS_PENDING)
4199 break;
4200 if(plci->Sig.Id!=0xff)
4201 {
4202 plci->State = OUTG_DIS_PENDING;
4203 sendf(appl,_DISCONNECT_R|CONFIRM,Id,Number,"w",0);
4204 }
4205 break;
4206
4207 case SUSPEND_REQ:
4208 break;
4209
4210 case RESUME_REQ:
4211 break;
4212
4213 case _CONNECT_B3_R:
4214 if(rc!=OK)
4215 {
4216 sendf(appl,_CONNECT_B3_R|CONFIRM,Id,Number,"w",_WRONG_IDENTIFIER);
4217 break;
4218 }
4219 ncci = get_ncci (plci, ch, 0);
4220 Id = (Id & 0xffff) | (((dword) ncci) << 16);
4221 plci->channels++;
4222 if(req==N_RESET)
4223 {
4224 a->ncci_state[ncci] = INC_ACT_PENDING;
4225 sendf(appl,_CONNECT_B3_R|CONFIRM,Id,Number,"w",0);
4226 sendf(appl,_CONNECT_B3_ACTIVE_I,Id,0,"s","");
4227 }
4228 else
4229 {
4230 a->ncci_state[ncci] = OUTG_CON_PENDING;
4231 sendf(appl,_CONNECT_B3_R|CONFIRM,Id,Number,"w",0);
4232 }
4233 break;
4234
4235 case _CONNECT_B3_I|RESPONSE:
4236 break;
4237
4238 case _RESET_B3_R:
4239 /* sendf(appl,_RESET_B3_R|CONFIRM,Id,Number,"w",0);*/
4240 break;
4241
4242 case _DISCONNECT_B3_R:
4243 sendf(appl,_DISCONNECT_B3_R|CONFIRM,Id,Number,"w",0);
4244 break;
4245
4246 case _MANUFACTURER_R:
4247 break;
4248
4249 case PERM_LIST_REQ:
4250 if(rc!=OK)
4251 {
4252 Info = _WRONG_IDENTIFIER;
4253 sendf(plci->appl,_CONNECT_R|CONFIRM,Id,Number,"w",Info);
4254 plci_remove(plci);
4255 }
4256 else
4257 sendf(plci->appl,_CONNECT_R|CONFIRM,Id,Number,"w",Info);
4258 break;
4259
4260 default:
4261 break;
4262 }
4263 plci->command = 0;
4264 }
4265 else if (plci->internal_command)
4266 {
4267 switch(plci->internal_command)
4268 {
4269 case BLOCK_PLCI:
4270 return;
4271
4272 case GET_MWI_STATE:
4273 if(rc==OK) /* command supported, wait for indication */
4274 {
4275 return;
4276 }
4277 plci_remove(plci);
4278 break;
4279
4280 /* Get Supported Services */
4281 case GETSERV_REQ_PEND:
4282 if(rc==OK) /* command supported, wait for indication */
4283 {
4284 break;
4285 }
4286 PUT_DWORD(&SSstruct[6], MASK_TERMINAL_PORTABILITY);
4287 sendf(appl, _FACILITY_R|CONFIRM, Id, Number, "wws",0,3,SSstruct);
4288 plci_remove(plci);
4289 break;
4290
4291 case INTERR_DIVERSION_REQ_PEND: /* Interrogate Parameters */
4292 case INTERR_NUMBERS_REQ_PEND:
4293 case CF_START_PEND: /* Call Forwarding Start pending */
4294 case CF_STOP_PEND: /* Call Forwarding Stop pending */
4295 case CCBS_REQUEST_REQ_PEND:
4296 case CCBS_DEACTIVATE_REQ_PEND:
4297 case CCBS_INTERROGATE_REQ_PEND:
4298 switch(plci->internal_command)
4299 {
4300 case INTERR_DIVERSION_REQ_PEND:
4301 SSparms[1] = S_INTERROGATE_DIVERSION;
4302 break;
4303 case INTERR_NUMBERS_REQ_PEND:
4304 SSparms[1] = S_INTERROGATE_NUMBERS;
4305 break;
4306 case CF_START_PEND:
4307 SSparms[1] = S_CALL_FORWARDING_START;
4308 break;
4309 case CF_STOP_PEND:
4310 SSparms[1] = S_CALL_FORWARDING_STOP;
4311 break;
4312 case CCBS_REQUEST_REQ_PEND:
4313 SSparms[1] = S_CCBS_REQUEST;
4314 break;
4315 case CCBS_DEACTIVATE_REQ_PEND:
4316 SSparms[1] = S_CCBS_DEACTIVATE;
4317 break;
4318 case CCBS_INTERROGATE_REQ_PEND:
4319 SSparms[1] = S_CCBS_INTERROGATE;
4320 break;
4321 }
4322 if(global_req==ASSIGN)
4323 {
4324 dbug(1,dprintf("AssignDiversion_RC=0x%x/0x%x",req,rc));
4325 return;
4326 }
4327 if(!plci->appl) break;
4328 if(rc==ISDN_GUARD_REJ)
4329 {
4330 Info = _CAPI_GUARD_ERROR;
4331 }
4332 else if(rc!=OK)
4333 {
4334 Info = _SUPPLEMENTARY_SERVICE_NOT_SUPPORTED;
4335 }
4336 sendf(plci->appl,_FACILITY_R|CONFIRM,Id&0x7,
4337 plci->number,"wws",Info,(word)3,SSparms);
4338 if(Info) plci_remove(plci);
4339 break;
4340
4341 /* 3pty conference pending */
4342 case PTY_REQ_PEND:
4343 if(!plci->relatedPTYPLCI) break;
4344 rplci = plci->relatedPTYPLCI;
4345 SSparms[1] = plci->ptyState;
4346 rId = ((word)rplci->Id<<8)|rplci->adapter->Id;
4347 if(rplci->tel) rId|=EXT_CONTROLLER;
4348 if(rc!=OK)
4349 {
4350 Info = 0x300E; /* not supported */
4351 plci->relatedPTYPLCI = NULL;
4352 plci->ptyState = 0;
4353 }
4354 sendf(rplci->appl,
4355 _FACILITY_R|CONFIRM,
4356 rId,
4357 plci->number,
4358 "wws",Info,(word)3,SSparms);
4359 break;
4360
4361 /* Explicit Call Transfer pending */
4362 case ECT_REQ_PEND:
4363 dbug(1,dprintf("ECT_RC=0x%x/0x%x",req,rc));
4364 if(!plci->relatedPTYPLCI) break;
4365 rplci = plci->relatedPTYPLCI;
4366 SSparms[1] = S_ECT;
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 case _MANUFACTURER_R:
4383 dbug(1,dprintf("_Manufacturer_R=0x%x/0x%x",req,rc));
4384 if ((global_req == ASSIGN) && (rc != ASSIGN_OK))
4385 {
4386 dbug(1,dprintf("No more IDs"));
4387 sendf(appl,_MANUFACTURER_R|CONFIRM,Id,Number,"dww",_DI_MANU_ID,_MANUFACTURER_R,_OUT_OF_PLCI);
4388 plci_remove(plci); /* after codec init, internal codec commands pending */
4389 }
4390 break;
4391
4392 case _CONNECT_R:
4393 dbug(1,dprintf("_Connect_R=0x%x/0x%x",req,rc));
4394 if ((global_req == ASSIGN) && (rc != ASSIGN_OK))
4395 {
4396 dbug(1,dprintf("No more IDs"));
4397 sendf(appl,_CONNECT_R|CONFIRM,Id&0xffL,Number,"w",_OUT_OF_PLCI);
4398 plci_remove(plci); /* after codec init, internal codec commands pending */
4399 }
4400 break;
4401
4402 case PERM_COD_HOOK: /* finished with Hook_Ind */
4403 return;
4404
4405 case PERM_COD_CALL:
4406 dbug(1,dprintf("***Codec Connect_Pending A, Rc = 0x%x",rc));
4407 plci->internal_command = PERM_COD_CONN_PEND;
4408 return;
4409
4410 case PERM_COD_ASSIGN:
4411 dbug(1,dprintf("***Codec Assign A, Rc = 0x%x",rc));
4412 if(rc!=ASSIGN_OK) break;
4413 sig_req(plci,CALL_REQ,0);
4414 send_req(plci);
4415 plci->internal_command = PERM_COD_CALL;
4416 return;
4417
4418 /* Null Call Reference Request pending */
4419 case C_NCR_FAC_REQ:
4420 dbug(1,dprintf("NCR_FAC=0x%x/0x%x",req,rc));
4421 if(global_req==ASSIGN)
4422 {
4423 if(rc==ASSIGN_OK)
4424 {
4425 return;
4426 }
4427 else
4428 {
4429 sendf(appl,_INFO_R|CONFIRM,Id&0xf,Number,"w",_WRONG_STATE);
4430 appl->NullCREnable = false;
4431 plci_remove(plci);
4432 }
4433 }
4434 else if(req==NCR_FACILITY)
4435 {
4436 if(rc==OK)
4437 {
4438 sendf(appl,_INFO_R|CONFIRM,Id&0xf,Number,"w",0);
4439 }
4440 else
4441 {
4442 sendf(appl,_INFO_R|CONFIRM,Id&0xf,Number,"w",_WRONG_STATE);
4443 appl->NullCREnable = false;
4444 }
4445 plci_remove(plci);
4446 }
4447 break;
4448
4449 case HOOK_ON_REQ:
4450 if(plci->channels)
4451 {
4452 if(a->ncci_state[ncci]==CONNECTED)
4453 {
4454 a->ncci_state[ncci] = OUTG_DIS_PENDING;
4455 cleanup_ncci_data (plci, ncci);
4456 nl_req_ncci(plci,N_DISC,(byte)ncci);
4457 }
4458 break;
4459 }
4460 break;
4461
4462 case HOOK_OFF_REQ:
4463 if (plci->State == INC_DIS_PENDING)
4464 break;
4465 sig_req(plci,CALL_REQ,0);
4466 send_req(plci);
4467 plci->State=OUTG_CON_PENDING;
4468 break;
4469
4470
4471 case MWI_ACTIVATE_REQ_PEND:
4472 case MWI_DEACTIVATE_REQ_PEND:
4473 if(global_req == ASSIGN && rc==ASSIGN_OK)
4474 {
4475 dbug(1,dprintf("MWI_REQ assigned"));
4476 return;
4477 }
4478 else if(rc!=OK)
4479 {
4480 if(rc==WRONG_IE)
4481 {
4482 Info = 0x2007; /* Illegal message parameter coding */
4483 dbug(1,dprintf("MWI_REQ invalid parameter"));
4484 }
4485 else
4486 {
4487 Info = 0x300B; /* not supported */
4488 dbug(1,dprintf("MWI_REQ not supported"));
4489 }
4490 /* 0x3010: Request not allowed in this state */
4491 PUT_WORD(&SSparms[4],0x300E); /* SS not supported */
4492
4493 }
4494 if(plci->internal_command==MWI_ACTIVATE_REQ_PEND)
4495 {
4496 PUT_WORD(&SSparms[1],S_MWI_ACTIVATE);
4497 }
4498 else PUT_WORD(&SSparms[1],S_MWI_DEACTIVATE);
4499
4500 if(plci->cr_enquiry)
4501 {
4502 sendf(plci->appl,
4503 _FACILITY_R|CONFIRM,
4504 Id&0xf,
4505 plci->number,
4506 "wws",Info,(word)3,SSparms);
4507 if(rc!=OK) plci_remove(plci);
4508 }
4509 else
4510 {
4511 sendf(plci->appl,
4512 _FACILITY_R|CONFIRM,
4513 Id,
4514 plci->number,
4515 "wws",Info,(word)3,SSparms);
4516 }
4517 break;
4518
4519 case CONF_BEGIN_REQ_PEND:
4520 case CONF_ADD_REQ_PEND:
4521 case CONF_SPLIT_REQ_PEND:
4522 case CONF_DROP_REQ_PEND:
4523 case CONF_ISOLATE_REQ_PEND:
4524 case CONF_REATTACH_REQ_PEND:
4525 dbug(1,dprintf("CONF_RC=0x%x/0x%x",req,rc));
4526 if((plci->internal_command==CONF_ADD_REQ_PEND)&&(!plci->relatedPTYPLCI)) break;
4527 rplci = plci;
4528 rId = Id;
4529 switch(plci->internal_command)
4530 {
4531 case CONF_BEGIN_REQ_PEND:
4532 SSparms[1] = S_CONF_BEGIN;
4533 break;
4534 case CONF_ADD_REQ_PEND:
4535 SSparms[1] = S_CONF_ADD;
4536 rplci = plci->relatedPTYPLCI;
4537 rId = ((word)rplci->Id<<8)|rplci->adapter->Id;
4538 break;
4539 case CONF_SPLIT_REQ_PEND:
4540 SSparms[1] = S_CONF_SPLIT;
4541 break;
4542 case CONF_DROP_REQ_PEND:
4543 SSparms[1] = S_CONF_DROP;
4544 break;
4545 case CONF_ISOLATE_REQ_PEND:
4546 SSparms[1] = S_CONF_ISOLATE;
4547 break;
4548 case CONF_REATTACH_REQ_PEND:
4549 SSparms[1] = S_CONF_REATTACH;
4550 break;
4551 }
4552
4553 if(rc!=OK)
4554 {
4555 Info = 0x300E; /* not supported */
4556 plci->relatedPTYPLCI = NULL;
4557 plci->ptyState = 0;
4558 }
4559 sendf(rplci->appl,
4560 _FACILITY_R|CONFIRM,
4561 rId,
4562 plci->number,
4563 "wws",Info,(word)3,SSparms);
4564 break;
4565
4566 case VSWITCH_REQ_PEND:
4567 if(rc!=OK)
4568 {
4569 if(plci->relatedPTYPLCI)
4570 {
4571 plci->relatedPTYPLCI->vswitchstate=0;
4572 plci->relatedPTYPLCI->vsprot=0;
4573 plci->relatedPTYPLCI->vsprotdialect=0;
4574 }
4575 plci->vswitchstate=0;
4576 plci->vsprot=0;
4577 plci->vsprotdialect=0;
4578 }
4579 else
4580 {
4581 if(plci->relatedPTYPLCI &&
4582 plci->vswitchstate==1 &&
4583 plci->relatedPTYPLCI->vswitchstate==3) /* join complete */
4584 plci->vswitchstate=3;
4585 }
4586 break;
4587
4588 /* Call Deflection Request pending (SSCT) */
4589 case CD_REQ_PEND:
4590 SSparms[1] = S_CALL_DEFLECTION;
4591 if(rc!=OK)
4592 {
4593 Info = 0x300E; /* not supported */
4594 plci->appl->CDEnable = 0;
4595 }
4596 sendf(plci->appl,_FACILITY_R|CONFIRM,Id,
4597 plci->number,"wws",Info,(word)3,SSparms);
4598 break;
4599
4600 case RTP_CONNECT_B3_REQ_COMMAND_2:
4601 if (rc == OK)
4602 {
4603 ncci = get_ncci (plci, ch, 0);
4604 Id = (Id & 0xffff) | (((dword) ncci) << 16);
4605 plci->channels++;
4606 a->ncci_state[ncci] = OUTG_CON_PENDING;
4607 }
4608
4609 default:
4610 if (plci->internal_command_queue[0])
4611 {
4612 (*(plci->internal_command_queue[0]))(Id, plci, rc);
4613 if (plci->internal_command)
4614 return;
4615 }
4616 break;
4617 }
4618 next_internal_command (Id, plci);
4619 }
4620 }
4621 else /* appl==0 */
4622 {
4623 Id = ((word)plci->Id<<8)|plci->adapter->Id;
4624 if(plci->tel) Id|=EXT_CONTROLLER;
4625
4626 switch(plci->internal_command)
4627 {
4628 case BLOCK_PLCI:
4629 return;
4630
4631 case START_L1_SIG_ASSIGN_PEND:
4632 case REM_L1_SIG_ASSIGN_PEND:
4633 if(global_req == ASSIGN)
4634 {
4635 break;
4636 }
4637 else
4638 {
4639 dbug(1,dprintf("***L1 Req rem PLCI"));
4640 plci->internal_command = 0;
4641 sig_req(plci,REMOVE,0);
4642 send_req(plci);
4643 }
4644 break;
4645
4646 /* Call Deflection Request pending, just no appl ptr assigned */
4647 case CD_REQ_PEND:
4648 SSparms[1] = S_CALL_DEFLECTION;
4649 if(rc!=OK)
4650 {
4651 Info = 0x300E; /* not supported */
4652 }
4653 for(i=0; i<max_appl; i++)
4654 {
4655 if(application[i].CDEnable)
4656 {
4657 if(!application[i].Id) application[i].CDEnable = 0;
4658 else
4659 {
4660 sendf(&application[i],_FACILITY_R|CONFIRM,Id,
4661 plci->number,"wws",Info,(word)3,SSparms);
4662 if(Info) application[i].CDEnable = 0;
4663 }
4664 }
4665 }
4666 plci->internal_command = 0;
4667 break;
4668
4669 case PERM_COD_HOOK: /* finished with Hook_Ind */
4670 return;
4671
4672 case PERM_COD_CALL:
4673 plci->internal_command = PERM_COD_CONN_PEND;
4674 dbug(1,dprintf("***Codec Connect_Pending, Rc = 0x%x",rc));
4675 return;
4676
4677 case PERM_COD_ASSIGN:
4678 dbug(1,dprintf("***Codec Assign, Rc = 0x%x",rc));
4679 plci->internal_command = 0;
4680 if(rc!=ASSIGN_OK) break;
4681 plci->internal_command = PERM_COD_CALL;
4682 sig_req(plci,CALL_REQ,0);
4683 send_req(plci);
4684 return;
4685
4686 case LISTEN_SIG_ASSIGN_PEND:
4687 if(rc == ASSIGN_OK)
4688 {
4689 plci->internal_command = 0;
4690 dbug(1,dprintf("ListenCheck, new SIG_ID = 0x%x",plci->Sig.Id));
4691 add_p(plci,ESC,"\x02\x18\x00"); /* support call waiting */
4692 sig_req(plci,INDICATE_REQ,0);
4693 send_req(plci);
4694 }
4695 else
4696 {
4697 dbug(1,dprintf("ListenCheck failed (assignRc=0x%x)",rc));
4698 a->listen_active--;
4699 plci_remove(plci);
4700 plci->State = IDLE;
4701 }
4702 break;
4703
4704 case USELAW_REQ:
4705 if(global_req == ASSIGN)
4706 {
4707 if (rc==ASSIGN_OK)
4708 {
4709 sig_req(plci,LAW_REQ,0);
4710 send_req(plci);
4711 dbug(1,dprintf("Auto-Law assigned"));
4712 }
4713 else
4714 {
4715 dbug(1,dprintf("Auto-Law assign failed"));
4716 a->automatic_law = 3;
4717 plci->internal_command = 0;
4718 a->automatic_lawPLCI = NULL;
4719 }
4720 break;
4721 }
4722 else if(req == LAW_REQ && rc==OK)
4723 {
4724 dbug(1,dprintf("Auto-Law initiated"));
4725 a->automatic_law = 2;
4726 plci->internal_command = 0;
4727 }
4728 else
4729 {
4730 dbug(1,dprintf("Auto-Law not supported"));
4731 a->automatic_law = 3;
4732 plci->internal_command = 0;
4733 sig_req(plci,REMOVE,0);
4734 send_req(plci);
4735 a->automatic_lawPLCI = NULL;
4736 }
4737 break;
4738 }
4739 plci_remove_check(plci);
4740 }
4741 }
4742
4743 void data_rc(PLCI * plci, byte ch)
4744 {
4745 dword Id;
4746 DIVA_CAPI_ADAPTER * a;
4747 NCCI *ncci_ptr;
4748 DATA_B3_DESC *data;
4749 word ncci;
4750
4751 if (plci->appl)
4752 {
4753 TransmitBufferFree (plci->appl, plci->data_sent_ptr);
4754 a = plci->adapter;
4755 ncci = a->ch_ncci[ch];
4756 if (ncci && (a->ncci_plci[ncci] == plci->Id))
4757 {
4758 ncci_ptr = &(a->ncci[ncci]);
4759 dbug(1,dprintf("data_out=%d, data_pending=%d",ncci_ptr->data_out,ncci_ptr->data_pending));
4760 if (ncci_ptr->data_pending)
4761 {
4762 data = &(ncci_ptr->DBuffer[ncci_ptr->data_out]);
4763 if (!(data->Flags &4) && a->ncci_state[ncci])
4764 {
4765 Id = (((dword)ncci)<<16)|((word)plci->Id<<8)|a->Id;
4766 if(plci->tel) Id|=EXT_CONTROLLER;
4767 sendf(plci->appl,_DATA_B3_R|CONFIRM,Id,data->Number,
4768 "ww",data->Handle,0);
4769 }
4770 (ncci_ptr->data_out)++;
4771 if (ncci_ptr->data_out == MAX_DATA_B3)
4772 ncci_ptr->data_out = 0;
4773 (ncci_ptr->data_pending)--;
4774 }
4775 }
4776 }
4777 }
4778
4779 void data_ack(PLCI * plci, byte ch)
4780 {
4781 dword Id;
4782 DIVA_CAPI_ADAPTER * a;
4783 NCCI *ncci_ptr;
4784 word ncci;
4785
4786 a = plci->adapter;
4787 ncci = a->ch_ncci[ch];
4788 ncci_ptr = &(a->ncci[ncci]);
4789 if (ncci_ptr->data_ack_pending)
4790 {
4791 if (a->ncci_state[ncci] && (a->ncci_plci[ncci] == plci->Id))
4792 {
4793 Id = (((dword)ncci)<<16)|((word)plci->Id<<8)|a->Id;
4794 if(plci->tel) Id|=EXT_CONTROLLER;
4795 sendf(plci->appl,_DATA_B3_R|CONFIRM,Id,ncci_ptr->DataAck[ncci_ptr->data_ack_out].Number,
4796 "ww",ncci_ptr->DataAck[ncci_ptr->data_ack_out].Handle,0);
4797 }
4798 (ncci_ptr->data_ack_out)++;
4799 if (ncci_ptr->data_ack_out == MAX_DATA_ACK)
4800 ncci_ptr->data_ack_out = 0;
4801 (ncci_ptr->data_ack_pending)--;
4802 }
4803 }
4804
4805 void sig_ind(PLCI * plci)
4806 {
4807 dword x_Id;
4808 dword Id;
4809 dword rId;
4810 word Number = 0;
4811 word i;
4812 word cip;
4813 dword cip_mask;
4814 byte *ie;
4815 DIVA_CAPI_ADAPTER * a;
4816 API_PARSE saved_parms[MAX_MSG_PARMS+1];
4817 #define MAXPARMSIDS 31
4818 byte * parms[MAXPARMSIDS];
4819 byte * add_i[4];
4820 byte * multi_fac_parms[MAX_MULTI_IE];
4821 byte * multi_pi_parms [MAX_MULTI_IE];
4822 byte * multi_ssext_parms [MAX_MULTI_IE];
4823 byte * multi_CiPN_parms [MAX_MULTI_IE];
4824
4825 byte * multi_vswitch_parms [MAX_MULTI_IE];
4826
4827 byte ai_len;
4828 byte *esc_chi = "";
4829 byte *esc_law = "";
4830 byte *pty_cai = "";
4831 byte *esc_cr = "";
4832 byte *esc_profile = "";
4833
4834 byte facility[256];
4835 PLCI * tplci = NULL;
4836 byte chi[] = "\x02\x18\x01";
4837 byte voice_cai[] = "\x06\x14\x00\x00\x00\x00\x08";
4838 byte resume_cau[] = "\x05\x05\x00\x02\x00\x00";
4839 /* ESC_MSGTYPE must be the last but one message, a new IE has to be */
4840 /* included before the ESC_MSGTYPE and MAXPARMSIDS has to be incremented */
4841 /* SMSG is situated at the end because its 0 (for compatibility reasons */
4842 /* (see Info_Mask Bit 4, first IE. then the message type) */
4843 word parms_id[] =
4844 {MAXPARMSIDS, CPN, 0xff, DSA, OSA, BC, LLC, HLC, ESC_CAUSE, DSP, DT, CHA,
4845 UUI, CONG_RR, CONG_RNR, ESC_CHI, KEY, CHI, CAU, ESC_LAW,
4846 RDN, RDX, CONN_NR, RIN, NI, CAI, ESC_CR,
4847 CST, ESC_PROFILE, 0xff, ESC_MSGTYPE, SMSG};
4848 /* 14 FTY repl by ESC_CHI */
4849 /* 18 PI repl by ESC_LAW */
4850 /* removed OAD changed to 0xff for future use, OAD is multiIE now */
4851 word multi_fac_id[] = {1, FTY};
4852 word multi_pi_id[] = {1, PI};
4853 word multi_CiPN_id[] = {1, OAD};
4854 word multi_ssext_id[] = {1, ESC_SSEXT};
4855
4856 word multi_vswitch_id[] = {1, ESC_VSWITCH};
4857
4858 byte * cau;
4859 word ncci;
4860 byte SS_Ind[] = "\x05\x02\x00\x02\x00\x00"; /* Hold_Ind struct*/
4861 byte CF_Ind[] = "\x09\x02\x00\x06\x00\x00\x00\x00\x00\x00";
4862 byte Interr_Err_Ind[] = "\x0a\x02\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
4863 byte CONF_Ind[] = "\x09\x16\x00\x06\x00\x00\0x00\0x00\0x00\0x00";
4864 byte force_mt_info = false;
4865 byte dir;
4866 dword d;
4867 word w;
4868
4869 a = plci->adapter;
4870 Id = ((word)plci->Id<<8)|a->Id;
4871 PUT_WORD(&SS_Ind[4],0x0000);
4872
4873 if (plci->sig_remove_id)
4874 {
4875 plci->Sig.RNR = 2; /* discard */
4876 dbug(1,dprintf("SIG discard while remove pending"));
4877 return;
4878 }
4879 if(plci->tel && plci->SuppState!=CALL_HELD) Id|=EXT_CONTROLLER;
4880 dbug(1,dprintf("SigInd-Id=%08lx,plci=%x,tel=%x,state=0x%x,channels=%d,Discflowcl=%d",
4881 Id,plci->Id,plci->tel,plci->State,plci->channels,plci->hangup_flow_ctrl_timer));
4882 if(plci->Sig.Ind==CALL_HOLD_ACK && plci->channels)
4883 {
4884 plci->Sig.RNR = 1;
4885 return;
4886 }
4887 if(plci->Sig.Ind==HANGUP && plci->channels)
4888 {
4889 plci->Sig.RNR = 1;
4890 plci->hangup_flow_ctrl_timer++;
4891 /* recover the network layer after timeout */
4892 if(plci->hangup_flow_ctrl_timer==100)
4893 {
4894 dbug(1,dprintf("Exceptional disc"));
4895 plci->Sig.RNR = 0;
4896 plci->hangup_flow_ctrl_timer = 0;
4897 for (ncci = 1; ncci < MAX_NCCI+1; ncci++)
4898 {
4899 if (a->ncci_plci[ncci] == plci->Id)
4900 {
4901 cleanup_ncci_data (plci, ncci);
4902 if(plci->channels)plci->channels--;
4903 if (plci->appl)
4904 sendf(plci->appl,_DISCONNECT_B3_I, (((dword) ncci) << 16) | Id,0,"ws",0,"");
4905 }
4906 }
4907 if (plci->appl)
4908 sendf(plci->appl, _DISCONNECT_I, Id, 0, "w", 0);
4909 plci_remove(plci);
4910 plci->State=IDLE;
4911 }
4912 return;
4913 }
4914
4915 /* do first parse the info with no OAD in, because OAD will be converted */
4916 /* first the multiple facility IE, then mult. progress ind. */
4917 /* then the parameters for the info_ind + conn_ind */
4918 IndParse(plci,multi_fac_id,multi_fac_parms,MAX_MULTI_IE);
4919 IndParse(plci,multi_pi_id,multi_pi_parms,MAX_MULTI_IE);
4920 IndParse(plci,multi_ssext_id,multi_ssext_parms,MAX_MULTI_IE);
4921
4922 IndParse(plci,multi_vswitch_id,multi_vswitch_parms,MAX_MULTI_IE);
4923
4924 IndParse(plci,parms_id,parms,0);
4925 IndParse(plci,multi_CiPN_id,multi_CiPN_parms,MAX_MULTI_IE);
4926 esc_chi = parms[14];
4927 esc_law = parms[18];
4928 pty_cai = parms[24];
4929 esc_cr = parms[25];
4930 esc_profile = parms[27];
4931 if(esc_cr[0] && plci)
4932 {
4933 if(plci->cr_enquiry && plci->appl)
4934 {
4935 plci->cr_enquiry = false;
4936 /* d = MANU_ID */
4937 /* w = m_command */
4938 /* b = total length */
4939 /* b = indication type */
4940 /* b = length of all IEs */
4941 /* b = IE1 */
4942 /* S = IE1 length + cont. */
4943 /* b = IE2 */
4944 /* S = IE2 lenght + cont. */
4945 sendf(plci->appl,
4946 _MANUFACTURER_I,
4947 Id,
4948 0,
4949 "dwbbbbSbS",_DI_MANU_ID,plci->m_command,
4950 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);
4951 }
4952 }
4953 /* create the additional info structure */
4954 add_i[1] = parms[15]; /* KEY of additional info */
4955 add_i[2] = parms[11]; /* UUI of additional info */
4956 ai_len = AddInfo(add_i,multi_fac_parms, esc_chi, facility);
4957
4958 /* the ESC_LAW indicates if u-Law or a-Law is actually used by the card */
4959 /* indication returns by the card if requested by the function */
4960 /* AutomaticLaw() after driver init */
4961 if (a->automatic_law<4)
4962 {
4963 if(esc_law[0]){
4964 if(esc_law[2]){
4965 dbug(0,dprintf("u-Law selected"));
4966 a->u_law = 1;
4967 }
4968 else {
4969 dbug(0,dprintf("a-Law selected"));
4970 a->u_law = 0;
4971 }
4972 a->automatic_law = 4;
4973 if(plci==a->automatic_lawPLCI) {
4974 plci->internal_command = 0;
4975 sig_req(plci,REMOVE,0);
4976 send_req(plci);
4977 a->automatic_lawPLCI = NULL;
4978 }
4979 }
4980 if (esc_profile[0])
4981 {
4982 dbug (1, dprintf ("[%06x] CardProfile: %lx %lx %lx %lx %lx",
4983 UnMapController (a->Id), GET_DWORD (&esc_profile[6]),
4984 GET_DWORD (&esc_profile[10]), GET_DWORD (&esc_profile[14]),
4985 GET_DWORD (&esc_profile[18]), GET_DWORD (&esc_profile[46])));
4986
4987 a->profile.Global_Options &= 0x000000ffL;
4988 a->profile.B1_Protocols &= 0x000003ffL;
4989 a->profile.B2_Protocols &= 0x00001fdfL;
4990 a->profile.B3_Protocols &= 0x000000b7L;
4991
4992 a->profile.Global_Options &= GET_DWORD (&esc_profile[6]) |
4993 GL_BCHANNEL_OPERATION_SUPPORTED;
4994 a->profile.B1_Protocols &= GET_DWORD (&esc_profile[10]);
4995 a->profile.B2_Protocols &= GET_DWORD (&esc_profile[14]);
4996 a->profile.B3_Protocols &= GET_DWORD (&esc_profile[18]);
4997 a->manufacturer_features = GET_DWORD (&esc_profile[46]);
4998 a->man_profile.private_options = 0;
4999
5000 if (a->manufacturer_features & MANUFACTURER_FEATURE_ECHO_CANCELLER)
5001 {
5002 a->man_profile.private_options |= 1L << PRIVATE_ECHO_CANCELLER;
5003 a->profile.Global_Options |= GL_ECHO_CANCELLER_SUPPORTED;
5004 }
5005
5006
5007 if (a->manufacturer_features & MANUFACTURER_FEATURE_RTP)
5008 a->man_profile.private_options |= 1L << PRIVATE_RTP;
5009 a->man_profile.rtp_primary_payloads = GET_DWORD (&esc_profile[50]);
5010 a->man_profile.rtp_additional_payloads = GET_DWORD (&esc_profile[54]);
5011
5012
5013 if (a->manufacturer_features & MANUFACTURER_FEATURE_T38)
5014 a->man_profile.private_options |= 1L << PRIVATE_T38;
5015
5016
5017 if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_SUB_SEP_PWD)
5018 a->man_profile.private_options |= 1L << PRIVATE_FAX_SUB_SEP_PWD;
5019
5020
5021 if (a->manufacturer_features & MANUFACTURER_FEATURE_V18)
5022 a->man_profile.private_options |= 1L << PRIVATE_V18;
5023
5024
5025 if (a->manufacturer_features & MANUFACTURER_FEATURE_DTMF_TONE)
5026 a->man_profile.private_options |= 1L << PRIVATE_DTMF_TONE;
5027
5028
5029 if (a->manufacturer_features & MANUFACTURER_FEATURE_PIAFS)
5030 a->man_profile.private_options |= 1L << PRIVATE_PIAFS;
5031
5032
5033 if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
5034 a->man_profile.private_options |= 1L << PRIVATE_FAX_PAPER_FORMATS;
5035
5036
5037 if (a->manufacturer_features & MANUFACTURER_FEATURE_VOWN)
5038 a->man_profile.private_options |= 1L << PRIVATE_VOWN;
5039
5040
5041 if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_NONSTANDARD)
5042 a->man_profile.private_options |= 1L << PRIVATE_FAX_NONSTANDARD;
5043
5044 }
5045 else
5046 {
5047 a->profile.Global_Options &= 0x0000007fL;
5048 a->profile.B1_Protocols &= 0x000003dfL;
5049 a->profile.B2_Protocols &= 0x00001adfL;
5050 a->profile.B3_Protocols &= 0x000000b7L;
5051 a->manufacturer_features &= MANUFACTURER_FEATURE_HARDDTMF;
5052 }
5053 if (a->manufacturer_features & (MANUFACTURER_FEATURE_HARDDTMF |
5054 MANUFACTURER_FEATURE_SOFTDTMF_SEND | MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE))
5055 {
5056 a->profile.Global_Options |= GL_DTMF_SUPPORTED;
5057 }
5058 a->manufacturer_features &= ~MANUFACTURER_FEATURE_OOB_CHANNEL;
5059 dbug (1, dprintf ("[%06x] Profile: %lx %lx %lx %lx %lx",
5060 UnMapController (a->Id), a->profile.Global_Options,
5061 a->profile.B1_Protocols, a->profile.B2_Protocols,
5062 a->profile.B3_Protocols, a->manufacturer_features));
5063 }
5064 /* codec plci for the handset/hook state support is just an internal id */
5065 if(plci!=a->AdvCodecPLCI)
5066 {
5067 force_mt_info = SendMultiIE(plci,Id,multi_fac_parms, FTY, 0x20, 0);
5068 force_mt_info |= SendMultiIE(plci,Id,multi_pi_parms, PI, 0x210, 0);
5069 SendSSExtInd(NULL,plci,Id,multi_ssext_parms);
5070 SendInfo(plci,Id, parms, force_mt_info);
5071
5072 VSwitchReqInd(plci,Id,multi_vswitch_parms);
5073
5074 }
5075
5076 /* switch the codec to the b-channel */
5077 if(esc_chi[0] && plci && !plci->SuppState){
5078 plci->b_channel = esc_chi[esc_chi[0]]&0x1f;
5079 mixer_set_bchannel_id_esc (plci, plci->b_channel);
5080 dbug(1,dprintf("storeChannel=0x%x",plci->b_channel));
5081 if(plci->tel==ADV_VOICE && plci->appl) {
5082 SetVoiceChannel(a->AdvCodecPLCI, esc_chi, a);
5083 }
5084 }
5085
5086 if(plci->appl) Number = plci->appl->Number++;
5087
5088 switch(plci->Sig.Ind) {
5089 /* Response to Get_Supported_Services request */
5090 case S_SUPPORTED:
5091 dbug(1,dprintf("S_Supported"));
5092 if(!plci->appl) break;
5093 if(pty_cai[0]==4)
5094 {
5095 PUT_DWORD(&CF_Ind[6],GET_DWORD(&pty_cai[1]) );
5096 }
5097 else
5098 {
5099 PUT_DWORD(&CF_Ind[6],MASK_TERMINAL_PORTABILITY | MASK_HOLD_RETRIEVE);
5100 }
5101 PUT_WORD (&CF_Ind[1], 0);
5102 PUT_WORD (&CF_Ind[4], 0);
5103 sendf(plci->appl,_FACILITY_R|CONFIRM,Id&0x7,plci->number, "wws",0,3,CF_Ind);
5104 plci_remove(plci);
5105 break;
5106
5107 /* Supplementary Service rejected */
5108 case S_SERVICE_REJ:
5109 dbug(1,dprintf("S_Reject=0x%x",pty_cai[5]));
5110 if(!pty_cai[0]) break;
5111 switch (pty_cai[5])
5112 {
5113 case ECT_EXECUTE:
5114 case THREE_PTY_END:
5115 case THREE_PTY_BEGIN:
5116 if(!plci->relatedPTYPLCI) break;
5117 tplci = plci->relatedPTYPLCI;
5118 rId = ( (word)tplci->Id<<8)|tplci->adapter->Id;
5119 if(tplci->tel) rId|=EXT_CONTROLLER;
5120 if(pty_cai[5]==ECT_EXECUTE)
5121 {
5122 PUT_WORD(&SS_Ind[1],S_ECT);
5123
5124 plci->vswitchstate=0;
5125 plci->relatedPTYPLCI->vswitchstate=0;
5126
5127 }
5128 else
5129 {
5130 PUT_WORD(&SS_Ind[1],pty_cai[5]+3);
5131 }
5132 if(pty_cai[2]!=0xff)
5133 {
5134 PUT_WORD(&SS_Ind[4],0x3600|(word)pty_cai[2]);
5135 }
5136 else
5137 {
5138 PUT_WORD(&SS_Ind[4],0x300E);
5139 }
5140 plci->relatedPTYPLCI = NULL;
5141 plci->ptyState = 0;
5142 sendf(tplci->appl,_FACILITY_I,rId,0,"ws",3, SS_Ind);
5143 break;
5144
5145 case CALL_DEFLECTION:
5146 if(pty_cai[2]!=0xff)
5147 {
5148 PUT_WORD(&SS_Ind[4],0x3600|(word)pty_cai[2]);
5149 }
5150 else
5151 {
5152 PUT_WORD(&SS_Ind[4],0x300E);
5153 }
5154 PUT_WORD(&SS_Ind[1],pty_cai[5]);
5155 for(i=0; i<max_appl; i++)
5156 {
5157 if(application[i].CDEnable)
5158 {
5159 if(application[i].Id) sendf(&application[i],_FACILITY_I,Id,0,"ws",3, SS_Ind);
5160 application[i].CDEnable = false;
5161 }
5162 }
5163 break;
5164
5165 case DEACTIVATION_DIVERSION:
5166 case ACTIVATION_DIVERSION:
5167 case DIVERSION_INTERROGATE_CFU:
5168 case DIVERSION_INTERROGATE_CFB:
5169 case DIVERSION_INTERROGATE_CFNR:
5170 case DIVERSION_INTERROGATE_NUM:
5171 case CCBS_REQUEST:
5172 case CCBS_DEACTIVATE:
5173 case CCBS_INTERROGATE:
5174 if(!plci->appl) break;
5175 if(pty_cai[2]!=0xff)
5176 {
5177 PUT_WORD(&Interr_Err_Ind[4],0x3600|(word)pty_cai[2]);
5178 }
5179 else
5180 {
5181 PUT_WORD(&Interr_Err_Ind[4],0x300E);
5182 }
5183 switch (pty_cai[5])
5184 {
5185 case DEACTIVATION_DIVERSION:
5186 dbug(1,dprintf("Deact_Div"));
5187 Interr_Err_Ind[0]=0x9;
5188 Interr_Err_Ind[3]=0x6;
5189 PUT_WORD(&Interr_Err_Ind[1],S_CALL_FORWARDING_STOP);
5190 break;
5191 case ACTIVATION_DIVERSION:
5192 dbug(1,dprintf("Act_Div"));
5193 Interr_Err_Ind[0]=0x9;
5194 Interr_Err_Ind[3]=0x6;
5195 PUT_WORD(&Interr_Err_Ind[1],S_CALL_FORWARDING_START);
5196 break;
5197 case DIVERSION_INTERROGATE_CFU:
5198 case DIVERSION_INTERROGATE_CFB:
5199 case DIVERSION_INTERROGATE_CFNR:
5200 dbug(1,dprintf("Interr_Div"));
5201 Interr_Err_Ind[0]=0xa;
5202 Interr_Err_Ind[3]=0x7;
5203 PUT_WORD(&Interr_Err_Ind[1],S_INTERROGATE_DIVERSION);
5204 break;
5205 case DIVERSION_INTERROGATE_NUM:
5206 dbug(1,dprintf("Interr_Num"));
5207 Interr_Err_Ind[0]=0xa;
5208 Interr_Err_Ind[3]=0x7;
5209 PUT_WORD(&Interr_Err_Ind[1],S_INTERROGATE_NUMBERS);
5210 break;
5211 case CCBS_REQUEST:
5212 dbug(1,dprintf("CCBS Request"));
5213 Interr_Err_Ind[0]=0xd;
5214 Interr_Err_Ind[3]=0xa;
5215 PUT_WORD(&Interr_Err_Ind[1],S_CCBS_REQUEST);
5216 break;
5217 case CCBS_DEACTIVATE:
5218 dbug(1,dprintf("CCBS Deactivate"));
5219 Interr_Err_Ind[0]=0x9;
5220 Interr_Err_Ind[3]=0x6;
5221 PUT_WORD(&Interr_Err_Ind[1],S_CCBS_DEACTIVATE);
5222 break;
5223 case CCBS_INTERROGATE:
5224 dbug(1,dprintf("CCBS Interrogate"));
5225 Interr_Err_Ind[0]=0xb;
5226 Interr_Err_Ind[3]=0x8;
5227 PUT_WORD(&Interr_Err_Ind[1],S_CCBS_INTERROGATE);
5228 break;
5229 }
5230 PUT_DWORD(&Interr_Err_Ind[6],plci->appl->S_Handle);
5231 sendf(plci->appl,_FACILITY_I,Id&0x7,0,"ws",3, Interr_Err_Ind);
5232 plci_remove(plci);
5233 break;
5234 case ACTIVATION_MWI:
5235 case DEACTIVATION_MWI:
5236 if(pty_cai[5]==ACTIVATION_MWI)
5237 {
5238 PUT_WORD(&SS_Ind[1],S_MWI_ACTIVATE);
5239 }
5240 else PUT_WORD(&SS_Ind[1],S_MWI_DEACTIVATE);
5241
5242 if(pty_cai[2]!=0xff)
5243 {
5244 PUT_WORD(&SS_Ind[4],0x3600|(word)pty_cai[2]);
5245 }
5246 else
5247 {
5248 PUT_WORD(&SS_Ind[4],0x300E);
5249 }
5250
5251 if(plci->cr_enquiry)
5252 {
5253 sendf(plci->appl,_FACILITY_I,Id&0xf,0,"ws",3, SS_Ind);
5254 plci_remove(plci);
5255 }
5256 else
5257 {
5258 sendf(plci->appl,_FACILITY_I,Id,0,"ws",3, SS_Ind);
5259 }
5260 break;
5261 case CONF_ADD: /* ERROR */
5262 case CONF_BEGIN:
5263 case CONF_DROP:
5264 case CONF_ISOLATE:
5265 case CONF_REATTACH:
5266 CONF_Ind[0]=9;
5267 CONF_Ind[3]=6;
5268 switch(pty_cai[5])
5269 {
5270 case CONF_BEGIN:
5271 PUT_WORD(&CONF_Ind[1],S_CONF_BEGIN);
5272 plci->ptyState = 0;
5273 break;
5274 case CONF_DROP:
5275 CONF_Ind[0]=5;
5276 CONF_Ind[3]=2;
5277 PUT_WORD(&CONF_Ind[1],S_CONF_DROP);
5278 plci->ptyState = CONNECTED;
5279 break;
5280 case CONF_ISOLATE:
5281 CONF_Ind[0]=5;
5282 CONF_Ind[3]=2;
5283 PUT_WORD(&CONF_Ind[1],S_CONF_ISOLATE);
5284 plci->ptyState = CONNECTED;
5285 break;
5286 case CONF_REATTACH:
5287 CONF_Ind[0]=5;
5288 CONF_Ind[3]=2;
5289 PUT_WORD(&CONF_Ind[1],S_CONF_REATTACH);
5290 plci->ptyState = CONNECTED;
5291 break;
5292 case CONF_ADD:
5293 PUT_WORD(&CONF_Ind[1],S_CONF_ADD);
5294 plci->relatedPTYPLCI = NULL;
5295 tplci=plci->relatedPTYPLCI;
5296 if(tplci) tplci->ptyState = CONNECTED;
5297 plci->ptyState = CONNECTED;
5298 break;
5299 }
5300
5301 if(pty_cai[2]!=0xff)
5302 {
5303 PUT_WORD(&CONF_Ind[4],0x3600|(word)pty_cai[2]);
5304 }
5305 else
5306 {
5307 PUT_WORD(&CONF_Ind[4],0x3303); /* Time-out: network did not respond
5308 within the required time */
5309 }
5310
5311 PUT_DWORD(&CONF_Ind[6],0x0);
5312 sendf(plci->appl,_FACILITY_I,Id,0,"ws",3, CONF_Ind);
5313 break;
5314 }
5315 break;
5316
5317 /* Supplementary Service indicates success */
5318 case S_SERVICE:
5319 dbug(1,dprintf("Service_Ind"));
5320 PUT_WORD (&CF_Ind[4], 0);
5321 switch (pty_cai[5])
5322 {
5323 case THREE_PTY_END:
5324 case THREE_PTY_BEGIN:
5325 case ECT_EXECUTE:
5326 if(!plci->relatedPTYPLCI) break;
5327 tplci = plci->relatedPTYPLCI;
5328 rId = ( (word)tplci->Id<<8)|tplci->adapter->Id;
5329 if(tplci->tel) rId|=EXT_CONTROLLER;
5330 if(pty_cai[5]==ECT_EXECUTE)
5331 {
5332 PUT_WORD(&SS_Ind[1],S_ECT);
5333
5334 if(plci->vswitchstate!=3)
5335 {
5336
5337 plci->ptyState = IDLE;
5338 plci->relatedPTYPLCI = NULL;
5339 plci->ptyState = 0;
5340
5341 }
5342
5343 dbug(1,dprintf("ECT OK"));
5344 sendf(tplci->appl,_FACILITY_I,rId,0,"ws",3, SS_Ind);
5345
5346
5347
5348 }
5349 else
5350 {
5351 switch (plci->ptyState)
5352 {
5353 case S_3PTY_BEGIN:
5354 plci->ptyState = CONNECTED;
5355 dbug(1,dprintf("3PTY ON"));
5356 break;
5357
5358 case S_3PTY_END:
5359 plci->ptyState = IDLE;
5360 plci->relatedPTYPLCI = NULL;
5361 plci->ptyState = 0;
5362 dbug(1,dprintf("3PTY OFF"));
5363 break;
5364 }
5365 PUT_WORD(&SS_Ind[1],pty_cai[5]+3);
5366 sendf(tplci->appl,_FACILITY_I,rId,0,"ws",3, SS_Ind);
5367 }
5368 break;
5369
5370 case CALL_DEFLECTION:
5371 PUT_WORD(&SS_Ind[1],pty_cai[5]);
5372 for(i=0; i<max_appl; i++)
5373 {
5374 if(application[i].CDEnable)
5375 {
5376 if(application[i].Id) sendf(&application[i],_FACILITY_I,Id,0,"ws",3, SS_Ind);
5377 application[i].CDEnable = false;
5378 }
5379 }
5380 break;
5381
5382 case DEACTIVATION_DIVERSION:
5383 case ACTIVATION_DIVERSION:
5384 if(!plci->appl) break;
5385 PUT_WORD(&CF_Ind[1],pty_cai[5]+2);
5386 PUT_DWORD(&CF_Ind[6],plci->appl->S_Handle);
5387 sendf(plci->appl,_FACILITY_I,Id&0x7,0,"ws",3, CF_Ind);
5388 plci_remove(plci);
5389 break;
5390
5391 case DIVERSION_INTERROGATE_CFU:
5392 case DIVERSION_INTERROGATE_CFB:
5393 case DIVERSION_INTERROGATE_CFNR:
5394 case DIVERSION_INTERROGATE_NUM:
5395 case CCBS_REQUEST:
5396 case CCBS_DEACTIVATE:
5397 case CCBS_INTERROGATE:
5398 if(!plci->appl) break;
5399 switch (pty_cai[5])
5400 {
5401 case DIVERSION_INTERROGATE_CFU:
5402 case DIVERSION_INTERROGATE_CFB:
5403 case DIVERSION_INTERROGATE_CFNR:
5404 dbug(1,dprintf("Interr_Div"));
5405 PUT_WORD(&pty_cai[1],S_INTERROGATE_DIVERSION);
5406 pty_cai[3]=pty_cai[0]-3; /* Supplementary Service-specific parameter len */
5407 break;
5408 case DIVERSION_INTERROGATE_NUM:
5409 dbug(1,dprintf("Interr_Num"));
5410 PUT_WORD(&pty_cai[1],S_INTERROGATE_NUMBERS);
5411 pty_cai[3]=pty_cai[0]-3; /* Supplementary Service-specific parameter len */
5412 break;
5413 case CCBS_REQUEST:
5414 dbug(1,dprintf("CCBS Request"));
5415 PUT_WORD(&pty_cai[1],S_CCBS_REQUEST);
5416 pty_cai[3]=pty_cai[0]-3; /* Supplementary Service-specific parameter len */
5417 break;
5418 case CCBS_DEACTIVATE:
5419 dbug(1,dprintf("CCBS Deactivate"));
5420 PUT_WORD(&pty_cai[1],S_CCBS_DEACTIVATE);
5421 pty_cai[3]=pty_cai[0]-3; /* Supplementary Service-specific parameter len */
5422 break;
5423 case CCBS_INTERROGATE:
5424 dbug(1,dprintf("CCBS Interrogate"));
5425 PUT_WORD(&pty_cai[1],S_CCBS_INTERROGATE);
5426 pty_cai[3]=pty_cai[0]-3; /* Supplementary Service-specific parameter len */
5427 break;
5428 }
5429 PUT_WORD(&pty_cai[4],0); /* Supplementary Service Reason */
5430 PUT_DWORD(&pty_cai[6],plci->appl->S_Handle);
5431 sendf(plci->appl,_FACILITY_I,Id&0x7,0,"wS",3, pty_cai);
5432 plci_remove(plci);
5433 break;
5434
5435 case ACTIVATION_MWI:
5436 case DEACTIVATION_MWI:
5437 if(pty_cai[5]==ACTIVATION_MWI)
5438 {
5439 PUT_WORD(&SS_Ind[1],S_MWI_ACTIVATE);
5440 }
5441 else PUT_WORD(&SS_Ind[1],S_MWI_DEACTIVATE);
5442 if(plci->cr_enquiry)
5443 {
5444 sendf(plci->appl,_FACILITY_I,Id&0xf,0,"ws",3, SS_Ind);
5445 plci_remove(plci);
5446 }
5447 else
5448 {
5449 sendf(plci->appl,_FACILITY_I,Id,0,"ws",3, SS_Ind);
5450 }
5451 break;
5452 case MWI_INDICATION:
5453 if(pty_cai[0]>=0x12)
5454 {
5455 PUT_WORD(&pty_cai[3],S_MWI_INDICATE);
5456 pty_cai[2]=pty_cai[0]-2; /* len Parameter */
5457 pty_cai[5]=pty_cai[0]-5; /* Supplementary Service-specific parameter len */
5458 if(plci->appl && (a->Notification_Mask[plci->appl->Id-1]&SMASK_MWI))
5459 {
5460 if(plci->internal_command==GET_MWI_STATE) /* result on Message Waiting Listen */
5461 {
5462 sendf(plci->appl,_FACILITY_I,Id&0xf,0,"wS",3, &pty_cai[2]);
5463 plci_remove(plci);
5464 return;
5465 }
5466 else sendf(plci->appl,_FACILITY_I,Id,0,"wS",3, &pty_cai[2]);
5467 pty_cai[0]=0;
5468 }
5469 else
5470 {
5471 for(i=0; i<max_appl; i++)
5472 {
5473 if(a->Notification_Mask[i]&SMASK_MWI)
5474 {
5475 sendf(&application[i],_FACILITY_I,Id&0x7,0,"wS",3, &pty_cai[2]);
5476 pty_cai[0]=0;
5477 }
5478 }
5479 }
5480
5481 if(!pty_cai[0])
5482 { /* acknowledge */
5483 facility[2]= 0; /* returncode */
5484 }
5485 else facility[2]= 0xff;
5486 }
5487 else
5488 {
5489 /* reject */
5490 facility[2]= 0xff; /* returncode */
5491 }
5492 facility[0]= 2;
5493 facility[1]= MWI_RESPONSE; /* Function */
5494 add_p(plci,CAI,facility);
5495 add_p(plci,ESC,multi_ssext_parms[0]); /* remembered parameter -> only one possible */
5496 sig_req(plci,S_SERVICE,0);
5497 send_req(plci);
5498 plci->command = 0;
5499 next_internal_command (Id, plci);
5500 break;
5501 case CONF_ADD: /* OK */
5502 case CONF_BEGIN:
5503 case CONF_DROP:
5504 case CONF_ISOLATE:
5505 case CONF_REATTACH:
5506 case CONF_PARTYDISC:
5507 CONF_Ind[0]=9;
5508 CONF_Ind[3]=6;
5509 switch(pty_cai[5])
5510 {
5511 case CONF_BEGIN:
5512 PUT_WORD(&CONF_Ind[1],S_CONF_BEGIN);
5513 if(pty_cai[0]==6)
5514 {
5515 d=pty_cai[6];
5516 PUT_DWORD(&CONF_Ind[6],d); /* PartyID */
5517 }
5518 else
5519 {
5520 PUT_DWORD(&CONF_Ind[6],0x0);
5521 }
5522 break;
5523 case CONF_ISOLATE:
5524 PUT_WORD(&CONF_Ind[1],S_CONF_ISOLATE);
5525 CONF_Ind[0]=5;
5526 CONF_Ind[3]=2;
5527 break;
5528 case CONF_REATTACH:
5529 PUT_WORD(&CONF_Ind[1],S_CONF_REATTACH);
5530 CONF_Ind[0]=5;
5531 CONF_Ind[3]=2;
5532 break;
5533 case CONF_DROP:
5534 PUT_WORD(&CONF_Ind[1],S_CONF_DROP);
5535 CONF_Ind[0]=5;
5536 CONF_Ind[3]=2;
5537 break;
5538 case CONF_ADD:
5539 PUT_WORD(&CONF_Ind[1],S_CONF_ADD);
5540 d=pty_cai[6];
5541 PUT_DWORD(&CONF_Ind[6],d); /* PartyID */
5542 tplci=plci->relatedPTYPLCI;
5543 if(tplci) tplci->ptyState = CONNECTED;
5544 break;
5545 case CONF_PARTYDISC:
5546 CONF_Ind[0]=7;
5547 CONF_Ind[3]=4;
5548 PUT_WORD(&CONF_Ind[1],S_CONF_PARTYDISC);
5549 d=pty_cai[6];
5550 PUT_DWORD(&CONF_Ind[4],d); /* PartyID */
5551 break;
5552 }
5553 plci->ptyState = CONNECTED;
5554 sendf(plci->appl,_FACILITY_I,Id,0,"ws",3, CONF_Ind);
5555 break;
5556 case CCBS_INFO_RETAIN:
5557 case CCBS_ERASECALLLINKAGEID:
5558 case CCBS_STOP_ALERTING:
5559 CONF_Ind[0]=5;
5560 CONF_Ind[3]=2;
5561 switch(pty_cai[5])
5562 {
5563 case CCBS_INFO_RETAIN:
5564 PUT_WORD(&CONF_Ind[1],S_CCBS_INFO_RETAIN);
5565 break;
5566 case CCBS_STOP_ALERTING:
5567 PUT_WORD(&CONF_Ind[1],S_CCBS_STOP_ALERTING);
5568 break;
5569 case CCBS_ERASECALLLINKAGEID:
5570 PUT_WORD(&CONF_Ind[1],S_CCBS_ERASECALLLINKAGEID);
5571 CONF_Ind[0]=7;
5572 CONF_Ind[3]=4;
5573 CONF_Ind[6]=0;
5574 CONF_Ind[7]=0;
5575 break;
5576 }
5577 w=pty_cai[6];
5578 PUT_WORD(&CONF_Ind[4],w); /* PartyID */
5579
5580 if(plci->appl && (a->Notification_Mask[plci->appl->Id-1]&SMASK_CCBS))
5581 {
5582 sendf(plci->appl,_FACILITY_I,Id,0,"ws",3, CONF_Ind);
5583 }
5584 else
5585 {
5586 for(i=0; i<max_appl; i++)
5587 if(a->Notification_Mask[i]&SMASK_CCBS)
5588 sendf(&application[i],_FACILITY_I,Id&0x7,0,"ws",3, CONF_Ind);
5589 }
5590 break;
5591 }
5592 break;
5593 case CALL_HOLD_REJ:
5594 cau = parms[7];
5595 if(cau)
5596 {
5597 i = _L3_CAUSE | cau[2];
5598 if(cau[2]==0) i = 0x3603;
5599 }
5600 else
5601 {
5602 i = 0x3603;
5603 }
5604 PUT_WORD(&SS_Ind[1],S_HOLD);
5605 PUT_WORD(&SS_Ind[4],i);
5606 if(plci->SuppState == HOLD_REQUEST)
5607 {
5608 plci->SuppState = IDLE;
5609 sendf(plci->appl,_FACILITY_I,Id,0,"ws",3, SS_Ind);
5610 }
5611 break;
5612
5613 case CALL_HOLD_ACK:
5614 if(plci->SuppState == HOLD_REQUEST)
5615 {
5616 plci->SuppState = CALL_HELD;
5617 CodecIdCheck(a, plci);
5618 start_internal_command (Id, plci, hold_save_command);
5619 }
5620 break;
5621
5622 case CALL_RETRIEVE_REJ:
5623 cau = parms[7];
5624 if(cau)
5625 {
5626 i = _L3_CAUSE | cau[2];
5627 if(cau[2]==0) i = 0x3603;
5628 }
5629 else
5630 {
5631 i = 0x3603;
5632 }
5633 PUT_WORD(&SS_Ind[1],S_RETRIEVE);
5634 PUT_WORD(&SS_Ind[4],i);
5635 if(plci->SuppState == RETRIEVE_REQUEST)
5636 {
5637 plci->SuppState = CALL_HELD;
5638 CodecIdCheck(a, plci);
5639 sendf(plci->appl,_FACILITY_I,Id,0,"ws",3, SS_Ind);
5640 }
5641 break;
5642
5643 case CALL_RETRIEVE_ACK:
5644 PUT_WORD(&SS_Ind[1],S_RETRIEVE);
5645 if(plci->SuppState == RETRIEVE_REQUEST)
5646 {
5647 plci->SuppState = IDLE;
5648 plci->call_dir |= CALL_DIR_FORCE_OUTG_NL;
5649 plci->b_channel = esc_chi[esc_chi[0]]&0x1f;
5650 if(plci->tel)
5651 {
5652 mixer_set_bchannel_id_esc (plci, plci->b_channel);
5653 dbug(1,dprintf("RetrChannel=0x%x",plci->b_channel));
5654 SetVoiceChannel(a->AdvCodecPLCI, esc_chi, a);
5655 if(plci->B2_prot==B2_TRANSPARENT && plci->B3_prot==B3_TRANSPARENT)
5656 {
5657 dbug(1,dprintf("Get B-ch"));
5658 start_internal_command (Id, plci, retrieve_restore_command);
5659 }
5660 else
5661 sendf(plci->appl,_FACILITY_I,Id,0,"ws",3, SS_Ind);
5662 }
5663 else
5664 start_internal_command (Id, plci, retrieve_restore_command);
5665 }
5666 break;
5667
5668 case INDICATE_IND:
5669 if(plci->State != LISTENING) {
5670 sig_req(plci,HANGUP,0);
5671 send_req(plci);
5672 break;
5673 }
5674 cip = find_cip(a,parms[4],parms[6]);
5675 cip_mask = 1L<<cip;
5676 dbug(1,dprintf("cip=%d,cip_mask=%lx",cip,cip_mask));
5677 clear_c_ind_mask (plci);
5678 if (!remove_started && !a->adapter_disabled)
5679 {
5680 set_c_ind_mask_bit (plci, MAX_APPL);
5681 group_optimization(a, plci);
5682 for(i=0; i<max_appl; i++) {
5683 if(application[i].Id
5684 && (a->CIP_Mask[i]&1 || a->CIP_Mask[i]&cip_mask)
5685 && CPN_filter_ok(parms[0],a,i)
5686 && test_group_ind_mask_bit (plci, i) ) {
5687 dbug(1,dprintf("storedcip_mask[%d]=0x%lx",i,a->CIP_Mask[i] ));
5688 set_c_ind_mask_bit (plci, i);
5689 dump_c_ind_mask (plci);
5690 plci->State = INC_CON_PENDING;
5691 plci->call_dir = (plci->call_dir & ~(CALL_DIR_OUT | CALL_DIR_ORIGINATE)) |
5692 CALL_DIR_IN | CALL_DIR_ANSWER;
5693 if(esc_chi[0]) {
5694 plci->b_channel = esc_chi[esc_chi[0]]&0x1f;
5695 mixer_set_bchannel_id_esc (plci, plci->b_channel);
5696 }
5697 /* if a listen on the ext controller is done, check if hook states */
5698 /* are supported or if just a on board codec must be activated */
5699 if(a->codec_listen[i] && !a->AdvSignalPLCI) {
5700 if(a->profile.Global_Options & HANDSET)
5701 plci->tel = ADV_VOICE;
5702 else if(a->profile.Global_Options & ON_BOARD_CODEC)
5703 plci->tel = CODEC;
5704 if(plci->tel) Id|=EXT_CONTROLLER;
5705 a->codec_listen[i] = plci;
5706 }
5707
5708 sendf(&application[i],_CONNECT_I,Id,0,
5709 "wSSSSSSSbSSSSS", cip, /* CIP */
5710 parms[0], /* CalledPartyNumber */
5711 multi_CiPN_parms[0], /* CallingPartyNumber */
5712 parms[2], /* CalledPartySubad */
5713 parms[3], /* CallingPartySubad */
5714 parms[4], /* BearerCapability */
5715 parms[5], /* LowLC */
5716 parms[6], /* HighLC */
5717 ai_len, /* nested struct add_i */
5718 add_i[0], /* B channel info */
5719 add_i[1], /* keypad facility */
5720 add_i[2], /* user user data */
5721 add_i[3], /* nested facility */
5722 multi_CiPN_parms[1] /* second CiPN(SCR) */
5723 );
5724 SendSSExtInd(&application[i],
5725 plci,
5726 Id,
5727 multi_ssext_parms);
5728 SendSetupInfo(&application[i],
5729 plci,
5730 Id,
5731 parms,
5732 SendMultiIE(plci,Id,multi_pi_parms, PI, 0x210, true));
5733 }
5734 }
5735 clear_c_ind_mask_bit (plci, MAX_APPL);
5736 dump_c_ind_mask (plci);
5737 }
5738 if(c_ind_mask_empty (plci)) {
5739 sig_req(plci,HANGUP,0);
5740 send_req(plci);
5741 plci->State = IDLE;
5742 }
5743 plci->notifiedcall = 0;
5744 a->listen_active--;
5745 listen_check(a);
5746 break;
5747
5748 case CALL_PEND_NOTIFY:
5749 plci->notifiedcall = 1;
5750 listen_check(a);
5751 break;
5752
5753 case CALL_IND:
5754 case CALL_CON:
5755 if(plci->State==ADVANCED_VOICE_SIG || plci->State==ADVANCED_VOICE_NOSIG)
5756 {
5757 if(plci->internal_command==PERM_COD_CONN_PEND)
5758 {
5759 if(plci->State==ADVANCED_VOICE_NOSIG)
5760 {
5761 dbug(1,dprintf("***Codec OK"));
5762 if(a->AdvSignalPLCI)
5763 {
5764 tplci = a->AdvSignalPLCI;
5765 if(tplci->spoofed_msg)
5766 {
5767 dbug(1,dprintf("***Spoofed Msg(0x%x)",tplci->spoofed_msg));
5768 tplci->command = 0;
5769 tplci->internal_command = 0;
5770 x_Id = ((word)tplci->Id<<8)|tplci->adapter->Id | 0x80;
5771 switch (tplci->spoofed_msg)
5772 {
5773 case CALL_RES:
5774 tplci->command = _CONNECT_I|RESPONSE;
5775 api_load_msg (&tplci->saved_msg, saved_parms);
5776 add_b1(tplci,&saved_parms[1],0,tplci->B1_facilities);
5777 if (tplci->adapter->Info_Mask[tplci->appl->Id-1] & 0x200)
5778 {
5779 /* early B3 connect (CIP mask bit 9) no release after a disc */
5780 add_p(tplci,LLI,"\x01\x01");
5781 }
5782 add_s(tplci, CONN_NR, &saved_parms[2]);
5783 add_s(tplci, LLC, &saved_parms[4]);
5784 add_ai(tplci, &saved_parms[5]);
5785 tplci->State = INC_CON_ACCEPT;
5786 sig_req(tplci, CALL_RES,0);
5787 send_req(tplci);
5788 break;
5789
5790 case AWAITING_SELECT_B:
5791 dbug(1,dprintf("Select_B continue"));
5792 start_internal_command (x_Id, tplci, select_b_command);
5793 break;
5794
5795 case AWAITING_MANUF_CON: /* Get_Plci per Manufacturer_Req to ext controller */
5796 if(!tplci->Sig.Id)
5797 {
5798 dbug(1,dprintf("No SigID!"));
5799 sendf(tplci->appl, _MANUFACTURER_R|CONFIRM,x_Id,tplci->number, "dww",_DI_MANU_ID,_MANUFACTURER_R,_OUT_OF_PLCI);
5800 plci_remove(tplci);
5801 break;
5802 }
5803 tplci->command = _MANUFACTURER_R;
5804 api_load_msg (&tplci->saved_msg, saved_parms);
5805 dir = saved_parms[2].info[0];
5806 if(dir==1) {
5807 sig_req(tplci,CALL_REQ,0);
5808 }
5809 else if(!dir){
5810 sig_req(tplci,LISTEN_REQ,0);
5811 }
5812 send_req(tplci);
5813 sendf(tplci->appl, _MANUFACTURER_R|CONFIRM,x_Id,tplci->number, "dww",_DI_MANU_ID,_MANUFACTURER_R,0);
5814 break;
5815
5816 case (CALL_REQ|AWAITING_MANUF_CON):
5817 sig_req(tplci,CALL_REQ,0);
5818 send_req(tplci);
5819 break;
5820
5821 case CALL_REQ:
5822 if(!tplci->Sig.Id)
5823 {
5824 dbug(1,dprintf("No SigID!"));
5825 sendf(tplci->appl,_CONNECT_R|CONFIRM,tplci->adapter->Id,0,"w",_OUT_OF_PLCI);
5826 plci_remove(tplci);
5827 break;
5828 }
5829 tplci->command = _CONNECT_R;
5830 api_load_msg (&tplci->saved_msg, saved_parms);
5831 add_s(tplci,CPN,&saved_parms[1]);
5832 add_s(tplci,DSA,&saved_parms[3]);
5833 add_ai(tplci,&saved_parms[9]);
5834 sig_req(tplci,CALL_REQ,0);
5835 send_req(tplci);
5836 break;
5837
5838 case CALL_RETRIEVE:
5839 tplci->command = C_RETRIEVE_REQ;
5840 sig_req(tplci,CALL_RETRIEVE,0);
5841 send_req(tplci);
5842 break;
5843 }
5844 tplci->spoofed_msg = 0;
5845 if (tplci->internal_command == 0)
5846 next_internal_command (x_Id, tplci);
5847 }
5848 }
5849 next_internal_command (Id, plci);
5850 break;
5851 }
5852 dbug(1,dprintf("***Codec Hook Init Req"));
5853 plci->internal_command = PERM_COD_HOOK;
5854 add_p(plci,FTY,"\x01\x09"); /* Get Hook State*/
5855 sig_req(plci,TEL_CTRL,0);
5856 send_req(plci);
5857 }
5858 }
5859 else if(plci->command != _MANUFACTURER_R /* old style permanent connect */
5860 && plci->State!=INC_ACT_PENDING)
5861 {
5862 mixer_set_bchannel_id_esc (plci, plci->b_channel);
5863 if(plci->tel == ADV_VOICE && plci->SuppState == IDLE) /* with permanent codec switch on immediately */
5864 {
5865 chi[2] = plci->b_channel;
5866 SetVoiceChannel(a->AdvCodecPLCI, chi, a);
5867 }
5868 sendf(plci->appl,_CONNECT_ACTIVE_I,Id,0,"Sss",parms[21],"","");
5869 plci->State = INC_ACT_PENDING;
5870 }
5871 break;
5872
5873 case TEL_CTRL:
5874 Number = 0;
5875 ie = multi_fac_parms[0]; /* inspect the facility hook indications */
5876 if(plci->State==ADVANCED_VOICE_SIG && ie[0]){
5877 switch (ie[1]&0x91) {
5878 case 0x80: /* hook off */
5879 case 0x81:
5880 if(plci->internal_command==PERM_COD_HOOK)
5881 {
5882 dbug(1,dprintf("init:hook_off"));
5883 plci->hook_state = ie[1];
5884 next_internal_command (Id, plci);
5885 break;
5886 }
5887 else /* ignore doubled hook indications */
5888 {
5889 if( ((plci->hook_state)&0xf0)==0x80)
5890 {
5891 dbug(1,dprintf("ignore hook"));
5892 break;
5893 }
5894 plci->hook_state = ie[1]&0x91;
5895 }
5896 /* check for incoming call pending */
5897 /* and signal '+'.Appl must decide */
5898 /* with connect_res if call must */
5899 /* accepted or not */
5900 for(i=0, tplci=NULL;i<max_appl;i++){
5901 if(a->codec_listen[i]
5902 && (a->codec_listen[i]->State==INC_CON_PENDING
5903 ||a->codec_listen[i]->State==INC_CON_ALERT) ){
5904 tplci = a->codec_listen[i];
5905 tplci->appl = &application[i];
5906 }
5907 }
5908 /* no incoming call, do outgoing call */
5909 /* and signal '+' if outg. setup */
5910 if(!a->AdvSignalPLCI && !tplci){
5911 if((i=get_plci(a))) {
5912 a->AdvSignalPLCI = &a->plci[i-1];
5913 tplci = a->AdvSignalPLCI;
5914 tplci->tel = ADV_VOICE;
5915 PUT_WORD(&voice_cai[5],a->AdvSignalAppl->MaxDataLength);
5916 if (a->Info_Mask[a->AdvSignalAppl->Id-1] & 0x200){
5917 /* early B3 connect (CIP mask bit 9) no release after a disc */
5918 add_p(tplci,LLI,"\x01\x01");
5919 }
5920 add_p(tplci, CAI, voice_cai);
5921 add_p(tplci, OAD, a->TelOAD);
5922 add_p(tplci, OSA, a->TelOSA);
5923 add_p(tplci,SHIFT|6,NULL);
5924 add_p(tplci,SIN,"\x02\x01\x00");
5925 add_p(tplci,UID,"\x06\x43\x61\x70\x69\x32\x30");
5926 sig_req(tplci,ASSIGN,DSIG_ID);
5927 a->AdvSignalPLCI->internal_command = HOOK_OFF_REQ;
5928 a->AdvSignalPLCI->command = 0;
5929 tplci->appl = a->AdvSignalAppl;
5930 tplci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
5931 send_req(tplci);
5932 }
5933
5934 }
5935
5936 if(!tplci) break;
5937 Id = ((word)tplci->Id<<8)|a->Id;
5938 Id|=EXT_CONTROLLER;
5939 sendf(tplci->appl,
5940 _FACILITY_I,
5941 Id,
5942 0,
5943 "ws", (word)0, "\x01+");
5944 break;
5945
5946 case 0x90: /* hook on */
5947 case 0x91:
5948 if(plci->internal_command==PERM_COD_HOOK)
5949 {
5950 dbug(1,dprintf("init:hook_on"));
5951 plci->hook_state = ie[1]&0x91;
5952 next_internal_command (Id, plci);
5953 break;
5954 }
5955 else /* ignore doubled hook indications */
5956 {
5957 if( ((plci->hook_state)&0xf0)==0x90) break;
5958 plci->hook_state = ie[1]&0x91;
5959 }
5960 /* hangup the adv. voice call and signal '-' to the appl */
5961 if(a->AdvSignalPLCI) {
5962 Id = ((word)a->AdvSignalPLCI->Id<<8)|a->Id;
5963 if(plci->tel) Id|=EXT_CONTROLLER;
5964 sendf(a->AdvSignalAppl,
5965 _FACILITY_I,
5966 Id,
5967 0,
5968 "ws", (word)0, "\x01-");
5969 a->AdvSignalPLCI->internal_command = HOOK_ON_REQ;
5970 a->AdvSignalPLCI->command = 0;
5971 sig_req(a->AdvSignalPLCI,HANGUP,0);
5972 send_req(a->AdvSignalPLCI);
5973 }
5974 break;
5975 }
5976 }
5977 break;
5978
5979 case RESUME:
5980 clear_c_ind_mask_bit (plci, (word)(plci->appl->Id-1));
5981 PUT_WORD(&resume_cau[4],GOOD);
5982 sendf(plci->appl,_FACILITY_I,Id,0,"ws", (word)3, resume_cau);
5983 break;
5984
5985 case SUSPEND:
5986 clear_c_ind_mask (plci);
5987
5988 if (plci->NL.Id && !plci->nl_remove_id) {
5989 mixer_remove (plci);
5990 nl_req_ncci(plci,REMOVE,0);
5991 }
5992 if (!plci->sig_remove_id) {
5993 plci->internal_command = 0;
5994 sig_req(plci,REMOVE,0);
5995 }
5996 send_req(plci);
5997 if(!plci->channels) {
5998 sendf(plci->appl,_FACILITY_I,Id,0,"ws", (word)3, "\x05\x04\x00\x02\x00\x00");
5999 sendf(plci->appl, _DISCONNECT_I, Id, 0, "w", 0);
6000 }
6001 break;
6002
6003 case SUSPEND_REJ:
6004 break;
6005
6006 case HANGUP:
6007 plci->hangup_flow_ctrl_timer=0;
6008 if(plci->manufacturer && plci->State==LOCAL_CONNECT) break;
6009 cau = parms[7];
6010 if(cau) {
6011 i = _L3_CAUSE | cau[2];
6012 if(cau[2]==0) i = 0;
6013 else if(cau[2]==8) i = _L1_ERROR;
6014 else if(cau[2]==9 || cau[2]==10) i = _L2_ERROR;
6015 else if(cau[2]==5) i = _CAPI_GUARD_ERROR;
6016 }
6017 else {
6018 i = _L3_ERROR;
6019 }
6020
6021 if(plci->State==INC_CON_PENDING || plci->State==INC_CON_ALERT)
6022 {
6023 for(i=0; i<max_appl; i++)
6024 {
6025 if(test_c_ind_mask_bit (plci, i))
6026 sendf(&application[i], _DISCONNECT_I, Id, 0, "w", 0);
6027 }
6028 }
6029 else
6030 {
6031 clear_c_ind_mask (plci);
6032 }
6033 if(!plci->appl)
6034 {
6035 if (plci->State == LISTENING)
6036 {
6037 plci->notifiedcall=0;
6038 a->listen_active--;
6039 }
6040 plci->State = INC_DIS_PENDING;
6041 if(c_ind_mask_empty (plci))
6042 {
6043 plci->State = IDLE;
6044 if (plci->NL.Id && !plci->nl_remove_id)
6045 {
6046 mixer_remove (plci);
6047 nl_req_ncci(plci,REMOVE,0);
6048 }
6049 if (!plci->sig_remove_id)
6050 {
6051 plci->internal_command = 0;
6052 sig_req(plci,REMOVE,0);
6053 }
6054 send_req(plci);
6055 }
6056 }
6057 else
6058 {
6059 /* collision of DISCONNECT or CONNECT_RES with HANGUP can */
6060 /* result in a second HANGUP! Don't generate another */
6061 /* DISCONNECT */
6062 if(plci->State!=IDLE && plci->State!=INC_DIS_PENDING)
6063 {
6064 if(plci->State==RESUMING)
6065 {
6066 PUT_WORD(&resume_cau[4],i);
6067 sendf(plci->appl,_FACILITY_I,Id,0,"ws", (word)3, resume_cau);
6068 }
6069 plci->State = INC_DIS_PENDING;
6070 sendf(plci->appl,_DISCONNECT_I,Id,0,"w",i);
6071 }
6072 }
6073 break;
6074
6075 case SSEXT_IND:
6076 SendSSExtInd(NULL,plci,Id,multi_ssext_parms);
6077 break;
6078
6079 case VSWITCH_REQ:
6080 VSwitchReqInd(plci,Id,multi_vswitch_parms);
6081 break;
6082 case VSWITCH_IND:
6083 if(plci->relatedPTYPLCI &&
6084 plci->vswitchstate==3 &&
6085 plci->relatedPTYPLCI->vswitchstate==3 &&
6086 parms[MAXPARMSIDS-1][0])
6087 {
6088 add_p(plci->relatedPTYPLCI,SMSG,parms[MAXPARMSIDS-1]);
6089 sig_req(plci->relatedPTYPLCI,VSWITCH_REQ,0);
6090 send_req(plci->relatedPTYPLCI);
6091 }
6092 else VSwitchReqInd(plci,Id,multi_vswitch_parms);
6093 break;
6094
6095 }
6096 }
6097
6098
6099 static void SendSetupInfo(APPL * appl, PLCI * plci, dword Id, byte * * parms, byte Info_Sent_Flag)
6100 {
6101 word i;
6102 byte * ie;
6103 word Info_Number;
6104 byte * Info_Element;
6105 word Info_Mask = 0;
6106
6107 dbug(1,dprintf("SetupInfo"));
6108
6109 for(i=0; i<MAXPARMSIDS; i++) {
6110 ie = parms[i];
6111 Info_Number = 0;
6112 Info_Element = ie;
6113 if(ie[0]) {
6114 switch(i) {
6115 case 0:
6116 dbug(1,dprintf("CPN "));
6117 Info_Number = 0x0070;
6118 Info_Mask = 0x80;
6119 Info_Sent_Flag = true;
6120 break;
6121 case 8: /* display */
6122 dbug(1,dprintf("display(%d)",i));
6123 Info_Number = 0x0028;
6124 Info_Mask = 0x04;
6125 Info_Sent_Flag = true;
6126 break;
6127 case 16: /* Channel Id */
6128 dbug(1,dprintf("CHI"));
6129 Info_Number = 0x0018;
6130 Info_Mask = 0x100;
6131 Info_Sent_Flag = true;
6132 mixer_set_bchannel_id (plci, Info_Element);
6133 break;
6134 case 19: /* Redirected Number */
6135 dbug(1,dprintf("RDN"));
6136 Info_Number = 0x0074;
6137 Info_Mask = 0x400;
6138 Info_Sent_Flag = true;
6139 break;
6140 case 20: /* Redirected Number extended */
6141 dbug(1,dprintf("RDX"));
6142 Info_Number = 0x0073;
6143 Info_Mask = 0x400;
6144 Info_Sent_Flag = true;
6145 break;
6146 case 22: /* Redirecing Number */
6147 dbug(1,dprintf("RIN"));
6148 Info_Number = 0x0076;
6149 Info_Mask = 0x400;
6150 Info_Sent_Flag = true;
6151 break;
6152 default:
6153 Info_Number = 0;
6154 break;
6155 }
6156 }
6157
6158 if(i==MAXPARMSIDS-2){ /* to indicate the message type "Setup" */
6159 Info_Number = 0x8000 |5;
6160 Info_Mask = 0x10;
6161 Info_Element = "";
6162 }
6163
6164 if(Info_Sent_Flag && Info_Number){
6165 if(plci->adapter->Info_Mask[appl->Id-1] & Info_Mask) {
6166 sendf(appl,_INFO_I,Id,0,"wS",Info_Number,Info_Element);
6167 }
6168 }
6169 }
6170 }
6171
6172
6173 void SendInfo(PLCI * plci, dword Id, byte * * parms, byte iesent)
6174 {
6175 word i;
6176 word j;
6177 word k;
6178 byte * ie;
6179 word Info_Number;
6180 byte * Info_Element;
6181 word Info_Mask = 0;
6182 static byte charges[5] = {4,0,0,0,0};
6183 static byte cause[] = {0x02,0x80,0x00};
6184 APPL *appl;
6185
6186 dbug(1,dprintf("InfoParse "));
6187
6188 if(
6189 !plci->appl
6190 && !plci->State
6191 && plci->Sig.Ind!=NCR_FACILITY
6192 )
6193 {
6194 dbug(1,dprintf("NoParse "));
6195 return;
6196 }
6197 cause[2] = 0;
6198 for(i=0; i<MAXPARMSIDS; i++) {
6199 ie = parms[i];
6200 Info_Number = 0;
6201 Info_Element = ie;
6202 if(ie[0]) {
6203 switch(i) {
6204 case 0:
6205 dbug(1,dprintf("CPN "));
6206 Info_Number = 0x0070;
6207 Info_Mask = 0x80;
6208 break;
6209 case 7: /* ESC_CAU */
6210 dbug(1,dprintf("cau(0x%x)",ie[2]));
6211 Info_Number = 0x0008;
6212 Info_Mask = 0x00;
6213 cause[2] = ie[2];
6214 Info_Element = NULL;
6215 break;
6216 case 8: /* display */
6217 dbug(1,dprintf("display(%d)",i));
6218 Info_Number = 0x0028;
6219 Info_Mask = 0x04;
6220 break;
6221 case 9: /* Date display */
6222 dbug(1,dprintf("date(%d)",i));
6223 Info_Number = 0x0029;
6224 Info_Mask = 0x02;
6225 break;
6226 case 10: /* charges */
6227 for(j=0;j<4;j++) charges[1+j] = 0;
6228 for(j=0; j<ie[0] && !(ie[1+j]&0x80); j++);
6229 for(k=1,j++; j<ie[0] && k<=4; j++,k++) charges[k] = ie[1+j];
6230 Info_Number = 0x4000;
6231 Info_Mask = 0x40;
6232 Info_Element = charges;
6233 break;
6234 case 11: /* user user info */
6235 dbug(1,dprintf("uui"));
6236 Info_Number = 0x007E;
6237 Info_Mask = 0x08;
6238 break;
6239 case 12: /* congestion receiver ready */
6240 dbug(1,dprintf("clRDY"));
6241 Info_Number = 0x00B0;
6242 Info_Mask = 0x08;
6243 Info_Element = "";
6244 break;
6245 case 13: /* congestion receiver not ready */
6246 dbug(1,dprintf("clNRDY"));
6247 Info_Number = 0x00BF;
6248 Info_Mask = 0x08;
6249 Info_Element = "";
6250 break;
6251 case 15: /* Keypad Facility */
6252 dbug(1,dprintf("KEY"));
6253 Info_Number = 0x002C;
6254 Info_Mask = 0x20;
6255 break;
6256 case 16: /* Channel Id */
6257 dbug(1,dprintf("CHI"));
6258 Info_Number = 0x0018;
6259 Info_Mask = 0x100;
6260 mixer_set_bchannel_id (plci, Info_Element);
6261 break;
6262 case 17: /* if no 1tr6 cause, send full cause, else esc_cause */
6263 dbug(1,dprintf("q9cau(0x%x)",ie[2]));
6264 if(!cause[2] || cause[2]<0x80) break; /* eg. layer 1 error */
6265 Info_Number = 0x0008;
6266 Info_Mask = 0x01;
6267 if(cause[2] != ie[2]) Info_Element = cause;
6268 break;
6269 case 19: /* Redirected Number */
6270 dbug(1,dprintf("RDN"));
6271 Info_Number = 0x0074;
6272 Info_Mask = 0x400;
6273 break;
6274 case 22: /* Redirecing Number */
6275 dbug(1,dprintf("RIN"));
6276 Info_Number = 0x0076;
6277 Info_Mask = 0x400;
6278 break;
6279 case 23: /* Notification Indicator */
6280 dbug(1,dprintf("NI"));
6281 Info_Number = (word)NI;
6282 Info_Mask = 0x210;
6283 break;
6284 case 26: /* Call State */
6285 dbug(1,dprintf("CST"));
6286 Info_Number = (word)CST;
6287 Info_Mask = 0x01; /* do with cause i.e. for now */
6288 break;
6289 case MAXPARMSIDS-2: /* Escape Message Type, must be the last indication */
6290 dbug(1,dprintf("ESC/MT[0x%x]",ie[3]));
6291 Info_Number = 0x8000 |ie[3];
6292 if(iesent) Info_Mask = 0xffff;
6293 else Info_Mask = 0x10;
6294 Info_Element = "";
6295 break;
6296 default:
6297 Info_Number = 0;
6298 Info_Mask = 0;
6299 Info_Element = "";
6300 break;
6301 }
6302 }
6303
6304 if(plci->Sig.Ind==NCR_FACILITY) /* check controller broadcast */
6305 {
6306 for(j=0; j<max_appl; j++)
6307 {
6308 appl = &application[j];
6309 if(Info_Number
6310 && appl->Id
6311 && plci->adapter->Info_Mask[appl->Id-1] &Info_Mask)
6312 {
6313 dbug(1,dprintf("NCR_Ind"));
6314 iesent=true;
6315 sendf(&application[j],_INFO_I,Id&0x0f,0,"wS",Info_Number,Info_Element);
6316 }
6317 }
6318 }
6319 else if(!plci->appl)
6320 { /* overlap receiving broadcast */
6321 if(Info_Number==CPN
6322 || Info_Number==KEY
6323 || Info_Number==NI
6324 || Info_Number==DSP
6325 || Info_Number==UUI )
6326 {
6327 for(j=0; j<max_appl; j++)
6328 {
6329 if(test_c_ind_mask_bit (plci, j))
6330 {
6331 dbug(1,dprintf("Ovl_Ind"));
6332 iesent=true;
6333 sendf(&application[j],_INFO_I,Id,0,"wS",Info_Number,Info_Element);
6334 }
6335 }
6336 }
6337 } /* all other signalling states */
6338 else if(Info_Number
6339 && plci->adapter->Info_Mask[plci->appl->Id-1] &Info_Mask)
6340 {
6341 dbug(1,dprintf("Std_Ind"));
6342 iesent=true;
6343 sendf(plci->appl,_INFO_I,Id,0,"wS",Info_Number,Info_Element);
6344 }
6345 }
6346 }
6347
6348
6349 byte SendMultiIE(PLCI * plci, dword Id, byte * * parms, byte ie_type, dword info_mask, byte setupParse)
6350 {
6351 word i;
6352 word j;
6353 byte * ie;
6354 word Info_Number;
6355 byte * Info_Element;
6356 APPL *appl;
6357 word Info_Mask = 0;
6358 byte iesent=0;
6359
6360 if(
6361 !plci->appl
6362 && !plci->State
6363 && plci->Sig.Ind!=NCR_FACILITY
6364 && !setupParse
6365 )
6366 {
6367 dbug(1,dprintf("NoM-IEParse "));
6368 return 0;
6369 }
6370 dbug(1,dprintf("M-IEParse "));
6371
6372 for(i=0; i<MAX_MULTI_IE; i++)
6373 {
6374 ie = parms[i];
6375 Info_Number = 0;
6376 Info_Element = ie;
6377 if(ie[0])
6378 {
6379 dbug(1,dprintf("[Ind0x%x]:IE=0x%x",plci->Sig.Ind,ie_type));
6380 Info_Number = (word)ie_type;
6381 Info_Mask = (word)info_mask;
6382 }
6383
6384 if(plci->Sig.Ind==NCR_FACILITY) /* check controller broadcast */
6385 {
6386 for(j=0; j<max_appl; j++)
6387 {
6388 appl = &application[j];
6389 if(Info_Number
6390 && appl->Id
6391 && plci->adapter->Info_Mask[appl->Id-1] &Info_Mask)
6392 {
6393 iesent = true;
6394 dbug(1,dprintf("Mlt_NCR_Ind"));
6395 sendf(&application[j],_INFO_I,Id&0x0f,0,"wS",Info_Number,Info_Element);
6396 }
6397 }
6398 }
6399 else if(!plci->appl && Info_Number)
6400 { /* overlap receiving broadcast */
6401 for(j=0; j<max_appl; j++)
6402 {
6403 if(test_c_ind_mask_bit (plci, j))
6404 {
6405 iesent = true;
6406 dbug(1,dprintf("Mlt_Ovl_Ind"));
6407 sendf(&application[j],_INFO_I,Id,0,"wS",Info_Number,Info_Element);
6408 }
6409 }
6410 } /* all other signalling states */
6411 else if(Info_Number
6412 && plci->adapter->Info_Mask[plci->appl->Id-1] &Info_Mask)
6413 {
6414 iesent = true;
6415 dbug(1,dprintf("Mlt_Std_Ind"));
6416 sendf(plci->appl,_INFO_I,Id,0,"wS",Info_Number,Info_Element);
6417 }
6418 }
6419 return iesent;
6420 }
6421
6422 static void SendSSExtInd(APPL * appl, PLCI * plci, dword Id, byte * * parms)
6423 {
6424 word i;
6425 /* Format of multi_ssext_parms[i][]:
6426 0 byte length
6427 1 byte SSEXTIE
6428 2 byte SSEXT_REQ/SSEXT_IND
6429 3 byte length
6430 4 word SSExtCommand
6431 6... Params
6432 */
6433 if(
6434 plci
6435 && plci->State
6436 && plci->Sig.Ind!=NCR_FACILITY
6437 )
6438 for(i=0;i<MAX_MULTI_IE;i++)
6439 {
6440 if(parms[i][0]<6) continue;
6441 if(parms[i][2]==SSEXT_REQ) continue;
6442
6443 if(appl)
6444 {
6445 parms[i][0]=0; /* kill it */
6446 sendf(appl,_MANUFACTURER_I,
6447 Id,
6448 0,
6449 "dwS",
6450 _DI_MANU_ID,
6451 _DI_SSEXT_CTRL,
6452 &parms[i][3]);
6453 }
6454 else if(plci->appl)
6455 {
6456 parms[i][0]=0; /* kill it */
6457 sendf(plci->appl,_MANUFACTURER_I,
6458 Id,
6459 0,
6460 "dwS",
6461 _DI_MANU_ID,
6462 _DI_SSEXT_CTRL,
6463 &parms[i][3]);
6464 }
6465 }
6466 };
6467
6468 void nl_ind(PLCI * plci)
6469 {
6470 byte ch;
6471 word ncci;
6472 dword Id;
6473 DIVA_CAPI_ADAPTER * a;
6474 word NCCIcode;
6475 APPL * APPLptr;
6476 word count;
6477 word Num;
6478 word i, ncpi_state;
6479 byte len, ncci_state;
6480 word msg;
6481 word info = 0;
6482 word fax_feature_bits;
6483 byte fax_send_edata_ack;
6484 static byte v120_header_buffer[2 + 3];
6485 static word fax_info[] = {
6486 0, /* T30_SUCCESS */
6487 _FAX_NO_CONNECTION, /* T30_ERR_NO_DIS_RECEIVED */
6488 _FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_NO_RESPONSE */
6489 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_RESPONSE */
6490 _FAX_PROTOCOL_ERROR, /* T30_ERR_TOO_MANY_REPEATS */
6491 _FAX_PROTOCOL_ERROR, /* T30_ERR_UNEXPECTED_MESSAGE */
6492 _FAX_REMOTE_ABORT, /* T30_ERR_UNEXPECTED_DCN */
6493 _FAX_LOCAL_ABORT, /* T30_ERR_DTC_UNSUPPORTED */
6494 _FAX_TRAINING_ERROR, /* T30_ERR_ALL_RATES_FAILED */
6495 _FAX_TRAINING_ERROR, /* T30_ERR_TOO_MANY_TRAINS */
6496 _FAX_PARAMETER_ERROR, /* T30_ERR_RECEIVE_CORRUPTED */
6497 _FAX_REMOTE_ABORT, /* T30_ERR_UNEXPECTED_DISC */
6498 _FAX_LOCAL_ABORT, /* T30_ERR_APPLICATION_DISC */
6499 _FAX_REMOTE_REJECT, /* T30_ERR_INCOMPATIBLE_DIS */
6500 _FAX_LOCAL_ABORT, /* T30_ERR_INCOMPATIBLE_DCS */
6501 _FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_NO_COMMAND */
6502 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_COMMAND */
6503 _FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_COMMAND_TOO_LONG */
6504 _FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_RESPONSE_TOO_LONG */
6505 _FAX_NO_CONNECTION, /* T30_ERR_NOT_IDENTIFIED */
6506 _FAX_PROTOCOL_ERROR, /* T30_ERR_SUPERVISORY_TIMEOUT */
6507 _FAX_PARAMETER_ERROR, /* T30_ERR_TOO_LONG_SCAN_LINE */
6508 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_PAGE_AFTER_MPS */
6509 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_PAGE_AFTER_CFR */
6510 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCS_AFTER_FTT */
6511 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCS_AFTER_EOM */
6512 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCS_AFTER_MPS */
6513 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCN_AFTER_MCF */
6514 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCN_AFTER_RTN */
6515 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_CFR */
6516 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_MCF_AFTER_EOP */
6517 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_MCF_AFTER_EOM */
6518 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_MCF_AFTER_MPS */
6519 0x331d, /* T30_ERR_SUB_SEP_UNSUPPORTED */
6520 0x331e, /* T30_ERR_PWD_UNSUPPORTED */
6521 0x331f, /* T30_ERR_SUB_SEP_PWD_UNSUPPORTED */
6522 _FAX_PROTOCOL_ERROR, /* T30_ERR_INVALID_COMMAND_FRAME */
6523 _FAX_PARAMETER_ERROR, /* T30_ERR_UNSUPPORTED_PAGE_CODING */
6524 _FAX_PARAMETER_ERROR, /* T30_ERR_INVALID_PAGE_CODING */
6525 _FAX_REMOTE_REJECT, /* T30_ERR_INCOMPATIBLE_PAGE_CONFIG */
6526 _FAX_LOCAL_ABORT, /* T30_ERR_TIMEOUT_FROM_APPLICATION */
6527 _FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_NO_REACTION_ON_MARK */
6528 _FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_TRAINING_TIMEOUT */
6529 _FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_UNEXPECTED_V21 */
6530 _FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_PRIMARY_CTS_ON */
6531 _FAX_LOCAL_ABORT, /* T30_ERR_V34FAX_TURNAROUND_POLLING */
6532 _FAX_LOCAL_ABORT /* T30_ERR_V34FAX_V8_INCOMPATIBILITY */
6533 };
6534
6535 byte dtmf_code_buffer[CAPIDTMF_RECV_DIGIT_BUFFER_SIZE + 1];
6536
6537
6538 static word rtp_info[] = {
6539 GOOD, /* RTP_SUCCESS */
6540 0x3600 /* RTP_ERR_SSRC_OR_PAYLOAD_CHANGE */
6541 };
6542
6543 static dword udata_forwarding_table[0x100 / sizeof(dword)] =
6544 {
6545 0x0020301e, 0x00000000, 0x00000000, 0x00000000,
6546 0x00000000, 0x00000000, 0x00000000, 0x00000000
6547 };
6548
6549 ch = plci->NL.IndCh;
6550 a = plci->adapter;
6551 ncci = a->ch_ncci[ch];
6552 Id = (((dword)(ncci ? ncci : ch)) << 16) | (((word) plci->Id) << 8) | a->Id;
6553 if(plci->tel) Id|=EXT_CONTROLLER;
6554 APPLptr = plci->appl;
6555 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",
6556 plci->NL.Id,Id,plci->Id,plci->tel,plci->State,ch,plci->channels,plci->NL.Ind &0x0f));
6557
6558 /* in the case if no connect_active_Ind was sent to the appl we wait for */
6559
6560 if (plci->nl_remove_id)
6561 {
6562 plci->NL.RNR = 2; /* discard */
6563 dbug(1,dprintf("NL discard while remove pending"));
6564 return;
6565 }
6566 if((plci->NL.Ind &0x0f)==N_CONNECT)
6567 {
6568 if(plci->State==INC_DIS_PENDING
6569 || plci->State==OUTG_DIS_PENDING
6570 || plci->State==IDLE)
6571 {
6572 plci->NL.RNR = 2; /* discard */
6573 dbug(1,dprintf("discard n_connect"));
6574 return;
6575 }
6576 if(plci->State < INC_ACT_PENDING)
6577 {
6578 plci->NL.RNR = 1; /* flow control */
6579 channel_x_off (plci, ch, N_XON_CONNECT_IND);
6580 return;
6581 }
6582 }
6583
6584 if(!APPLptr) /* no application or invalid data */
6585 { /* while reloading the DSP */
6586 dbug(1,dprintf("discard1"));
6587 plci->NL.RNR = 2;
6588 return;
6589 }
6590
6591 if (((plci->NL.Ind &0x0f) == N_UDATA)
6592 && (((plci->B2_prot != B2_SDLC) && ((plci->B1_resource == 17) || (plci->B1_resource == 18)))
6593 || (plci->B2_prot == 7)
6594 || (plci->B3_prot == 7)) )
6595 {
6596 plci->ncpi_buffer[0] = 0;
6597
6598 ncpi_state = plci->ncpi_state;
6599 if (plci->NL.complete == 1)
6600 {
6601 byte * data = &plci->NL.RBuffer->P[0];
6602
6603 if ((plci->NL.RBuffer->length >= 12)
6604 &&( (*data == DSP_UDATA_INDICATION_DCD_ON)
6605 ||(*data == DSP_UDATA_INDICATION_CTS_ON)) )
6606 {
6607 word conn_opt, ncpi_opt = 0x00;
6608 /* HexDump ("MDM N_UDATA:", plci->NL.RBuffer->length, data); */
6609
6610 if (*data == DSP_UDATA_INDICATION_DCD_ON)
6611 plci->ncpi_state |= NCPI_MDM_DCD_ON_RECEIVED;
6612 if (*data == DSP_UDATA_INDICATION_CTS_ON)
6613 plci->ncpi_state |= NCPI_MDM_CTS_ON_RECEIVED;
6614
6615 data++; /* indication code */
6616 data += 2; /* timestamp */
6617 if ((*data == DSP_CONNECTED_NORM_V18) || (*data == DSP_CONNECTED_NORM_VOWN))
6618 ncpi_state &= ~(NCPI_MDM_DCD_ON_RECEIVED | NCPI_MDM_CTS_ON_RECEIVED);
6619 data++; /* connected norm */
6620 conn_opt = GET_WORD(data);
6621 data += 2; /* connected options */
6622
6623 PUT_WORD (&(plci->ncpi_buffer[1]), (word)(GET_DWORD(data) & 0x0000FFFF));
6624
6625 if (conn_opt & DSP_CONNECTED_OPTION_MASK_V42)
6626 {
6627 ncpi_opt |= MDM_NCPI_ECM_V42;
6628 }
6629 else if (conn_opt & DSP_CONNECTED_OPTION_MASK_MNP)
6630 {
6631 ncpi_opt |= MDM_NCPI_ECM_MNP;
6632 }
6633 else
6634 {
6635 ncpi_opt |= MDM_NCPI_TRANSPARENT;
6636 }
6637 if (conn_opt & DSP_CONNECTED_OPTION_MASK_COMPRESSION)
6638 {
6639 ncpi_opt |= MDM_NCPI_COMPRESSED;
6640 }
6641 PUT_WORD (&(plci->ncpi_buffer[3]), ncpi_opt);
6642 plci->ncpi_buffer[0] = 4;
6643
6644 plci->ncpi_state |= NCPI_VALID_CONNECT_B3_IND | NCPI_VALID_CONNECT_B3_ACT | NCPI_VALID_DISC_B3_IND;
6645 }
6646 }
6647 if (plci->B3_prot == 7)
6648 {
6649 if (((a->ncci_state[ncci] == INC_ACT_PENDING) || (a->ncci_state[ncci] == OUTG_CON_PENDING))
6650 && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6651 && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6652 {
6653 a->ncci_state[ncci] = INC_ACT_PENDING;
6654 sendf(plci->appl,_CONNECT_B3_ACTIVE_I,Id,0,"S",plci->ncpi_buffer);
6655 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6656 }
6657 }
6658
6659 if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id-1])
6660 & ((1L << PRIVATE_V18) | (1L << PRIVATE_VOWN)))
6661 || !(ncpi_state & NCPI_MDM_DCD_ON_RECEIVED)
6662 || !(ncpi_state & NCPI_MDM_CTS_ON_RECEIVED))
6663
6664 {
6665 plci->NL.RNR = 2;
6666 return;
6667 }
6668 }
6669
6670 if(plci->NL.complete == 2)
6671 {
6672 if (((plci->NL.Ind &0x0f) == N_UDATA)
6673 && !(udata_forwarding_table[plci->RData[0].P[0] >> 5] & (1L << (plci->RData[0].P[0] & 0x1f))))
6674 {
6675 switch(plci->RData[0].P[0])
6676 {
6677
6678 case DTMF_UDATA_INDICATION_FAX_CALLING_TONE:
6679 if (plci->dtmf_rec_active & DTMF_LISTEN_ACTIVE_FLAG)
6680 sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0,"ws", SELECTOR_DTMF, "\x01X");
6681 break;
6682 case DTMF_UDATA_INDICATION_ANSWER_TONE:
6683 if (plci->dtmf_rec_active & DTMF_LISTEN_ACTIVE_FLAG)
6684 sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0,"ws", SELECTOR_DTMF, "\x01Y");
6685 break;
6686 case DTMF_UDATA_INDICATION_DIGITS_RECEIVED:
6687 dtmf_indication (Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6688 break;
6689 case DTMF_UDATA_INDICATION_DIGITS_SENT:
6690 dtmf_confirmation (Id, plci);
6691 break;
6692
6693
6694 case UDATA_INDICATION_MIXER_TAP_DATA:
6695 capidtmf_recv_process_block (&(plci->capidtmf_state), plci->RData[0].P + 1, (word)(plci->RData[0].PLength - 1));
6696 i = capidtmf_indication (&(plci->capidtmf_state), dtmf_code_buffer + 1);
6697 if (i != 0)
6698 {
6699 dtmf_code_buffer[0] = DTMF_UDATA_INDICATION_DIGITS_RECEIVED;
6700 dtmf_indication (Id, plci, dtmf_code_buffer, (word)(i + 1));
6701 }
6702 break;
6703
6704
6705 case UDATA_INDICATION_MIXER_COEFS_SET:
6706 mixer_indication_coefs_set (Id, plci);
6707 break;
6708 case UDATA_INDICATION_XCONNECT_FROM:
6709 mixer_indication_xconnect_from (Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6710 break;
6711 case UDATA_INDICATION_XCONNECT_TO:
6712 mixer_indication_xconnect_to (Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6713 break;
6714
6715
6716 case LEC_UDATA_INDICATION_DISABLE_DETECT:
6717 ec_indication (Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6718 break;
6719
6720
6721
6722 default:
6723 break;
6724 }
6725 }
6726 else
6727 {
6728 if ((plci->RData[0].PLength != 0)
6729 && ((plci->B2_prot == B2_V120_ASYNC)
6730 || (plci->B2_prot == B2_V120_ASYNC_V42BIS)
6731 || (plci->B2_prot == B2_V120_BIT_TRANSPARENT)))
6732 {
6733
6734 sendf(plci->appl,_DATA_B3_I,Id,0,
6735 "dwww",
6736 plci->RData[1].P,
6737 (plci->NL.RNum < 2) ? 0 : plci->RData[1].PLength,
6738 plci->RNum,
6739 plci->RFlags);
6740
6741 }
6742 else
6743 {
6744
6745 sendf(plci->appl,_DATA_B3_I,Id,0,
6746 "dwww",
6747 plci->RData[0].P,
6748 plci->RData[0].PLength,
6749 plci->RNum,
6750 plci->RFlags);
6751
6752 }
6753 }
6754 return;
6755 }
6756
6757 fax_feature_bits = 0;
6758 if((plci->NL.Ind &0x0f)==N_CONNECT ||
6759 (plci->NL.Ind &0x0f)==N_CONNECT_ACK ||
6760 (plci->NL.Ind &0x0f)==N_DISC ||
6761 (plci->NL.Ind &0x0f)==N_EDATA ||
6762 (plci->NL.Ind &0x0f)==N_DISC_ACK)
6763 {
6764 info = 0;
6765 plci->ncpi_buffer[0] = 0;
6766 switch (plci->B3_prot) {
6767 case 0: /*XPARENT*/
6768 case 1: /*T.90 NL*/
6769 break; /* no network control protocol info - jfr */
6770 case 2: /*ISO8202*/
6771 case 3: /*X25 DCE*/
6772 for(i=0; i<plci->NL.RLength; i++) plci->ncpi_buffer[4+i] = plci->NL.RBuffer->P[i];
6773 plci->ncpi_buffer[0] = (byte)(i+3);
6774 plci->ncpi_buffer[1] = (byte)(plci->NL.Ind &N_D_BIT? 1:0);
6775 plci->ncpi_buffer[2] = 0;
6776 plci->ncpi_buffer[3] = 0;
6777 break;
6778 case 4: /*T.30 - FAX*/
6779 case 5: /*T.30 - FAX*/
6780 if(plci->NL.RLength>=sizeof(T30_INFO))
6781 {
6782 dbug(1,dprintf("FaxStatus %04x", ((T30_INFO *)plci->NL.RBuffer->P)->code));
6783 len = 9;
6784 PUT_WORD(&(plci->ncpi_buffer[1]),((T30_INFO *)plci->NL.RBuffer->P)->rate_div_2400 * 2400);
6785 fax_feature_bits = GET_WORD(&((T30_INFO *)plci->NL.RBuffer->P)->feature_bits_low);
6786 i = (((T30_INFO *)plci->NL.RBuffer->P)->resolution & T30_RESOLUTION_R8_0770_OR_200) ? 0x0001 : 0x0000;
6787 if (plci->B3_prot == 5)
6788 {
6789 if (!(fax_feature_bits & T30_FEATURE_BIT_ECM))
6790 i |= 0x8000; /* This is not an ECM connection */
6791 if (fax_feature_bits & T30_FEATURE_BIT_T6_CODING)
6792 i |= 0x4000; /* This is a connection with MMR compression */
6793 if (fax_feature_bits & T30_FEATURE_BIT_2D_CODING)
6794 i |= 0x2000; /* This is a connection with MR compression */
6795 if (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS)
6796 i |= 0x0004; /* More documents */
6797 if (fax_feature_bits & T30_FEATURE_BIT_POLLING)
6798 i |= 0x0002; /* Fax-polling indication */
6799 }
6800 dbug(1,dprintf("FAX Options %04x %04x",fax_feature_bits,i));
6801 PUT_WORD(&(plci->ncpi_buffer[3]),i);
6802 PUT_WORD(&(plci->ncpi_buffer[5]),((T30_INFO *)plci->NL.RBuffer->P)->data_format);
6803 plci->ncpi_buffer[7] = ((T30_INFO *)plci->NL.RBuffer->P)->pages_low;
6804 plci->ncpi_buffer[8] = ((T30_INFO *)plci->NL.RBuffer->P)->pages_high;
6805 plci->ncpi_buffer[len] = 0;
6806 if(((T30_INFO *)plci->NL.RBuffer->P)->station_id_len)
6807 {
6808 plci->ncpi_buffer[len] = 20;
6809 for (i = 0; i < 20; i++)
6810 plci->ncpi_buffer[++len] = ((T30_INFO *)plci->NL.RBuffer->P)->station_id[i];
6811 }
6812 if (((plci->NL.Ind & 0x0f) == N_DISC) || ((plci->NL.Ind & 0x0f) == N_DISC_ACK))
6813 {
6814 if (((T30_INFO *)plci->NL.RBuffer->P)->code < ARRAY_SIZE(fax_info))
6815 info = fax_info[((T30_INFO *)plci->NL.RBuffer->P)->code];
6816 else
6817 info = _FAX_PROTOCOL_ERROR;
6818 }
6819
6820 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id-1])
6821 & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
6822 {
6823 i = ((word)(((T30_INFO *) 0)->station_id + 20)) + ((T30_INFO *)plci->NL.RBuffer->P)->head_line_len;
6824 while (i < plci->NL.RBuffer->length)
6825 plci->ncpi_buffer[++len] = plci->NL.RBuffer->P[i++];
6826 }
6827
6828 plci->ncpi_buffer[0] = len;
6829 fax_feature_bits = GET_WORD(&((T30_INFO *)plci->NL.RBuffer->P)->feature_bits_low);
6830 PUT_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->feature_bits_low, fax_feature_bits);
6831
6832 plci->ncpi_state |= NCPI_VALID_CONNECT_B3_IND;
6833 if (((plci->NL.Ind &0x0f) == N_CONNECT_ACK)
6834 || (((plci->NL.Ind &0x0f) == N_CONNECT)
6835 && (fax_feature_bits & T30_FEATURE_BIT_POLLING))
6836 || (((plci->NL.Ind &0x0f) == N_EDATA)
6837 && ((((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_TRAIN_OK)
6838 || (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_DIS)
6839 || (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_DTC))))
6840 {
6841 plci->ncpi_state |= NCPI_VALID_CONNECT_B3_ACT;
6842 }
6843 if (((plci->NL.Ind &0x0f) == N_DISC)
6844 || ((plci->NL.Ind &0x0f) == N_DISC_ACK)
6845 || (((plci->NL.Ind &0x0f) == N_EDATA)
6846 && (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_EOP_CAPI)))
6847 {
6848 plci->ncpi_state |= NCPI_VALID_CONNECT_B3_ACT | NCPI_VALID_DISC_B3_IND;
6849 }
6850 }
6851 break;
6852
6853 case B3_RTP:
6854 if (((plci->NL.Ind & 0x0f) == N_DISC) || ((plci->NL.Ind & 0x0f) == N_DISC_ACK))
6855 {
6856 if (plci->NL.RLength != 0)
6857 {
6858 info = rtp_info[plci->NL.RBuffer->P[0]];
6859 plci->ncpi_buffer[0] = plci->NL.RLength - 1;
6860 for (i = 1; i < plci->NL.RLength; i++)
6861 plci->ncpi_buffer[i] = plci->NL.RBuffer->P[i];
6862 }
6863 }
6864 break;
6865
6866 }
6867 plci->NL.RNR = 2;
6868 }
6869 switch(plci->NL.Ind &0x0f) {
6870 case N_EDATA:
6871 if ((plci->B3_prot == 4) || (plci->B3_prot == 5))
6872 {
6873 dbug(1,dprintf("EDATA ncci=0x%x state=%d code=%02x", ncci, a->ncci_state[ncci],
6874 ((T30_INFO *)plci->NL.RBuffer->P)->code));
6875 fax_send_edata_ack = (((T30_INFO *)(plci->fax_connect_info_buffer))->operating_mode == T30_OPERATING_MODE_CAPI_NEG);
6876
6877 if ((plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF)
6878 && (plci->nsf_control_bits & (T30_NSF_CONTROL_BIT_NEGOTIATE_IND | T30_NSF_CONTROL_BIT_NEGOTIATE_RESP))
6879 && (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_DIS)
6880 && (a->ncci_state[ncci] == OUTG_CON_PENDING)
6881 && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6882 && !(plci->ncpi_state & NCPI_NEGOTIATE_B3_SENT))
6883 {
6884 ((T30_INFO *)(plci->fax_connect_info_buffer))->code = ((T30_INFO *)plci->NL.RBuffer->P)->code;
6885 sendf(plci->appl,_MANUFACTURER_I,Id,0,"dwbS",_DI_MANU_ID,_DI_NEGOTIATE_B3,
6886 (byte)(plci->ncpi_buffer[0] + 1), plci->ncpi_buffer);
6887 plci->ncpi_state |= NCPI_NEGOTIATE_B3_SENT;
6888 if (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP)
6889 fax_send_edata_ack = false;
6890 }
6891
6892 if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
6893 {
6894 switch (((T30_INFO *)plci->NL.RBuffer->P)->code)
6895 {
6896 case EDATA_T30_DIS:
6897 if ((a->ncci_state[ncci] == OUTG_CON_PENDING)
6898 && !(GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low) & T30_CONTROL_BIT_REQUEST_POLLING)
6899 && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6900 && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6901 {
6902 a->ncci_state[ncci] = INC_ACT_PENDING;
6903 if (plci->B3_prot == 4)
6904 sendf(plci->appl,_CONNECT_B3_ACTIVE_I,Id,0,"s","");
6905 else
6906 sendf(plci->appl,_CONNECT_B3_ACTIVE_I,Id,0,"S",plci->ncpi_buffer);
6907 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6908 }
6909 break;
6910
6911 case EDATA_T30_TRAIN_OK:
6912 if ((a->ncci_state[ncci] == INC_ACT_PENDING)
6913 && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6914 && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6915 {
6916 if (plci->B3_prot == 4)
6917 sendf(plci->appl,_CONNECT_B3_ACTIVE_I,Id,0,"s","");
6918 else
6919 sendf(plci->appl,_CONNECT_B3_ACTIVE_I,Id,0,"S",plci->ncpi_buffer);
6920 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6921 }
6922 break;
6923
6924 case EDATA_T30_EOP_CAPI:
6925 if (a->ncci_state[ncci] == CONNECTED)
6926 {
6927 sendf(plci->appl,_DISCONNECT_B3_I,Id,0,"wS",GOOD,plci->ncpi_buffer);
6928 a->ncci_state[ncci] = INC_DIS_PENDING;
6929 plci->ncpi_state = 0;
6930 fax_send_edata_ack = false;
6931 }
6932 break;
6933 }
6934 }
6935 else
6936 {
6937 switch (((T30_INFO *)plci->NL.RBuffer->P)->code)
6938 {
6939 case EDATA_T30_TRAIN_OK:
6940 if ((a->ncci_state[ncci] == INC_ACT_PENDING)
6941 && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6942 && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6943 {
6944 if (plci->B3_prot == 4)
6945 sendf(plci->appl,_CONNECT_B3_ACTIVE_I,Id,0,"s","");
6946 else
6947 sendf(plci->appl,_CONNECT_B3_ACTIVE_I,Id,0,"S",plci->ncpi_buffer);
6948 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6949 }
6950 break;
6951 }
6952 }
6953 if (fax_send_edata_ack)
6954 {
6955 ((T30_INFO *)(plci->fax_connect_info_buffer))->code = ((T30_INFO *)plci->NL.RBuffer->P)->code;
6956 plci->fax_edata_ack_length = 1;
6957 start_internal_command (Id, plci, fax_edata_ack_command);
6958 }
6959 }
6960 else
6961 {
6962 dbug(1,dprintf("EDATA ncci=0x%x state=%d", ncci, a->ncci_state[ncci]));
6963 }
6964 break;
6965 case N_CONNECT:
6966 if (!a->ch_ncci[ch])
6967 {
6968 ncci = get_ncci (plci, ch, 0);
6969 Id = (Id & 0xffff) | (((dword) ncci) << 16);
6970 }
6971 dbug(1,dprintf("N_CONNECT: ch=%d state=%d plci=%lx plci_Id=%lx plci_State=%d",
6972 ch, a->ncci_state[ncci], a->ncci_plci[ncci], plci->Id, plci->State));
6973
6974 msg = _CONNECT_B3_I;
6975 if (a->ncci_state[ncci] == IDLE)
6976 plci->channels++;
6977 else if (plci->B3_prot == 1)
6978 msg = _CONNECT_B3_T90_ACTIVE_I;
6979
6980 a->ncci_state[ncci] = INC_CON_PENDING;
6981 if(plci->B3_prot == 4)
6982 sendf(plci->appl,msg,Id,0,"s","");
6983 else
6984 sendf(plci->appl,msg,Id,0,"S",plci->ncpi_buffer);
6985 break;
6986 case N_CONNECT_ACK:
6987 dbug(1,dprintf("N_connect_Ack"));
6988 if (plci->internal_command_queue[0]
6989 && ((plci->adjust_b_state == ADJUST_B_CONNECT_2)
6990 || (plci->adjust_b_state == ADJUST_B_CONNECT_3)
6991 || (plci->adjust_b_state == ADJUST_B_CONNECT_4)))
6992 {
6993 (*(plci->internal_command_queue[0]))(Id, plci, 0);
6994 if (!plci->internal_command)
6995 next_internal_command (Id, plci);
6996 break;
6997 }
6998 msg = _CONNECT_B3_ACTIVE_I;
6999 if (plci->B3_prot == 1)
7000 {
7001 if (a->ncci_state[ncci] != OUTG_CON_PENDING)
7002 msg = _CONNECT_B3_T90_ACTIVE_I;
7003 a->ncci_state[ncci] = INC_ACT_PENDING;
7004 sendf(plci->appl,msg,Id,0,"S",plci->ncpi_buffer);
7005 }
7006 else if ((plci->B3_prot == 4) || (plci->B3_prot == 5) || (plci->B3_prot == 7))
7007 {
7008 if ((a->ncci_state[ncci] == OUTG_CON_PENDING)
7009 && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
7010 && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
7011 {
7012 a->ncci_state[ncci] = INC_ACT_PENDING;
7013 if (plci->B3_prot == 4)
7014 sendf(plci->appl,msg,Id,0,"s","");
7015 else
7016 sendf(plci->appl,msg,Id,0,"S",plci->ncpi_buffer);
7017 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
7018 }
7019 }
7020 else
7021 {
7022 a->ncci_state[ncci] = INC_ACT_PENDING;
7023 sendf(plci->appl,msg,Id,0,"S",plci->ncpi_buffer);
7024 }
7025 if (plci->adjust_b_restore)
7026 {
7027 plci->adjust_b_restore = false;
7028 start_internal_command (Id, plci, adjust_b_restore);
7029 }
7030 break;
7031 case N_DISC:
7032 case N_DISC_ACK:
7033 if (plci->internal_command_queue[0]
7034 && ((plci->internal_command == FAX_DISCONNECT_COMMAND_1)
7035 || (plci->internal_command == FAX_DISCONNECT_COMMAND_2)
7036 || (plci->internal_command == FAX_DISCONNECT_COMMAND_3)))
7037 {
7038 (*(plci->internal_command_queue[0]))(Id, plci, 0);
7039 if (!plci->internal_command)
7040 next_internal_command (Id, plci);
7041 }
7042 ncci_state = a->ncci_state[ncci];
7043 ncci_remove (plci, ncci, false);
7044
7045 /* with N_DISC or N_DISC_ACK the IDI frees the respective */
7046 /* channel, so we cannot store the state in ncci_state! The */
7047 /* information which channel we received a N_DISC is thus */
7048 /* stored in the inc_dis_ncci_table buffer. */
7049 for(i=0; plci->inc_dis_ncci_table[i]; i++);
7050 plci->inc_dis_ncci_table[i] = (byte) ncci;
7051
7052 /* need a connect_b3_ind before a disconnect_b3_ind with FAX */
7053 if (!plci->channels
7054 && (plci->B1_resource == 16)
7055 && (plci->State <= CONNECTED))
7056 {
7057 len = 9;
7058 i = ((T30_INFO *)plci->fax_connect_info_buffer)->rate_div_2400 * 2400;
7059 PUT_WORD (&plci->ncpi_buffer[1], i);
7060 PUT_WORD (&plci->ncpi_buffer[3], 0);
7061 i = ((T30_INFO *)plci->fax_connect_info_buffer)->data_format;
7062 PUT_WORD (&plci->ncpi_buffer[5], i);
7063 PUT_WORD (&plci->ncpi_buffer[7], 0);
7064 plci->ncpi_buffer[len] = 0;
7065 plci->ncpi_buffer[0] = len;
7066 if(plci->B3_prot == 4)
7067 sendf(plci->appl,_CONNECT_B3_I,Id,0,"s","");
7068 else
7069 {
7070
7071 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id-1])
7072 & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
7073 {
7074 plci->ncpi_buffer[++len] = 0;
7075 plci->ncpi_buffer[++len] = 0;
7076 plci->ncpi_buffer[++len] = 0;
7077 plci->ncpi_buffer[0] = len;
7078 }
7079
7080 sendf(plci->appl,_CONNECT_B3_I,Id,0,"S",plci->ncpi_buffer);
7081 }
7082 sendf(plci->appl,_DISCONNECT_B3_I,Id,0,"wS",info,plci->ncpi_buffer);
7083 plci->ncpi_state = 0;
7084 sig_req(plci,HANGUP,0);
7085 send_req(plci);
7086 plci->State = OUTG_DIS_PENDING;
7087 /* disc here */
7088 }
7089 else if ((a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
7090 && ((plci->B3_prot == 4) || (plci->B3_prot == 5))
7091 && ((ncci_state == INC_DIS_PENDING) || (ncci_state == IDLE)))
7092 {
7093 if (ncci_state == IDLE)
7094 {
7095 if (plci->channels)
7096 plci->channels--;
7097 if((plci->State==IDLE || plci->State==SUSPENDING) && !plci->channels){
7098 if(plci->State == SUSPENDING){
7099 sendf(plci->appl,
7100 _FACILITY_I,
7101 Id & 0xffffL,
7102 0,
7103 "ws", (word)3, "\x03\x04\x00\x00");
7104 sendf(plci->appl, _DISCONNECT_I, Id & 0xffffL, 0, "w", 0);
7105 }
7106 plci_remove(plci);
7107 plci->State=IDLE;
7108 }
7109 }
7110 }
7111 else if (plci->channels)
7112 {
7113 sendf(plci->appl,_DISCONNECT_B3_I,Id,0,"wS",info,plci->ncpi_buffer);
7114 plci->ncpi_state = 0;
7115 if ((ncci_state == OUTG_REJ_PENDING)
7116 && ((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE)))
7117 {
7118 sig_req(plci,HANGUP,0);
7119 send_req(plci);
7120 plci->State = OUTG_DIS_PENDING;
7121 }
7122 }
7123 break;
7124 case N_RESET:
7125 a->ncci_state[ncci] = INC_RES_PENDING;
7126 sendf(plci->appl,_RESET_B3_I,Id,0,"S",plci->ncpi_buffer);
7127 break;
7128 case N_RESET_ACK:
7129 a->ncci_state[ncci] = CONNECTED;
7130 sendf(plci->appl,_RESET_B3_I,Id,0,"S",plci->ncpi_buffer);
7131 break;
7132
7133 case N_UDATA:
7134 if (!(udata_forwarding_table[plci->NL.RBuffer->P[0] >> 5] & (1L << (plci->NL.RBuffer->P[0] & 0x1f))))
7135 {
7136 plci->RData[0].P = plci->internal_ind_buffer + (-((int)(long)(plci->internal_ind_buffer)) & 3);
7137 plci->RData[0].PLength = INTERNAL_IND_BUFFER_SIZE;
7138 plci->NL.R = plci->RData;
7139 plci->NL.RNum = 1;
7140 return;
7141 }
7142 case N_BDATA:
7143 case N_DATA:
7144 if (((a->ncci_state[ncci] != CONNECTED) && (plci->B2_prot == 1)) /* transparent */
7145 || (a->ncci_state[ncci] == IDLE)
7146 || (a->ncci_state[ncci] == INC_DIS_PENDING))
7147 {
7148 plci->NL.RNR = 2;
7149 break;
7150 }
7151 if ((a->ncci_state[ncci] != CONNECTED)
7152 && (a->ncci_state[ncci] != OUTG_DIS_PENDING)
7153 && (a->ncci_state[ncci] != OUTG_REJ_PENDING))
7154 {
7155 dbug(1,dprintf("flow control"));
7156 plci->NL.RNR = 1; /* flow control */
7157 channel_x_off (plci, ch, 0);
7158 break;
7159 }
7160
7161 NCCIcode = ncci | (((word)a->Id) << 8);
7162
7163 /* count all buffers within the Application pool */
7164 /* belonging to the same NCCI. If this is below the */
7165 /* number of buffers available per NCCI we accept */
7166 /* this packet, otherwise we reject it */
7167 count = 0;
7168 Num = 0xffff;
7169 for(i=0; i<APPLptr->MaxBuffer; i++) {
7170 if(NCCIcode==APPLptr->DataNCCI[i]) count++;
7171 if(!APPLptr->DataNCCI[i] && Num==0xffff) Num = i;
7172 }
7173
7174 if(count>=APPLptr->MaxNCCIData || Num==0xffff)
7175 {
7176 dbug(3,dprintf("Flow-Control"));
7177 plci->NL.RNR = 1;
7178 if( ++(APPLptr->NCCIDataFlowCtrlTimer)>=
7179 (word)((a->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL) ? 40 : 2000))
7180 {
7181 plci->NL.RNR = 2;
7182 dbug(3,dprintf("DiscardData"));
7183 } else {
7184 channel_x_off (plci, ch, 0);
7185 }
7186 break;
7187 }
7188 else
7189 {
7190 APPLptr->NCCIDataFlowCtrlTimer = 0;
7191 }
7192
7193 plci->RData[0].P = ReceiveBufferGet(APPLptr,Num);
7194 if(!plci->RData[0].P) {
7195 plci->NL.RNR = 1;
7196 channel_x_off (plci, ch, 0);
7197 break;
7198 }
7199
7200 APPLptr->DataNCCI[Num] = NCCIcode;
7201 APPLptr->DataFlags[Num] = (plci->Id<<8) | (plci->NL.Ind>>4);
7202 dbug(3,dprintf("Buffer(%d), Max = %d",Num,APPLptr->MaxBuffer));
7203
7204 plci->RNum = Num;
7205 plci->RFlags = plci->NL.Ind>>4;
7206 plci->RData[0].PLength = APPLptr->MaxDataLength;
7207 plci->NL.R = plci->RData;
7208 if ((plci->NL.RLength != 0)
7209 && ((plci->B2_prot == B2_V120_ASYNC)
7210 || (plci->B2_prot == B2_V120_ASYNC_V42BIS)
7211 || (plci->B2_prot == B2_V120_BIT_TRANSPARENT)))
7212 {
7213 plci->RData[1].P = plci->RData[0].P;
7214 plci->RData[1].PLength = plci->RData[0].PLength;
7215 plci->RData[0].P = v120_header_buffer + (-((int) v120_header_buffer) & 3);
7216 if ((plci->NL.RBuffer->P[0] & V120_HEADER_EXTEND_BIT) || (plci->NL.RLength == 1))
7217 plci->RData[0].PLength = 1;
7218 else
7219 plci->RData[0].PLength = 2;
7220 if (plci->NL.RBuffer->P[0] & V120_HEADER_BREAK_BIT)
7221 plci->RFlags |= 0x0010;
7222 if (plci->NL.RBuffer->P[0] & (V120_HEADER_C1_BIT | V120_HEADER_C2_BIT))
7223 plci->RFlags |= 0x8000;
7224 plci->NL.RNum = 2;
7225 }
7226 else
7227 {
7228 if((plci->NL.Ind &0x0f)==N_UDATA)
7229 plci->RFlags |= 0x0010;
7230
7231 else if ((plci->B3_prot == B3_RTP) && ((plci->NL.Ind & 0x0f) == N_BDATA))
7232 plci->RFlags |= 0x0001;
7233
7234 plci->NL.RNum = 1;
7235 }
7236 break;
7237 case N_DATA_ACK:
7238 data_ack (plci, ch);
7239 break;
7240 default:
7241 plci->NL.RNR = 2;
7242 break;
7243 }
7244 }
7245
7246 /*------------------------------------------------------------------*/
7247 /* find a free PLCI */
7248 /*------------------------------------------------------------------*/
7249
7250 word get_plci(DIVA_CAPI_ADAPTER * a)
7251 {
7252 word i,j;
7253 PLCI * plci;
7254
7255 dump_plcis (a);
7256 for(i=0;i<a->max_plci && a->plci[i].Id;i++);
7257 if(i==a->max_plci) {
7258 dbug(1,dprintf("get_plci: out of PLCIs"));
7259 return 0;
7260 }
7261 plci = &a->plci[i];
7262 plci->Id = (byte)(i+1);
7263
7264 plci->Sig.Id = 0;
7265 plci->NL.Id = 0;
7266 plci->sig_req = 0;
7267 plci->nl_req = 0;
7268
7269 plci->appl = NULL;
7270 plci->relatedPTYPLCI = NULL;
7271 plci->State = IDLE;
7272 plci->SuppState = IDLE;
7273 plci->channels = 0;
7274 plci->tel = 0;
7275 plci->B1_resource = 0;
7276 plci->B2_prot = 0;
7277 plci->B3_prot = 0;
7278
7279 plci->command = 0;
7280 plci->m_command = 0;
7281 init_internal_command_queue (plci);
7282 plci->number = 0;
7283 plci->req_in_start = 0;
7284 plci->req_in = 0;
7285 plci->req_out = 0;
7286 plci->msg_in_write_pos = MSG_IN_QUEUE_SIZE;
7287 plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
7288 plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
7289
7290 plci->data_sent = false;
7291 plci->send_disc = 0;
7292 plci->sig_global_req = 0;
7293 plci->sig_remove_id = 0;
7294 plci->nl_global_req = 0;
7295 plci->nl_remove_id = 0;
7296 plci->adv_nl = 0;
7297 plci->manufacturer = false;
7298 plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
7299 plci->spoofed_msg = 0;
7300 plci->ptyState = 0;
7301 plci->cr_enquiry = false;
7302 plci->hangup_flow_ctrl_timer = 0;
7303
7304 plci->ncci_ring_list = 0;
7305 for(j=0;j<MAX_CHANNELS_PER_PLCI;j++) plci->inc_dis_ncci_table[j] = 0;
7306 clear_c_ind_mask (plci);
7307 set_group_ind_mask (plci);
7308 plci->fax_connect_info_length = 0;
7309 plci->nsf_control_bits = 0;
7310 plci->ncpi_state = 0x00;
7311 plci->ncpi_buffer[0] = 0;
7312
7313 plci->requested_options_conn = 0;
7314 plci->requested_options = 0;
7315 plci->notifiedcall = 0;
7316 plci->vswitchstate = 0;
7317 plci->vsprot = 0;
7318 plci->vsprotdialect = 0;
7319 init_b1_config (plci);
7320 dbug(1,dprintf("get_plci(%x)",plci->Id));
7321 return i+1;
7322 }
7323
7324 /*------------------------------------------------------------------*/
7325 /* put a parameter in the parameter buffer */
7326 /*------------------------------------------------------------------*/
7327
7328 static void add_p(PLCI * plci, byte code, byte * p)
7329 {
7330 word p_length;
7331
7332 p_length = 0;
7333 if(p) p_length = p[0];
7334 add_ie(plci, code, p, p_length);
7335 }
7336
7337 /*------------------------------------------------------------------*/
7338 /* put a structure in the parameter buffer */
7339 /*------------------------------------------------------------------*/
7340 static void add_s(PLCI * plci, byte code, API_PARSE * p)
7341 {
7342 if(p) add_ie(plci, code, p->info, (word)p->length);
7343 }
7344
7345 /*------------------------------------------------------------------*/
7346 /* put multiple structures in the parameter buffer */
7347 /*------------------------------------------------------------------*/
7348 static void add_ss(PLCI * plci, byte code, API_PARSE * p)
7349 {
7350 byte i;
7351
7352 if(p){
7353 dbug(1,dprintf("add_ss(%x,len=%d)",code,p->length));
7354 for(i=2;i<(byte)p->length;i+=p->info[i]+2){
7355 dbug(1,dprintf("add_ss_ie(%x,len=%d)",p->info[i-1],p->info[i]));
7356 add_ie(plci, p->info[i-1], (byte *)&(p->info[i]), (word)p->info[i]);
7357 }
7358 }
7359 }
7360
7361 /*------------------------------------------------------------------*/
7362 /* return the channel number sent by the application in a esc_chi */
7363 /*------------------------------------------------------------------*/
7364 static byte getChannel(API_PARSE * p)
7365 {
7366 byte i;
7367
7368 if(p){
7369 for(i=2;i<(byte)p->length;i+=p->info[i]+2){
7370 if(p->info[i]==2){
7371 if(p->info[i-1]==ESC && p->info[i+1]==CHI) return (p->info[i+2]);
7372 }
7373 }
7374 }
7375 return 0;
7376 }
7377
7378
7379 /*------------------------------------------------------------------*/
7380 /* put an information element in the parameter buffer */
7381 /*------------------------------------------------------------------*/
7382
7383 static void add_ie(PLCI * plci, byte code, byte * p, word p_length)
7384 {
7385 word i;
7386
7387 if(!(code &0x80) && !p_length) return;
7388
7389 if(plci->req_in==plci->req_in_start) {
7390 plci->req_in +=2;
7391 }
7392 else {
7393 plci->req_in--;
7394 }
7395 plci->RBuffer[plci->req_in++] = code;
7396
7397 if(p) {
7398 plci->RBuffer[plci->req_in++] = (byte)p_length;
7399 for(i=0;i<p_length;i++) plci->RBuffer[plci->req_in++] = p[1+i];
7400 }
7401
7402 plci->RBuffer[plci->req_in++] = 0;
7403 }
7404
7405 /*------------------------------------------------------------------*/
7406 /* put a unstructured data into the buffer */
7407 /*------------------------------------------------------------------*/
7408
7409 void add_d(PLCI * plci, word length, byte * p)
7410 {
7411 word i;
7412
7413 if(plci->req_in==plci->req_in_start) {
7414 plci->req_in +=2;
7415 }
7416 else {
7417 plci->req_in--;
7418 }
7419 for(i=0;i<length;i++) plci->RBuffer[plci->req_in++] = p[i];
7420 }
7421
7422 /*------------------------------------------------------------------*/
7423 /* put parameters from the Additional Info parameter in the */
7424 /* parameter buffer */
7425 /*------------------------------------------------------------------*/
7426
7427 void add_ai(PLCI * plci, API_PARSE * ai)
7428 {
7429 word i;
7430 API_PARSE ai_parms[5];
7431
7432 for(i=0;i<5;i++) ai_parms[i].length = 0;
7433
7434 if(!ai->length)
7435 return;
7436 if(api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms))
7437 return;
7438
7439 add_s (plci,KEY,&ai_parms[1]);
7440 add_s (plci,UUI,&ai_parms[2]);
7441 add_ss(plci,FTY,&ai_parms[3]);
7442 }
7443
7444 /*------------------------------------------------------------------*/
7445 /* put parameter for b1 protocol in the parameter buffer */
7446 /*------------------------------------------------------------------*/
7447
7448 word add_b1(PLCI * plci, API_PARSE * bp, word b_channel_info, word b1_facilities)
7449 {
7450 API_PARSE bp_parms[8];
7451 API_PARSE mdm_cfg[9];
7452 API_PARSE global_config[2];
7453 byte cai[256];
7454 byte resource[] = {5,9,13,12,16,39,9,17,17,18};
7455 byte voice_cai[] = "\x06\x14\x00\x00\x00\x00\x08";
7456 word i;
7457
7458 API_PARSE mdm_cfg_v18[4];
7459 word j, n, w;
7460 dword d;
7461
7462
7463 for(i=0;i<8;i++) bp_parms[i].length = 0;
7464 for(i=0;i<2;i++) global_config[i].length = 0;
7465
7466 dbug(1,dprintf("add_b1"));
7467 api_save_msg(bp, "s", &plci->B_protocol);
7468
7469 if(b_channel_info==2){
7470 plci->B1_resource = 0;
7471 adjust_b1_facilities (plci, plci->B1_resource, b1_facilities);
7472 add_p(plci, CAI, "\x01\x00");
7473 dbug(1,dprintf("Cai=1,0 (no resource)"));
7474 return 0;
7475 }
7476
7477 if(plci->tel == CODEC_PERMANENT) return 0;
7478 else if(plci->tel == CODEC){
7479 plci->B1_resource = 1;
7480 adjust_b1_facilities (plci, plci->B1_resource, b1_facilities);
7481 add_p(plci, CAI, "\x01\x01");
7482 dbug(1,dprintf("Cai=1,1 (Codec)"));
7483 return 0;
7484 }
7485 else if(plci->tel == ADV_VOICE){
7486 plci->B1_resource = add_b1_facilities (plci, 9, (word)(b1_facilities | B1_FACILITY_VOICE));
7487 adjust_b1_facilities (plci, plci->B1_resource, (word)(b1_facilities | B1_FACILITY_VOICE));
7488 voice_cai[1] = plci->B1_resource;
7489 PUT_WORD (&voice_cai[5], plci->appl->MaxDataLength);
7490 add_p(plci, CAI, voice_cai);
7491 dbug(1,dprintf("Cai=1,0x%x (AdvVoice)",voice_cai[1]));
7492 return 0;
7493 }
7494 plci->call_dir &= ~(CALL_DIR_ORIGINATE | CALL_DIR_ANSWER);
7495 if (plci->call_dir & CALL_DIR_OUT)
7496 plci->call_dir |= CALL_DIR_ORIGINATE;
7497 else if (plci->call_dir & CALL_DIR_IN)
7498 plci->call_dir |= CALL_DIR_ANSWER;
7499
7500 if(!bp->length){
7501 plci->B1_resource = 0x5;
7502 adjust_b1_facilities (plci, plci->B1_resource, b1_facilities);
7503 add_p(plci, CAI, "\x01\x05");
7504 return 0;
7505 }
7506
7507 dbug(1,dprintf("b_prot_len=%d",(word)bp->length));
7508 if(bp->length>256) return _WRONG_MESSAGE_FORMAT;
7509 if(api_parse(&bp->info[1], (word)bp->length, "wwwsssb", bp_parms))
7510 {
7511 bp_parms[6].length = 0;
7512 if(api_parse(&bp->info[1], (word)bp->length, "wwwsss", bp_parms))
7513 {
7514 dbug(1,dprintf("b-form.!"));
7515 return _WRONG_MESSAGE_FORMAT;
7516 }
7517 }
7518 else if (api_parse(&bp->info[1], (word)bp->length, "wwwssss", bp_parms))
7519 {
7520 dbug(1,dprintf("b-form.!"));
7521 return _WRONG_MESSAGE_FORMAT;
7522 }
7523
7524 if(bp_parms[6].length)
7525 {
7526 if(api_parse(&bp_parms[6].info[1], (word)bp_parms[6].length, "w", global_config))
7527 {
7528 return _WRONG_MESSAGE_FORMAT;
7529 }
7530 switch(GET_WORD(global_config[0].info))
7531 {
7532 case 1:
7533 plci->call_dir = (plci->call_dir & ~CALL_DIR_ANSWER) | CALL_DIR_ORIGINATE;
7534 break;
7535 case 2:
7536 plci->call_dir = (plci->call_dir & ~CALL_DIR_ORIGINATE) | CALL_DIR_ANSWER;
7537 break;
7538 }
7539 }
7540 dbug(1,dprintf("call_dir=%04x", plci->call_dir));
7541
7542
7543 if ((GET_WORD(bp_parms[0].info) == B1_RTP)
7544 && (plci->adapter->man_profile.private_options & (1L << PRIVATE_RTP)))
7545 {
7546 plci->B1_resource = add_b1_facilities (plci, 31, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7547 adjust_b1_facilities (plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7548 cai[1] = plci->B1_resource;
7549 cai[2] = 0;
7550 cai[3] = 0;
7551 cai[4] = 0;
7552 PUT_WORD(&cai[5],plci->appl->MaxDataLength);
7553 for (i = 0; i < bp_parms[3].length; i++)
7554 cai[7+i] = bp_parms[3].info[1+i];
7555 cai[0] = 6 + bp_parms[3].length;
7556 add_p(plci, CAI, cai);
7557 return 0;
7558 }
7559
7560
7561 if ((GET_WORD(bp_parms[0].info) == B1_PIAFS)
7562 && (plci->adapter->man_profile.private_options & (1L << PRIVATE_PIAFS)))
7563 {
7564 plci->B1_resource = add_b1_facilities (plci, 35/* PIAFS HARDWARE FACILITY */, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7565 adjust_b1_facilities (plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7566 cai[1] = plci->B1_resource;
7567 cai[2] = 0;
7568 cai[3] = 0;
7569 cai[4] = 0;
7570 PUT_WORD(&cai[5],plci->appl->MaxDataLength);
7571 cai[0] = 6;
7572 add_p(plci, CAI, cai);
7573 return 0;
7574 }
7575
7576
7577 if ((GET_WORD(bp_parms[0].info) >= 32)
7578 || (!((1L << GET_WORD(bp_parms[0].info)) & plci->adapter->profile.B1_Protocols)
7579 && ((GET_WORD(bp_parms[0].info) != 3)
7580 || !((1L << B1_HDLC) & plci->adapter->profile.B1_Protocols)
7581 || ((bp_parms[3].length != 0) && (GET_WORD(&bp_parms[3].info[1]) != 0) && (GET_WORD(&bp_parms[3].info[1]) != 56000)))))
7582 {
7583 return _B1_NOT_SUPPORTED;
7584 }
7585 plci->B1_resource = add_b1_facilities (plci, resource[GET_WORD(bp_parms[0].info)],
7586 (word)(b1_facilities & ~B1_FACILITY_VOICE));
7587 adjust_b1_facilities (plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7588 cai[0] = 6;
7589 cai[1] = plci->B1_resource;
7590 for (i=2;i<sizeof(cai);i++) cai[i] = 0;
7591
7592 if ((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE)
7593 || (GET_WORD(bp_parms[0].info) == B1_MODEM_ASYNC)
7594 || (GET_WORD(bp_parms[0].info) == B1_MODEM_SYNC_HDLC))
7595 { /* B1 - modem */
7596 for (i=0;i<7;i++) mdm_cfg[i].length = 0;
7597
7598 if (bp_parms[3].length)
7599 {
7600 if(api_parse(&bp_parms[3].info[1],(word)bp_parms[3].length,"wwwwww", mdm_cfg))
7601 {
7602 return (_WRONG_MESSAGE_FORMAT);
7603 }
7604
7605 cai[2] = 0; /* Bit rate for adaptation */
7606
7607 dbug(1,dprintf("MDM Max Bit Rate:<%d>", GET_WORD(mdm_cfg[0].info)));
7608
7609 PUT_WORD (&cai[13], 0); /* Min Tx speed */
7610 PUT_WORD (&cai[15], GET_WORD(mdm_cfg[0].info)); /* Max Tx speed */
7611 PUT_WORD (&cai[17], 0); /* Min Rx speed */
7612 PUT_WORD (&cai[19], GET_WORD(mdm_cfg[0].info)); /* Max Rx speed */
7613
7614 cai[3] = 0; /* Async framing parameters */
7615 switch (GET_WORD (mdm_cfg[2].info))
7616 { /* Parity */
7617 case 1: /* odd parity */
7618 cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_ODD);
7619 dbug(1,dprintf("MDM: odd parity"));
7620 break;
7621
7622 case 2: /* even parity */
7623 cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_EVEN);
7624 dbug(1,dprintf("MDM: even parity"));
7625 break;
7626
7627 default:
7628 dbug(1,dprintf("MDM: no parity"));
7629 break;
7630 }
7631
7632 switch (GET_WORD (mdm_cfg[3].info))
7633 { /* stop bits */
7634 case 1: /* 2 stop bits */
7635 cai[3] |= DSP_CAI_ASYNC_TWO_STOP_BITS;
7636 dbug(1,dprintf("MDM: 2 stop bits"));
7637 break;
7638
7639 default:
7640 dbug(1,dprintf("MDM: 1 stop bit"));
7641 break;
7642 }
7643
7644 switch (GET_WORD (mdm_cfg[1].info))
7645 { /* char length */
7646 case 5:
7647 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_5;
7648 dbug(1,dprintf("MDM: 5 bits"));
7649 break;
7650
7651 case 6:
7652 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_6;
7653 dbug(1,dprintf("MDM: 6 bits"));
7654 break;
7655
7656 case 7:
7657 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_7;
7658 dbug(1,dprintf("MDM: 7 bits"));
7659 break;
7660
7661 default:
7662 dbug(1,dprintf("MDM: 8 bits"));
7663 break;
7664 }
7665
7666 cai[7] = 0; /* Line taking options */
7667 cai[8] = 0; /* Modulation negotiation options */
7668 cai[9] = 0; /* Modulation options */
7669
7670 if (((plci->call_dir & CALL_DIR_ORIGINATE) != 0) ^ ((plci->call_dir & CALL_DIR_OUT) != 0))
7671 {
7672 cai[9] |= DSP_CAI_MODEM_REVERSE_DIRECTION;
7673 dbug(1, dprintf("MDM: Reverse direction"));
7674 }
7675
7676 if (GET_WORD (mdm_cfg[4].info) & MDM_CAPI_DISABLE_RETRAIN)
7677 {
7678 cai[9] |= DSP_CAI_MODEM_DISABLE_RETRAIN;
7679 dbug(1, dprintf("MDM: Disable retrain"));
7680 }
7681
7682 if (GET_WORD (mdm_cfg[4].info) & MDM_CAPI_DISABLE_RING_TONE)
7683 {
7684 cai[7] |= DSP_CAI_MODEM_DISABLE_CALLING_TONE | DSP_CAI_MODEM_DISABLE_ANSWER_TONE;
7685 dbug(1, dprintf("MDM: Disable ring tone"));
7686 }
7687
7688 if (GET_WORD (mdm_cfg[4].info) & MDM_CAPI_GUARD_1800)
7689 {
7690 cai[8] |= DSP_CAI_MODEM_GUARD_TONE_1800HZ;
7691 dbug(1, dprintf("MDM: 1800 guard tone"));
7692 }
7693 else if (GET_WORD (mdm_cfg[4].info) & MDM_CAPI_GUARD_550 )
7694 {
7695 cai[8] |= DSP_CAI_MODEM_GUARD_TONE_550HZ;
7696 dbug(1, dprintf("MDM: 550 guard tone"));
7697 }
7698
7699 if ((GET_WORD (mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_V100)
7700 {
7701 cai[8] |= DSP_CAI_MODEM_NEGOTIATE_V100;
7702 dbug(1, dprintf("MDM: V100"));
7703 }
7704 else if ((GET_WORD (mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_MOD_CLASS)
7705 {
7706 cai[8] |= DSP_CAI_MODEM_NEGOTIATE_IN_CLASS;
7707 dbug(1, dprintf("MDM: IN CLASS"));
7708 }
7709 else if ((GET_WORD (mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_DISABLED)
7710 {
7711 cai[8] |= DSP_CAI_MODEM_NEGOTIATE_DISABLED;
7712 dbug(1, dprintf("MDM: DISABLED"));
7713 }
7714 cai[0] = 20;
7715
7716 if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_V18))
7717 && (GET_WORD(mdm_cfg[5].info) & 0x8000)) /* Private V.18 enable */
7718 {
7719 plci->requested_options |= 1L << PRIVATE_V18;
7720 }
7721 if (GET_WORD(mdm_cfg[5].info) & 0x4000) /* Private VOWN enable */
7722 plci->requested_options |= 1L << PRIVATE_VOWN;
7723
7724 if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id-1])
7725 & ((1L << PRIVATE_V18) | (1L << PRIVATE_VOWN)))
7726 {
7727 if (!api_parse(&bp_parms[3].info[1],(word)bp_parms[3].length,"wwwwwws", mdm_cfg))
7728 {
7729 i = 27;
7730 if (mdm_cfg[6].length >= 4)
7731 {
7732 d = GET_DWORD(&mdm_cfg[6].info[1]);
7733 cai[7] |= (byte) d; /* line taking options */
7734 cai[9] |= (byte)(d >> 8); /* modulation options */
7735 cai[++i] = (byte)(d >> 16); /* vown modulation options */
7736 cai[++i] = (byte)(d >> 24);
7737 if (mdm_cfg[6].length >= 8)
7738 {
7739 d = GET_DWORD(&mdm_cfg[6].info[5]);
7740 cai[10] |= (byte) d; /* disabled modulations mask */
7741 cai[11] |= (byte)(d >> 8);
7742 if (mdm_cfg[6].length >= 12)
7743 {
7744 d = GET_DWORD(&mdm_cfg[6].info[9]);
7745 cai[12] = (byte) d; /* enabled modulations mask */
7746 cai[++i] = (byte)(d >> 8); /* vown enabled modulations */
7747 cai[++i] = (byte)(d >> 16);
7748 cai[++i] = (byte)(d >> 24);
7749 cai[++i] = 0;
7750 if (mdm_cfg[6].length >= 14)
7751 {
7752 w = GET_WORD(&mdm_cfg[6].info[13]);
7753 if (w != 0)
7754 PUT_WORD(&cai[13], w); /* min tx speed */
7755 if (mdm_cfg[6].length >= 16)
7756 {
7757 w = GET_WORD(&mdm_cfg[6].info[15]);
7758 if (w != 0)
7759 PUT_WORD(&cai[15], w); /* max tx speed */
7760 if (mdm_cfg[6].length >= 18)
7761 {
7762 w = GET_WORD(&mdm_cfg[6].info[17]);
7763 if (w != 0)
7764 PUT_WORD(&cai[17], w); /* min rx speed */
7765 if (mdm_cfg[6].length >= 20)
7766 {
7767 w = GET_WORD(&mdm_cfg[6].info[19]);
7768 if (w != 0)
7769 PUT_WORD(&cai[19], w); /* max rx speed */
7770 if (mdm_cfg[6].length >= 22)
7771 {
7772 w = GET_WORD(&mdm_cfg[6].info[21]);
7773 cai[23] = (byte)(-((short) w)); /* transmit level */
7774 if (mdm_cfg[6].length >= 24)
7775 {
7776 w = GET_WORD(&mdm_cfg[6].info[23]);
7777 cai[22] |= (byte) w; /* info options mask */
7778 cai[21] |= (byte)(w >> 8); /* disabled symbol rates */
7779 }
7780 }
7781 }
7782 }
7783 }
7784 }
7785 }
7786 }
7787 }
7788 cai[27] = i - 27;
7789 i++;
7790 if (!api_parse(&bp_parms[3].info[1],(word)bp_parms[3].length,"wwwwwwss", mdm_cfg))
7791 {
7792 if (!api_parse(&mdm_cfg[7].info[1],(word)mdm_cfg[7].length,"sss", mdm_cfg_v18))
7793 {
7794 for (n = 0; n < 3; n++)
7795 {
7796 cai[i] = (byte)(mdm_cfg_v18[n].length);
7797 for (j = 1; j < ((word)(cai[i] + 1)); j++)
7798 cai[i+j] = mdm_cfg_v18[n].info[j];
7799 i += cai[i] + 1;
7800 }
7801 }
7802 }
7803 cai[0] = (byte)(i - 1);
7804 }
7805 }
7806
7807 }
7808 }
7809 if(GET_WORD(bp_parms[0].info)==2 || /* V.110 async */
7810 GET_WORD(bp_parms[0].info)==3 ) /* V.110 sync */
7811 {
7812 if(bp_parms[3].length){
7813 dbug(1,dprintf("V.110,%d",GET_WORD(&bp_parms[3].info[1])));
7814 switch(GET_WORD(&bp_parms[3].info[1])){ /* Rate */
7815 case 0:
7816 case 56000:
7817 if(GET_WORD(bp_parms[0].info)==3){ /* V.110 sync 56k */
7818 dbug(1,dprintf("56k sync HSCX"));
7819 cai[1] = 8;
7820 cai[2] = 0;
7821 cai[3] = 0;
7822 }
7823 else if(GET_WORD(bp_parms[0].info)==2){
7824 dbug(1,dprintf("56k async DSP"));
7825 cai[2] = 9;
7826 }
7827 break;
7828 case 50: cai[2] = 1; break;
7829 case 75: cai[2] = 1; break;
7830 case 110: cai[2] = 1; break;
7831 case 150: cai[2] = 1; break;
7832 case 200: cai[2] = 1; break;
7833 case 300: cai[2] = 1; break;
7834 case 600: cai[2] = 1; break;
7835 case 1200: cai[2] = 2; break;
7836 case 2400: cai[2] = 3; break;
7837 case 4800: cai[2] = 4; break;
7838 case 7200: cai[2] = 10; break;
7839 case 9600: cai[2] = 5; break;
7840 case 12000: cai[2] = 13; break;
7841 case 24000: cai[2] = 0; break;
7842 case 14400: cai[2] = 11; break;
7843 case 19200: cai[2] = 6; break;
7844 case 28800: cai[2] = 12; break;
7845 case 38400: cai[2] = 7; break;
7846 case 48000: cai[2] = 8; break;
7847 case 76: cai[2] = 15; break; /* 75/1200 */
7848 case 1201: cai[2] = 14; break; /* 1200/75 */
7849 case 56001: cai[2] = 9; break; /* V.110 56000 */
7850
7851 default:
7852 return _B1_PARM_NOT_SUPPORTED;
7853 }
7854 cai[3] = 0;
7855 if (cai[1] == 13) /* v.110 async */
7856 {
7857 if (bp_parms[3].length >= 8)
7858 {
7859 switch (GET_WORD (&bp_parms[3].info[3]))
7860 { /* char length */
7861 case 5:
7862 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_5;
7863 break;
7864 case 6:
7865 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_6;
7866 break;
7867 case 7:
7868 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_7;
7869 break;
7870 }
7871 switch (GET_WORD (&bp_parms[3].info[5]))
7872 { /* Parity */
7873 case 1: /* odd parity */
7874 cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_ODD);
7875 break;
7876 case 2: /* even parity */
7877 cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_EVEN);
7878 break;
7879 }
7880 switch (GET_WORD (&bp_parms[3].info[7]))
7881 { /* stop bits */
7882 case 1: /* 2 stop bits */
7883 cai[3] |= DSP_CAI_ASYNC_TWO_STOP_BITS;
7884 break;
7885 }
7886 }
7887 }
7888 }
7889 else if(cai[1]==8 || GET_WORD(bp_parms[0].info)==3 ){
7890 dbug(1,dprintf("V.110 default 56k sync"));
7891 cai[1] = 8;
7892 cai[2] = 0;
7893 cai[3] = 0;
7894 }
7895 else {
7896 dbug(1,dprintf("V.110 default 9600 async"));
7897 cai[2] = 5;
7898 }
7899 }
7900 PUT_WORD(&cai[5],plci->appl->MaxDataLength);
7901 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]));
7902 /* HexDump ("CAI", sizeof(cai), &cai[0]); */
7903
7904 add_p(plci, CAI, cai);
7905 return 0;
7906 }
7907
7908 /*------------------------------------------------------------------*/
7909 /* put parameter for b2 and B3 protocol in the parameter buffer */
7910 /*------------------------------------------------------------------*/
7911
7912 word add_b23(PLCI * plci, API_PARSE * bp)
7913 {
7914 word i, fax_control_bits;
7915 byte pos, len;
7916 byte SAPI = 0x40; /* default SAPI 16 for x.31 */
7917 API_PARSE bp_parms[8];
7918 API_PARSE * b1_config;
7919 API_PARSE * b2_config;
7920 API_PARSE b2_config_parms[8];
7921 API_PARSE * b3_config;
7922 API_PARSE b3_config_parms[6];
7923 API_PARSE global_config[2];
7924
7925 static byte llc[3] = {2,0,0};
7926 static byte dlc[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
7927 static byte nlc[256];
7928 static byte lli[12] = {1,1};
7929
7930 const byte llc2_out[] = {1,2,4,6,2,0,0,0, X75_V42BIS,V120_L2,V120_V42BIS,V120_L2,6};
7931 const byte llc2_in[] = {1,3,4,6,3,0,0,0, X75_V42BIS,V120_L2,V120_V42BIS,V120_L2,6};
7932
7933 const byte llc3[] = {4,3,2,2,6,6,0};
7934 const byte header[] = {0,2,3,3,0,0,0};
7935
7936 for(i=0;i<8;i++) bp_parms[i].length = 0;
7937 for(i=0;i<6;i++) b2_config_parms[i].length = 0;
7938 for(i=0;i<5;i++) b3_config_parms[i].length = 0;
7939
7940 lli[0] = 1;
7941 lli[1] = 1;
7942 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL)
7943 lli[1] |= 2;
7944 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL)
7945 lli[1] |= 4;
7946
7947 if ((lli[1] & 0x02) && (diva_xdi_extended_features & DIVA_CAPI_USE_CMA)) {
7948 lli[1] |= 0x10;
7949 if (plci->rx_dma_descriptor <= 0) {
7950 plci->rx_dma_descriptor=diva_get_dma_descriptor(plci,&plci->rx_dma_magic);
7951 if (plci->rx_dma_descriptor >= 0)
7952 plci->rx_dma_descriptor++;
7953 }
7954 if (plci->rx_dma_descriptor > 0) {
7955 lli[0] = 6;
7956 lli[1] |= 0x40;
7957 lli[2] = (byte)(plci->rx_dma_descriptor - 1);
7958 lli[3] = (byte)plci->rx_dma_magic;
7959 lli[4] = (byte)(plci->rx_dma_magic >> 8);
7960 lli[5] = (byte)(plci->rx_dma_magic >> 16);
7961 lli[6] = (byte)(plci->rx_dma_magic >> 24);
7962 }
7963 }
7964
7965 if (DIVA_CAPI_SUPPORTS_NO_CANCEL(plci->adapter)) {
7966 lli[1] |= 0x20;
7967 }
7968
7969 dbug(1,dprintf("add_b23"));
7970 api_save_msg(bp, "s", &plci->B_protocol);
7971
7972 if(!bp->length && plci->tel)
7973 {
7974 plci->adv_nl = true;
7975 dbug(1,dprintf("Default adv.Nl"));
7976 add_p(plci,LLI,lli);
7977 plci->B2_prot = 1 /*XPARENT*/;
7978 plci->B3_prot = 0 /*XPARENT*/;
7979 llc[1] = 2;
7980 llc[2] = 4;
7981 add_p(plci, LLC, llc);
7982 dlc[0] = 2;
7983 PUT_WORD(&dlc[1],plci->appl->MaxDataLength);
7984 add_p(plci, DLC, dlc);
7985 return 0;
7986 }
7987
7988 if(!bp->length) /*default*/
7989 {
7990 dbug(1,dprintf("ret default"));
7991 add_p(plci,LLI,lli);
7992 plci->B2_prot = 0 /*X.75 */;
7993 plci->B3_prot = 0 /*XPARENT*/;
7994 llc[1] = 1;
7995 llc[2] = 4;
7996 add_p(plci, LLC, llc);
7997 dlc[0] = 2;
7998 PUT_WORD(&dlc[1],plci->appl->MaxDataLength);
7999 add_p(plci, DLC, dlc);
8000 return 0;
8001 }
8002 dbug(1,dprintf("b_prot_len=%d",(word)bp->length));
8003 if((word)bp->length > 256) return _WRONG_MESSAGE_FORMAT;
8004
8005 if(api_parse(&bp->info[1], (word)bp->length, "wwwsssb", bp_parms))
8006 {
8007 bp_parms[6].length = 0;
8008 if(api_parse(&bp->info[1], (word)bp->length, "wwwsss", bp_parms))
8009 {
8010 dbug(1,dprintf("b-form.!"));
8011 return _WRONG_MESSAGE_FORMAT;
8012 }
8013 }
8014 else if (api_parse(&bp->info[1], (word)bp->length, "wwwssss", bp_parms))
8015 {
8016 dbug(1,dprintf("b-form.!"));
8017 return _WRONG_MESSAGE_FORMAT;
8018 }
8019
8020 if(plci->tel==ADV_VOICE) /* transparent B on advanced voice */
8021 {
8022 if(GET_WORD(bp_parms[1].info)!=1
8023 || GET_WORD(bp_parms[2].info)!=0) return _B2_NOT_SUPPORTED;
8024 plci->adv_nl = true;
8025 }
8026 else if(plci->tel) return _B2_NOT_SUPPORTED;
8027
8028
8029 if ((GET_WORD(bp_parms[1].info) == B2_RTP)
8030 && (GET_WORD(bp_parms[2].info) == B3_RTP)
8031 && (plci->adapter->man_profile.private_options & (1L << PRIVATE_RTP)))
8032 {
8033 add_p(plci,LLI,lli);
8034 plci->B2_prot = (byte) GET_WORD(bp_parms[1].info);
8035 plci->B3_prot = (byte) GET_WORD(bp_parms[2].info);
8036 llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ? 14 : 13;
8037 llc[2] = 4;
8038 add_p(plci, LLC, llc);
8039 dlc[0] = 2;
8040 PUT_WORD(&dlc[1],plci->appl->MaxDataLength);
8041 dlc[3] = 3; /* Addr A */
8042 dlc[4] = 1; /* Addr B */
8043 dlc[5] = 7; /* modulo mode */
8044 dlc[6] = 7; /* window size */
8045 dlc[7] = 0; /* XID len Lo */
8046 dlc[8] = 0; /* XID len Hi */
8047 for (i = 0; i < bp_parms[4].length; i++)
8048 dlc[9+i] = bp_parms[4].info[1+i];
8049 dlc[0] = (byte)(8 + bp_parms[4].length);
8050 add_p(plci, DLC, dlc);
8051 for (i = 0; i < bp_parms[5].length; i++)
8052 nlc[1+i] = bp_parms[5].info[1+i];
8053 nlc[0] = (byte)(bp_parms[5].length);
8054 add_p(plci, NLC, nlc);
8055 return 0;
8056 }
8057
8058
8059
8060 if ((GET_WORD(bp_parms[1].info) >= 32)
8061 || (!((1L << GET_WORD(bp_parms[1].info)) & plci->adapter->profile.B2_Protocols)
8062 && ((GET_WORD(bp_parms[1].info) != B2_PIAFS)
8063 || !(plci->adapter->man_profile.private_options & (1L << PRIVATE_PIAFS)))))
8064
8065 {
8066 return _B2_NOT_SUPPORTED;
8067 }
8068 if ((GET_WORD(bp_parms[2].info) >= 32)
8069 || !((1L << GET_WORD(bp_parms[2].info)) & plci->adapter->profile.B3_Protocols))
8070 {
8071 return _B3_NOT_SUPPORTED;
8072 }
8073 if ((GET_WORD(bp_parms[1].info) != B2_SDLC)
8074 && ((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE)
8075 || (GET_WORD(bp_parms[0].info) == B1_MODEM_ASYNC)
8076 || (GET_WORD(bp_parms[0].info) == B1_MODEM_SYNC_HDLC)))
8077 {
8078 return (add_modem_b23 (plci, bp_parms));
8079 }
8080
8081 add_p(plci,LLI,lli);
8082
8083 plci->B2_prot = (byte) GET_WORD(bp_parms[1].info);
8084 plci->B3_prot = (byte) GET_WORD(bp_parms[2].info);
8085 if(plci->B2_prot==12) SAPI = 0; /* default SAPI D-channel */
8086
8087 if(bp_parms[6].length)
8088 {
8089 if(api_parse(&bp_parms[6].info[1], (word)bp_parms[6].length, "w", global_config))
8090 {
8091 return _WRONG_MESSAGE_FORMAT;
8092 }
8093 switch(GET_WORD(global_config[0].info))
8094 {
8095 case 1:
8096 plci->call_dir = (plci->call_dir & ~CALL_DIR_ANSWER) | CALL_DIR_ORIGINATE;
8097 break;
8098 case 2:
8099 plci->call_dir = (plci->call_dir & ~CALL_DIR_ORIGINATE) | CALL_DIR_ANSWER;
8100 break;
8101 }
8102 }
8103 dbug(1,dprintf("call_dir=%04x", plci->call_dir));
8104
8105
8106 if (plci->B2_prot == B2_PIAFS)
8107 llc[1] = PIAFS_CRC;
8108 else
8109 /* IMPLEMENT_PIAFS */
8110 {
8111 llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ?
8112 llc2_out[GET_WORD(bp_parms[1].info)] : llc2_in[GET_WORD(bp_parms[1].info)];
8113 }
8114 llc[2] = llc3[GET_WORD(bp_parms[2].info)];
8115
8116 add_p(plci, LLC, llc);
8117
8118 dlc[0] = 2;
8119 PUT_WORD(&dlc[1], plci->appl->MaxDataLength +
8120 header[GET_WORD(bp_parms[2].info)]);
8121
8122 b1_config = &bp_parms[3];
8123 nlc[0] = 0;
8124 if(plci->B3_prot == 4
8125 || plci->B3_prot == 5)
8126 {
8127 for (i=0;i<sizeof(T30_INFO);i++) nlc[i] = 0;
8128 nlc[0] = sizeof(T30_INFO);
8129 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
8130 ((T30_INFO *)&nlc[1])->operating_mode = T30_OPERATING_MODE_CAPI;
8131 ((T30_INFO *)&nlc[1])->rate_div_2400 = 0xff;
8132 if(b1_config->length>=2)
8133 {
8134 ((T30_INFO *)&nlc[1])->rate_div_2400 = (byte)(GET_WORD(&b1_config->info[1])/2400);
8135 }
8136 }
8137 b2_config = &bp_parms[4];
8138
8139
8140 if (llc[1] == PIAFS_CRC)
8141 {
8142 if (plci->B3_prot != B3_TRANSPARENT)
8143 {
8144 return _B_STACK_NOT_SUPPORTED;
8145 }
8146 if(b2_config->length && api_parse(&b2_config->info[1], (word)b2_config->length, "bwww", b2_config_parms)) {
8147 return _WRONG_MESSAGE_FORMAT;
8148 }
8149 PUT_WORD(&dlc[1],plci->appl->MaxDataLength);
8150 dlc[3] = 0; /* Addr A */
8151 dlc[4] = 0; /* Addr B */
8152 dlc[5] = 0; /* modulo mode */
8153 dlc[6] = 0; /* window size */
8154 if (b2_config->length >= 7){
8155 dlc[ 7] = 7;
8156 dlc[ 8] = 0;
8157 dlc[ 9] = b2_config_parms[0].info[0]; /* PIAFS protocol Speed configuration */
8158 dlc[10] = b2_config_parms[1].info[0]; /* V.42bis P0 */
8159 dlc[11] = b2_config_parms[1].info[1]; /* V.42bis P0 */
8160 dlc[12] = b2_config_parms[2].info[0]; /* V.42bis P1 */
8161 dlc[13] = b2_config_parms[2].info[1]; /* V.42bis P1 */
8162 dlc[14] = b2_config_parms[3].info[0]; /* V.42bis P2 */
8163 dlc[15] = b2_config_parms[3].info[1]; /* V.42bis P2 */
8164 dlc[ 0] = 15;
8165 if(b2_config->length >= 8) { /* PIAFS control abilities */
8166 dlc[ 7] = 10;
8167 dlc[16] = 2; /* Length of PIAFS extention */
8168 dlc[17] = PIAFS_UDATA_ABILITIES; /* control (UDATA) ability */
8169 dlc[18] = b2_config_parms[4].info[0]; /* value */
8170 dlc[ 0] = 18;
8171 }
8172 }
8173 else /* default values, 64K, variable, no compression */
8174 {
8175 dlc[ 7] = 7;
8176 dlc[ 8] = 0;
8177 dlc[ 9] = 0x03; /* PIAFS protocol Speed configuration */
8178 dlc[10] = 0x03; /* V.42bis P0 */
8179 dlc[11] = 0; /* V.42bis P0 */
8180 dlc[12] = 0; /* V.42bis P1 */
8181 dlc[13] = 0; /* V.42bis P1 */
8182 dlc[14] = 0; /* V.42bis P2 */
8183 dlc[15] = 0; /* V.42bis P2 */
8184 dlc[ 0] = 15;
8185 }
8186 add_p(plci, DLC, dlc);
8187 }
8188 else
8189
8190 if ((llc[1] == V120_L2) || (llc[1] == V120_V42BIS))
8191 {
8192 if (plci->B3_prot != B3_TRANSPARENT)
8193 return _B_STACK_NOT_SUPPORTED;
8194
8195 dlc[0] = 6;
8196 PUT_WORD (&dlc[1], GET_WORD (&dlc[1]) + 2);
8197 dlc[3] = 0x08;
8198 dlc[4] = 0x01;
8199 dlc[5] = 127;
8200 dlc[6] = 7;
8201 if (b2_config->length != 0)
8202 {
8203 if((llc[1]==V120_V42BIS) && api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbwww", b2_config_parms)) {
8204 return _WRONG_MESSAGE_FORMAT;
8205 }
8206 dlc[3] = (byte)((b2_config->info[2] << 3) | ((b2_config->info[1] >> 5) & 0x04));
8207 dlc[4] = (byte)((b2_config->info[1] << 1) | 0x01);
8208 if (b2_config->info[3] != 128)
8209 {
8210 dbug(1,dprintf("1D-dlc= %x %x %x %x %x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4]));
8211 return _B2_PARM_NOT_SUPPORTED;
8212 }
8213 dlc[5] = (byte)(b2_config->info[3] - 1);
8214 dlc[6] = b2_config->info[4];
8215 if(llc[1]==V120_V42BIS){
8216 if (b2_config->length >= 10){
8217 dlc[ 7] = 6;
8218 dlc[ 8] = 0;
8219 dlc[ 9] = b2_config_parms[4].info[0];
8220 dlc[10] = b2_config_parms[4].info[1];
8221 dlc[11] = b2_config_parms[5].info[0];
8222 dlc[12] = b2_config_parms[5].info[1];
8223 dlc[13] = b2_config_parms[6].info[0];
8224 dlc[14] = b2_config_parms[6].info[1];
8225 dlc[ 0] = 14;
8226 dbug(1,dprintf("b2_config_parms[4].info[0] [1]: %x %x", b2_config_parms[4].info[0], b2_config_parms[4].info[1]));
8227 dbug(1,dprintf("b2_config_parms[5].info[0] [1]: %x %x", b2_config_parms[5].info[0], b2_config_parms[5].info[1]));
8228 dbug(1,dprintf("b2_config_parms[6].info[0] [1]: %x %x", b2_config_parms[6].info[0], b2_config_parms[6].info[1]));
8229 }
8230 else {
8231 dlc[ 6] = 14;
8232 }
8233 }
8234 }
8235 }
8236 else
8237 {
8238 if(b2_config->length)
8239 {
8240 dbug(1,dprintf("B2-Config"));
8241 if(llc[1]==X75_V42BIS){
8242 if(api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbwww", b2_config_parms))
8243 {
8244 return _WRONG_MESSAGE_FORMAT;
8245 }
8246 }
8247 else {
8248 if(api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbs", b2_config_parms))
8249 {
8250 return _WRONG_MESSAGE_FORMAT;
8251 }
8252 }
8253 /* if B2 Protocol is LAPD, b2_config structure is different */
8254 if(llc[1]==6)
8255 {
8256 dlc[0] = 4;
8257 if(b2_config->length>=1) dlc[2] = b2_config->info[1]; /* TEI */
8258 else dlc[2] = 0x01;
8259 if( (b2_config->length>=2) && (plci->B2_prot==12) )
8260 {
8261 SAPI = b2_config->info[2]; /* SAPI */
8262 }
8263 dlc[1] = SAPI;
8264 if( (b2_config->length>=3) && (b2_config->info[3]==128) )
8265 {
8266 dlc[3] = 127; /* Mode */
8267 }
8268 else
8269 {
8270 dlc[3] = 7; /* Mode */
8271 }
8272
8273 if(b2_config->length>=4) dlc[4] = b2_config->info[4]; /* Window */
8274 else dlc[4] = 1;
8275 dbug(1,dprintf("D-dlc[%d]=%x,%x,%x,%x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4]));
8276 if(b2_config->length>5) return _B2_PARM_NOT_SUPPORTED;
8277 }
8278 else
8279 {
8280 dlc[0] = (byte)(b2_config_parms[4].length+6);
8281 dlc[3] = b2_config->info[1];
8282 dlc[4] = b2_config->info[2];
8283 if(b2_config->info[3]!=8 && b2_config->info[3]!=128){
8284 dbug(1,dprintf("1D-dlc= %x %x %x %x %x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4]));
8285 return _B2_PARM_NOT_SUPPORTED;
8286 }
8287
8288 dlc[5] = (byte)(b2_config->info[3]-1);
8289 dlc[6] = b2_config->info[4];
8290 if(dlc[6]>dlc[5]){
8291 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]));
8292 return _B2_PARM_NOT_SUPPORTED;
8293 }
8294
8295 if(llc[1]==X75_V42BIS) {
8296 if (b2_config->length >= 10){
8297 dlc[ 7] = 6;
8298 dlc[ 8] = 0;
8299 dlc[ 9] = b2_config_parms[4].info[0];
8300 dlc[10] = b2_config_parms[4].info[1];
8301 dlc[11] = b2_config_parms[5].info[0];
8302 dlc[12] = b2_config_parms[5].info[1];
8303 dlc[13] = b2_config_parms[6].info[0];
8304 dlc[14] = b2_config_parms[6].info[1];
8305 dlc[ 0] = 14;
8306 dbug(1,dprintf("b2_config_parms[4].info[0] [1]: %x %x", b2_config_parms[4].info[0], b2_config_parms[4].info[1]));
8307 dbug(1,dprintf("b2_config_parms[5].info[0] [1]: %x %x", b2_config_parms[5].info[0], b2_config_parms[5].info[1]));
8308 dbug(1,dprintf("b2_config_parms[6].info[0] [1]: %x %x", b2_config_parms[6].info[0], b2_config_parms[6].info[1]));
8309 }
8310 else {
8311 dlc[ 6] = 14;
8312 }
8313
8314 }
8315 else {
8316 PUT_WORD(&dlc[7], (word)b2_config_parms[4].length);
8317 for(i=0; i<b2_config_parms[4].length; i++)
8318 dlc[11+i] = b2_config_parms[4].info[1+i];
8319 }
8320 }
8321 }
8322 }
8323 add_p(plci, DLC, dlc);
8324
8325 b3_config = &bp_parms[5];
8326 if(b3_config->length)
8327 {
8328 if(plci->B3_prot == 4
8329 || plci->B3_prot == 5)
8330 {
8331 if(api_parse(&b3_config->info[1], (word)b3_config->length, "wwss", b3_config_parms))
8332 {
8333 return _WRONG_MESSAGE_FORMAT;
8334 }
8335 i = GET_WORD((byte *)(b3_config_parms[0].info));
8336 ((T30_INFO *)&nlc[1])->resolution = (byte)(((i & 0x0001) ||
8337 ((plci->B3_prot == 4) && (((byte)(GET_WORD((byte *)b3_config_parms[1].info))) != 5))) ? T30_RESOLUTION_R8_0770_OR_200 : 0);
8338 ((T30_INFO *)&nlc[1])->data_format = (byte)(GET_WORD((byte *)b3_config_parms[1].info));
8339 fax_control_bits = T30_CONTROL_BIT_ALL_FEATURES;
8340 if ((((T30_INFO *)&nlc[1])->rate_div_2400 != 0) && (((T30_INFO *)&nlc[1])->rate_div_2400 <= 6))
8341 fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_V34FAX;
8342 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
8343 {
8344
8345 if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id-1])
8346 & (1L << PRIVATE_FAX_PAPER_FORMATS))
8347 {
8348 ((T30_INFO *)&nlc[1])->resolution |= T30_RESOLUTION_R8_1540 |
8349 T30_RESOLUTION_R16_1540_OR_400 | T30_RESOLUTION_300_300 |
8350 T30_RESOLUTION_INCH_BASED | T30_RESOLUTION_METRIC_BASED;
8351 }
8352
8353 ((T30_INFO *)&nlc[1])->recording_properties =
8354 T30_RECORDING_WIDTH_ISO_A3 |
8355 (T30_RECORDING_LENGTH_UNLIMITED << 2) |
8356 (T30_MIN_SCANLINE_TIME_00_00_00 << 4);
8357 }
8358 if(plci->B3_prot == 5)
8359 {
8360 if (i & 0x0002) /* Accept incoming fax-polling requests */
8361 fax_control_bits |= T30_CONTROL_BIT_ACCEPT_POLLING;
8362 if (i & 0x2000) /* Do not use MR compression */
8363 fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_2D_CODING;
8364 if (i & 0x4000) /* Do not use MMR compression */
8365 fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_T6_CODING;
8366 if (i & 0x8000) /* Do not use ECM */
8367 fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_ECM;
8368 if (plci->fax_connect_info_length != 0)
8369 {
8370 ((T30_INFO *)&nlc[1])->resolution = ((T30_INFO *)plci->fax_connect_info_buffer)->resolution;
8371 ((T30_INFO *)&nlc[1])->data_format = ((T30_INFO *)plci->fax_connect_info_buffer)->data_format;
8372 ((T30_INFO *)&nlc[1])->recording_properties = ((T30_INFO *)plci->fax_connect_info_buffer)->recording_properties;
8373 fax_control_bits |= GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low) &
8374 (T30_CONTROL_BIT_REQUEST_POLLING | T30_CONTROL_BIT_MORE_DOCUMENTS);
8375 }
8376 }
8377 /* copy station id to NLC */
8378 for(i=0; i<20; i++)
8379 {
8380 if(i<b3_config_parms[2].length)
8381 {
8382 ((T30_INFO *)&nlc[1])->station_id[i] = ((byte *)b3_config_parms[2].info)[1+i];
8383 }
8384 else
8385 {
8386 ((T30_INFO *)&nlc[1])->station_id[i] = ' ';
8387 }
8388 }
8389 ((T30_INFO *)&nlc[1])->station_id_len = 20;
8390 /* copy head line to NLC */
8391 if(b3_config_parms[3].length)
8392 {
8393
8394 pos = (byte)(fax_head_line_time (&(((T30_INFO *)&nlc[1])->station_id[20])));
8395 if (pos != 0)
8396 {
8397 if (CAPI_MAX_DATE_TIME_LENGTH + 2 + b3_config_parms[3].length > CAPI_MAX_HEAD_LINE_SPACE)
8398 pos = 0;
8399 else
8400 {
8401 ((T30_INFO *)&nlc[1])->station_id[20 + pos++] = ' ';
8402 ((T30_INFO *)&nlc[1])->station_id[20 + pos++] = ' ';
8403 len = (byte)b3_config_parms[2].length;
8404 if (len > 20)
8405 len = 20;
8406 if (CAPI_MAX_DATE_TIME_LENGTH + 2 + len + 2 + b3_config_parms[3].length <= CAPI_MAX_HEAD_LINE_SPACE)
8407 {
8408 for (i = 0; i < len; i++)
8409 ((T30_INFO *)&nlc[1])->station_id[20 + pos++] = ((byte *)b3_config_parms[2].info)[1+i];
8410 ((T30_INFO *)&nlc[1])->station_id[20 + pos++] = ' ';
8411 ((T30_INFO *)&nlc[1])->station_id[20 + pos++] = ' ';
8412 }
8413 }
8414 }
8415
8416 len = (byte)b3_config_parms[3].length;
8417 if (len > CAPI_MAX_HEAD_LINE_SPACE - pos)
8418 len = (byte)(CAPI_MAX_HEAD_LINE_SPACE - pos);
8419 ((T30_INFO *)&nlc[1])->head_line_len = (byte)(pos + len);
8420 nlc[0] += (byte)(pos + len);
8421 for (i = 0; i < len; i++)
8422 ((T30_INFO *)&nlc[1])->station_id[20 + pos++] = ((byte *)b3_config_parms[3].info)[1+i];
8423 }
8424 else
8425 ((T30_INFO *)&nlc[1])->head_line_len = 0;
8426
8427 plci->nsf_control_bits = 0;
8428 if(plci->B3_prot == 5)
8429 {
8430 if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_FAX_SUB_SEP_PWD))
8431 && (GET_WORD((byte *)b3_config_parms[1].info) & 0x8000)) /* Private SUB/SEP/PWD enable */
8432 {
8433 plci->requested_options |= 1L << PRIVATE_FAX_SUB_SEP_PWD;
8434 }
8435 if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_FAX_NONSTANDARD))
8436 && (GET_WORD((byte *)b3_config_parms[1].info) & 0x4000)) /* Private non-standard facilities enable */
8437 {
8438 plci->requested_options |= 1L << PRIVATE_FAX_NONSTANDARD;
8439 }
8440 if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id-1])
8441 & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
8442 {
8443 if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id-1])
8444 & (1L << PRIVATE_FAX_SUB_SEP_PWD))
8445 {
8446 fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_PASSWORD;
8447 if (fax_control_bits & T30_CONTROL_BIT_ACCEPT_POLLING)
8448 fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SEL_POLLING;
8449 }
8450 len = nlc[0];
8451 pos = ((byte)(((T30_INFO *) 0)->station_id + 20));
8452 if (pos < plci->fax_connect_info_length)
8453 {
8454 for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--)
8455 nlc[++len] = plci->fax_connect_info_buffer[pos++];
8456 }
8457 else
8458 nlc[++len] = 0;
8459 if (pos < plci->fax_connect_info_length)
8460 {
8461 for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--)
8462 nlc[++len] = plci->fax_connect_info_buffer[pos++];
8463 }
8464 else
8465 nlc[++len] = 0;
8466 if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id-1])
8467 & (1L << PRIVATE_FAX_NONSTANDARD))
8468 {
8469 if ((pos < plci->fax_connect_info_length) && (plci->fax_connect_info_buffer[pos] != 0))
8470 {
8471 if ((plci->fax_connect_info_buffer[pos] >= 3) && (plci->fax_connect_info_buffer[pos+1] >= 2))
8472 plci->nsf_control_bits = GET_WORD(&plci->fax_connect_info_buffer[pos+2]);
8473 for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--)
8474 nlc[++len] = plci->fax_connect_info_buffer[pos++];
8475 }
8476 else
8477 {
8478 if(api_parse(&b3_config->info[1], (word)b3_config->length, "wwsss", b3_config_parms))
8479 {
8480 dbug(1,dprintf("non-standard facilities info missing or wrong format"));
8481 nlc[++len] = 0;
8482 }
8483 else
8484 {
8485 if ((b3_config_parms[4].length >= 3) && (b3_config_parms[4].info[1] >= 2))
8486 plci->nsf_control_bits = GET_WORD(&b3_config_parms[4].info[2]);
8487 nlc[++len] = (byte)(b3_config_parms[4].length);
8488 for (i = 0; i < b3_config_parms[4].length; i++)
8489 nlc[++len] = b3_config_parms[4].info[1+i];
8490 }
8491 }
8492 }
8493 nlc[0] = len;
8494 if ((plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF)
8495 && (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP))
8496 {
8497 ((T30_INFO *)&nlc[1])->operating_mode = T30_OPERATING_MODE_CAPI_NEG;
8498 }
8499 }
8500 }
8501
8502 PUT_WORD(&(((T30_INFO *)&nlc[1])->control_bits_low), fax_control_bits);
8503 len = ((byte)(((T30_INFO *) 0)->station_id + 20));
8504 for (i = 0; i < len; i++)
8505 plci->fax_connect_info_buffer[i] = nlc[1+i];
8506 ((T30_INFO *) plci->fax_connect_info_buffer)->head_line_len = 0;
8507 i += ((T30_INFO *)&nlc[1])->head_line_len;
8508 while (i < nlc[0])
8509 plci->fax_connect_info_buffer[len++] = nlc[++i];
8510 plci->fax_connect_info_length = len;
8511 }
8512 else
8513 {
8514 nlc[0] = 14;
8515 if(b3_config->length!=16)
8516 return _B3_PARM_NOT_SUPPORTED;
8517 for(i=0; i<12; i++) nlc[1+i] = b3_config->info[1+i];
8518 if(GET_WORD(&b3_config->info[13])!=8 && GET_WORD(&b3_config->info[13])!=128)
8519 return _B3_PARM_NOT_SUPPORTED;
8520 nlc[13] = b3_config->info[13];
8521 if(GET_WORD(&b3_config->info[15])>=nlc[13])
8522 return _B3_PARM_NOT_SUPPORTED;
8523 nlc[14] = b3_config->info[15];
8524 }
8525 }
8526 else
8527 {
8528 if (plci->B3_prot == 4
8529 || plci->B3_prot == 5 /*T.30 - FAX*/ ) return _B3_PARM_NOT_SUPPORTED;
8530 }
8531 add_p(plci, NLC, nlc);
8532 return 0;
8533 }
8534
8535 /*----------------------------------------------------------------*/
8536 /* make the same as add_b23, but only for the modem related */
8537 /* L2 and L3 B-Chan protocol. */
8538 /* */
8539 /* Enabled L2 and L3 Configurations: */
8540 /* If L1 == Modem all negotiation */
8541 /* only L2 == Modem with full negotiation is allowed */
8542 /* If L1 == Modem async or sync */
8543 /* only L2 == Transparent is allowed */
8544 /* L3 == Modem or L3 == Transparent are allowed */
8545 /* B2 Configuration for modem: */
8546 /* word : enable/disable compression, bitoptions */
8547 /* B3 Configuration for modem: */
8548 /* empty */
8549 /*----------------------------------------------------------------*/
8550 static word add_modem_b23 (PLCI * plci, API_PARSE* bp_parms)
8551 {
8552 static byte lli[12] = {1,1};
8553 static byte llc[3] = {2,0,0};
8554 static byte dlc[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
8555 API_PARSE mdm_config[2];
8556 word i;
8557 word b2_config = 0;
8558
8559 for(i=0;i<2;i++) mdm_config[i].length = 0;
8560 for(i=0;i<sizeof(dlc);i++) dlc[i] = 0;
8561
8562 if (((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE)
8563 && (GET_WORD(bp_parms[1].info) != B2_MODEM_EC_COMPRESSION))
8564 || ((GET_WORD(bp_parms[0].info) != B1_MODEM_ALL_NEGOTIATE)
8565 && (GET_WORD(bp_parms[1].info) != B2_TRANSPARENT)))
8566 {
8567 return (_B_STACK_NOT_SUPPORTED);
8568 }
8569 if ((GET_WORD(bp_parms[2].info) != B3_MODEM)
8570 && (GET_WORD(bp_parms[2].info) != B3_TRANSPARENT))
8571 {
8572 return (_B_STACK_NOT_SUPPORTED);
8573 }
8574
8575 plci->B2_prot = (byte) GET_WORD(bp_parms[1].info);
8576 plci->B3_prot = (byte) GET_WORD(bp_parms[2].info);
8577
8578 if ((GET_WORD(bp_parms[1].info) == B2_MODEM_EC_COMPRESSION) && bp_parms[4].length)
8579 {
8580 if (api_parse (&bp_parms[4].info[1],
8581 (word)bp_parms[4].length, "w",
8582 mdm_config))
8583 {
8584 return (_WRONG_MESSAGE_FORMAT);
8585 }
8586 b2_config = GET_WORD(mdm_config[0].info);
8587 }
8588
8589 /* OK, L2 is modem */
8590
8591 lli[0] = 1;
8592 lli[1] = 1;
8593 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL)
8594 lli[1] |= 2;
8595 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL)
8596 lli[1] |= 4;
8597
8598 if ((lli[1] & 0x02) && (diva_xdi_extended_features & DIVA_CAPI_USE_CMA)) {
8599 lli[1] |= 0x10;
8600 if (plci->rx_dma_descriptor <= 0) {
8601 plci->rx_dma_descriptor=diva_get_dma_descriptor(plci,&plci->rx_dma_magic);
8602 if (plci->rx_dma_descriptor >= 0)
8603 plci->rx_dma_descriptor++;
8604 }
8605 if (plci->rx_dma_descriptor > 0) {
8606 lli[1] |= 0x40;
8607 lli[0] = 6;
8608 lli[2] = (byte)(plci->rx_dma_descriptor - 1);
8609 lli[3] = (byte)plci->rx_dma_magic;
8610 lli[4] = (byte)(plci->rx_dma_magic >> 8);
8611 lli[5] = (byte)(plci->rx_dma_magic >> 16);
8612 lli[6] = (byte)(plci->rx_dma_magic >> 24);
8613 }
8614 }
8615
8616 if (DIVA_CAPI_SUPPORTS_NO_CANCEL(plci->adapter)) {
8617 lli[1] |= 0x20;
8618 }
8619
8620 llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ?
8621 /*V42*/ 10 : /*V42_IN*/ 9;
8622 llc[2] = 4; /* pass L3 always transparent */
8623 add_p(plci, LLI, lli);
8624 add_p(plci, LLC, llc);
8625 i = 1;
8626 PUT_WORD (&dlc[i], plci->appl->MaxDataLength);
8627 i += 2;
8628 if (GET_WORD(bp_parms[1].info) == B2_MODEM_EC_COMPRESSION)
8629 {
8630 if (bp_parms[4].length)
8631 {
8632 dbug(1, dprintf("MDM b2_config=%02x", b2_config));
8633 dlc[i++] = 3; /* Addr A */
8634 dlc[i++] = 1; /* Addr B */
8635 dlc[i++] = 7; /* modulo mode */
8636 dlc[i++] = 7; /* window size */
8637 dlc[i++] = 0; /* XID len Lo */
8638 dlc[i++] = 0; /* XID len Hi */
8639
8640 if (b2_config & MDM_B2_DISABLE_V42bis)
8641 {
8642 dlc[i] |= DLC_MODEMPROT_DISABLE_V42_V42BIS;
8643 }
8644 if (b2_config & MDM_B2_DISABLE_MNP)
8645 {
8646 dlc[i] |= DLC_MODEMPROT_DISABLE_MNP_MNP5;
8647 }
8648 if (b2_config & MDM_B2_DISABLE_TRANS)
8649 {
8650 dlc[i] |= DLC_MODEMPROT_REQUIRE_PROTOCOL;
8651 }
8652 if (b2_config & MDM_B2_DISABLE_V42)
8653 {
8654 dlc[i] |= DLC_MODEMPROT_DISABLE_V42_DETECT;
8655 }
8656 if (b2_config & MDM_B2_DISABLE_COMP)
8657 {
8658 dlc[i] |= DLC_MODEMPROT_DISABLE_COMPRESSION;
8659 }
8660 i++;
8661 }
8662 }
8663 else
8664 {
8665 dlc[i++] = 3; /* Addr A */
8666 dlc[i++] = 1; /* Addr B */
8667 dlc[i++] = 7; /* modulo mode */
8668 dlc[i++] = 7; /* window size */
8669 dlc[i++] = 0; /* XID len Lo */
8670 dlc[i++] = 0; /* XID len Hi */
8671 dlc[i++] = DLC_MODEMPROT_DISABLE_V42_V42BIS |
8672 DLC_MODEMPROT_DISABLE_MNP_MNP5 |
8673 DLC_MODEMPROT_DISABLE_V42_DETECT |
8674 DLC_MODEMPROT_DISABLE_COMPRESSION;
8675 }
8676 dlc[0] = (byte)(i - 1);
8677 /* HexDump ("DLC", sizeof(dlc), &dlc[0]); */
8678 add_p(plci, DLC, dlc);
8679 return (0);
8680 }
8681
8682
8683 /*------------------------------------------------------------------*/
8684 /* send a request for the signaling entity */
8685 /*------------------------------------------------------------------*/
8686
8687 void sig_req(PLCI * plci, byte req, byte Id)
8688 {
8689 if(!plci) return;
8690 if(plci->adapter->adapter_disabled) return;
8691 dbug(1,dprintf("sig_req(%x)",req));
8692 if (req == REMOVE)
8693 plci->sig_remove_id = plci->Sig.Id;
8694 if(plci->req_in==plci->req_in_start) {
8695 plci->req_in +=2;
8696 plci->RBuffer[plci->req_in++] = 0;
8697 }
8698 PUT_WORD(&plci->RBuffer[plci->req_in_start], plci->req_in-plci->req_in_start-2);
8699 plci->RBuffer[plci->req_in++] = Id; /* sig/nl flag */
8700 plci->RBuffer[plci->req_in++] = req; /* request */
8701 plci->RBuffer[plci->req_in++] = 0; /* channel */
8702 plci->req_in_start = plci->req_in;
8703 }
8704
8705 /*------------------------------------------------------------------*/
8706 /* send a request for the network layer entity */
8707 /*------------------------------------------------------------------*/
8708
8709 void nl_req_ncci(PLCI * plci, byte req, byte ncci)
8710 {
8711 if(!plci) return;
8712 if(plci->adapter->adapter_disabled) return;
8713 dbug(1,dprintf("nl_req %02x %02x %02x", plci->Id, req, ncci));
8714 if (req == REMOVE)
8715 {
8716 plci->nl_remove_id = plci->NL.Id;
8717 ncci_remove (plci, 0, (byte)(ncci != 0));
8718 ncci = 0;
8719 }
8720 if(plci->req_in==plci->req_in_start) {
8721 plci->req_in +=2;
8722 plci->RBuffer[plci->req_in++] = 0;
8723 }
8724 PUT_WORD(&plci->RBuffer[plci->req_in_start], plci->req_in-plci->req_in_start-2);
8725 plci->RBuffer[plci->req_in++] = 1; /* sig/nl flag */
8726 plci->RBuffer[plci->req_in++] = req; /* request */
8727 plci->RBuffer[plci->req_in++] = plci->adapter->ncci_ch[ncci]; /* channel */
8728 plci->req_in_start = plci->req_in;
8729 }
8730
8731 void send_req(PLCI * plci)
8732 {
8733 ENTITY * e;
8734 word l;
8735 /* word i; */
8736
8737 if(!plci) return;
8738 if(plci->adapter->adapter_disabled) return;
8739 channel_xmit_xon (plci);
8740
8741 /* if nothing to do, return */
8742 if(plci->req_in==plci->req_out) return;
8743 dbug(1,dprintf("send_req(in=%d,out=%d)",plci->req_in,plci->req_out));
8744
8745 if(plci->nl_req || plci->sig_req) return;
8746
8747 l = GET_WORD(&plci->RBuffer[plci->req_out]);
8748 plci->req_out += 2;
8749 plci->XData[0].P = &plci->RBuffer[plci->req_out];
8750 plci->req_out += l;
8751 if(plci->RBuffer[plci->req_out]==1)
8752 {
8753 e = &plci->NL;
8754 plci->req_out++;
8755 e->Req = plci->nl_req = plci->RBuffer[plci->req_out++];
8756 e->ReqCh = plci->RBuffer[plci->req_out++];
8757 if(!(e->Id & 0x1f))
8758 {
8759 e->Id = NL_ID;
8760 plci->RBuffer[plci->req_out-4] = CAI;
8761 plci->RBuffer[plci->req_out-3] = 1;
8762 plci->RBuffer[plci->req_out-2] = (plci->Sig.Id==0xff) ? 0 : plci->Sig.Id;
8763 plci->RBuffer[plci->req_out-1] = 0;
8764 l+=3;
8765 plci->nl_global_req = plci->nl_req;
8766 }
8767 dbug(1,dprintf("%x:NLREQ(%x:%x:%x)",plci->adapter->Id,e->Id,e->Req,e->ReqCh));
8768 }
8769 else
8770 {
8771 e = &plci->Sig;
8772 if(plci->RBuffer[plci->req_out])
8773 e->Id = plci->RBuffer[plci->req_out];
8774 plci->req_out++;
8775 e->Req = plci->sig_req = plci->RBuffer[plci->req_out++];
8776 e->ReqCh = plci->RBuffer[plci->req_out++];
8777 if(!(e->Id & 0x1f))
8778 plci->sig_global_req = plci->sig_req;
8779 dbug(1,dprintf("%x:SIGREQ(%x:%x:%x)",plci->adapter->Id,e->Id,e->Req,e->ReqCh));
8780 }
8781 plci->XData[0].PLength = l;
8782 e->X = plci->XData;
8783 plci->adapter->request(e);
8784 dbug(1,dprintf("send_ok"));
8785 }
8786
8787 void send_data(PLCI * plci)
8788 {
8789 DIVA_CAPI_ADAPTER * a;
8790 DATA_B3_DESC * data;
8791 NCCI *ncci_ptr;
8792 word ncci;
8793
8794 if (!plci->nl_req && plci->ncci_ring_list)
8795 {
8796 a = plci->adapter;
8797 ncci = plci->ncci_ring_list;
8798 do
8799 {
8800 ncci = a->ncci_next[ncci];
8801 ncci_ptr = &(a->ncci[ncci]);
8802 if (!(a->ncci_ch[ncci]
8803 && (a->ch_flow_control[a->ncci_ch[ncci]] & N_OK_FC_PENDING)))
8804 {
8805 if (ncci_ptr->data_pending)
8806 {
8807 if ((a->ncci_state[ncci] == CONNECTED)
8808 || (a->ncci_state[ncci] == INC_ACT_PENDING)
8809 || (plci->send_disc == ncci))
8810 {
8811 data = &(ncci_ptr->DBuffer[ncci_ptr->data_out]);
8812 if ((plci->B2_prot == B2_V120_ASYNC)
8813 || (plci->B2_prot == B2_V120_ASYNC_V42BIS)
8814 || (plci->B2_prot == B2_V120_BIT_TRANSPARENT))
8815 {
8816 plci->NData[1].P = TransmitBufferGet (plci->appl, data->P);
8817 plci->NData[1].PLength = data->Length;
8818 if (data->Flags & 0x10)
8819 plci->NData[0].P = v120_break_header;
8820 else
8821 plci->NData[0].P = v120_default_header;
8822 plci->NData[0].PLength = 1 ;
8823 plci->NL.XNum = 2;
8824 plci->NL.Req = plci->nl_req = (byte)((data->Flags&0x07)<<4 |N_DATA);
8825 }
8826 else
8827 {
8828 plci->NData[0].P = TransmitBufferGet (plci->appl, data->P);
8829 plci->NData[0].PLength = data->Length;
8830 if (data->Flags & 0x10)
8831 plci->NL.Req = plci->nl_req = (byte)N_UDATA;
8832
8833 else if ((plci->B3_prot == B3_RTP) && (data->Flags & 0x01))
8834 plci->NL.Req = plci->nl_req = (byte)N_BDATA;
8835
8836 else
8837 plci->NL.Req = plci->nl_req = (byte)((data->Flags&0x07)<<4 |N_DATA);
8838 }
8839 plci->NL.X = plci->NData;
8840 plci->NL.ReqCh = a->ncci_ch[ncci];
8841 dbug(1,dprintf("%x:DREQ(%x:%x)",a->Id,plci->NL.Id,plci->NL.Req));
8842 plci->data_sent = true;
8843 plci->data_sent_ptr = data->P;
8844 a->request(&plci->NL);
8845 }
8846 else {
8847 cleanup_ncci_data (plci, ncci);
8848 }
8849 }
8850 else if (plci->send_disc == ncci)
8851 {
8852 /* dprintf("N_DISC"); */
8853 plci->NData[0].PLength = 0;
8854 plci->NL.ReqCh = a->ncci_ch[ncci];
8855 plci->NL.Req = plci->nl_req = N_DISC;
8856 a->request(&plci->NL);
8857 plci->command = _DISCONNECT_B3_R;
8858 plci->send_disc = 0;
8859 }
8860 }
8861 } while (!plci->nl_req && (ncci != plci->ncci_ring_list));
8862 plci->ncci_ring_list = ncci;
8863 }
8864 }
8865
8866 void listen_check(DIVA_CAPI_ADAPTER * a)
8867 {
8868 word i,j;
8869 PLCI * plci;
8870 byte activnotifiedcalls = 0;
8871
8872 dbug(1,dprintf("listen_check(%d,%d)",a->listen_active,a->max_listen));
8873 if (!remove_started && !a->adapter_disabled)
8874 {
8875 for(i=0;i<a->max_plci;i++)
8876 {
8877 plci = &(a->plci[i]);
8878 if(plci->notifiedcall) activnotifiedcalls++;
8879 }
8880 dbug(1,dprintf("listen_check(%d)",activnotifiedcalls));
8881
8882 for(i=a->listen_active; i < ((word)(a->max_listen+activnotifiedcalls)); i++) {
8883 if((j=get_plci(a))) {
8884 a->listen_active++;
8885 plci = &a->plci[j-1];
8886 plci->State = LISTENING;
8887
8888 add_p(plci,OAD,"\x01\xfd");
8889
8890 add_p(plci,KEY,"\x04\x43\x41\x32\x30");
8891
8892 add_p(plci,CAI,"\x01\xc0");
8893 add_p(plci,UID,"\x06\x43\x61\x70\x69\x32\x30");
8894 add_p(plci,LLI,"\x01\xc4"); /* support Dummy CR FAC + MWI + SpoofNotify */
8895 add_p(plci,SHIFT|6,NULL);
8896 add_p(plci,SIN,"\x02\x00\x00");
8897 plci->internal_command = LISTEN_SIG_ASSIGN_PEND; /* do indicate_req if OK */
8898 sig_req(plci,ASSIGN,DSIG_ID);
8899 send_req(plci);
8900 }
8901 }
8902 }
8903 }
8904
8905 /*------------------------------------------------------------------*/
8906 /* functions for all parameters sent in INDs */
8907 /*------------------------------------------------------------------*/
8908
8909 void IndParse(PLCI * plci, word * parms_id, byte ** parms, byte multiIEsize)
8910 {
8911 word ploc; /* points to current location within packet */
8912 byte w;
8913 byte wlen;
8914 byte codeset,lock;
8915 byte * in;
8916 word i;
8917 word code;
8918 word mIEindex = 0;
8919 ploc = 0;
8920 codeset = 0;
8921 lock = 0;
8922
8923 in = plci->Sig.RBuffer->P;
8924 for(i=0; i<parms_id[0]; i++) /* multiIE parms_id contains just the 1st */
8925 { /* element but parms array is larger */
8926 parms[i] = (byte *)"";
8927 }
8928 for(i=0; i<multiIEsize; i++)
8929 {
8930 parms[i] = (byte *)"";
8931 }
8932
8933 while(ploc<plci->Sig.RBuffer->length-1) {
8934
8935 /* read information element id and length */
8936 w = in[ploc];
8937
8938 if(w & 0x80) {
8939 /* w &=0xf0; removed, cannot detect congestion levels */
8940 /* upper 4 bit masked with w==SHIFT now */
8941 wlen = 0;
8942 }
8943 else {
8944 wlen = (byte)(in[ploc+1]+1);
8945 }
8946 /* check if length valid (not exceeding end of packet) */
8947 if((ploc+wlen) > 270) return ;
8948 if(lock & 0x80) lock &=0x7f;
8949 else codeset = lock;
8950
8951 if((w&0xf0)==SHIFT) {
8952 codeset = in[ploc];
8953 if(!(codeset & 0x08)) lock = (byte)(codeset & 7);
8954 codeset &=7;
8955 lock |=0x80;
8956 }
8957 else {
8958 if(w==ESC && wlen>=3) code = in[ploc+2] |0x800;
8959 else code = w;
8960 code |= (codeset<<8);
8961
8962 for(i=1; i<parms_id[0]+1 && parms_id[i]!=code; i++);
8963
8964 if(i<parms_id[0]+1) {
8965 if(!multiIEsize) { /* with multiIEs use next field index, */
8966 mIEindex = i-1; /* with normal IEs use same index like parms_id */
8967 }
8968
8969 parms[mIEindex] = &in[ploc+1];
8970 dbug(1,dprintf("mIE[%d]=0x%x",*parms[mIEindex],in[ploc]));
8971 if(parms_id[i]==OAD
8972 || parms_id[i]==CONN_NR
8973 || parms_id[i]==CAD) {
8974 if(in[ploc+2] &0x80) {
8975 in[ploc+0] = (byte)(in[ploc+1]+1);
8976 in[ploc+1] = (byte)(in[ploc+2] &0x7f);
8977 in[ploc+2] = 0x80;
8978 parms[mIEindex] = &in[ploc];
8979 }
8980 }
8981 mIEindex++; /* effects multiIEs only */
8982 }
8983 }
8984
8985 ploc +=(wlen+1);
8986 }
8987 return ;
8988 }
8989
8990 /*------------------------------------------------------------------*/
8991 /* try to match a cip from received BC and HLC */
8992 /*------------------------------------------------------------------*/
8993
8994 byte ie_compare(byte * ie1, byte * ie2)
8995 {
8996 word i;
8997 if(!ie1 || ! ie2) return false;
8998 if(!ie1[0]) return false;
8999 for(i=0;i<(word)(ie1[0]+1);i++) if(ie1[i]!=ie2[i]) return false;
9000 return true;
9001 }
9002
9003 word find_cip(DIVA_CAPI_ADAPTER * a, byte * bc, byte * hlc)
9004 {
9005 word i;
9006 word j;
9007
9008 for(i=9;i && !ie_compare(bc,cip_bc[i][a->u_law]);i--);
9009
9010 for(j=16;j<29 &&
9011 (!ie_compare(bc,cip_bc[j][a->u_law]) || !ie_compare(hlc,cip_hlc[j])); j++);
9012 if(j==29) return i;
9013 return j;
9014 }
9015
9016
9017 static byte AddInfo(byte **add_i,
9018 byte **fty_i,
9019 byte *esc_chi,
9020 byte *facility)
9021 {
9022 byte i;
9023 byte j;
9024 byte k;
9025 byte flen;
9026 byte len=0;
9027 /* facility is a nested structure */
9028 /* FTY can be more than once */
9029
9030 if(esc_chi[0] && !(esc_chi[esc_chi[0]])&0x7f )
9031 {
9032 add_i[0] = (byte *)"\x02\x02\x00"; /* use neither b nor d channel */
9033 }
9034
9035 else
9036 {
9037 add_i[0] = (byte *)"";
9038 }
9039 if(!fty_i[0][0])
9040 {
9041 add_i[3] = (byte *)"";
9042 }
9043 else
9044 { /* facility array found */
9045 for(i=0,j=1;i<MAX_MULTI_IE && fty_i[i][0];i++)
9046 {
9047 dbug(1,dprintf("AddIFac[%d]",fty_i[i][0]));
9048 len += fty_i[i][0];
9049 len += 2;
9050 flen=fty_i[i][0];
9051 facility[j++]=0x1c; /* copy fac IE */
9052 for(k=0;k<=flen;k++,j++)
9053 {
9054 facility[j]=fty_i[i][k];
9055 /* dbug(1,dprintf("%x ",facility[j])); */
9056 }
9057 }
9058 facility[0] = len;
9059 add_i[3] = facility;
9060 }
9061 /* dbug(1,dprintf("FacArrLen=%d ",len)); */
9062 len = add_i[0][0]+add_i[1][0]+add_i[2][0]+add_i[3][0];
9063 len += 4; /* calculate length of all */
9064 return(len);
9065 }
9066
9067 /*------------------------------------------------------------------*/
9068 /* voice and codec features */
9069 /*------------------------------------------------------------------*/
9070
9071 void SetVoiceChannel(PLCI *plci, byte *chi, DIVA_CAPI_ADAPTER * a)
9072 {
9073 byte voice_chi[] = "\x02\x18\x01";
9074 byte channel;
9075
9076 channel = chi[chi[0]]&0x3;
9077 dbug(1,dprintf("ExtDevON(Ch=0x%x)",channel));
9078 voice_chi[2] = (channel) ? channel : 1;
9079 add_p(plci,FTY,"\x02\x01\x07"); /* B On, default on 1 */
9080 add_p(plci,ESC,voice_chi); /* Channel */
9081 sig_req(plci,TEL_CTRL,0);
9082 send_req(plci);
9083 if(a->AdvSignalPLCI)
9084 {
9085 adv_voice_write_coefs (a->AdvSignalPLCI, ADV_VOICE_WRITE_ACTIVATION);
9086 }
9087 }
9088
9089 void VoiceChannelOff(PLCI *plci)
9090 {
9091 dbug(1,dprintf("ExtDevOFF"));
9092 add_p(plci,FTY,"\x02\x01\x08"); /* B Off */
9093 sig_req(plci,TEL_CTRL,0);
9094 send_req(plci);
9095 if(plci->adapter->AdvSignalPLCI)
9096 {
9097 adv_voice_clear_config (plci->adapter->AdvSignalPLCI);
9098 }
9099 }
9100
9101
9102 word AdvCodecSupport(DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, byte hook_listen)
9103 {
9104 word j;
9105 PLCI *splci;
9106
9107 /* check if hardware supports handset with hook states (adv.codec) */
9108 /* or if just a on board codec is supported */
9109 /* the advanced codec plci is just for internal use */
9110
9111 /* diva Pro with on-board codec: */
9112 if(a->profile.Global_Options & HANDSET)
9113 {
9114 /* new call, but hook states are already signalled */
9115 if(a->AdvCodecFLAG)
9116 {
9117 if(a->AdvSignalAppl!=appl || a->AdvSignalPLCI)
9118 {
9119 dbug(1,dprintf("AdvSigPlci=0x%x",a->AdvSignalPLCI));
9120 return 0x2001; /* codec in use by another application */
9121 }
9122 if(plci!=0)
9123 {
9124 a->AdvSignalPLCI = plci;
9125 plci->tel=ADV_VOICE;
9126 }
9127 return 0; /* adv codec still used */
9128 }
9129 if((j=get_plci(a)))
9130 {
9131 splci = &a->plci[j-1];
9132 splci->tel = CODEC_PERMANENT;
9133 /* hook_listen indicates if a facility_req with handset/hook support */
9134 /* was sent. Otherwise if just a call on an external device was made */
9135 /* the codec will be used but the hook info will be discarded (just */
9136 /* the external controller is in use */
9137 if(hook_listen) splci->State = ADVANCED_VOICE_SIG;
9138 else
9139 {
9140 splci->State = ADVANCED_VOICE_NOSIG;
9141 if(plci)
9142 {
9143 plci->spoofed_msg = SPOOFING_REQUIRED;
9144 }
9145 /* indicate D-ch connect if */
9146 } /* codec is connected OK */
9147 if(plci!=0)
9148 {
9149 a->AdvSignalPLCI = plci;
9150 plci->tel=ADV_VOICE;
9151 }
9152 a->AdvSignalAppl = appl;
9153 a->AdvCodecFLAG = true;
9154 a->AdvCodecPLCI = splci;
9155 add_p(splci,CAI,"\x01\x15");
9156 add_p(splci,LLI,"\x01\x00");
9157 add_p(splci,ESC,"\x02\x18\x00");
9158 add_p(splci,UID,"\x06\x43\x61\x70\x69\x32\x30");
9159 splci->internal_command = PERM_COD_ASSIGN;
9160 dbug(1,dprintf("Codec Assign"));
9161 sig_req(splci,ASSIGN,DSIG_ID);
9162 send_req(splci);
9163 }
9164 else
9165 {
9166 return 0x2001; /* wrong state, no more plcis */
9167 }
9168 }
9169 else if(a->profile.Global_Options & ON_BOARD_CODEC)
9170 {
9171 if(hook_listen) return 0x300B; /* Facility not supported */
9172 /* no hook with SCOM */
9173 if(plci!=0) plci->tel = CODEC;
9174 dbug(1,dprintf("S/SCOM codec"));
9175 /* first time we use the scom-s codec we must shut down the internal */
9176 /* handset application of the card. This can be done by an assign with */
9177 /* a cai with the 0x80 bit set. Assign return code is 'out of resource'*/
9178 if(!a->scom_appl_disable){
9179 if((j=get_plci(a))) {
9180 splci = &a->plci[j-1];
9181 add_p(splci,CAI,"\x01\x80");
9182 add_p(splci,UID,"\x06\x43\x61\x70\x69\x32\x30");
9183 sig_req(splci,ASSIGN,0xC0); /* 0xc0 is the TEL_ID */
9184 send_req(splci);
9185 a->scom_appl_disable = true;
9186 }
9187 else{
9188 return 0x2001; /* wrong state, no more plcis */
9189 }
9190 }
9191 }
9192 else return 0x300B; /* Facility not supported */
9193
9194 return 0;
9195 }
9196
9197
9198 void CodecIdCheck(DIVA_CAPI_ADAPTER *a, PLCI *plci)
9199 {
9200
9201 dbug(1,dprintf("CodecIdCheck"));
9202
9203 if(a->AdvSignalPLCI == plci)
9204 {
9205 dbug(1,dprintf("PLCI owns codec"));
9206 VoiceChannelOff(a->AdvCodecPLCI);
9207 if(a->AdvCodecPLCI->State == ADVANCED_VOICE_NOSIG)
9208 {
9209 dbug(1,dprintf("remove temp codec PLCI"));
9210 plci_remove(a->AdvCodecPLCI);
9211 a->AdvCodecFLAG = 0;
9212 a->AdvCodecPLCI = NULL;
9213 a->AdvSignalAppl = NULL;
9214 }
9215 a->AdvSignalPLCI = NULL;
9216 }
9217 }
9218
9219 /* -------------------------------------------------------------------
9220 Ask for physical address of card on PCI bus
9221 ------------------------------------------------------------------- */
9222 static void diva_ask_for_xdi_sdram_bar (DIVA_CAPI_ADAPTER * a,
9223 IDI_SYNC_REQ * preq) {
9224 a->sdram_bar = 0;
9225 if (diva_xdi_extended_features & DIVA_CAPI_XDI_PROVIDES_SDRAM_BAR) {
9226 ENTITY * e = (ENTITY *)preq;
9227
9228 e->user[0] = a->Id - 1;
9229 preq->xdi_sdram_bar.info.bar = 0;
9230 preq->xdi_sdram_bar.Req = 0;
9231 preq->xdi_sdram_bar.Rc = IDI_SYNC_REQ_XDI_GET_ADAPTER_SDRAM_BAR;
9232
9233 (*(a->request))(e);
9234
9235 a->sdram_bar = preq->xdi_sdram_bar.info.bar;
9236 dbug(3,dprintf("A(%d) SDRAM BAR = %08x", a->Id, a->sdram_bar));
9237 }
9238 }
9239
9240 /* -------------------------------------------------------------------
9241 Ask XDI about extended features
9242 ------------------------------------------------------------------- */
9243 static void diva_get_extended_adapter_features (DIVA_CAPI_ADAPTER * a) {
9244 IDI_SYNC_REQ * preq;
9245 char buffer[ ((sizeof(preq->xdi_extended_features)+4) > sizeof(ENTITY)) ? (sizeof(preq->xdi_extended_features)+4) : sizeof(ENTITY)];
9246
9247 char features[4];
9248 preq = (IDI_SYNC_REQ *)&buffer[0];
9249
9250 if (!diva_xdi_extended_features) {
9251 ENTITY * e = (ENTITY *)preq;
9252 diva_xdi_extended_features |= 0x80000000;
9253
9254 e->user[0] = a->Id - 1;
9255 preq->xdi_extended_features.Req = 0;
9256 preq->xdi_extended_features.Rc = IDI_SYNC_REQ_XDI_GET_EXTENDED_FEATURES;
9257 preq->xdi_extended_features.info.buffer_length_in_bytes = sizeof(features);
9258 preq->xdi_extended_features.info.features = &features[0];
9259
9260 (*(a->request))(e);
9261
9262 if (features[0] & DIVA_XDI_EXTENDED_FEATURES_VALID) {
9263 /*
9264 Check features located in the byte '0'
9265 */
9266 if (features[0] & DIVA_XDI_EXTENDED_FEATURE_CMA) {
9267 diva_xdi_extended_features |= DIVA_CAPI_USE_CMA;
9268 }
9269 if (features[0] & DIVA_XDI_EXTENDED_FEATURE_RX_DMA) {
9270 diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_RX_DMA;
9271 dbug(1,dprintf("XDI provides RxDMA"));
9272 }
9273 if (features[0] & DIVA_XDI_EXTENDED_FEATURE_SDRAM_BAR) {
9274 diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_SDRAM_BAR;
9275 }
9276 if (features[0] & DIVA_XDI_EXTENDED_FEATURE_NO_CANCEL_RC) {
9277 diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_NO_CANCEL;
9278 dbug(3,dprintf("XDI provides NO_CANCEL_RC feature"));
9279 }
9280
9281 }
9282 }
9283
9284 diva_ask_for_xdi_sdram_bar (a, preq);
9285 }
9286
9287 /*------------------------------------------------------------------*/
9288 /* automatic law */
9289 /*------------------------------------------------------------------*/
9290 /* called from OS specific part after init time to get the Law */
9291 /* a-law (Euro) and u-law (us,japan) use different BCs in the Setup message */
9292 void AutomaticLaw(DIVA_CAPI_ADAPTER *a)
9293 {
9294 word j;
9295 PLCI *splci;
9296
9297 if(a->automatic_law) {
9298 return;
9299 }
9300 if((j=get_plci(a))) {
9301 diva_get_extended_adapter_features (a);
9302 splci = &a->plci[j-1];
9303 a->automatic_lawPLCI = splci;
9304 a->automatic_law = 1;
9305 add_p(splci,CAI,"\x01\x80");
9306 add_p(splci,UID,"\x06\x43\x61\x70\x69\x32\x30");
9307 splci->internal_command = USELAW_REQ;
9308 splci->command = 0;
9309 splci->number = 0;
9310 sig_req(splci,ASSIGN,DSIG_ID);
9311 send_req(splci);
9312 }
9313 }
9314
9315 /* called from OS specific part if an application sends an Capi20Release */
9316 word CapiRelease(word Id)
9317 {
9318 word i, j, appls_found;
9319 PLCI *plci;
9320 APPL *this;
9321 DIVA_CAPI_ADAPTER *a;
9322
9323 if (!Id)
9324 {
9325 dbug(0,dprintf("A: CapiRelease(Id==0)"));
9326 return (_WRONG_APPL_ID);
9327 }
9328
9329 this = &application[Id-1]; /* get application pointer */
9330
9331 for(i=0,appls_found=0; i<max_appl; i++)
9332 {
9333 if(application[i].Id) /* an application has been found */
9334 {
9335 appls_found++;
9336 }
9337 }
9338
9339 for(i=0; i<max_adapter; i++) /* scan all adapters... */
9340 {
9341 a = &adapter[i];
9342 if (a->request)
9343 {
9344 a->Info_Mask[Id-1] = 0;
9345 a->CIP_Mask[Id-1] = 0;
9346 a->Notification_Mask[Id-1] = 0;
9347 a->codec_listen[Id-1] = NULL;
9348 a->requested_options_table[Id-1] = 0;
9349 for(j=0; j<a->max_plci; j++) /* and all PLCIs connected */
9350 { /* with this application */
9351 plci = &a->plci[j];
9352 if(plci->Id) /* if plci owns no application */
9353 { /* it may be not jet connected */
9354 if(plci->State==INC_CON_PENDING
9355 || plci->State==INC_CON_ALERT)
9356 {
9357 if(test_c_ind_mask_bit (plci, (word)(Id-1)))
9358 {
9359 clear_c_ind_mask_bit (plci, (word)(Id-1));
9360 if(c_ind_mask_empty (plci))
9361 {
9362 sig_req(plci,HANGUP,0);
9363 send_req(plci);
9364 plci->State = OUTG_DIS_PENDING;
9365 }
9366 }
9367 }
9368 if(test_c_ind_mask_bit (plci, (word)(Id-1)))
9369 {
9370 clear_c_ind_mask_bit (plci, (word)(Id-1));
9371 if(c_ind_mask_empty (plci))
9372 {
9373 if(!plci->appl)
9374 {
9375 plci_remove(plci);
9376 plci->State = IDLE;
9377 }
9378 }
9379 }
9380 if(plci->appl==this)
9381 {
9382 plci->appl = NULL;
9383 plci_remove(plci);
9384 plci->State = IDLE;
9385 }
9386 }
9387 }
9388 listen_check(a);
9389
9390 if(a->flag_dynamic_l1_down)
9391 {
9392 if(appls_found==1) /* last application does a capi release */
9393 {
9394 if((j=get_plci(a)))
9395 {
9396 plci = &a->plci[j-1];
9397 plci->command = 0;
9398 add_p(plci,OAD,"\x01\xfd");
9399 add_p(plci,CAI,"\x01\x80");
9400 add_p(plci,UID,"\x06\x43\x61\x70\x69\x32\x30");
9401 add_p(plci,SHIFT|6,NULL);
9402 add_p(plci,SIN,"\x02\x00\x00");
9403 plci->internal_command = REM_L1_SIG_ASSIGN_PEND;
9404 sig_req(plci,ASSIGN,DSIG_ID);
9405 add_p(plci,FTY,"\x02\xff\x06"); /* l1 down */
9406 sig_req(plci,SIG_CTRL,0);
9407 send_req(plci);
9408 }
9409 }
9410 }
9411 if(a->AdvSignalAppl==this)
9412 {
9413 this->NullCREnable = false;
9414 if (a->AdvCodecPLCI)
9415 {
9416 plci_remove(a->AdvCodecPLCI);
9417 a->AdvCodecPLCI->tel = 0;
9418 a->AdvCodecPLCI->adv_nl = 0;
9419 }
9420 a->AdvSignalAppl = NULL;
9421 a->AdvSignalPLCI = NULL;
9422 a->AdvCodecFLAG = 0;
9423 a->AdvCodecPLCI = NULL;
9424 }
9425 }
9426 }
9427
9428 this->Id = 0;
9429
9430 return GOOD;
9431 }
9432
9433 static word plci_remove_check(PLCI *plci)
9434 {
9435 if(!plci) return true;
9436 if(!plci->NL.Id && c_ind_mask_empty (plci))
9437 {
9438 if(plci->Sig.Id == 0xff)
9439 plci->Sig.Id = 0;
9440 if(!plci->Sig.Id)
9441 {
9442 dbug(1,dprintf("plci_remove_complete(%x)",plci->Id));
9443 dbug(1,dprintf("tel=0x%x,Sig=0x%x",plci->tel,plci->Sig.Id));
9444 if (plci->Id)
9445 {
9446 CodecIdCheck(plci->adapter, plci);
9447 clear_b1_config (plci);
9448 ncci_remove (plci, 0, false);
9449 plci_free_msg_in_queue (plci);
9450 channel_flow_control_remove (plci);
9451 plci->Id = 0;
9452 plci->State = IDLE;
9453 plci->channels = 0;
9454 plci->appl = NULL;
9455 plci->notifiedcall = 0;
9456 }
9457 listen_check(plci->adapter);
9458 return true;
9459 }
9460 }
9461 return false;
9462 }
9463
9464
9465 /*------------------------------------------------------------------*/
9466
9467 static byte plci_nl_busy (PLCI *plci)
9468 {
9469 /* only applicable for non-multiplexed protocols */
9470 return (plci->nl_req
9471 || (plci->ncci_ring_list
9472 && plci->adapter->ncci_ch[plci->ncci_ring_list]
9473 && (plci->adapter->ch_flow_control[plci->adapter->ncci_ch[plci->ncci_ring_list]] & N_OK_FC_PENDING)));
9474 }
9475
9476
9477 /*------------------------------------------------------------------*/
9478 /* DTMF facilities */
9479 /*------------------------------------------------------------------*/
9480
9481
9482 static struct
9483 {
9484 byte send_mask;
9485 byte listen_mask;
9486 byte character;
9487 byte code;
9488 } dtmf_digit_map[] =
9489 {
9490 { 0x01, 0x01, 0x23, DTMF_DIGIT_TONE_CODE_HASHMARK },
9491 { 0x01, 0x01, 0x2a, DTMF_DIGIT_TONE_CODE_STAR },
9492 { 0x01, 0x01, 0x30, DTMF_DIGIT_TONE_CODE_0 },
9493 { 0x01, 0x01, 0x31, DTMF_DIGIT_TONE_CODE_1 },
9494 { 0x01, 0x01, 0x32, DTMF_DIGIT_TONE_CODE_2 },
9495 { 0x01, 0x01, 0x33, DTMF_DIGIT_TONE_CODE_3 },
9496 { 0x01, 0x01, 0x34, DTMF_DIGIT_TONE_CODE_4 },
9497 { 0x01, 0x01, 0x35, DTMF_DIGIT_TONE_CODE_5 },
9498 { 0x01, 0x01, 0x36, DTMF_DIGIT_TONE_CODE_6 },
9499 { 0x01, 0x01, 0x37, DTMF_DIGIT_TONE_CODE_7 },
9500 { 0x01, 0x01, 0x38, DTMF_DIGIT_TONE_CODE_8 },
9501 { 0x01, 0x01, 0x39, DTMF_DIGIT_TONE_CODE_9 },
9502 { 0x01, 0x01, 0x41, DTMF_DIGIT_TONE_CODE_A },
9503 { 0x01, 0x01, 0x42, DTMF_DIGIT_TONE_CODE_B },
9504 { 0x01, 0x01, 0x43, DTMF_DIGIT_TONE_CODE_C },
9505 { 0x01, 0x01, 0x44, DTMF_DIGIT_TONE_CODE_D },
9506 { 0x01, 0x00, 0x61, DTMF_DIGIT_TONE_CODE_A },
9507 { 0x01, 0x00, 0x62, DTMF_DIGIT_TONE_CODE_B },
9508 { 0x01, 0x00, 0x63, DTMF_DIGIT_TONE_CODE_C },
9509 { 0x01, 0x00, 0x64, DTMF_DIGIT_TONE_CODE_D },
9510
9511 { 0x04, 0x04, 0x80, DTMF_SIGNAL_NO_TONE },
9512 { 0x00, 0x04, 0x81, DTMF_SIGNAL_UNIDENTIFIED_TONE },
9513 { 0x04, 0x04, 0x82, DTMF_SIGNAL_DIAL_TONE },
9514 { 0x04, 0x04, 0x83, DTMF_SIGNAL_PABX_INTERNAL_DIAL_TONE },
9515 { 0x04, 0x04, 0x84, DTMF_SIGNAL_SPECIAL_DIAL_TONE },
9516 { 0x04, 0x04, 0x85, DTMF_SIGNAL_SECOND_DIAL_TONE },
9517 { 0x04, 0x04, 0x86, DTMF_SIGNAL_RINGING_TONE },
9518 { 0x04, 0x04, 0x87, DTMF_SIGNAL_SPECIAL_RINGING_TONE },
9519 { 0x04, 0x04, 0x88, DTMF_SIGNAL_BUSY_TONE },
9520 { 0x04, 0x04, 0x89, DTMF_SIGNAL_CONGESTION_TONE },
9521 { 0x04, 0x04, 0x8a, DTMF_SIGNAL_SPECIAL_INFORMATION_TONE },
9522 { 0x04, 0x04, 0x8b, DTMF_SIGNAL_COMFORT_TONE },
9523 { 0x04, 0x04, 0x8c, DTMF_SIGNAL_HOLD_TONE },
9524 { 0x04, 0x04, 0x8d, DTMF_SIGNAL_RECORD_TONE },
9525 { 0x04, 0x04, 0x8e, DTMF_SIGNAL_CALLER_WAITING_TONE },
9526 { 0x04, 0x04, 0x8f, DTMF_SIGNAL_CALL_WAITING_TONE },
9527 { 0x04, 0x04, 0x90, DTMF_SIGNAL_PAY_TONE },
9528 { 0x04, 0x04, 0x91, DTMF_SIGNAL_POSITIVE_INDICATION_TONE },
9529 { 0x04, 0x04, 0x92, DTMF_SIGNAL_NEGATIVE_INDICATION_TONE },
9530 { 0x04, 0x04, 0x93, DTMF_SIGNAL_WARNING_TONE },
9531 { 0x04, 0x04, 0x94, DTMF_SIGNAL_INTRUSION_TONE },
9532 { 0x04, 0x04, 0x95, DTMF_SIGNAL_CALLING_CARD_SERVICE_TONE },
9533 { 0x04, 0x04, 0x96, DTMF_SIGNAL_PAYPHONE_RECOGNITION_TONE },
9534 { 0x04, 0x04, 0x97, DTMF_SIGNAL_CPE_ALERTING_SIGNAL },
9535 { 0x04, 0x04, 0x98, DTMF_SIGNAL_OFF_HOOK_WARNING_TONE },
9536 { 0x04, 0x04, 0xbf, DTMF_SIGNAL_INTERCEPT_TONE },
9537 { 0x04, 0x04, 0xc0, DTMF_SIGNAL_MODEM_CALLING_TONE },
9538 { 0x04, 0x04, 0xc1, DTMF_SIGNAL_FAX_CALLING_TONE },
9539 { 0x04, 0x04, 0xc2, DTMF_SIGNAL_ANSWER_TONE },
9540 { 0x04, 0x04, 0xc3, DTMF_SIGNAL_REVERSED_ANSWER_TONE },
9541 { 0x04, 0x04, 0xc4, DTMF_SIGNAL_ANSAM_TONE },
9542 { 0x04, 0x04, 0xc5, DTMF_SIGNAL_REVERSED_ANSAM_TONE },
9543 { 0x04, 0x04, 0xc6, DTMF_SIGNAL_BELL103_ANSWER_TONE },
9544 { 0x04, 0x04, 0xc7, DTMF_SIGNAL_FAX_FLAGS },
9545 { 0x04, 0x04, 0xc8, DTMF_SIGNAL_G2_FAX_GROUP_ID },
9546 { 0x00, 0x04, 0xc9, DTMF_SIGNAL_HUMAN_SPEECH },
9547 { 0x04, 0x04, 0xca, DTMF_SIGNAL_ANSWERING_MACHINE_390 },
9548 { 0x02, 0x02, 0xf1, DTMF_MF_DIGIT_TONE_CODE_1 },
9549 { 0x02, 0x02, 0xf2, DTMF_MF_DIGIT_TONE_CODE_2 },
9550 { 0x02, 0x02, 0xf3, DTMF_MF_DIGIT_TONE_CODE_3 },
9551 { 0x02, 0x02, 0xf4, DTMF_MF_DIGIT_TONE_CODE_4 },
9552 { 0x02, 0x02, 0xf5, DTMF_MF_DIGIT_TONE_CODE_5 },
9553 { 0x02, 0x02, 0xf6, DTMF_MF_DIGIT_TONE_CODE_6 },
9554 { 0x02, 0x02, 0xf7, DTMF_MF_DIGIT_TONE_CODE_7 },
9555 { 0x02, 0x02, 0xf8, DTMF_MF_DIGIT_TONE_CODE_8 },
9556 { 0x02, 0x02, 0xf9, DTMF_MF_DIGIT_TONE_CODE_9 },
9557 { 0x02, 0x02, 0xfa, DTMF_MF_DIGIT_TONE_CODE_0 },
9558 { 0x02, 0x02, 0xfb, DTMF_MF_DIGIT_TONE_CODE_K1 },
9559 { 0x02, 0x02, 0xfc, DTMF_MF_DIGIT_TONE_CODE_K2 },
9560 { 0x02, 0x02, 0xfd, DTMF_MF_DIGIT_TONE_CODE_KP },
9561 { 0x02, 0x02, 0xfe, DTMF_MF_DIGIT_TONE_CODE_S1 },
9562 { 0x02, 0x02, 0xff, DTMF_MF_DIGIT_TONE_CODE_ST },
9563
9564 };
9565
9566 #define DTMF_DIGIT_MAP_ENTRIES ARRAY_SIZE(dtmf_digit_map)
9567
9568
9569 static void dtmf_enable_receiver (PLCI *plci, byte enable_mask)
9570 {
9571 word min_digit_duration, min_gap_duration;
9572
9573 dbug (1, dprintf ("[%06lx] %s,%d: dtmf_enable_receiver %02x",
9574 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
9575 (char *)(FILE_), __LINE__, enable_mask));
9576
9577 if (enable_mask != 0)
9578 {
9579 min_digit_duration = (plci->dtmf_rec_pulse_ms == 0) ? 40 : plci->dtmf_rec_pulse_ms;
9580 min_gap_duration = (plci->dtmf_rec_pause_ms == 0) ? 40 : plci->dtmf_rec_pause_ms;
9581 plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_ENABLE_RECEIVER;
9582 PUT_WORD (&plci->internal_req_buffer[1], min_digit_duration);
9583 PUT_WORD (&plci->internal_req_buffer[3], min_gap_duration);
9584 plci->NData[0].PLength = 5;
9585
9586 PUT_WORD (&plci->internal_req_buffer[5], INTERNAL_IND_BUFFER_SIZE);
9587 plci->NData[0].PLength += 2;
9588 capidtmf_recv_enable (&(plci->capidtmf_state), min_digit_duration, min_gap_duration);
9589
9590 }
9591 else
9592 {
9593 plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_DISABLE_RECEIVER;
9594 plci->NData[0].PLength = 1;
9595
9596 capidtmf_recv_disable (&(plci->capidtmf_state));
9597
9598 }
9599 plci->NData[0].P = plci->internal_req_buffer;
9600 plci->NL.X = plci->NData;
9601 plci->NL.ReqCh = 0;
9602 plci->NL.Req = plci->nl_req = (byte) N_UDATA;
9603 plci->adapter->request (&plci->NL);
9604 }
9605
9606
9607 static void dtmf_send_digits (PLCI *plci, byte *digit_buffer, word digit_count)
9608 {
9609 word w, i;
9610
9611 dbug (1, dprintf ("[%06lx] %s,%d: dtmf_send_digits %d",
9612 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
9613 (char *)(FILE_), __LINE__, digit_count));
9614
9615 plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_SEND_DIGITS;
9616 w = (plci->dtmf_send_pulse_ms == 0) ? 40 : plci->dtmf_send_pulse_ms;
9617 PUT_WORD (&plci->internal_req_buffer[1], w);
9618 w = (plci->dtmf_send_pause_ms == 0) ? 40 : plci->dtmf_send_pause_ms;
9619 PUT_WORD (&plci->internal_req_buffer[3], w);
9620 for (i = 0; i < digit_count; i++)
9621 {
9622 w = 0;
9623 while ((w < DTMF_DIGIT_MAP_ENTRIES)
9624 && (digit_buffer[i] != dtmf_digit_map[w].character))
9625 {
9626 w++;
9627 }
9628 plci->internal_req_buffer[5+i] = (w < DTMF_DIGIT_MAP_ENTRIES) ?
9629 dtmf_digit_map[w].code : DTMF_DIGIT_TONE_CODE_STAR;
9630 }
9631 plci->NData[0].PLength = 5 + digit_count;
9632 plci->NData[0].P = plci->internal_req_buffer;
9633 plci->NL.X = plci->NData;
9634 plci->NL.ReqCh = 0;
9635 plci->NL.Req = plci->nl_req = (byte) N_UDATA;
9636 plci->adapter->request (&plci->NL);
9637 }
9638
9639
9640 static void dtmf_rec_clear_config (PLCI *plci)
9641 {
9642
9643 dbug (1, dprintf ("[%06lx] %s,%d: dtmf_rec_clear_config",
9644 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
9645 (char *)(FILE_), __LINE__));
9646
9647 plci->dtmf_rec_active = 0;
9648 plci->dtmf_rec_pulse_ms = 0;
9649 plci->dtmf_rec_pause_ms = 0;
9650
9651 capidtmf_init (&(plci->capidtmf_state), plci->adapter->u_law);
9652
9653 }
9654
9655
9656 static void dtmf_send_clear_config (PLCI *plci)
9657 {
9658
9659 dbug (1, dprintf ("[%06lx] %s,%d: dtmf_send_clear_config",
9660 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
9661 (char *)(FILE_), __LINE__));
9662
9663 plci->dtmf_send_requests = 0;
9664 plci->dtmf_send_pulse_ms = 0;
9665 plci->dtmf_send_pause_ms = 0;
9666 }
9667
9668
9669 static void dtmf_prepare_switch (dword Id, PLCI *plci)
9670 {
9671
9672 dbug (1, dprintf ("[%06lx] %s,%d: dtmf_prepare_switch",
9673 UnMapId (Id), (char *)(FILE_), __LINE__));
9674
9675 while (plci->dtmf_send_requests != 0)
9676 dtmf_confirmation (Id, plci);
9677 }
9678
9679
9680 static word dtmf_save_config (dword Id, PLCI *plci, byte Rc)
9681 {
9682
9683 dbug (1, dprintf ("[%06lx] %s,%d: dtmf_save_config %02x %d",
9684 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
9685
9686 return (GOOD);
9687 }
9688
9689
9690 static word dtmf_restore_config (dword Id, PLCI *plci, byte Rc)
9691 {
9692 word Info;
9693
9694 dbug (1, dprintf ("[%06lx] %s,%d: dtmf_restore_config %02x %d",
9695 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
9696
9697 Info = GOOD;
9698 if (plci->B1_facilities & B1_FACILITY_DTMFR)
9699 {
9700 switch (plci->adjust_b_state)
9701 {
9702 case ADJUST_B_RESTORE_DTMF_1:
9703 plci->internal_command = plci->adjust_b_command;
9704 if (plci_nl_busy (plci))
9705 {
9706 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
9707 break;
9708 }
9709 dtmf_enable_receiver (plci, plci->dtmf_rec_active);
9710 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_2;
9711 break;
9712 case ADJUST_B_RESTORE_DTMF_2:
9713 if ((Rc != OK) && (Rc != OK_FC))
9714 {
9715 dbug (1, dprintf ("[%06lx] %s,%d: Reenable DTMF receiver failed %02x",
9716 UnMapId (Id), (char *)(FILE_), __LINE__, Rc));
9717 Info = _WRONG_STATE;
9718 break;
9719 }
9720 break;
9721 }
9722 }
9723 return (Info);
9724 }
9725
9726
9727 static void dtmf_command (dword Id, PLCI *plci, byte Rc)
9728 {
9729 word internal_command, Info;
9730 byte mask;
9731 byte result[4];
9732
9733 dbug (1, dprintf ("[%06lx] %s,%d: dtmf_command %02x %04x %04x %d %d %d %d",
9734 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command,
9735 plci->dtmf_cmd, plci->dtmf_rec_pulse_ms, plci->dtmf_rec_pause_ms,
9736 plci->dtmf_send_pulse_ms, plci->dtmf_send_pause_ms));
9737
9738 Info = GOOD;
9739 result[0] = 2;
9740 PUT_WORD (&result[1], DTMF_SUCCESS);
9741 internal_command = plci->internal_command;
9742 plci->internal_command = 0;
9743 mask = 0x01;
9744 switch (plci->dtmf_cmd)
9745 {
9746
9747 case DTMF_LISTEN_TONE_START:
9748 mask <<= 1;
9749 case DTMF_LISTEN_MF_START:
9750 mask <<= 1;
9751
9752 case DTMF_LISTEN_START:
9753 switch (internal_command)
9754 {
9755 default:
9756 adjust_b1_resource (Id, plci, NULL, (word)(plci->B1_facilities |
9757 B1_FACILITY_DTMFR), DTMF_COMMAND_1);
9758 case DTMF_COMMAND_1:
9759 if (adjust_b_process (Id, plci, Rc) != GOOD)
9760 {
9761 dbug (1, dprintf ("[%06lx] %s,%d: Load DTMF failed",
9762 UnMapId (Id), (char *)(FILE_), __LINE__));
9763 Info = _FACILITY_NOT_SUPPORTED;
9764 break;
9765 }
9766 if (plci->internal_command)
9767 return;
9768 case DTMF_COMMAND_2:
9769 if (plci_nl_busy (plci))
9770 {
9771 plci->internal_command = DTMF_COMMAND_2;
9772 return;
9773 }
9774 plci->internal_command = DTMF_COMMAND_3;
9775 dtmf_enable_receiver (plci, (byte)(plci->dtmf_rec_active | mask));
9776 return;
9777 case DTMF_COMMAND_3:
9778 if ((Rc != OK) && (Rc != OK_FC))
9779 {
9780 dbug (1, dprintf ("[%06lx] %s,%d: Enable DTMF receiver failed %02x",
9781 UnMapId (Id), (char *)(FILE_), __LINE__, Rc));
9782 Info = _FACILITY_NOT_SUPPORTED;
9783 break;
9784 }
9785
9786 plci->tone_last_indication_code = DTMF_SIGNAL_NO_TONE;
9787
9788 plci->dtmf_rec_active |= mask;
9789 break;
9790 }
9791 break;
9792
9793
9794 case DTMF_LISTEN_TONE_STOP:
9795 mask <<= 1;
9796 case DTMF_LISTEN_MF_STOP:
9797 mask <<= 1;
9798
9799 case DTMF_LISTEN_STOP:
9800 switch (internal_command)
9801 {
9802 default:
9803 plci->dtmf_rec_active &= ~mask;
9804 if (plci->dtmf_rec_active)
9805 break;
9806 /*
9807 case DTMF_COMMAND_1:
9808 if (plci->dtmf_rec_active)
9809 {
9810 if (plci_nl_busy (plci))
9811 {
9812 plci->internal_command = DTMF_COMMAND_1;
9813 return;
9814 }
9815 plci->dtmf_rec_active &= ~mask;
9816 plci->internal_command = DTMF_COMMAND_2;
9817 dtmf_enable_receiver (plci, false);
9818 return;
9819 }
9820 Rc = OK;
9821 case DTMF_COMMAND_2:
9822 if ((Rc != OK) && (Rc != OK_FC))
9823 {
9824 dbug (1, dprintf ("[%06lx] %s,%d: Disable DTMF receiver failed %02x",
9825 UnMapId (Id), (char far *)(FILE_), __LINE__, Rc));
9826 Info = _FACILITY_NOT_SUPPORTED;
9827 break;
9828 }
9829 */
9830 adjust_b1_resource (Id, plci, NULL, (word)(plci->B1_facilities &
9831 ~(B1_FACILITY_DTMFX | B1_FACILITY_DTMFR)), DTMF_COMMAND_3);
9832 case DTMF_COMMAND_3:
9833 if (adjust_b_process (Id, plci, Rc) != GOOD)
9834 {
9835 dbug (1, dprintf ("[%06lx] %s,%d: Unload DTMF failed",
9836 UnMapId (Id), (char *)(FILE_), __LINE__));
9837 Info = _FACILITY_NOT_SUPPORTED;
9838 break;
9839 }
9840 if (plci->internal_command)
9841 return;
9842 break;
9843 }
9844 break;
9845
9846
9847 case DTMF_SEND_TONE:
9848 mask <<= 1;
9849 case DTMF_SEND_MF:
9850 mask <<= 1;
9851
9852 case DTMF_DIGITS_SEND:
9853 switch (internal_command)
9854 {
9855 default:
9856 adjust_b1_resource (Id, plci, NULL, (word)(plci->B1_facilities |
9857 ((plci->dtmf_parameter_length != 0) ? B1_FACILITY_DTMFX | B1_FACILITY_DTMFR : B1_FACILITY_DTMFX)),
9858 DTMF_COMMAND_1);
9859 case DTMF_COMMAND_1:
9860 if (adjust_b_process (Id, plci, Rc) != GOOD)
9861 {
9862 dbug (1, dprintf ("[%06lx] %s,%d: Load DTMF failed",
9863 UnMapId (Id), (char *)(FILE_), __LINE__));
9864 Info = _FACILITY_NOT_SUPPORTED;
9865 break;
9866 }
9867 if (plci->internal_command)
9868 return;
9869 case DTMF_COMMAND_2:
9870 if (plci_nl_busy (plci))
9871 {
9872 plci->internal_command = DTMF_COMMAND_2;
9873 return;
9874 }
9875 plci->dtmf_msg_number_queue[(plci->dtmf_send_requests)++] = plci->number;
9876 plci->internal_command = DTMF_COMMAND_3;
9877 dtmf_send_digits (plci, &plci->saved_msg.parms[3].info[1], plci->saved_msg.parms[3].length);
9878 return;
9879 case DTMF_COMMAND_3:
9880 if ((Rc != OK) && (Rc != OK_FC))
9881 {
9882 dbug (1, dprintf ("[%06lx] %s,%d: Send DTMF digits failed %02x",
9883 UnMapId (Id), (char *)(FILE_), __LINE__, Rc));
9884 if (plci->dtmf_send_requests != 0)
9885 (plci->dtmf_send_requests)--;
9886 Info = _FACILITY_NOT_SUPPORTED;
9887 break;
9888 }
9889 return;
9890 }
9891 break;
9892 }
9893 sendf (plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->number,
9894 "wws", Info, SELECTOR_DTMF, result);
9895 }
9896
9897
9898 static byte dtmf_request (dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg)
9899 {
9900 word Info;
9901 word i, j;
9902 byte mask;
9903 API_PARSE dtmf_parms[5];
9904 byte result[40];
9905
9906 dbug (1, dprintf ("[%06lx] %s,%d: dtmf_request",
9907 UnMapId (Id), (char *)(FILE_), __LINE__));
9908
9909 Info = GOOD;
9910 result[0] = 2;
9911 PUT_WORD (&result[1], DTMF_SUCCESS);
9912 if (!(a->profile.Global_Options & GL_DTMF_SUPPORTED))
9913 {
9914 dbug (1, dprintf ("[%06lx] %s,%d: Facility not supported",
9915 UnMapId (Id), (char *)(FILE_), __LINE__));
9916 Info = _FACILITY_NOT_SUPPORTED;
9917 }
9918 else if (api_parse (&msg[1].info[1], msg[1].length, "w", dtmf_parms))
9919 {
9920 dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
9921 UnMapId (Id), (char *)(FILE_), __LINE__));
9922 Info = _WRONG_MESSAGE_FORMAT;
9923 }
9924
9925 else if ((GET_WORD (dtmf_parms[0].info) == DTMF_GET_SUPPORTED_DETECT_CODES)
9926 || (GET_WORD (dtmf_parms[0].info) == DTMF_GET_SUPPORTED_SEND_CODES))
9927 {
9928 if (!((a->requested_options_table[appl->Id-1])
9929 & (1L << PRIVATE_DTMF_TONE)))
9930 {
9931 dbug (1, dprintf ("[%06lx] %s,%d: DTMF unknown request %04x",
9932 UnMapId (Id), (char *)(FILE_), __LINE__, GET_WORD (dtmf_parms[0].info)));
9933 PUT_WORD (&result[1], DTMF_UNKNOWN_REQUEST);
9934 }
9935 else
9936 {
9937 for (i = 0; i < 32; i++)
9938 result[4 + i] = 0;
9939 if (GET_WORD (dtmf_parms[0].info) == DTMF_GET_SUPPORTED_DETECT_CODES)
9940 {
9941 for (i = 0; i < DTMF_DIGIT_MAP_ENTRIES; i++)
9942 {
9943 if (dtmf_digit_map[i].listen_mask != 0)
9944 result[4 + (dtmf_digit_map[i].character >> 3)] |= (1 << (dtmf_digit_map[i].character & 0x7));
9945 }
9946 }
9947 else
9948 {
9949 for (i = 0; i < DTMF_DIGIT_MAP_ENTRIES; i++)
9950 {
9951 if (dtmf_digit_map[i].send_mask != 0)
9952 result[4 + (dtmf_digit_map[i].character >> 3)] |= (1 << (dtmf_digit_map[i].character & 0x7));
9953 }
9954 }
9955 result[0] = 3 + 32;
9956 result[3] = 32;
9957 }
9958 }
9959
9960 else if (plci == NULL)
9961 {
9962 dbug (1, dprintf ("[%06lx] %s,%d: Wrong PLCI",
9963 UnMapId (Id), (char *)(FILE_), __LINE__));
9964 Info = _WRONG_IDENTIFIER;
9965 }
9966 else
9967 {
9968 if (!plci->State
9969 || !plci->NL.Id || plci->nl_remove_id)
9970 {
9971 dbug (1, dprintf ("[%06lx] %s,%d: Wrong state",
9972 UnMapId (Id), (char *)(FILE_), __LINE__));
9973 Info = _WRONG_STATE;
9974 }
9975 else
9976 {
9977 plci->command = 0;
9978 plci->dtmf_cmd = GET_WORD (dtmf_parms[0].info);
9979 mask = 0x01;
9980 switch (plci->dtmf_cmd)
9981 {
9982
9983 case DTMF_LISTEN_TONE_START:
9984 case DTMF_LISTEN_TONE_STOP:
9985 mask <<= 1;
9986 case DTMF_LISTEN_MF_START:
9987 case DTMF_LISTEN_MF_STOP:
9988 mask <<= 1;
9989 if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[appl->Id-1])
9990 & (1L << PRIVATE_DTMF_TONE)))
9991 {
9992 dbug (1, dprintf ("[%06lx] %s,%d: DTMF unknown request %04x",
9993 UnMapId (Id), (char *)(FILE_), __LINE__, GET_WORD (dtmf_parms[0].info)));
9994 PUT_WORD (&result[1], DTMF_UNKNOWN_REQUEST);
9995 break;
9996 }
9997
9998 case DTMF_LISTEN_START:
9999 case DTMF_LISTEN_STOP:
10000 if (!(a->manufacturer_features & MANUFACTURER_FEATURE_HARDDTMF)
10001 && !(a->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE))
10002 {
10003 dbug (1, dprintf ("[%06lx] %s,%d: Facility not supported",
10004 UnMapId (Id), (char *)(FILE_), __LINE__));
10005 Info = _FACILITY_NOT_SUPPORTED;
10006 break;
10007 }
10008 if (mask & DTMF_LISTEN_ACTIVE_FLAG)
10009 {
10010 if (api_parse (&msg[1].info[1], msg[1].length, "wwws", dtmf_parms))
10011 {
10012 plci->dtmf_rec_pulse_ms = 0;
10013 plci->dtmf_rec_pause_ms = 0;
10014 }
10015 else
10016 {
10017 plci->dtmf_rec_pulse_ms = GET_WORD (dtmf_parms[1].info);
10018 plci->dtmf_rec_pause_ms = GET_WORD (dtmf_parms[2].info);
10019 }
10020 }
10021 start_internal_command (Id, plci, dtmf_command);
10022 return (false);
10023
10024
10025 case DTMF_SEND_TONE:
10026 mask <<= 1;
10027 case DTMF_SEND_MF:
10028 mask <<= 1;
10029 if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[appl->Id-1])
10030 & (1L << PRIVATE_DTMF_TONE)))
10031 {
10032 dbug (1, dprintf ("[%06lx] %s,%d: DTMF unknown request %04x",
10033 UnMapId (Id), (char *)(FILE_), __LINE__, GET_WORD (dtmf_parms[0].info)));
10034 PUT_WORD (&result[1], DTMF_UNKNOWN_REQUEST);
10035 break;
10036 }
10037
10038 case DTMF_DIGITS_SEND:
10039 if (api_parse (&msg[1].info[1], msg[1].length, "wwws", dtmf_parms))
10040 {
10041 dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
10042 UnMapId (Id), (char *)(FILE_), __LINE__));
10043 Info = _WRONG_MESSAGE_FORMAT;
10044 break;
10045 }
10046 if (mask & DTMF_LISTEN_ACTIVE_FLAG)
10047 {
10048 plci->dtmf_send_pulse_ms = GET_WORD (dtmf_parms[1].info);
10049 plci->dtmf_send_pause_ms = GET_WORD (dtmf_parms[2].info);
10050 }
10051 i = 0;
10052 j = 0;
10053 while ((i < dtmf_parms[3].length) && (j < DTMF_DIGIT_MAP_ENTRIES))
10054 {
10055 j = 0;
10056 while ((j < DTMF_DIGIT_MAP_ENTRIES)
10057 && ((dtmf_parms[3].info[i+1] != dtmf_digit_map[j].character)
10058 || ((dtmf_digit_map[j].send_mask & mask) == 0)))
10059 {
10060 j++;
10061 }
10062 i++;
10063 }
10064 if (j == DTMF_DIGIT_MAP_ENTRIES)
10065 {
10066 dbug (1, dprintf ("[%06lx] %s,%d: Incorrect DTMF digit %02x",
10067 UnMapId (Id), (char *)(FILE_), __LINE__, dtmf_parms[3].info[i]));
10068 PUT_WORD (&result[1], DTMF_INCORRECT_DIGIT);
10069 break;
10070 }
10071 if (plci->dtmf_send_requests >= ARRAY_SIZE(plci->dtmf_msg_number_queue))
10072 {
10073 dbug (1, dprintf ("[%06lx] %s,%d: DTMF request overrun",
10074 UnMapId (Id), (char *)(FILE_), __LINE__));
10075 Info = _WRONG_STATE;
10076 break;
10077 }
10078 api_save_msg (dtmf_parms, "wwws", &plci->saved_msg);
10079 start_internal_command (Id, plci, dtmf_command);
10080 return (false);
10081
10082 default:
10083 dbug (1, dprintf ("[%06lx] %s,%d: DTMF unknown request %04x",
10084 UnMapId (Id), (char *)(FILE_), __LINE__, plci->dtmf_cmd));
10085 PUT_WORD (&result[1], DTMF_UNKNOWN_REQUEST);
10086 }
10087 }
10088 }
10089 sendf (appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
10090 "wws", Info, SELECTOR_DTMF, result);
10091 return (false);
10092 }
10093
10094
10095 static void dtmf_confirmation (dword Id, PLCI *plci)
10096 {
10097 word Info;
10098 word i;
10099 byte result[4];
10100
10101 dbug (1, dprintf ("[%06lx] %s,%d: dtmf_confirmation",
10102 UnMapId (Id), (char *)(FILE_), __LINE__));
10103
10104 Info = GOOD;
10105 result[0] = 2;
10106 PUT_WORD (&result[1], DTMF_SUCCESS);
10107 if (plci->dtmf_send_requests != 0)
10108 {
10109 sendf (plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->dtmf_msg_number_queue[0],
10110 "wws", GOOD, SELECTOR_DTMF, result);
10111 (plci->dtmf_send_requests)--;
10112 for (i = 0; i < plci->dtmf_send_requests; i++)
10113 plci->dtmf_msg_number_queue[i] = plci->dtmf_msg_number_queue[i+1];
10114 }
10115 }
10116
10117
10118 static void dtmf_indication (dword Id, PLCI *plci, byte *msg, word length)
10119 {
10120 word i, j, n;
10121
10122 dbug (1, dprintf ("[%06lx] %s,%d: dtmf_indication",
10123 UnMapId (Id), (char *)(FILE_), __LINE__));
10124
10125 n = 0;
10126 for (i = 1; i < length; i++)
10127 {
10128 j = 0;
10129 while ((j < DTMF_DIGIT_MAP_ENTRIES)
10130 && ((msg[i] != dtmf_digit_map[j].code)
10131 || ((dtmf_digit_map[j].listen_mask & plci->dtmf_rec_active) == 0)))
10132 {
10133 j++;
10134 }
10135 if (j < DTMF_DIGIT_MAP_ENTRIES)
10136 {
10137
10138 if ((dtmf_digit_map[j].listen_mask & DTMF_TONE_LISTEN_ACTIVE_FLAG)
10139 && (plci->tone_last_indication_code == DTMF_SIGNAL_NO_TONE)
10140 && (dtmf_digit_map[j].character != DTMF_SIGNAL_UNIDENTIFIED_TONE))
10141 {
10142 if (n + 1 == i)
10143 {
10144 for (i = length; i > n + 1; i--)
10145 msg[i] = msg[i - 1];
10146 length++;
10147 i++;
10148 }
10149 msg[++n] = DTMF_SIGNAL_UNIDENTIFIED_TONE;
10150 }
10151 plci->tone_last_indication_code = dtmf_digit_map[j].character;
10152
10153 msg[++n] = dtmf_digit_map[j].character;
10154 }
10155 }
10156 if (n != 0)
10157 {
10158 msg[0] = (byte) n;
10159 sendf (plci->appl, _FACILITY_I, Id & 0xffffL, 0, "wS", SELECTOR_DTMF, msg);
10160 }
10161 }
10162
10163
10164 /*------------------------------------------------------------------*/
10165 /* DTMF parameters */
10166 /*------------------------------------------------------------------*/
10167
10168 static void dtmf_parameter_write (PLCI *plci)
10169 {
10170 word i;
10171 byte parameter_buffer[DTMF_PARAMETER_BUFFER_SIZE + 2];
10172
10173 dbug (1, dprintf ("[%06lx] %s,%d: dtmf_parameter_write",
10174 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
10175 (char *)(FILE_), __LINE__));
10176
10177 parameter_buffer[0] = plci->dtmf_parameter_length + 1;
10178 parameter_buffer[1] = DSP_CTRL_SET_DTMF_PARAMETERS;
10179 for (i = 0; i < plci->dtmf_parameter_length; i++)
10180 parameter_buffer[2+i] = plci->dtmf_parameter_buffer[i];
10181 add_p (plci, FTY, parameter_buffer);
10182 sig_req (plci, TEL_CTRL, 0);
10183 send_req (plci);
10184 }
10185
10186
10187 static void dtmf_parameter_clear_config (PLCI *plci)
10188 {
10189
10190 dbug (1, dprintf ("[%06lx] %s,%d: dtmf_parameter_clear_config",
10191 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
10192 (char *)(FILE_), __LINE__));
10193
10194 plci->dtmf_parameter_length = 0;
10195 }
10196
10197
10198 static void dtmf_parameter_prepare_switch (dword Id, PLCI *plci)
10199 {
10200
10201 dbug (1, dprintf ("[%06lx] %s,%d: dtmf_parameter_prepare_switch",
10202 UnMapId (Id), (char *)(FILE_), __LINE__));
10203
10204 }
10205
10206
10207 static word dtmf_parameter_save_config (dword Id, PLCI *plci, byte Rc)
10208 {
10209
10210 dbug (1, dprintf ("[%06lx] %s,%d: dtmf_parameter_save_config %02x %d",
10211 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
10212
10213 return (GOOD);
10214 }
10215
10216
10217 static word dtmf_parameter_restore_config (dword Id, PLCI *plci, byte Rc)
10218 {
10219 word Info;
10220
10221 dbug (1, dprintf ("[%06lx] %s,%d: dtmf_parameter_restore_config %02x %d",
10222 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
10223
10224 Info = GOOD;
10225 if ((plci->B1_facilities & B1_FACILITY_DTMFR)
10226 && (plci->dtmf_parameter_length != 0))
10227 {
10228 switch (plci->adjust_b_state)
10229 {
10230 case ADJUST_B_RESTORE_DTMF_PARAMETER_1:
10231 plci->internal_command = plci->adjust_b_command;
10232 if (plci->sig_req)
10233 {
10234 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_1;
10235 break;
10236 }
10237 dtmf_parameter_write (plci);
10238 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_2;
10239 break;
10240 case ADJUST_B_RESTORE_DTMF_PARAMETER_2:
10241 if ((Rc != OK) && (Rc != OK_FC))
10242 {
10243 dbug (1, dprintf ("[%06lx] %s,%d: Restore DTMF parameters failed %02x",
10244 UnMapId (Id), (char *)(FILE_), __LINE__, Rc));
10245 Info = _WRONG_STATE;
10246 break;
10247 }
10248 break;
10249 }
10250 }
10251 return (Info);
10252 }
10253
10254
10255 /*------------------------------------------------------------------*/
10256 /* Line interconnect facilities */
10257 /*------------------------------------------------------------------*/
10258
10259
10260 LI_CONFIG *li_config_table;
10261 word li_total_channels;
10262
10263
10264 /*------------------------------------------------------------------*/
10265 /* translate a CHI information element to a channel number */
10266 /* returns 0xff - any channel */
10267 /* 0xfe - chi wrong coding */
10268 /* 0xfd - D-channel */
10269 /* 0x00 - no channel */
10270 /* else channel number / PRI: timeslot */
10271 /* if channels is provided we accept more than one channel. */
10272 /*------------------------------------------------------------------*/
10273
10274 static byte chi_to_channel (byte *chi, dword *pchannelmap)
10275 {
10276 int p;
10277 int i;
10278 dword map;
10279 byte excl;
10280 byte ofs;
10281 byte ch;
10282
10283 if (pchannelmap) *pchannelmap = 0;
10284 if(!chi[0]) return 0xff;
10285 excl = 0;
10286
10287 if(chi[1] & 0x20) {
10288 if(chi[0]==1 && chi[1]==0xac) return 0xfd; /* exclusive d-channel */
10289 for(i=1; i<chi[0] && !(chi[i] &0x80); i++);
10290 if(i==chi[0] || !(chi[i] &0x80)) return 0xfe;
10291 if((chi[1] |0xc8)!=0xe9) return 0xfe;
10292 if(chi[1] &0x08) excl = 0x40;
10293
10294 /* int. id present */
10295 if(chi[1] &0x40) {
10296 p=i+1;
10297 for(i=p; i<chi[0] && !(chi[i] &0x80); i++);
10298 if(i==chi[0] || !(chi[i] &0x80)) return 0xfe;
10299 }
10300
10301 /* coding standard, Number/Map, Channel Type */
10302 p=i+1;
10303 for(i=p; i<chi[0] && !(chi[i] &0x80); i++);
10304 if(i==chi[0] || !(chi[i] &0x80)) return 0xfe;
10305 if((chi[p]|0xd0)!=0xd3) return 0xfe;
10306
10307 /* Number/Map */
10308 if(chi[p] &0x10) {
10309
10310 /* map */
10311 if((chi[0]-p)==4) ofs = 0;
10312 else if((chi[0]-p)==3) ofs = 1;
10313 else return 0xfe;
10314 ch = 0;
10315 map = 0;
10316 for(i=0; i<4 && p<chi[0]; i++) {
10317 p++;
10318 ch += 8;
10319 map <<= 8;
10320 if(chi[p]) {
10321 for (ch=0; !(chi[p] & (1 << ch)); ch++);
10322 map |= chi[p];
10323 }
10324 }
10325 ch += ofs;
10326 map <<= ofs;
10327 }
10328 else {
10329
10330 /* number */
10331 p=i+1;
10332 ch = chi[p] &0x3f;
10333 if(pchannelmap) {
10334 if((byte)(chi[0]-p)>30) return 0xfe;
10335 map = 0;
10336 for(i=p; i<=chi[0]; i++) {
10337 if ((chi[i] &0x7f) > 31) return 0xfe;
10338 map |= (1L << (chi[i] &0x7f));
10339 }
10340 }
10341 else {
10342 if(p!=chi[0]) return 0xfe;
10343 if (ch > 31) return 0xfe;
10344 map = (1L << ch);
10345 }
10346 if(chi[p] &0x40) return 0xfe;
10347 }
10348 if (pchannelmap) *pchannelmap = map;
10349 else if (map != ((dword)(1L << ch))) return 0xfe;
10350 return (byte)(excl | ch);
10351 }
10352 else { /* not PRI */
10353 for(i=1; i<chi[0] && !(chi[i] &0x80); i++);
10354 if(i!=chi[0] || !(chi[i] &0x80)) return 0xfe;
10355 if(chi[1] &0x08) excl = 0x40;
10356
10357 switch(chi[1] |0x98) {
10358 case 0x98: return 0;
10359 case 0x99:
10360 if (pchannelmap) *pchannelmap = 2;
10361 return excl |1;
10362 case 0x9a:
10363 if (pchannelmap) *pchannelmap = 4;
10364 return excl |2;
10365 case 0x9b: return 0xff;
10366 case 0x9c: return 0xfd; /* d-ch */
10367 default: return 0xfe;
10368 }
10369 }
10370 }
10371
10372
10373 static void mixer_set_bchannel_id_esc (PLCI *plci, byte bchannel_id)
10374 {
10375 DIVA_CAPI_ADAPTER *a;
10376 PLCI *splci;
10377 byte old_id;
10378
10379 a = plci->adapter;
10380 old_id = plci->li_bchannel_id;
10381 if (a->li_pri)
10382 {
10383 if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10384 li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10385 plci->li_bchannel_id = (bchannel_id & 0x1f) + 1;
10386 if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10387 li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10388 }
10389 else
10390 {
10391 if (((bchannel_id & 0x03) == 1) || ((bchannel_id & 0x03) == 2))
10392 {
10393 if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10394 li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10395 plci->li_bchannel_id = bchannel_id & 0x03;
10396 if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI != plci) && (a->AdvSignalPLCI->tel == ADV_VOICE))
10397 {
10398 splci = a->AdvSignalPLCI;
10399 if (li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci == NULL)
10400 {
10401 if ((splci->li_bchannel_id != 0)
10402 && (li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci == splci))
10403 {
10404 li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci = NULL;
10405 }
10406 splci->li_bchannel_id = 3 - plci->li_bchannel_id;
10407 li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci = splci;
10408 dbug (1, dprintf ("[%06lx] %s,%d: adv_voice_set_bchannel_id_esc %d",
10409 (dword)((splci->Id << 8) | UnMapController (splci->adapter->Id)),
10410 (char *)(FILE_), __LINE__, splci->li_bchannel_id));
10411 }
10412 }
10413 if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10414 li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10415 }
10416 }
10417 if ((old_id == 0) && (plci->li_bchannel_id != 0)
10418 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
10419 {
10420 mixer_clear_config (plci);
10421 }
10422 dbug (1, dprintf ("[%06lx] %s,%d: mixer_set_bchannel_id_esc %d %d",
10423 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
10424 (char *)(FILE_), __LINE__, bchannel_id, plci->li_bchannel_id));
10425 }
10426
10427
10428 static void mixer_set_bchannel_id (PLCI *plci, byte *chi)
10429 {
10430 DIVA_CAPI_ADAPTER *a;
10431 PLCI *splci;
10432 byte ch, old_id;
10433
10434 a = plci->adapter;
10435 old_id = plci->li_bchannel_id;
10436 ch = chi_to_channel (chi, NULL);
10437 if (!(ch & 0x80))
10438 {
10439 if (a->li_pri)
10440 {
10441 if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10442 li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10443 plci->li_bchannel_id = (ch & 0x1f) + 1;
10444 if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10445 li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10446 }
10447 else
10448 {
10449 if (((ch & 0x1f) == 1) || ((ch & 0x1f) == 2))
10450 {
10451 if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10452 li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10453 plci->li_bchannel_id = ch & 0x1f;
10454 if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI != plci) && (a->AdvSignalPLCI->tel == ADV_VOICE))
10455 {
10456 splci = a->AdvSignalPLCI;
10457 if (li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci == NULL)
10458 {
10459 if ((splci->li_bchannel_id != 0)
10460 && (li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci == splci))
10461 {
10462 li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci = NULL;
10463 }
10464 splci->li_bchannel_id = 3 - plci->li_bchannel_id;
10465 li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci = splci;
10466 dbug (1, dprintf ("[%06lx] %s,%d: adv_voice_set_bchannel_id %d",
10467 (dword)((splci->Id << 8) | UnMapController (splci->adapter->Id)),
10468 (char *)(FILE_), __LINE__, splci->li_bchannel_id));
10469 }
10470 }
10471 if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10472 li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10473 }
10474 }
10475 }
10476 if ((old_id == 0) && (plci->li_bchannel_id != 0)
10477 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
10478 {
10479 mixer_clear_config (plci);
10480 }
10481 dbug (1, dprintf ("[%06lx] %s,%d: mixer_set_bchannel_id %02x %d",
10482 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
10483 (char *)(FILE_), __LINE__, ch, plci->li_bchannel_id));
10484 }
10485
10486
10487 #define MIXER_MAX_DUMP_CHANNELS 34
10488
10489 static void mixer_calculate_coefs (DIVA_CAPI_ADAPTER *a)
10490 {
10491 static char hex_digit_table[0x10] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
10492 word n, i, j;
10493 char *p;
10494 char hex_line[2 * MIXER_MAX_DUMP_CHANNELS + MIXER_MAX_DUMP_CHANNELS / 8 + 4];
10495
10496 dbug (1, dprintf ("[%06lx] %s,%d: mixer_calculate_coefs",
10497 (dword)(UnMapController (a->Id)), (char *)(FILE_), __LINE__));
10498
10499 for (i = 0; i < li_total_channels; i++)
10500 {
10501 li_config_table[i].channel &= LI_CHANNEL_ADDRESSES_SET;
10502 if (li_config_table[i].chflags != 0)
10503 li_config_table[i].channel |= LI_CHANNEL_INVOLVED;
10504 else
10505 {
10506 for (j = 0; j < li_total_channels; j++)
10507 {
10508 if (((li_config_table[i].flag_table[j]) != 0)
10509 || ((li_config_table[j].flag_table[i]) != 0))
10510 {
10511 li_config_table[i].channel |= LI_CHANNEL_INVOLVED;
10512 }
10513 if (((li_config_table[i].flag_table[j] & LI_FLAG_CONFERENCE) != 0)
10514 || ((li_config_table[j].flag_table[i] & LI_FLAG_CONFERENCE) != 0))
10515 {
10516 li_config_table[i].channel |= LI_CHANNEL_CONFERENCE;
10517 }
10518 }
10519 }
10520 }
10521 for (i = 0; i < li_total_channels; i++)
10522 {
10523 for (j = 0; j < li_total_channels; j++)
10524 {
10525 li_config_table[i].coef_table[j] &= ~(LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC);
10526 if (li_config_table[i].flag_table[j] & LI_FLAG_CONFERENCE)
10527 li_config_table[i].coef_table[j] |= LI_COEF_CH_CH;
10528 }
10529 }
10530 for (n = 0; n < li_total_channels; n++)
10531 {
10532 if (li_config_table[n].channel & LI_CHANNEL_CONFERENCE)
10533 {
10534 for (i = 0; i < li_total_channels; i++)
10535 {
10536 if (li_config_table[i].channel & LI_CHANNEL_CONFERENCE)
10537 {
10538 for (j = 0; j < li_total_channels; j++)
10539 {
10540 li_config_table[i].coef_table[j] |=
10541 li_config_table[i].coef_table[n] & li_config_table[n].coef_table[j];
10542 }
10543 }
10544 }
10545 }
10546 }
10547 for (i = 0; i < li_total_channels; i++)
10548 {
10549 if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10550 {
10551 li_config_table[i].coef_table[i] &= ~LI_COEF_CH_CH;
10552 for (j = 0; j < li_total_channels; j++)
10553 {
10554 if (li_config_table[i].coef_table[j] & LI_COEF_CH_CH)
10555 li_config_table[i].flag_table[j] |= LI_FLAG_CONFERENCE;
10556 }
10557 if (li_config_table[i].flag_table[i] & LI_FLAG_CONFERENCE)
10558 li_config_table[i].coef_table[i] |= LI_COEF_CH_CH;
10559 }
10560 }
10561 for (i = 0; i < li_total_channels; i++)
10562 {
10563 if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10564 {
10565 for (j = 0; j < li_total_channels; j++)
10566 {
10567 if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
10568 li_config_table[i].coef_table[j] |= LI_COEF_CH_CH;
10569 if (li_config_table[i].flag_table[j] & LI_FLAG_MONITOR)
10570 li_config_table[i].coef_table[j] |= LI_COEF_CH_PC;
10571 if (li_config_table[i].flag_table[j] & LI_FLAG_MIX)
10572 li_config_table[i].coef_table[j] |= LI_COEF_PC_CH;
10573 if (li_config_table[i].flag_table[j] & LI_FLAG_PCCONNECT)
10574 li_config_table[i].coef_table[j] |= LI_COEF_PC_PC;
10575 }
10576 if (li_config_table[i].chflags & LI_CHFLAG_MONITOR)
10577 {
10578 for (j = 0; j < li_total_channels; j++)
10579 {
10580 if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
10581 {
10582 li_config_table[i].coef_table[j] |= LI_COEF_CH_PC;
10583 if (li_config_table[j].chflags & LI_CHFLAG_MIX)
10584 li_config_table[i].coef_table[j] |= LI_COEF_PC_CH | LI_COEF_PC_PC;
10585 }
10586 }
10587 }
10588 if (li_config_table[i].chflags & LI_CHFLAG_MIX)
10589 {
10590 for (j = 0; j < li_total_channels; j++)
10591 {
10592 if (li_config_table[j].flag_table[i] & LI_FLAG_INTERCONNECT)
10593 li_config_table[j].coef_table[i] |= LI_COEF_PC_CH;
10594 }
10595 }
10596 if (li_config_table[i].chflags & LI_CHFLAG_LOOP)
10597 {
10598 for (j = 0; j < li_total_channels; j++)
10599 {
10600 if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
10601 {
10602 for (n = 0; n < li_total_channels; n++)
10603 {
10604 if (li_config_table[n].flag_table[i] & LI_FLAG_INTERCONNECT)
10605 {
10606 li_config_table[n].coef_table[j] |= LI_COEF_CH_CH;
10607 if (li_config_table[j].chflags & LI_CHFLAG_MIX)
10608 {
10609 li_config_table[n].coef_table[j] |= LI_COEF_PC_CH;
10610 if (li_config_table[n].chflags & LI_CHFLAG_MONITOR)
10611 li_config_table[n].coef_table[j] |= LI_COEF_CH_PC | LI_COEF_PC_PC;
10612 }
10613 else if (li_config_table[n].chflags & LI_CHFLAG_MONITOR)
10614 li_config_table[n].coef_table[j] |= LI_COEF_CH_PC;
10615 }
10616 }
10617 }
10618 }
10619 }
10620 }
10621 }
10622 for (i = 0; i < li_total_channels; i++)
10623 {
10624 if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10625 {
10626 if (li_config_table[i].chflags & (LI_CHFLAG_MONITOR | LI_CHFLAG_MIX | LI_CHFLAG_LOOP))
10627 li_config_table[i].channel |= LI_CHANNEL_ACTIVE;
10628 if (li_config_table[i].chflags & LI_CHFLAG_MONITOR)
10629 li_config_table[i].channel |= LI_CHANNEL_RX_DATA;
10630 if (li_config_table[i].chflags & LI_CHFLAG_MIX)
10631 li_config_table[i].channel |= LI_CHANNEL_TX_DATA;
10632 for (j = 0; j < li_total_channels; j++)
10633 {
10634 if ((li_config_table[i].flag_table[j] &
10635 (LI_FLAG_INTERCONNECT | LI_FLAG_PCCONNECT | LI_FLAG_CONFERENCE | LI_FLAG_MONITOR))
10636 || (li_config_table[j].flag_table[i] &
10637 (LI_FLAG_INTERCONNECT | LI_FLAG_PCCONNECT | LI_FLAG_CONFERENCE | LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX)))
10638 {
10639 li_config_table[i].channel |= LI_CHANNEL_ACTIVE;
10640 }
10641 if (li_config_table[i].flag_table[j] & (LI_FLAG_PCCONNECT | LI_FLAG_MONITOR))
10642 li_config_table[i].channel |= LI_CHANNEL_RX_DATA;
10643 if (li_config_table[j].flag_table[i] & (LI_FLAG_PCCONNECT | LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX))
10644 li_config_table[i].channel |= LI_CHANNEL_TX_DATA;
10645 }
10646 if (!(li_config_table[i].channel & LI_CHANNEL_ACTIVE))
10647 {
10648 li_config_table[i].coef_table[i] |= LI_COEF_PC_CH | LI_COEF_CH_PC;
10649 li_config_table[i].channel |= LI_CHANNEL_TX_DATA | LI_CHANNEL_RX_DATA;
10650 }
10651 }
10652 }
10653 for (i = 0; i < li_total_channels; i++)
10654 {
10655 if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10656 {
10657 j = 0;
10658 while ((j < li_total_channels) && !(li_config_table[i].flag_table[j] & LI_FLAG_ANNOUNCEMENT))
10659 j++;
10660 if (j < li_total_channels)
10661 {
10662 for (j = 0; j < li_total_channels; j++)
10663 {
10664 li_config_table[i].coef_table[j] &= ~(LI_COEF_CH_CH | LI_COEF_PC_CH);
10665 if (li_config_table[i].flag_table[j] & LI_FLAG_ANNOUNCEMENT)
10666 li_config_table[i].coef_table[j] |= LI_COEF_PC_CH;
10667 }
10668 }
10669 }
10670 }
10671 n = li_total_channels;
10672 if (n > MIXER_MAX_DUMP_CHANNELS)
10673 n = MIXER_MAX_DUMP_CHANNELS;
10674 p = hex_line;
10675 for (j = 0; j < n; j++)
10676 {
10677 if ((j & 0x7) == 0)
10678 *(p++) = ' ';
10679 *(p++) = hex_digit_table[li_config_table[j].curchnl >> 4];
10680 *(p++) = hex_digit_table[li_config_table[j].curchnl & 0xf];
10681 }
10682 *p = '\0';
10683 dbug (1, dprintf ("[%06lx] CURRENT %s",
10684 (dword)(UnMapController (a->Id)), (char *) hex_line));
10685 p = hex_line;
10686 for (j = 0; j < n; j++)
10687 {
10688 if ((j & 0x7) == 0)
10689 *(p++) = ' ';
10690 *(p++) = hex_digit_table[li_config_table[j].channel >> 4];
10691 *(p++) = hex_digit_table[li_config_table[j].channel & 0xf];
10692 }
10693 *p = '\0';
10694 dbug (1, dprintf ("[%06lx] CHANNEL %s",
10695 (dword)(UnMapController (a->Id)), (char *) hex_line));
10696 p = hex_line;
10697 for (j = 0; j < n; j++)
10698 {
10699 if ((j & 0x7) == 0)
10700 *(p++) = ' ';
10701 *(p++) = hex_digit_table[li_config_table[j].chflags >> 4];
10702 *(p++) = hex_digit_table[li_config_table[j].chflags & 0xf];
10703 }
10704 *p = '\0';
10705 dbug (1, dprintf ("[%06lx] CHFLAG %s",
10706 (dword)(UnMapController (a->Id)), (char *) hex_line));
10707 for (i = 0; i < n; i++)
10708 {
10709 p = hex_line;
10710 for (j = 0; j < n; j++)
10711 {
10712 if ((j & 0x7) == 0)
10713 *(p++) = ' ';
10714 *(p++) = hex_digit_table[li_config_table[i].flag_table[j] >> 4];
10715 *(p++) = hex_digit_table[li_config_table[i].flag_table[j] & 0xf];
10716 }
10717 *p = '\0';
10718 dbug (1, dprintf ("[%06lx] FLAG[%02x]%s",
10719 (dword)(UnMapController (a->Id)), i, (char *) hex_line));
10720 }
10721 for (i = 0; i < n; i++)
10722 {
10723 p = hex_line;
10724 for (j = 0; j < n; j++)
10725 {
10726 if ((j & 0x7) == 0)
10727 *(p++) = ' ';
10728 *(p++) = hex_digit_table[li_config_table[i].coef_table[j] >> 4];
10729 *(p++) = hex_digit_table[li_config_table[i].coef_table[j] & 0xf];
10730 }
10731 *p = '\0';
10732 dbug (1, dprintf ("[%06lx] COEF[%02x]%s",
10733 (dword)(UnMapController (a->Id)), i, (char *) hex_line));
10734 }
10735 }
10736
10737
10738 static struct
10739 {
10740 byte mask;
10741 byte line_flags;
10742 } mixer_write_prog_pri[] =
10743 {
10744 { LI_COEF_CH_CH, 0 },
10745 { LI_COEF_CH_PC, MIXER_COEF_LINE_TO_PC_FLAG },
10746 { LI_COEF_PC_CH, MIXER_COEF_LINE_FROM_PC_FLAG },
10747 { LI_COEF_PC_PC, MIXER_COEF_LINE_TO_PC_FLAG | MIXER_COEF_LINE_FROM_PC_FLAG }
10748 };
10749
10750 static struct
10751 {
10752 byte from_ch;
10753 byte to_ch;
10754 byte mask;
10755 byte xconnect_override;
10756 } mixer_write_prog_bri[] =
10757 {
10758 { 0, 0, LI_COEF_CH_CH, 0x01 }, /* B to B */
10759 { 1, 0, LI_COEF_CH_CH, 0x01 }, /* Alt B to B */
10760 { 0, 0, LI_COEF_PC_CH, 0x80 }, /* PC to B */
10761 { 1, 0, LI_COEF_PC_CH, 0x01 }, /* Alt PC to B */
10762 { 2, 0, LI_COEF_CH_CH, 0x00 }, /* IC to B */
10763 { 3, 0, LI_COEF_CH_CH, 0x00 }, /* Alt IC to B */
10764 { 0, 0, LI_COEF_CH_PC, 0x80 }, /* B to PC */
10765 { 1, 0, LI_COEF_CH_PC, 0x01 }, /* Alt B to PC */
10766 { 0, 0, LI_COEF_PC_PC, 0x01 }, /* PC to PC */
10767 { 1, 0, LI_COEF_PC_PC, 0x01 }, /* Alt PC to PC */
10768 { 2, 0, LI_COEF_CH_PC, 0x00 }, /* IC to PC */
10769 { 3, 0, LI_COEF_CH_PC, 0x00 }, /* Alt IC to PC */
10770 { 0, 2, LI_COEF_CH_CH, 0x00 }, /* B to IC */
10771 { 1, 2, LI_COEF_CH_CH, 0x00 }, /* Alt B to IC */
10772 { 0, 2, LI_COEF_PC_CH, 0x00 }, /* PC to IC */
10773 { 1, 2, LI_COEF_PC_CH, 0x00 }, /* Alt PC to IC */
10774 { 2, 2, LI_COEF_CH_CH, 0x00 }, /* IC to IC */
10775 { 3, 2, LI_COEF_CH_CH, 0x00 }, /* Alt IC to IC */
10776 { 1, 1, LI_COEF_CH_CH, 0x01 }, /* Alt B to Alt B */
10777 { 0, 1, LI_COEF_CH_CH, 0x01 }, /* B to Alt B */
10778 { 1, 1, LI_COEF_PC_CH, 0x80 }, /* Alt PC to Alt B */
10779 { 0, 1, LI_COEF_PC_CH, 0x01 }, /* PC to Alt B */
10780 { 3, 1, LI_COEF_CH_CH, 0x00 }, /* Alt IC to Alt B */
10781 { 2, 1, LI_COEF_CH_CH, 0x00 }, /* IC to Alt B */
10782 { 1, 1, LI_COEF_CH_PC, 0x80 }, /* Alt B to Alt PC */
10783 { 0, 1, LI_COEF_CH_PC, 0x01 }, /* B to Alt PC */
10784 { 1, 1, LI_COEF_PC_PC, 0x01 }, /* Alt PC to Alt PC */
10785 { 0, 1, LI_COEF_PC_PC, 0x01 }, /* PC to Alt PC */
10786 { 3, 1, LI_COEF_CH_PC, 0x00 }, /* Alt IC to Alt PC */
10787 { 2, 1, LI_COEF_CH_PC, 0x00 }, /* IC to Alt PC */
10788 { 1, 3, LI_COEF_CH_CH, 0x00 }, /* Alt B to Alt IC */
10789 { 0, 3, LI_COEF_CH_CH, 0x00 }, /* B to Alt IC */
10790 { 1, 3, LI_COEF_PC_CH, 0x00 }, /* Alt PC to Alt IC */
10791 { 0, 3, LI_COEF_PC_CH, 0x00 }, /* PC to Alt IC */
10792 { 3, 3, LI_COEF_CH_CH, 0x00 }, /* Alt IC to Alt IC */
10793 { 2, 3, LI_COEF_CH_CH, 0x00 } /* IC to Alt IC */
10794 };
10795
10796 static byte mixer_swapped_index_bri[] =
10797 {
10798 18, /* B to B */
10799 19, /* Alt B to B */
10800 20, /* PC to B */
10801 21, /* Alt PC to B */
10802 22, /* IC to B */
10803 23, /* Alt IC to B */
10804 24, /* B to PC */
10805 25, /* Alt B to PC */
10806 26, /* PC to PC */
10807 27, /* Alt PC to PC */
10808 28, /* IC to PC */
10809 29, /* Alt IC to PC */
10810 30, /* B to IC */
10811 31, /* Alt B to IC */
10812 32, /* PC to IC */
10813 33, /* Alt PC to IC */
10814 34, /* IC to IC */
10815 35, /* Alt IC to IC */
10816 0, /* Alt B to Alt B */
10817 1, /* B to Alt B */
10818 2, /* Alt PC to Alt B */
10819 3, /* PC to Alt B */
10820 4, /* Alt IC to Alt B */
10821 5, /* IC to Alt B */
10822 6, /* Alt B to Alt PC */
10823 7, /* B to Alt PC */
10824 8, /* Alt PC to Alt PC */
10825 9, /* PC to Alt PC */
10826 10, /* Alt IC to Alt PC */
10827 11, /* IC to Alt PC */
10828 12, /* Alt B to Alt IC */
10829 13, /* B to Alt IC */
10830 14, /* Alt PC to Alt IC */
10831 15, /* PC to Alt IC */
10832 16, /* Alt IC to Alt IC */
10833 17 /* IC to Alt IC */
10834 };
10835
10836 static struct
10837 {
10838 byte mask;
10839 byte from_pc;
10840 byte to_pc;
10841 } xconnect_write_prog[] =
10842 {
10843 { LI_COEF_CH_CH, false, false },
10844 { LI_COEF_CH_PC, false, true },
10845 { LI_COEF_PC_CH, true, false },
10846 { LI_COEF_PC_PC, true, true }
10847 };
10848
10849
10850 static void xconnect_query_addresses (PLCI *plci)
10851 {
10852 DIVA_CAPI_ADAPTER *a;
10853 word w, ch;
10854 byte *p;
10855
10856 dbug (1, dprintf ("[%06lx] %s,%d: xconnect_query_addresses",
10857 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
10858 (char *)(FILE_), __LINE__));
10859
10860 a = plci->adapter;
10861 if (a->li_pri && ((plci->li_bchannel_id == 0)
10862 || (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci)))
10863 {
10864 dbug (1, dprintf ("[%06x] %s,%d: Channel id wiped out",
10865 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
10866 (char *)(FILE_), __LINE__));
10867 return;
10868 }
10869 p = plci->internal_req_buffer;
10870 ch = (a->li_pri) ? plci->li_bchannel_id - 1 : 0;
10871 *(p++) = UDATA_REQUEST_XCONNECT_FROM;
10872 w = ch;
10873 *(p++) = (byte) w;
10874 *(p++) = (byte)(w >> 8);
10875 w = ch | XCONNECT_CHANNEL_PORT_PC;
10876 *(p++) = (byte) w;
10877 *(p++) = (byte)(w >> 8);
10878 plci->NData[0].P = plci->internal_req_buffer;
10879 plci->NData[0].PLength = p - plci->internal_req_buffer;
10880 plci->NL.X = plci->NData;
10881 plci->NL.ReqCh = 0;
10882 plci->NL.Req = plci->nl_req = (byte) N_UDATA;
10883 plci->adapter->request (&plci->NL);
10884 }
10885
10886
10887 static void xconnect_write_coefs (PLCI *plci, word internal_command)
10888 {
10889
10890 dbug (1, dprintf ("[%06lx] %s,%d: xconnect_write_coefs %04x",
10891 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
10892 (char *)(FILE_), __LINE__, internal_command));
10893
10894 plci->li_write_command = internal_command;
10895 plci->li_write_channel = 0;
10896 }
10897
10898
10899 static byte xconnect_write_coefs_process (dword Id, PLCI *plci, byte Rc)
10900 {
10901 DIVA_CAPI_ADAPTER *a;
10902 word w, n, i, j, r, s, to_ch;
10903 dword d;
10904 byte *p;
10905 struct xconnect_transfer_address_s *transfer_address;
10906 byte ch_map[MIXER_CHANNELS_BRI];
10907
10908 dbug (1, dprintf ("[%06x] %s,%d: xconnect_write_coefs_process %02x %d",
10909 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->li_write_channel));
10910
10911 a = plci->adapter;
10912 if ((plci->li_bchannel_id == 0)
10913 || (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci))
10914 {
10915 dbug (1, dprintf ("[%06x] %s,%d: Channel id wiped out",
10916 UnMapId (Id), (char *)(FILE_), __LINE__));
10917 return (true);
10918 }
10919 i = a->li_base + (plci->li_bchannel_id - 1);
10920 j = plci->li_write_channel;
10921 p = plci->internal_req_buffer;
10922 if (j != 0)
10923 {
10924 if ((Rc != OK) && (Rc != OK_FC))
10925 {
10926 dbug (1, dprintf ("[%06lx] %s,%d: LI write coefs failed %02x",
10927 UnMapId (Id), (char *)(FILE_), __LINE__, Rc));
10928 return (false);
10929 }
10930 }
10931 if (li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
10932 {
10933 r = 0;
10934 s = 0;
10935 if (j < li_total_channels)
10936 {
10937 if (li_config_table[i].channel & LI_CHANNEL_ADDRESSES_SET)
10938 {
10939 s = ((li_config_table[i].send_b.card_address.low | li_config_table[i].send_b.card_address.high) ?
10940 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_PC | LI_COEF_PC_PC)) &
10941 ((li_config_table[i].send_pc.card_address.low | li_config_table[i].send_pc.card_address.high) ?
10942 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_PC_CH));
10943 }
10944 r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
10945 while ((j < li_total_channels)
10946 && ((r == 0)
10947 || (!(li_config_table[j].channel & LI_CHANNEL_ADDRESSES_SET))
10948 || (!li_config_table[j].adapter->li_pri
10949 && (j >= li_config_table[j].adapter->li_base + MIXER_BCHANNELS_BRI))
10950 || (((li_config_table[j].send_b.card_address.low != li_config_table[i].send_b.card_address.low)
10951 || (li_config_table[j].send_b.card_address.high != li_config_table[i].send_b.card_address.high))
10952 && (!(a->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)
10953 || !(li_config_table[j].adapter->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)))
10954 || ((li_config_table[j].adapter->li_base != a->li_base)
10955 && !(r & s &
10956 ((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ?
10957 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) &
10958 ((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ?
10959 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC))))))
10960 {
10961 j++;
10962 if (j < li_total_channels)
10963 r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
10964 }
10965 }
10966 if (j < li_total_channels)
10967 {
10968 plci->internal_command = plci->li_write_command;
10969 if (plci_nl_busy (plci))
10970 return (true);
10971 to_ch = (a->li_pri) ? plci->li_bchannel_id - 1 : 0;
10972 *(p++) = UDATA_REQUEST_XCONNECT_TO;
10973 do
10974 {
10975 if (li_config_table[j].adapter->li_base != a->li_base)
10976 {
10977 r &= s &
10978 ((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ?
10979 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) &
10980 ((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ?
10981 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC));
10982 }
10983 n = 0;
10984 do
10985 {
10986 if (r & xconnect_write_prog[n].mask)
10987 {
10988 if (xconnect_write_prog[n].from_pc)
10989 transfer_address = &(li_config_table[j].send_pc);
10990 else
10991 transfer_address = &(li_config_table[j].send_b);
10992 d = transfer_address->card_address.low;
10993 *(p++) = (byte) d;
10994 *(p++) = (byte)(d >> 8);
10995 *(p++) = (byte)(d >> 16);
10996 *(p++) = (byte)(d >> 24);
10997 d = transfer_address->card_address.high;
10998 *(p++) = (byte) d;
10999 *(p++) = (byte)(d >> 8);
11000 *(p++) = (byte)(d >> 16);
11001 *(p++) = (byte)(d >> 24);
11002 d = transfer_address->offset;
11003 *(p++) = (byte) d;
11004 *(p++) = (byte)(d >> 8);
11005 *(p++) = (byte)(d >> 16);
11006 *(p++) = (byte)(d >> 24);
11007 w = xconnect_write_prog[n].to_pc ? to_ch | XCONNECT_CHANNEL_PORT_PC : to_ch;
11008 *(p++) = (byte) w;
11009 *(p++) = (byte)(w >> 8);
11010 w = ((li_config_table[i].coef_table[j] & xconnect_write_prog[n].mask) == 0) ? 0x01 :
11011 (li_config_table[i].adapter->u_law ?
11012 (li_config_table[j].adapter->u_law ? 0x80 : 0x86) :
11013 (li_config_table[j].adapter->u_law ? 0x7a : 0x80));
11014 *(p++) = (byte) w;
11015 *(p++) = (byte) 0;
11016 li_config_table[i].coef_table[j] ^= xconnect_write_prog[n].mask << 4;
11017 }
11018 n++;
11019 } while ((n < ARRAY_SIZE(xconnect_write_prog))
11020 && ((p - plci->internal_req_buffer) + 16 < INTERNAL_REQ_BUFFER_SIZE));
11021 if (n == ARRAY_SIZE(xconnect_write_prog))
11022 {
11023 do
11024 {
11025 j++;
11026 if (j < li_total_channels)
11027 r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
11028 } while ((j < li_total_channels)
11029 && ((r == 0)
11030 || (!(li_config_table[j].channel & LI_CHANNEL_ADDRESSES_SET))
11031 || (!li_config_table[j].adapter->li_pri
11032 && (j >= li_config_table[j].adapter->li_base + MIXER_BCHANNELS_BRI))
11033 || (((li_config_table[j].send_b.card_address.low != li_config_table[i].send_b.card_address.low)
11034 || (li_config_table[j].send_b.card_address.high != li_config_table[i].send_b.card_address.high))
11035 && (!(a->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)
11036 || !(li_config_table[j].adapter->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)))
11037 || ((li_config_table[j].adapter->li_base != a->li_base)
11038 && !(r & s &
11039 ((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ?
11040 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) &
11041 ((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ?
11042 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC))))));
11043 }
11044 } while ((j < li_total_channels)
11045 && ((p - plci->internal_req_buffer) + 16 < INTERNAL_REQ_BUFFER_SIZE));
11046 }
11047 else if (j == li_total_channels)
11048 {
11049 plci->internal_command = plci->li_write_command;
11050 if (plci_nl_busy (plci))
11051 return (true);
11052 if (a->li_pri)
11053 {
11054 *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_PRI_SYNC;
11055 w = 0;
11056 if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
11057 w |= MIXER_FEATURE_ENABLE_TX_DATA;
11058 if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
11059 w |= MIXER_FEATURE_ENABLE_RX_DATA;
11060 *(p++) = (byte) w;
11061 *(p++) = (byte)(w >> 8);
11062 }
11063 else
11064 {
11065 *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_BRI;
11066 w = 0;
11067 if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI)
11068 && (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length))
11069 {
11070 w = GET_WORD (a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE);
11071 }
11072 if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
11073 w |= MIXER_FEATURE_ENABLE_TX_DATA;
11074 if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
11075 w |= MIXER_FEATURE_ENABLE_RX_DATA;
11076 *(p++) = (byte) w;
11077 *(p++) = (byte)(w >> 8);
11078 for (j = 0; j < sizeof(ch_map); j += 2)
11079 {
11080 if (plci->li_bchannel_id == 2)
11081 {
11082 ch_map[j] = (byte)(j+1);
11083 ch_map[j+1] = (byte) j;
11084 }
11085 else
11086 {
11087 ch_map[j] = (byte) j;
11088 ch_map[j+1] = (byte)(j+1);
11089 }
11090 }
11091 for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++)
11092 {
11093 i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch];
11094 j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch];
11095 if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED)
11096 {
11097 *p = (mixer_write_prog_bri[n].xconnect_override != 0) ?
11098 mixer_write_prog_bri[n].xconnect_override :
11099 ((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01);
11100 if ((i >= a->li_base + MIXER_BCHANNELS_BRI) || (j >= a->li_base + MIXER_BCHANNELS_BRI))
11101 {
11102 w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
11103 li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4;
11104 }
11105 }
11106 else
11107 {
11108 *p = 0x00;
11109 if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI->tel == ADV_VOICE))
11110 {
11111 w = (plci == a->AdvSignalPLCI) ? n : mixer_swapped_index_bri[n];
11112 if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w < a->adv_voice_coef_length)
11113 *p = a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w];
11114 }
11115 }
11116 p++;
11117 }
11118 }
11119 j = li_total_channels + 1;
11120 }
11121 }
11122 else
11123 {
11124 if (j <= li_total_channels)
11125 {
11126 plci->internal_command = plci->li_write_command;
11127 if (plci_nl_busy (plci))
11128 return (true);
11129 if (j < a->li_base)
11130 j = a->li_base;
11131 if (a->li_pri)
11132 {
11133 *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_PRI_SYNC;
11134 w = 0;
11135 if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
11136 w |= MIXER_FEATURE_ENABLE_TX_DATA;
11137 if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
11138 w |= MIXER_FEATURE_ENABLE_RX_DATA;
11139 *(p++) = (byte) w;
11140 *(p++) = (byte)(w >> 8);
11141 for (n = 0; n < ARRAY_SIZE(mixer_write_prog_pri); n++)
11142 {
11143 *(p++) = (byte)((plci->li_bchannel_id - 1) | mixer_write_prog_pri[n].line_flags);
11144 for (j = a->li_base; j < a->li_base + MIXER_CHANNELS_PRI; j++)
11145 {
11146 w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
11147 if (w & mixer_write_prog_pri[n].mask)
11148 {
11149 *(p++) = (li_config_table[i].coef_table[j] & mixer_write_prog_pri[n].mask) ? 0x80 : 0x01;
11150 li_config_table[i].coef_table[j] ^= mixer_write_prog_pri[n].mask << 4;
11151 }
11152 else
11153 *(p++) = 0x00;
11154 }
11155 *(p++) = (byte)((plci->li_bchannel_id - 1) | MIXER_COEF_LINE_ROW_FLAG | mixer_write_prog_pri[n].line_flags);
11156 for (j = a->li_base; j < a->li_base + MIXER_CHANNELS_PRI; j++)
11157 {
11158 w = ((li_config_table[j].coef_table[i] & 0xf) ^ (li_config_table[j].coef_table[i] >> 4));
11159 if (w & mixer_write_prog_pri[n].mask)
11160 {
11161 *(p++) = (li_config_table[j].coef_table[i] & mixer_write_prog_pri[n].mask) ? 0x80 : 0x01;
11162 li_config_table[j].coef_table[i] ^= mixer_write_prog_pri[n].mask << 4;
11163 }
11164 else
11165 *(p++) = 0x00;
11166 }
11167 }
11168 }
11169 else
11170 {
11171 *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_BRI;
11172 w = 0;
11173 if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI)
11174 && (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length))
11175 {
11176 w = GET_WORD (a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE);
11177 }
11178 if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
11179 w |= MIXER_FEATURE_ENABLE_TX_DATA;
11180 if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
11181 w |= MIXER_FEATURE_ENABLE_RX_DATA;
11182 *(p++) = (byte) w;
11183 *(p++) = (byte)(w >> 8);
11184 for (j = 0; j < sizeof(ch_map); j += 2)
11185 {
11186 if (plci->li_bchannel_id == 2)
11187 {
11188 ch_map[j] = (byte)(j+1);
11189 ch_map[j+1] = (byte) j;
11190 }
11191 else
11192 {
11193 ch_map[j] = (byte) j;
11194 ch_map[j+1] = (byte)(j+1);
11195 }
11196 }
11197 for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++)
11198 {
11199 i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch];
11200 j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch];
11201 if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED)
11202 {
11203 *p = ((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01);
11204 w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
11205 li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4;
11206 }
11207 else
11208 {
11209 *p = 0x00;
11210 if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI->tel == ADV_VOICE))
11211 {
11212 w = (plci == a->AdvSignalPLCI) ? n : mixer_swapped_index_bri[n];
11213 if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w < a->adv_voice_coef_length)
11214 *p = a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w];
11215 }
11216 }
11217 p++;
11218 }
11219 }
11220 j = li_total_channels + 1;
11221 }
11222 }
11223 plci->li_write_channel = j;
11224 if (p != plci->internal_req_buffer)
11225 {
11226 plci->NData[0].P = plci->internal_req_buffer;
11227 plci->NData[0].PLength = p - plci->internal_req_buffer;
11228 plci->NL.X = plci->NData;
11229 plci->NL.ReqCh = 0;
11230 plci->NL.Req = plci->nl_req = (byte) N_UDATA;
11231 plci->adapter->request (&plci->NL);
11232 }
11233 return (true);
11234 }
11235
11236
11237 static void mixer_notify_update (PLCI *plci, byte others)
11238 {
11239 DIVA_CAPI_ADAPTER *a;
11240 word i, w;
11241 PLCI *notify_plci;
11242 byte msg[sizeof(CAPI_MSG_HEADER) + 6];
11243
11244 dbug (1, dprintf ("[%06lx] %s,%d: mixer_notify_update %d",
11245 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
11246 (char *)(FILE_), __LINE__, others));
11247
11248 a = plci->adapter;
11249 if (a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED)
11250 {
11251 if (others)
11252 plci->li_notify_update = true;
11253 i = 0;
11254 do
11255 {
11256 notify_plci = NULL;
11257 if (others)
11258 {
11259 while ((i < li_total_channels) && (li_config_table[i].plci == NULL))
11260 i++;
11261 if (i < li_total_channels)
11262 notify_plci = li_config_table[i++].plci;
11263 }
11264 else
11265 {
11266 if ((plci->li_bchannel_id != 0)
11267 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11268 {
11269 notify_plci = plci;
11270 }
11271 }
11272 if ((notify_plci != NULL)
11273 && !notify_plci->li_notify_update
11274 && (notify_plci->appl != NULL)
11275 && (notify_plci->State)
11276 && notify_plci->NL.Id && !notify_plci->nl_remove_id)
11277 {
11278 notify_plci->li_notify_update = true;
11279 ((CAPI_MSG *) msg)->header.length = 18;
11280 ((CAPI_MSG *) msg)->header.appl_id = notify_plci->appl->Id;
11281 ((CAPI_MSG *) msg)->header.command = _FACILITY_R;
11282 ((CAPI_MSG *) msg)->header.number = 0;
11283 ((CAPI_MSG *) msg)->header.controller = notify_plci->adapter->Id;
11284 ((CAPI_MSG *) msg)->header.plci = notify_plci->Id;
11285 ((CAPI_MSG *) msg)->header.ncci = 0;
11286 ((CAPI_MSG *) msg)->info.facility_req.Selector = SELECTOR_LINE_INTERCONNECT;
11287 ((CAPI_MSG *) msg)->info.facility_req.structs[0] = 3;
11288 PUT_WORD (&(((CAPI_MSG *) msg)->info.facility_req.structs[1]), LI_REQ_SILENT_UPDATE);
11289 ((CAPI_MSG *) msg)->info.facility_req.structs[3] = 0;
11290 w = api_put (notify_plci->appl, (CAPI_MSG *) msg);
11291 if (w != _QUEUE_FULL)
11292 {
11293 if (w != 0)
11294 {
11295 dbug (1, dprintf ("[%06lx] %s,%d: Interconnect notify failed %06x %d",
11296 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
11297 (char *)(FILE_), __LINE__,
11298 (dword)((notify_plci->Id << 8) | UnMapController (notify_plci->adapter->Id)), w));
11299 }
11300 notify_plci->li_notify_update = false;
11301 }
11302 }
11303 } while (others && (notify_plci != NULL));
11304 if (others)
11305 plci->li_notify_update = false;
11306 }
11307 }
11308
11309
11310 static void mixer_clear_config (PLCI *plci)
11311 {
11312 DIVA_CAPI_ADAPTER *a;
11313 word i, j;
11314
11315 dbug (1, dprintf ("[%06lx] %s,%d: mixer_clear_config",
11316 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
11317 (char *)(FILE_), __LINE__));
11318
11319 plci->li_notify_update = false;
11320 plci->li_plci_b_write_pos = 0;
11321 plci->li_plci_b_read_pos = 0;
11322 plci->li_plci_b_req_pos = 0;
11323 a = plci->adapter;
11324 if ((plci->li_bchannel_id != 0)
11325 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11326 {
11327 i = a->li_base + (plci->li_bchannel_id - 1);
11328 li_config_table[i].curchnl = 0;
11329 li_config_table[i].channel = 0;
11330 li_config_table[i].chflags = 0;
11331 for (j = 0; j < li_total_channels; j++)
11332 {
11333 li_config_table[j].flag_table[i] = 0;
11334 li_config_table[i].flag_table[j] = 0;
11335 li_config_table[i].coef_table[j] = 0;
11336 li_config_table[j].coef_table[i] = 0;
11337 }
11338 if (!a->li_pri)
11339 {
11340 li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET;
11341 if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
11342 {
11343 i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
11344 li_config_table[i].curchnl = 0;
11345 li_config_table[i].channel = 0;
11346 li_config_table[i].chflags = 0;
11347 for (j = 0; j < li_total_channels; j++)
11348 {
11349 li_config_table[i].flag_table[j] = 0;
11350 li_config_table[j].flag_table[i] = 0;
11351 li_config_table[i].coef_table[j] = 0;
11352 li_config_table[j].coef_table[i] = 0;
11353 }
11354 if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
11355 {
11356 i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
11357 li_config_table[i].curchnl = 0;
11358 li_config_table[i].channel = 0;
11359 li_config_table[i].chflags = 0;
11360 for (j = 0; j < li_total_channels; j++)
11361 {
11362 li_config_table[i].flag_table[j] = 0;
11363 li_config_table[j].flag_table[i] = 0;
11364 li_config_table[i].coef_table[j] = 0;
11365 li_config_table[j].coef_table[i] = 0;
11366 }
11367 }
11368 }
11369 }
11370 }
11371 }
11372
11373
11374 static void mixer_prepare_switch (dword Id, PLCI *plci)
11375 {
11376
11377 dbug (1, dprintf ("[%06lx] %s,%d: mixer_prepare_switch",
11378 UnMapId (Id), (char *)(FILE_), __LINE__));
11379
11380 do
11381 {
11382 mixer_indication_coefs_set (Id, plci);
11383 } while (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos);
11384 }
11385
11386
11387 static word mixer_save_config (dword Id, PLCI *plci, byte Rc)
11388 {
11389 DIVA_CAPI_ADAPTER *a;
11390 word i, j;
11391
11392 dbug (1, dprintf ("[%06lx] %s,%d: mixer_save_config %02x %d",
11393 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
11394
11395 a = plci->adapter;
11396 if ((plci->li_bchannel_id != 0)
11397 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11398 {
11399 i = a->li_base + (plci->li_bchannel_id - 1);
11400 for (j = 0; j < li_total_channels; j++)
11401 {
11402 li_config_table[i].coef_table[j] &= 0xf;
11403 li_config_table[j].coef_table[i] &= 0xf;
11404 }
11405 if (!a->li_pri)
11406 li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET;
11407 }
11408 return (GOOD);
11409 }
11410
11411
11412 static word mixer_restore_config (dword Id, PLCI *plci, byte Rc)
11413 {
11414 DIVA_CAPI_ADAPTER *a;
11415 word Info;
11416
11417 dbug (1, dprintf ("[%06lx] %s,%d: mixer_restore_config %02x %d",
11418 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
11419
11420 Info = GOOD;
11421 a = plci->adapter;
11422 if ((plci->B1_facilities & B1_FACILITY_MIXER)
11423 && (plci->li_bchannel_id != 0)
11424 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11425 {
11426 switch (plci->adjust_b_state)
11427 {
11428 case ADJUST_B_RESTORE_MIXER_1:
11429 if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
11430 {
11431 plci->internal_command = plci->adjust_b_command;
11432 if (plci_nl_busy (plci))
11433 {
11434 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_1;
11435 break;
11436 }
11437 xconnect_query_addresses (plci);
11438 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_2;
11439 break;
11440 }
11441 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5;
11442 Rc = OK;
11443 case ADJUST_B_RESTORE_MIXER_2:
11444 case ADJUST_B_RESTORE_MIXER_3:
11445 case ADJUST_B_RESTORE_MIXER_4:
11446 if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0))
11447 {
11448 dbug (1, dprintf ("[%06lx] %s,%d: Adjust B query addresses failed %02x",
11449 UnMapId (Id), (char *)(FILE_), __LINE__, Rc));
11450 Info = _WRONG_STATE;
11451 break;
11452 }
11453 if (Rc == OK)
11454 {
11455 if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2)
11456 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_3;
11457 else if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_4)
11458 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5;
11459 }
11460 else if (Rc == 0)
11461 {
11462 if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2)
11463 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_4;
11464 else if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_3)
11465 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5;
11466 }
11467 if (plci->adjust_b_state != ADJUST_B_RESTORE_MIXER_5)
11468 {
11469 plci->internal_command = plci->adjust_b_command;
11470 break;
11471 }
11472 case ADJUST_B_RESTORE_MIXER_5:
11473 xconnect_write_coefs (plci, plci->adjust_b_command);
11474 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_6;
11475 Rc = OK;
11476 case ADJUST_B_RESTORE_MIXER_6:
11477 if (!xconnect_write_coefs_process (Id, plci, Rc))
11478 {
11479 dbug (1, dprintf ("[%06lx] %s,%d: Write mixer coefs failed",
11480 UnMapId (Id), (char *)(FILE_), __LINE__));
11481 Info = _FACILITY_NOT_SUPPORTED;
11482 break;
11483 }
11484 if (plci->internal_command)
11485 break;
11486 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_7;
11487 case ADJUST_B_RESTORE_MIXER_7:
11488 break;
11489 }
11490 }
11491 return (Info);
11492 }
11493
11494
11495 static void mixer_command (dword Id, PLCI *plci, byte Rc)
11496 {
11497 DIVA_CAPI_ADAPTER *a;
11498 word i, internal_command, Info;
11499
11500 dbug (1, dprintf ("[%06lx] %s,%d: mixer_command %02x %04x %04x",
11501 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command,
11502 plci->li_cmd));
11503
11504 Info = GOOD;
11505 a = plci->adapter;
11506 internal_command = plci->internal_command;
11507 plci->internal_command = 0;
11508 switch (plci->li_cmd)
11509 {
11510 case LI_REQ_CONNECT:
11511 case LI_REQ_DISCONNECT:
11512 case LI_REQ_SILENT_UPDATE:
11513 switch (internal_command)
11514 {
11515 default:
11516 if (plci->li_channel_bits & LI_CHANNEL_INVOLVED)
11517 {
11518 adjust_b1_resource (Id, plci, NULL, (word)(plci->B1_facilities |
11519 B1_FACILITY_MIXER), MIXER_COMMAND_1);
11520 }
11521 case MIXER_COMMAND_1:
11522 if (plci->li_channel_bits & LI_CHANNEL_INVOLVED)
11523 {
11524 if (adjust_b_process (Id, plci, Rc) != GOOD)
11525 {
11526 dbug (1, dprintf ("[%06lx] %s,%d: Load mixer failed",
11527 UnMapId (Id), (char *)(FILE_), __LINE__));
11528 Info = _FACILITY_NOT_SUPPORTED;
11529 break;
11530 }
11531 if (plci->internal_command)
11532 return;
11533 }
11534 plci->li_plci_b_req_pos = plci->li_plci_b_write_pos;
11535 if ((plci->li_channel_bits & LI_CHANNEL_INVOLVED)
11536 || ((get_b1_facilities (plci, plci->B1_resource) & B1_FACILITY_MIXER)
11537 && (add_b1_facilities (plci, plci->B1_resource, (word)(plci->B1_facilities &
11538 ~B1_FACILITY_MIXER)) == plci->B1_resource)))
11539 {
11540 xconnect_write_coefs (plci, MIXER_COMMAND_2);
11541 }
11542 else
11543 {
11544 do
11545 {
11546 mixer_indication_coefs_set (Id, plci);
11547 } while (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos);
11548 }
11549 case MIXER_COMMAND_2:
11550 if ((plci->li_channel_bits & LI_CHANNEL_INVOLVED)
11551 || ((get_b1_facilities (plci, plci->B1_resource) & B1_FACILITY_MIXER)
11552 && (add_b1_facilities (plci, plci->B1_resource, (word)(plci->B1_facilities &
11553 ~B1_FACILITY_MIXER)) == plci->B1_resource)))
11554 {
11555 if (!xconnect_write_coefs_process (Id, plci, Rc))
11556 {
11557 dbug (1, dprintf ("[%06lx] %s,%d: Write mixer coefs failed",
11558 UnMapId (Id), (char *)(FILE_), __LINE__));
11559 if (plci->li_plci_b_write_pos != plci->li_plci_b_req_pos)
11560 {
11561 do
11562 {
11563 plci->li_plci_b_write_pos = (plci->li_plci_b_write_pos == 0) ?
11564 LI_PLCI_B_QUEUE_ENTRIES-1 : plci->li_plci_b_write_pos - 1;
11565 i = (plci->li_plci_b_write_pos == 0) ?
11566 LI_PLCI_B_QUEUE_ENTRIES-1 : plci->li_plci_b_write_pos - 1;
11567 } while ((plci->li_plci_b_write_pos != plci->li_plci_b_req_pos)
11568 && !(plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG));
11569 }
11570 Info = _FACILITY_NOT_SUPPORTED;
11571 break;
11572 }
11573 if (plci->internal_command)
11574 return;
11575 }
11576 if (!(plci->li_channel_bits & LI_CHANNEL_INVOLVED))
11577 {
11578 adjust_b1_resource (Id, plci, NULL, (word)(plci->B1_facilities &
11579 ~B1_FACILITY_MIXER), MIXER_COMMAND_3);
11580 }
11581 case MIXER_COMMAND_3:
11582 if (!(plci->li_channel_bits & LI_CHANNEL_INVOLVED))
11583 {
11584 if (adjust_b_process (Id, plci, Rc) != GOOD)
11585 {
11586 dbug (1, dprintf ("[%06lx] %s,%d: Unload mixer failed",
11587 UnMapId (Id), (char *)(FILE_), __LINE__));
11588 Info = _FACILITY_NOT_SUPPORTED;
11589 break;
11590 }
11591 if (plci->internal_command)
11592 return;
11593 }
11594 break;
11595 }
11596 break;
11597 }
11598 if ((plci->li_bchannel_id == 0)
11599 || (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci))
11600 {
11601 dbug (1, dprintf ("[%06x] %s,%d: Channel id wiped out %d",
11602 UnMapId (Id), (char *)(FILE_), __LINE__, (int)(plci->li_bchannel_id)));
11603 }
11604 else
11605 {
11606 i = a->li_base + (plci->li_bchannel_id - 1);
11607 li_config_table[i].curchnl = plci->li_channel_bits;
11608 if (!a->li_pri && (plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
11609 {
11610 i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
11611 li_config_table[i].curchnl = plci->li_channel_bits;
11612 if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
11613 {
11614 i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
11615 li_config_table[i].curchnl = plci->li_channel_bits;
11616 }
11617 }
11618 }
11619 }
11620
11621
11622 static void li_update_connect (dword Id, DIVA_CAPI_ADAPTER *a, PLCI *plci,
11623 dword plci_b_id, byte connect, dword li_flags)
11624 {
11625 word i, ch_a, ch_a_v, ch_a_s, ch_b, ch_b_v, ch_b_s;
11626 PLCI *plci_b;
11627 DIVA_CAPI_ADAPTER *a_b;
11628
11629 a_b = &(adapter[MapController ((byte)(plci_b_id & 0x7f)) - 1]);
11630 plci_b = &(a_b->plci[((plci_b_id >> 8) & 0xff) - 1]);
11631 ch_a = a->li_base + (plci->li_bchannel_id - 1);
11632 if (!a->li_pri && (plci->tel == ADV_VOICE)
11633 && (plci == a->AdvSignalPLCI) && (Id & EXT_CONTROLLER))
11634 {
11635 ch_a_v = ch_a + MIXER_IC_CHANNEL_BASE;
11636 ch_a_s = (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11637 a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id) : ch_a_v;
11638 }
11639 else
11640 {
11641 ch_a_v = ch_a;
11642 ch_a_s = ch_a;
11643 }
11644 ch_b = a_b->li_base + (plci_b->li_bchannel_id - 1);
11645 if (!a_b->li_pri && (plci_b->tel == ADV_VOICE)
11646 && (plci_b == a_b->AdvSignalPLCI) && (plci_b_id & EXT_CONTROLLER))
11647 {
11648 ch_b_v = ch_b + MIXER_IC_CHANNEL_BASE;
11649 ch_b_s = (a_b->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11650 a_b->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci_b->li_bchannel_id) : ch_b_v;
11651 }
11652 else
11653 {
11654 ch_b_v = ch_b;
11655 ch_b_s = ch_b;
11656 }
11657 if (connect)
11658 {
11659 li_config_table[ch_a].flag_table[ch_a_v] &= ~LI_FLAG_MONITOR;
11660 li_config_table[ch_a].flag_table[ch_a_s] &= ~LI_FLAG_MONITOR;
11661 li_config_table[ch_a_v].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11662 li_config_table[ch_a_s].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11663 }
11664 li_config_table[ch_a].flag_table[ch_b_v] &= ~LI_FLAG_MONITOR;
11665 li_config_table[ch_a].flag_table[ch_b_s] &= ~LI_FLAG_MONITOR;
11666 li_config_table[ch_b_v].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11667 li_config_table[ch_b_s].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11668 if (ch_a_v == ch_b_v)
11669 {
11670 li_config_table[ch_a_v].flag_table[ch_b_v] &= ~LI_FLAG_CONFERENCE;
11671 li_config_table[ch_a_s].flag_table[ch_b_s] &= ~LI_FLAG_CONFERENCE;
11672 }
11673 else
11674 {
11675 if (li_config_table[ch_a_v].flag_table[ch_b_v] & LI_FLAG_CONFERENCE)
11676 {
11677 for (i = 0; i < li_total_channels; i++)
11678 {
11679 if (i != ch_a_v)
11680 li_config_table[ch_a_v].flag_table[i] &= ~LI_FLAG_CONFERENCE;
11681 }
11682 }
11683 if (li_config_table[ch_a_s].flag_table[ch_b_v] & LI_FLAG_CONFERENCE)
11684 {
11685 for (i = 0; i < li_total_channels; i++)
11686 {
11687 if (i != ch_a_s)
11688 li_config_table[ch_a_s].flag_table[i] &= ~LI_FLAG_CONFERENCE;
11689 }
11690 }
11691 if (li_config_table[ch_b_v].flag_table[ch_a_v] & LI_FLAG_CONFERENCE)
11692 {
11693 for (i = 0; i < li_total_channels; i++)
11694 {
11695 if (i != ch_a_v)
11696 li_config_table[i].flag_table[ch_a_v] &= ~LI_FLAG_CONFERENCE;
11697 }
11698 }
11699 if (li_config_table[ch_b_v].flag_table[ch_a_s] & LI_FLAG_CONFERENCE)
11700 {
11701 for (i = 0; i < li_total_channels; i++)
11702 {
11703 if (i != ch_a_s)
11704 li_config_table[i].flag_table[ch_a_s] &= ~LI_FLAG_CONFERENCE;
11705 }
11706 }
11707 }
11708 if (li_flags & LI_FLAG_CONFERENCE_A_B)
11709 {
11710 li_config_table[ch_b_v].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11711 li_config_table[ch_b_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11712 li_config_table[ch_b_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11713 li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11714 }
11715 if (li_flags & LI_FLAG_CONFERENCE_B_A)
11716 {
11717 li_config_table[ch_a_v].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11718 li_config_table[ch_a_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11719 li_config_table[ch_a_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11720 li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11721 }
11722 if (li_flags & LI_FLAG_MONITOR_A)
11723 {
11724 li_config_table[ch_a].flag_table[ch_a_v] |= LI_FLAG_MONITOR;
11725 li_config_table[ch_a].flag_table[ch_a_s] |= LI_FLAG_MONITOR;
11726 }
11727 if (li_flags & LI_FLAG_MONITOR_B)
11728 {
11729 li_config_table[ch_a].flag_table[ch_b_v] |= LI_FLAG_MONITOR;
11730 li_config_table[ch_a].flag_table[ch_b_s] |= LI_FLAG_MONITOR;
11731 }
11732 if (li_flags & LI_FLAG_ANNOUNCEMENT_A)
11733 {
11734 li_config_table[ch_a_v].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11735 li_config_table[ch_a_s].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11736 }
11737 if (li_flags & LI_FLAG_ANNOUNCEMENT_B)
11738 {
11739 li_config_table[ch_b_v].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11740 li_config_table[ch_b_s].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11741 }
11742 if (li_flags & LI_FLAG_MIX_A)
11743 {
11744 li_config_table[ch_a_v].flag_table[ch_a] |= LI_FLAG_MIX;
11745 li_config_table[ch_a_s].flag_table[ch_a] |= LI_FLAG_MIX;
11746 }
11747 if (li_flags & LI_FLAG_MIX_B)
11748 {
11749 li_config_table[ch_b_v].flag_table[ch_a] |= LI_FLAG_MIX;
11750 li_config_table[ch_b_s].flag_table[ch_a] |= LI_FLAG_MIX;
11751 }
11752 if (ch_a_v != ch_a_s)
11753 {
11754 li_config_table[ch_a_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11755 li_config_table[ch_a_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11756 }
11757 if (ch_b_v != ch_b_s)
11758 {
11759 li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11760 li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11761 }
11762 }
11763
11764
11765 static void li2_update_connect (dword Id, DIVA_CAPI_ADAPTER *a, PLCI *plci,
11766 dword plci_b_id, byte connect, dword li_flags)
11767 {
11768 word ch_a, ch_a_v, ch_a_s, ch_b, ch_b_v, ch_b_s;
11769 PLCI *plci_b;
11770 DIVA_CAPI_ADAPTER *a_b;
11771
11772 a_b = &(adapter[MapController ((byte)(plci_b_id & 0x7f)) - 1]);
11773 plci_b = &(a_b->plci[((plci_b_id >> 8) & 0xff) - 1]);
11774 ch_a = a->li_base + (plci->li_bchannel_id - 1);
11775 if (!a->li_pri && (plci->tel == ADV_VOICE)
11776 && (plci == a->AdvSignalPLCI) && (Id & EXT_CONTROLLER))
11777 {
11778 ch_a_v = ch_a + MIXER_IC_CHANNEL_BASE;
11779 ch_a_s = (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11780 a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id) : ch_a_v;
11781 }
11782 else
11783 {
11784 ch_a_v = ch_a;
11785 ch_a_s = ch_a;
11786 }
11787 ch_b = a_b->li_base + (plci_b->li_bchannel_id - 1);
11788 if (!a_b->li_pri && (plci_b->tel == ADV_VOICE)
11789 && (plci_b == a_b->AdvSignalPLCI) && (plci_b_id & EXT_CONTROLLER))
11790 {
11791 ch_b_v = ch_b + MIXER_IC_CHANNEL_BASE;
11792 ch_b_s = (a_b->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11793 a_b->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci_b->li_bchannel_id) : ch_b_v;
11794 }
11795 else
11796 {
11797 ch_b_v = ch_b;
11798 ch_b_s = ch_b;
11799 }
11800 if (connect)
11801 {
11802 li_config_table[ch_b].flag_table[ch_b_v] &= ~LI_FLAG_MONITOR;
11803 li_config_table[ch_b].flag_table[ch_b_s] &= ~LI_FLAG_MONITOR;
11804 li_config_table[ch_b_v].flag_table[ch_b] &= ~LI_FLAG_MIX;
11805 li_config_table[ch_b_s].flag_table[ch_b] &= ~LI_FLAG_MIX;
11806 li_config_table[ch_b].flag_table[ch_b] &= ~LI_FLAG_PCCONNECT;
11807 li_config_table[ch_b].chflags &= ~(LI_CHFLAG_MONITOR | LI_CHFLAG_MIX | LI_CHFLAG_LOOP);
11808 }
11809 li_config_table[ch_b_v].flag_table[ch_a_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11810 li_config_table[ch_b_s].flag_table[ch_a_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11811 li_config_table[ch_b_v].flag_table[ch_a_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11812 li_config_table[ch_b_s].flag_table[ch_a_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11813 li_config_table[ch_a_v].flag_table[ch_b_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11814 li_config_table[ch_a_v].flag_table[ch_b_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11815 li_config_table[ch_a_s].flag_table[ch_b_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11816 li_config_table[ch_a_s].flag_table[ch_b_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11817 if (li_flags & LI2_FLAG_INTERCONNECT_A_B)
11818 {
11819 li_config_table[ch_b_v].flag_table[ch_a_v] |= LI_FLAG_INTERCONNECT;
11820 li_config_table[ch_b_s].flag_table[ch_a_v] |= LI_FLAG_INTERCONNECT;
11821 li_config_table[ch_b_v].flag_table[ch_a_s] |= LI_FLAG_INTERCONNECT;
11822 li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_INTERCONNECT;
11823 }
11824 if (li_flags & LI2_FLAG_INTERCONNECT_B_A)
11825 {
11826 li_config_table[ch_a_v].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11827 li_config_table[ch_a_v].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11828 li_config_table[ch_a_s].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11829 li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11830 }
11831 if (li_flags & LI2_FLAG_MONITOR_B)
11832 {
11833 li_config_table[ch_b].flag_table[ch_b_v] |= LI_FLAG_MONITOR;
11834 li_config_table[ch_b].flag_table[ch_b_s] |= LI_FLAG_MONITOR;
11835 }
11836 if (li_flags & LI2_FLAG_MIX_B)
11837 {
11838 li_config_table[ch_b_v].flag_table[ch_b] |= LI_FLAG_MIX;
11839 li_config_table[ch_b_s].flag_table[ch_b] |= LI_FLAG_MIX;
11840 }
11841 if (li_flags & LI2_FLAG_MONITOR_X)
11842 li_config_table[ch_b].chflags |= LI_CHFLAG_MONITOR;
11843 if (li_flags & LI2_FLAG_MIX_X)
11844 li_config_table[ch_b].chflags |= LI_CHFLAG_MIX;
11845 if (li_flags & LI2_FLAG_LOOP_B)
11846 {
11847 li_config_table[ch_b_v].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11848 li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11849 li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11850 li_config_table[ch_b_s].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11851 }
11852 if (li_flags & LI2_FLAG_LOOP_PC)
11853 li_config_table[ch_b].flag_table[ch_b] |= LI_FLAG_PCCONNECT;
11854 if (li_flags & LI2_FLAG_LOOP_X)
11855 li_config_table[ch_b].chflags |= LI_CHFLAG_LOOP;
11856 if (li_flags & LI2_FLAG_PCCONNECT_A_B)
11857 li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_PCCONNECT;
11858 if (li_flags & LI2_FLAG_PCCONNECT_B_A)
11859 li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_PCCONNECT;
11860 if (ch_a_v != ch_a_s)
11861 {
11862 li_config_table[ch_a_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11863 li_config_table[ch_a_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11864 }
11865 if (ch_b_v != ch_b_s)
11866 {
11867 li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11868 li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11869 }
11870 }
11871
11872
11873 static word li_check_main_plci (dword Id, PLCI *plci)
11874 {
11875 if (plci == NULL)
11876 {
11877 dbug (1, dprintf ("[%06lx] %s,%d: Wrong PLCI",
11878 UnMapId (Id), (char *)(FILE_), __LINE__));
11879 return (_WRONG_IDENTIFIER);
11880 }
11881 if (!plci->State
11882 || !plci->NL.Id || plci->nl_remove_id
11883 || (plci->li_bchannel_id == 0))
11884 {
11885 dbug (1, dprintf ("[%06lx] %s,%d: Wrong state",
11886 UnMapId (Id), (char *)(FILE_), __LINE__));
11887 return (_WRONG_STATE);
11888 }
11889 li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci = plci;
11890 return (GOOD);
11891 }
11892
11893
11894 static PLCI *li_check_plci_b (dword Id, PLCI *plci,
11895 dword plci_b_id, word plci_b_write_pos, byte *p_result)
11896 {
11897 byte ctlr_b;
11898 PLCI *plci_b;
11899
11900 if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
11901 LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2)
11902 {
11903 dbug (1, dprintf ("[%06lx] %s,%d: LI request overrun",
11904 UnMapId (Id), (char *)(FILE_), __LINE__));
11905 PUT_WORD (p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE);
11906 return (NULL);
11907 }
11908 ctlr_b = 0;
11909 if ((plci_b_id & 0x7f) != 0)
11910 {
11911 ctlr_b = MapController ((byte)(plci_b_id & 0x7f));
11912 if ((ctlr_b > max_adapter) || ((ctlr_b != 0) && (adapter[ctlr_b - 1].request == NULL)))
11913 ctlr_b = 0;
11914 }
11915 if ((ctlr_b == 0)
11916 || (((plci_b_id >> 8) & 0xff) == 0)
11917 || (((plci_b_id >> 8) & 0xff) > adapter[ctlr_b - 1].max_plci))
11918 {
11919 dbug (1, dprintf ("[%06lx] %s,%d: LI invalid second PLCI %08lx",
11920 UnMapId (Id), (char *)(FILE_), __LINE__, plci_b_id));
11921 PUT_WORD (p_result, _WRONG_IDENTIFIER);
11922 return (NULL);
11923 }
11924 plci_b = &(adapter[ctlr_b - 1].plci[((plci_b_id >> 8) & 0xff) - 1]);
11925 if (!plci_b->State
11926 || !plci_b->NL.Id || plci_b->nl_remove_id
11927 || (plci_b->li_bchannel_id == 0))
11928 {
11929 dbug (1, dprintf ("[%06lx] %s,%d: LI peer in wrong state %08lx",
11930 UnMapId (Id), (char *)(FILE_), __LINE__, plci_b_id));
11931 PUT_WORD (p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE);
11932 return (NULL);
11933 }
11934 li_config_table[plci_b->adapter->li_base + (plci_b->li_bchannel_id - 1)].plci = plci_b;
11935 if (((byte)(plci_b_id & ~EXT_CONTROLLER)) !=
11936 ((byte)(UnMapController (plci->adapter->Id) & ~EXT_CONTROLLER))
11937 && (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
11938 || !(plci_b->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)))
11939 {
11940 dbug (1, dprintf ("[%06lx] %s,%d: LI not on same ctrl %08lx",
11941 UnMapId (Id), (char *)(FILE_), __LINE__, plci_b_id));
11942 PUT_WORD (p_result, _WRONG_IDENTIFIER);
11943 return (NULL);
11944 }
11945 if (!(get_b1_facilities (plci_b, add_b1_facilities (plci_b, plci_b->B1_resource,
11946 (word)(plci_b->B1_facilities | B1_FACILITY_MIXER))) & B1_FACILITY_MIXER))
11947 {
11948 dbug (1, dprintf ("[%06lx] %s,%d: Interconnect peer cannot mix %d",
11949 UnMapId (Id), (char *)(FILE_), __LINE__, plci_b->B1_resource));
11950 PUT_WORD (p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE);
11951 return (NULL);
11952 }
11953 return (plci_b);
11954 }
11955
11956
11957 static PLCI *li2_check_plci_b (dword Id, PLCI *plci,
11958 dword plci_b_id, word plci_b_write_pos, byte *p_result)
11959 {
11960 byte ctlr_b;
11961 PLCI *plci_b;
11962
11963 if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
11964 LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2)
11965 {
11966 dbug (1, dprintf ("[%06lx] %s,%d: LI request overrun",
11967 UnMapId (Id), (char *)(FILE_), __LINE__));
11968 PUT_WORD (p_result, _WRONG_STATE);
11969 return (NULL);
11970 }
11971 ctlr_b = 0;
11972 if ((plci_b_id & 0x7f) != 0)
11973 {
11974 ctlr_b = MapController ((byte)(plci_b_id & 0x7f));
11975 if ((ctlr_b > max_adapter) || ((ctlr_b != 0) && (adapter[ctlr_b - 1].request == NULL)))
11976 ctlr_b = 0;
11977 }
11978 if ((ctlr_b == 0)
11979 || (((plci_b_id >> 8) & 0xff) == 0)
11980 || (((plci_b_id >> 8) & 0xff) > adapter[ctlr_b - 1].max_plci))
11981 {
11982 dbug (1, dprintf ("[%06lx] %s,%d: LI invalid second PLCI %08lx",
11983 UnMapId (Id), (char *)(FILE_), __LINE__, plci_b_id));
11984 PUT_WORD (p_result, _WRONG_IDENTIFIER);
11985 return (NULL);
11986 }
11987 plci_b = &(adapter[ctlr_b - 1].plci[((plci_b_id >> 8) & 0xff) - 1]);
11988 if (!plci_b->State
11989 || !plci_b->NL.Id || plci_b->nl_remove_id
11990 || (plci_b->li_bchannel_id == 0)
11991 || (li_config_table[plci_b->adapter->li_base + (plci_b->li_bchannel_id - 1)].plci != plci_b))
11992 {
11993 dbug (1, dprintf ("[%06lx] %s,%d: LI peer in wrong state %08lx",
11994 UnMapId (Id), (char *)(FILE_), __LINE__, plci_b_id));
11995 PUT_WORD (p_result, _WRONG_STATE);
11996 return (NULL);
11997 }
11998 if (((byte)(plci_b_id & ~EXT_CONTROLLER)) !=
11999 ((byte)(UnMapController (plci->adapter->Id) & ~EXT_CONTROLLER))
12000 && (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12001 || !(plci_b->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)))
12002 {
12003 dbug (1, dprintf ("[%06lx] %s,%d: LI not on same ctrl %08lx",
12004 UnMapId (Id), (char *)(FILE_), __LINE__, plci_b_id));
12005 PUT_WORD (p_result, _WRONG_IDENTIFIER);
12006 return (NULL);
12007 }
12008 if (!(get_b1_facilities (plci_b, add_b1_facilities (plci_b, plci_b->B1_resource,
12009 (word)(plci_b->B1_facilities | B1_FACILITY_MIXER))) & B1_FACILITY_MIXER))
12010 {
12011 dbug (1, dprintf ("[%06lx] %s,%d: Interconnect peer cannot mix %d",
12012 UnMapId (Id), (char *)(FILE_), __LINE__, plci_b->B1_resource));
12013 PUT_WORD (p_result, _WRONG_STATE);
12014 return (NULL);
12015 }
12016 return (plci_b);
12017 }
12018
12019
12020 static byte mixer_request (dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg)
12021 {
12022 word Info;
12023 word i;
12024 dword d, li_flags, plci_b_id;
12025 PLCI *plci_b;
12026 API_PARSE li_parms[3];
12027 API_PARSE li_req_parms[3];
12028 API_PARSE li_participant_struct[2];
12029 API_PARSE li_participant_parms[3];
12030 word participant_parms_pos;
12031 byte result_buffer[32];
12032 byte *result;
12033 word result_pos;
12034 word plci_b_write_pos;
12035
12036 dbug (1, dprintf ("[%06lx] %s,%d: mixer_request",
12037 UnMapId (Id), (char *)(FILE_), __LINE__));
12038
12039 Info = GOOD;
12040 result = result_buffer;
12041 result_buffer[0] = 0;
12042 if (!(a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED))
12043 {
12044 dbug (1, dprintf ("[%06lx] %s,%d: Facility not supported",
12045 UnMapId (Id), (char *)(FILE_), __LINE__));
12046 Info = _FACILITY_NOT_SUPPORTED;
12047 }
12048 else if (api_parse (&msg[1].info[1], msg[1].length, "ws", li_parms))
12049 {
12050 dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
12051 UnMapId (Id), (char *)(FILE_), __LINE__));
12052 Info = _WRONG_MESSAGE_FORMAT;
12053 }
12054 else
12055 {
12056 result_buffer[0] = 3;
12057 PUT_WORD (&result_buffer[1], GET_WORD (li_parms[0].info));
12058 result_buffer[3] = 0;
12059 switch (GET_WORD (li_parms[0].info))
12060 {
12061 case LI_GET_SUPPORTED_SERVICES:
12062 if (appl->appl_flags & APPL_FLAG_OLD_LI_SPEC)
12063 {
12064 result_buffer[0] = 17;
12065 result_buffer[3] = 14;
12066 PUT_WORD (&result_buffer[4], GOOD);
12067 d = 0;
12068 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_CH)
12069 d |= LI_CONFERENCING_SUPPORTED;
12070 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_PC)
12071 d |= LI_MONITORING_SUPPORTED;
12072 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_CH)
12073 d |= LI_ANNOUNCEMENTS_SUPPORTED | LI_MIXING_SUPPORTED;
12074 if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12075 d |= LI_CROSS_CONTROLLER_SUPPORTED;
12076 PUT_DWORD (&result_buffer[6], d);
12077 if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12078 {
12079 d = 0;
12080 for (i = 0; i < li_total_channels; i++)
12081 {
12082 if ((li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12083 && (li_config_table[i].adapter->li_pri
12084 || (i < li_config_table[i].adapter->li_base + MIXER_BCHANNELS_BRI)))
12085 {
12086 d++;
12087 }
12088 }
12089 }
12090 else
12091 {
12092 d = a->li_pri ? a->li_channels : MIXER_BCHANNELS_BRI;
12093 }
12094 PUT_DWORD (&result_buffer[10], d / 2);
12095 PUT_DWORD (&result_buffer[14], d);
12096 }
12097 else
12098 {
12099 result_buffer[0] = 25;
12100 result_buffer[3] = 22;
12101 PUT_WORD (&result_buffer[4], GOOD);
12102 d = LI2_ASYMMETRIC_SUPPORTED | LI2_B_LOOPING_SUPPORTED | LI2_X_LOOPING_SUPPORTED;
12103 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_PC)
12104 d |= LI2_MONITORING_SUPPORTED | LI2_REMOTE_MONITORING_SUPPORTED;
12105 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_CH)
12106 d |= LI2_MIXING_SUPPORTED | LI2_REMOTE_MIXING_SUPPORTED;
12107 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_PC)
12108 d |= LI2_PC_LOOPING_SUPPORTED;
12109 if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12110 d |= LI2_CROSS_CONTROLLER_SUPPORTED;
12111 PUT_DWORD (&result_buffer[6], d);
12112 d = a->li_pri ? a->li_channels : MIXER_BCHANNELS_BRI;
12113 PUT_DWORD (&result_buffer[10], d / 2);
12114 PUT_DWORD (&result_buffer[14], d - 1);
12115 if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12116 {
12117 d = 0;
12118 for (i = 0; i < li_total_channels; i++)
12119 {
12120 if ((li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12121 && (li_config_table[i].adapter->li_pri
12122 || (i < li_config_table[i].adapter->li_base + MIXER_BCHANNELS_BRI)))
12123 {
12124 d++;
12125 }
12126 }
12127 }
12128 PUT_DWORD (&result_buffer[18], d / 2);
12129 PUT_DWORD (&result_buffer[22], d - 1);
12130 }
12131 break;
12132
12133 case LI_REQ_CONNECT:
12134 if (li_parms[1].length == 8)
12135 {
12136 appl->appl_flags |= APPL_FLAG_OLD_LI_SPEC;
12137 if (api_parse (&li_parms[1].info[1], li_parms[1].length, "dd", li_req_parms))
12138 {
12139 dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
12140 UnMapId (Id), (char *)(FILE_), __LINE__));
12141 Info = _WRONG_MESSAGE_FORMAT;
12142 break;
12143 }
12144 plci_b_id = GET_DWORD (li_req_parms[0].info) & 0xffff;
12145 li_flags = GET_DWORD (li_req_parms[1].info);
12146 Info = li_check_main_plci (Id, plci);
12147 result_buffer[0] = 9;
12148 result_buffer[3] = 6;
12149 PUT_DWORD (&result_buffer[4], plci_b_id);
12150 PUT_WORD (&result_buffer[8], GOOD);
12151 if (Info != GOOD)
12152 break;
12153 result = plci->saved_msg.info;
12154 for (i = 0; i <= result_buffer[0]; i++)
12155 result[i] = result_buffer[i];
12156 plci_b_write_pos = plci->li_plci_b_write_pos;
12157 plci_b = li_check_plci_b (Id, plci, plci_b_id, plci_b_write_pos, &result[8]);
12158 if (plci_b == NULL)
12159 break;
12160 li_update_connect (Id, a, plci, plci_b_id, true, li_flags);
12161 plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_LAST_FLAG;
12162 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES-1) ? 0 : plci_b_write_pos + 1;
12163 plci->li_plci_b_write_pos = plci_b_write_pos;
12164 }
12165 else
12166 {
12167 appl->appl_flags &= ~APPL_FLAG_OLD_LI_SPEC;
12168 if (api_parse (&li_parms[1].info[1], li_parms[1].length, "ds", li_req_parms))
12169 {
12170 dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
12171 UnMapId (Id), (char *)(FILE_), __LINE__));
12172 Info = _WRONG_MESSAGE_FORMAT;
12173 break;
12174 }
12175 li_flags = GET_DWORD (li_req_parms[0].info) & ~(LI2_FLAG_INTERCONNECT_A_B | LI2_FLAG_INTERCONNECT_B_A);
12176 Info = li_check_main_plci (Id, plci);
12177 result_buffer[0] = 7;
12178 result_buffer[3] = 4;
12179 PUT_WORD (&result_buffer[4], Info);
12180 result_buffer[6] = 0;
12181 if (Info != GOOD)
12182 break;
12183 result = plci->saved_msg.info;
12184 for (i = 0; i <= result_buffer[0]; i++)
12185 result[i] = result_buffer[i];
12186 plci_b_write_pos = plci->li_plci_b_write_pos;
12187 participant_parms_pos = 0;
12188 result_pos = 7;
12189 li2_update_connect (Id, a, plci, UnMapId (Id), true, li_flags);
12190 while (participant_parms_pos < li_req_parms[1].length)
12191 {
12192 result[result_pos] = 6;
12193 result_pos += 7;
12194 PUT_DWORD (&result[result_pos - 6], 0);
12195 PUT_WORD (&result[result_pos - 2], GOOD);
12196 if (api_parse (&li_req_parms[1].info[1 + participant_parms_pos],
12197 (word)(li_parms[1].length - participant_parms_pos), "s", li_participant_struct))
12198 {
12199 dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
12200 UnMapId (Id), (char *)(FILE_), __LINE__));
12201 PUT_WORD (&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12202 break;
12203 }
12204 if (api_parse (&li_participant_struct[0].info[1],
12205 li_participant_struct[0].length, "dd", li_participant_parms))
12206 {
12207 dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
12208 UnMapId (Id), (char *)(FILE_), __LINE__));
12209 PUT_WORD (&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12210 break;
12211 }
12212 plci_b_id = GET_DWORD (li_participant_parms[0].info) & 0xffff;
12213 li_flags = GET_DWORD (li_participant_parms[1].info);
12214 PUT_DWORD (&result[result_pos - 6], plci_b_id);
12215 if (sizeof(result) - result_pos < 7)
12216 {
12217 dbug (1, dprintf ("[%06lx] %s,%d: LI result overrun",
12218 UnMapId (Id), (char *)(FILE_), __LINE__));
12219 PUT_WORD (&result[result_pos - 2], _WRONG_STATE);
12220 break;
12221 }
12222 plci_b = li2_check_plci_b (Id, plci, plci_b_id, plci_b_write_pos, &result[result_pos - 2]);
12223 if (plci_b != NULL)
12224 {
12225 li2_update_connect (Id, a, plci, plci_b_id, true, li_flags);
12226 plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id |
12227 ((li_flags & (LI2_FLAG_INTERCONNECT_A_B | LI2_FLAG_INTERCONNECT_B_A |
12228 LI2_FLAG_PCCONNECT_A_B | LI2_FLAG_PCCONNECT_B_A)) ? 0 : LI_PLCI_B_DISC_FLAG);
12229 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES-1) ? 0 : plci_b_write_pos + 1;
12230 }
12231 participant_parms_pos = (word)((&li_participant_struct[0].info[1 + li_participant_struct[0].length]) -
12232 (&li_req_parms[1].info[1]));
12233 }
12234 result[0] = (byte)(result_pos - 1);
12235 result[3] = (byte)(result_pos - 4);
12236 result[6] = (byte)(result_pos - 7);
12237 i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES-1 : plci_b_write_pos - 1;
12238 if ((plci_b_write_pos == plci->li_plci_b_read_pos)
12239 || (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG))
12240 {
12241 plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_FLAG | LI_PLCI_B_LAST_FLAG;
12242 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES-1) ? 0 : plci_b_write_pos + 1;
12243 }
12244 else
12245 plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG;
12246 plci->li_plci_b_write_pos = plci_b_write_pos;
12247 }
12248 mixer_calculate_coefs (a);
12249 plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel;
12250 mixer_notify_update (plci, true);
12251 sendf (appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
12252 "wwS", Info, SELECTOR_LINE_INTERCONNECT, result);
12253 plci->command = 0;
12254 plci->li_cmd = GET_WORD (li_parms[0].info);
12255 start_internal_command (Id, plci, mixer_command);
12256 return (false);
12257
12258 case LI_REQ_DISCONNECT:
12259 if (li_parms[1].length == 4)
12260 {
12261 appl->appl_flags |= APPL_FLAG_OLD_LI_SPEC;
12262 if (api_parse (&li_parms[1].info[1], li_parms[1].length, "d", li_req_parms))
12263 {
12264 dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
12265 UnMapId (Id), (char *)(FILE_), __LINE__));
12266 Info = _WRONG_MESSAGE_FORMAT;
12267 break;
12268 }
12269 plci_b_id = GET_DWORD (li_req_parms[0].info) & 0xffff;
12270 Info = li_check_main_plci (Id, plci);
12271 result_buffer[0] = 9;
12272 result_buffer[3] = 6;
12273 PUT_DWORD (&result_buffer[4], GET_DWORD (li_req_parms[0].info));
12274 PUT_WORD (&result_buffer[8], GOOD);
12275 if (Info != GOOD)
12276 break;
12277 result = plci->saved_msg.info;
12278 for (i = 0; i <= result_buffer[0]; i++)
12279 result[i] = result_buffer[i];
12280 plci_b_write_pos = plci->li_plci_b_write_pos;
12281 plci_b = li_check_plci_b (Id, plci, plci_b_id, plci_b_write_pos, &result[8]);
12282 if (plci_b == NULL)
12283 break;
12284 li_update_connect (Id, a, plci, plci_b_id, false, 0);
12285 plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG | LI_PLCI_B_LAST_FLAG;
12286 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES-1) ? 0 : plci_b_write_pos + 1;
12287 plci->li_plci_b_write_pos = plci_b_write_pos;
12288 }
12289 else
12290 {
12291 appl->appl_flags &= ~APPL_FLAG_OLD_LI_SPEC;
12292 if (api_parse (&li_parms[1].info[1], li_parms[1].length, "s", li_req_parms))
12293 {
12294 dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
12295 UnMapId (Id), (char *)(FILE_), __LINE__));
12296 Info = _WRONG_MESSAGE_FORMAT;
12297 break;
12298 }
12299 Info = li_check_main_plci (Id, plci);
12300 result_buffer[0] = 7;
12301 result_buffer[3] = 4;
12302 PUT_WORD (&result_buffer[4], Info);
12303 result_buffer[6] = 0;
12304 if (Info != GOOD)
12305 break;
12306 result = plci->saved_msg.info;
12307 for (i = 0; i <= result_buffer[0]; i++)
12308 result[i] = result_buffer[i];
12309 plci_b_write_pos = plci->li_plci_b_write_pos;
12310 participant_parms_pos = 0;
12311 result_pos = 7;
12312 while (participant_parms_pos < li_req_parms[0].length)
12313 {
12314 result[result_pos] = 6;
12315 result_pos += 7;
12316 PUT_DWORD (&result[result_pos - 6], 0);
12317 PUT_WORD (&result[result_pos - 2], GOOD);
12318 if (api_parse (&li_req_parms[0].info[1 + participant_parms_pos],
12319 (word)(li_parms[1].length - participant_parms_pos), "s", li_participant_struct))
12320 {
12321 dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
12322 UnMapId (Id), (char *)(FILE_), __LINE__));
12323 PUT_WORD (&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12324 break;
12325 }
12326 if (api_parse (&li_participant_struct[0].info[1],
12327 li_participant_struct[0].length, "d", li_participant_parms))
12328 {
12329 dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
12330 UnMapId (Id), (char *)(FILE_), __LINE__));
12331 PUT_WORD (&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12332 break;
12333 }
12334 plci_b_id = GET_DWORD (li_participant_parms[0].info) & 0xffff;
12335 PUT_DWORD (&result[result_pos - 6], plci_b_id);
12336 if (sizeof(result) - result_pos < 7)
12337 {
12338 dbug (1, dprintf ("[%06lx] %s,%d: LI result overrun",
12339 UnMapId (Id), (char *)(FILE_), __LINE__));
12340 PUT_WORD (&result[result_pos - 2], _WRONG_STATE);
12341 break;
12342 }
12343 plci_b = li2_check_plci_b (Id, plci, plci_b_id, plci_b_write_pos, &result[result_pos - 2]);
12344 if (plci_b != NULL)
12345 {
12346 li2_update_connect (Id, a, plci, plci_b_id, false, 0);
12347 plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG;
12348 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES-1) ? 0 : plci_b_write_pos + 1;
12349 }
12350 participant_parms_pos = (word)((&li_participant_struct[0].info[1 + li_participant_struct[0].length]) -
12351 (&li_req_parms[0].info[1]));
12352 }
12353 result[0] = (byte)(result_pos - 1);
12354 result[3] = (byte)(result_pos - 4);
12355 result[6] = (byte)(result_pos - 7);
12356 i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES-1 : plci_b_write_pos - 1;
12357 if ((plci_b_write_pos == plci->li_plci_b_read_pos)
12358 || (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG))
12359 {
12360 plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_FLAG | LI_PLCI_B_LAST_FLAG;
12361 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES-1) ? 0 : plci_b_write_pos + 1;
12362 }
12363 else
12364 plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG;
12365 plci->li_plci_b_write_pos = plci_b_write_pos;
12366 }
12367 mixer_calculate_coefs (a);
12368 plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel;
12369 mixer_notify_update (plci, true);
12370 sendf (appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
12371 "wwS", Info, SELECTOR_LINE_INTERCONNECT, result);
12372 plci->command = 0;
12373 plci->li_cmd = GET_WORD (li_parms[0].info);
12374 start_internal_command (Id, plci, mixer_command);
12375 return (false);
12376
12377 case LI_REQ_SILENT_UPDATE:
12378 if (!plci || !plci->State
12379 || !plci->NL.Id || plci->nl_remove_id
12380 || (plci->li_bchannel_id == 0)
12381 || (li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci != plci))
12382 {
12383 dbug (1, dprintf ("[%06lx] %s,%d: Wrong state",
12384 UnMapId (Id), (char *)(FILE_), __LINE__));
12385 return (false);
12386 }
12387 plci_b_write_pos = plci->li_plci_b_write_pos;
12388 if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
12389 LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2)
12390 {
12391 dbug (1, dprintf ("[%06lx] %s,%d: LI request overrun",
12392 UnMapId (Id), (char *)(FILE_), __LINE__));
12393 return (false);
12394 }
12395 i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES-1 : plci_b_write_pos - 1;
12396 if ((plci_b_write_pos == plci->li_plci_b_read_pos)
12397 || (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG))
12398 {
12399 plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_FLAG | LI_PLCI_B_LAST_FLAG;
12400 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES-1) ? 0 : plci_b_write_pos + 1;
12401 }
12402 else
12403 plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG;
12404 plci->li_plci_b_write_pos = plci_b_write_pos;
12405 plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel;
12406 plci->command = 0;
12407 plci->li_cmd = GET_WORD (li_parms[0].info);
12408 start_internal_command (Id, plci, mixer_command);
12409 return (false);
12410
12411 default:
12412 dbug (1, dprintf ("[%06lx] %s,%d: LI unknown request %04x",
12413 UnMapId (Id), (char *)(FILE_), __LINE__, GET_WORD (li_parms[0].info)));
12414 Info = _FACILITY_NOT_SUPPORTED;
12415 }
12416 }
12417 sendf (appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
12418 "wwS", Info, SELECTOR_LINE_INTERCONNECT, result);
12419 return (false);
12420 }
12421
12422
12423 static void mixer_indication_coefs_set (dword Id, PLCI *plci)
12424 {
12425 dword d;
12426 DIVA_CAPI_ADAPTER *a;
12427 byte result[12];
12428
12429 dbug (1, dprintf ("[%06lx] %s,%d: mixer_indication_coefs_set",
12430 UnMapId (Id), (char *)(FILE_), __LINE__));
12431
12432 a = plci->adapter;
12433 if (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos)
12434 {
12435 do
12436 {
12437 d = plci->li_plci_b_queue[plci->li_plci_b_read_pos];
12438 if (!(d & LI_PLCI_B_SKIP_FLAG))
12439 {
12440 if (plci->appl->appl_flags & APPL_FLAG_OLD_LI_SPEC)
12441 {
12442 if (d & LI_PLCI_B_DISC_FLAG)
12443 {
12444 result[0] = 5;
12445 PUT_WORD (&result[1], LI_IND_DISCONNECT);
12446 result[3] = 2;
12447 PUT_WORD (&result[4], _LI_USER_INITIATED);
12448 }
12449 else
12450 {
12451 result[0] = 7;
12452 PUT_WORD (&result[1], LI_IND_CONNECT_ACTIVE);
12453 result[3] = 4;
12454 PUT_DWORD (&result[4], d & ~LI_PLCI_B_FLAG_MASK);
12455 }
12456 }
12457 else
12458 {
12459 if (d & LI_PLCI_B_DISC_FLAG)
12460 {
12461 result[0] = 9;
12462 PUT_WORD (&result[1], LI_IND_DISCONNECT);
12463 result[3] = 6;
12464 PUT_DWORD (&result[4], d & ~LI_PLCI_B_FLAG_MASK);
12465 PUT_WORD (&result[8], _LI_USER_INITIATED);
12466 }
12467 else
12468 {
12469 result[0] = 7;
12470 PUT_WORD (&result[1], LI_IND_CONNECT_ACTIVE);
12471 result[3] = 4;
12472 PUT_DWORD (&result[4], d & ~LI_PLCI_B_FLAG_MASK);
12473 }
12474 }
12475 sendf (plci->appl, _FACILITY_I, Id & 0xffffL, 0,
12476 "ws", SELECTOR_LINE_INTERCONNECT, result);
12477 }
12478 plci->li_plci_b_read_pos = (plci->li_plci_b_read_pos == LI_PLCI_B_QUEUE_ENTRIES-1) ?
12479 0 : plci->li_plci_b_read_pos + 1;
12480 } while (!(d & LI_PLCI_B_LAST_FLAG) && (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos));
12481 }
12482 }
12483
12484
12485 static void mixer_indication_xconnect_from (dword Id, PLCI *plci, byte *msg, word length)
12486 {
12487 word i, j, ch;
12488 struct xconnect_transfer_address_s s, *p;
12489 DIVA_CAPI_ADAPTER *a;
12490
12491 dbug (1, dprintf ("[%06lx] %s,%d: mixer_indication_xconnect_from %d",
12492 UnMapId (Id), (char *)(FILE_), __LINE__, (int) length));
12493
12494 a = plci->adapter;
12495 i = 1;
12496 for (i = 1; i < length; i += 16)
12497 {
12498 s.card_address.low = msg[i] | (msg[i+1] << 8) | (((dword)(msg[i+2])) << 16) | (((dword)(msg[i+3])) << 24);
12499 s.card_address.high = msg[i+4] | (msg[i+5] << 8) | (((dword)(msg[i+6])) << 16) | (((dword)(msg[i+7])) << 24);
12500 s.offset = msg[i+8] | (msg[i+9] << 8) | (((dword)(msg[i+10])) << 16) | (((dword)(msg[i+11])) << 24);
12501 ch = msg[i+12] | (msg[i+13] << 8);
12502 j = ch & XCONNECT_CHANNEL_NUMBER_MASK;
12503 if (!a->li_pri && (plci->li_bchannel_id == 2))
12504 j = 1 - j;
12505 j += a->li_base;
12506 if (ch & XCONNECT_CHANNEL_PORT_PC)
12507 p = &(li_config_table[j].send_pc);
12508 else
12509 p = &(li_config_table[j].send_b);
12510 p->card_address.low = s.card_address.low;
12511 p->card_address.high = s.card_address.high;
12512 p->offset = s.offset;
12513 li_config_table[j].channel |= LI_CHANNEL_ADDRESSES_SET;
12514 }
12515 if (plci->internal_command_queue[0]
12516 && ((plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2)
12517 || (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_3)
12518 || (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_4)))
12519 {
12520 (*(plci->internal_command_queue[0]))(Id, plci, 0);
12521 if (!plci->internal_command)
12522 next_internal_command (Id, plci);
12523 }
12524 mixer_notify_update (plci, true);
12525 }
12526
12527
12528 static void mixer_indication_xconnect_to (dword Id, PLCI *plci, byte *msg, word length)
12529 {
12530
12531 dbug (1, dprintf ("[%06lx] %s,%d: mixer_indication_xconnect_to %d",
12532 UnMapId (Id), (char *)(FILE_), __LINE__, (int) length));
12533
12534 }
12535
12536
12537 static byte mixer_notify_source_removed (PLCI *plci, dword plci_b_id)
12538 {
12539 word plci_b_write_pos;
12540
12541 plci_b_write_pos = plci->li_plci_b_write_pos;
12542 if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
12543 LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 1)
12544 {
12545 dbug (1, dprintf ("[%06lx] %s,%d: LI request overrun",
12546 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
12547 (char *)(FILE_), __LINE__));
12548 return (false);
12549 }
12550 plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG;
12551 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES-1) ? 0 : plci_b_write_pos + 1;
12552 plci->li_plci_b_write_pos = plci_b_write_pos;
12553 return (true);
12554 }
12555
12556
12557 static void mixer_remove (PLCI *plci)
12558 {
12559 DIVA_CAPI_ADAPTER *a;
12560 PLCI *notify_plci;
12561 dword plci_b_id;
12562 word i, j;
12563
12564 dbug (1, dprintf ("[%06lx] %s,%d: mixer_remove",
12565 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
12566 (char *)(FILE_), __LINE__));
12567
12568 a = plci->adapter;
12569 plci_b_id = (plci->Id << 8) | UnMapController (plci->adapter->Id);
12570 if (a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED)
12571 {
12572 if ((plci->li_bchannel_id != 0)
12573 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
12574 {
12575 i = a->li_base + (plci->li_bchannel_id - 1);
12576 if ((li_config_table[i].curchnl | li_config_table[i].channel) & LI_CHANNEL_INVOLVED)
12577 {
12578 for (j = 0; j < li_total_channels; j++)
12579 {
12580 if ((li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
12581 || (li_config_table[j].flag_table[i] & LI_FLAG_INTERCONNECT))
12582 {
12583 notify_plci = li_config_table[j].plci;
12584 if ((notify_plci != NULL)
12585 && (notify_plci != plci)
12586 && (notify_plci->appl != NULL)
12587 && !(notify_plci->appl->appl_flags & APPL_FLAG_OLD_LI_SPEC)
12588 && (notify_plci->State)
12589 && notify_plci->NL.Id && !notify_plci->nl_remove_id)
12590 {
12591 mixer_notify_source_removed (notify_plci, plci_b_id);
12592 }
12593 }
12594 }
12595 mixer_clear_config (plci);
12596 mixer_calculate_coefs (a);
12597 mixer_notify_update (plci, true);
12598 }
12599 li_config_table[i].plci = NULL;
12600 plci->li_bchannel_id = 0;
12601 }
12602 }
12603 }
12604
12605
12606 /*------------------------------------------------------------------*/
12607 /* Echo canceller facilities */
12608 /*------------------------------------------------------------------*/
12609
12610
12611 static void ec_write_parameters (PLCI *plci)
12612 {
12613 word w;
12614 byte parameter_buffer[6];
12615
12616 dbug (1, dprintf ("[%06lx] %s,%d: ec_write_parameters",
12617 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
12618 (char *)(FILE_), __LINE__));
12619
12620 parameter_buffer[0] = 5;
12621 parameter_buffer[1] = DSP_CTRL_SET_LEC_PARAMETERS;
12622 PUT_WORD (&parameter_buffer[2], plci->ec_idi_options);
12623 plci->ec_idi_options &= ~LEC_RESET_COEFFICIENTS;
12624 w = (plci->ec_tail_length == 0) ? 128 : plci->ec_tail_length;
12625 PUT_WORD (&parameter_buffer[4], w);
12626 add_p (plci, FTY, parameter_buffer);
12627 sig_req (plci, TEL_CTRL, 0);
12628 send_req (plci);
12629 }
12630
12631
12632 static void ec_clear_config (PLCI *plci)
12633 {
12634
12635 dbug (1, dprintf ("[%06lx] %s,%d: ec_clear_config",
12636 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
12637 (char *)(FILE_), __LINE__));
12638
12639 plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER |
12640 LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING;
12641 plci->ec_tail_length = 0;
12642 }
12643
12644
12645 static void ec_prepare_switch (dword Id, PLCI *plci)
12646 {
12647
12648 dbug (1, dprintf ("[%06lx] %s,%d: ec_prepare_switch",
12649 UnMapId (Id), (char *)(FILE_), __LINE__));
12650
12651 }
12652
12653
12654 static word ec_save_config (dword Id, PLCI *plci, byte Rc)
12655 {
12656
12657 dbug (1, dprintf ("[%06lx] %s,%d: ec_save_config %02x %d",
12658 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
12659
12660 return (GOOD);
12661 }
12662
12663
12664 static word ec_restore_config (dword Id, PLCI *plci, byte Rc)
12665 {
12666 word Info;
12667
12668 dbug (1, dprintf ("[%06lx] %s,%d: ec_restore_config %02x %d",
12669 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
12670
12671 Info = GOOD;
12672 if (plci->B1_facilities & B1_FACILITY_EC)
12673 {
12674 switch (plci->adjust_b_state)
12675 {
12676 case ADJUST_B_RESTORE_EC_1:
12677 plci->internal_command = plci->adjust_b_command;
12678 if (plci->sig_req)
12679 {
12680 plci->adjust_b_state = ADJUST_B_RESTORE_EC_1;
12681 break;
12682 }
12683 ec_write_parameters (plci);
12684 plci->adjust_b_state = ADJUST_B_RESTORE_EC_2;
12685 break;
12686 case ADJUST_B_RESTORE_EC_2:
12687 if ((Rc != OK) && (Rc != OK_FC))
12688 {
12689 dbug (1, dprintf ("[%06lx] %s,%d: Restore EC failed %02x",
12690 UnMapId (Id), (char *)(FILE_), __LINE__, Rc));
12691 Info = _WRONG_STATE;
12692 break;
12693 }
12694 break;
12695 }
12696 }
12697 return (Info);
12698 }
12699
12700
12701 static void ec_command (dword Id, PLCI *plci, byte Rc)
12702 {
12703 word internal_command, Info;
12704 byte result[8];
12705
12706 dbug (1, dprintf ("[%06lx] %s,%d: ec_command %02x %04x %04x %04x %d",
12707 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command,
12708 plci->ec_cmd, plci->ec_idi_options, plci->ec_tail_length));
12709
12710 Info = GOOD;
12711 if (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC)
12712 {
12713 result[0] = 2;
12714 PUT_WORD (&result[1], EC_SUCCESS);
12715 }
12716 else
12717 {
12718 result[0] = 5;
12719 PUT_WORD (&result[1], plci->ec_cmd);
12720 result[3] = 2;
12721 PUT_WORD (&result[4], GOOD);
12722 }
12723 internal_command = plci->internal_command;
12724 plci->internal_command = 0;
12725 switch (plci->ec_cmd)
12726 {
12727 case EC_ENABLE_OPERATION:
12728 case EC_FREEZE_COEFFICIENTS:
12729 case EC_RESUME_COEFFICIENT_UPDATE:
12730 case EC_RESET_COEFFICIENTS:
12731 switch (internal_command)
12732 {
12733 default:
12734 adjust_b1_resource (Id, plci, NULL, (word)(plci->B1_facilities |
12735 B1_FACILITY_EC), EC_COMMAND_1);
12736 case EC_COMMAND_1:
12737 if (adjust_b_process (Id, plci, Rc) != GOOD)
12738 {
12739 dbug (1, dprintf ("[%06lx] %s,%d: Load EC failed",
12740 UnMapId (Id), (char *)(FILE_), __LINE__));
12741 Info = _FACILITY_NOT_SUPPORTED;
12742 break;
12743 }
12744 if (plci->internal_command)
12745 return;
12746 case EC_COMMAND_2:
12747 if (plci->sig_req)
12748 {
12749 plci->internal_command = EC_COMMAND_2;
12750 return;
12751 }
12752 plci->internal_command = EC_COMMAND_3;
12753 ec_write_parameters (plci);
12754 return;
12755 case EC_COMMAND_3:
12756 if ((Rc != OK) && (Rc != OK_FC))
12757 {
12758 dbug (1, dprintf ("[%06lx] %s,%d: Enable EC failed %02x",
12759 UnMapId (Id), (char *)(FILE_), __LINE__, Rc));
12760 Info = _FACILITY_NOT_SUPPORTED;
12761 break;
12762 }
12763 break;
12764 }
12765 break;
12766
12767 case EC_DISABLE_OPERATION:
12768 switch (internal_command)
12769 {
12770 default:
12771 case EC_COMMAND_1:
12772 if (plci->B1_facilities & B1_FACILITY_EC)
12773 {
12774 if (plci->sig_req)
12775 {
12776 plci->internal_command = EC_COMMAND_1;
12777 return;
12778 }
12779 plci->internal_command = EC_COMMAND_2;
12780 ec_write_parameters (plci);
12781 return;
12782 }
12783 Rc = OK;
12784 case EC_COMMAND_2:
12785 if ((Rc != OK) && (Rc != OK_FC))
12786 {
12787 dbug (1, dprintf ("[%06lx] %s,%d: Disable EC failed %02x",
12788 UnMapId (Id), (char *)(FILE_), __LINE__, Rc));
12789 Info = _FACILITY_NOT_SUPPORTED;
12790 break;
12791 }
12792 adjust_b1_resource (Id, plci, NULL, (word)(plci->B1_facilities &
12793 ~B1_FACILITY_EC), EC_COMMAND_3);
12794 case EC_COMMAND_3:
12795 if (adjust_b_process (Id, plci, Rc) != GOOD)
12796 {
12797 dbug (1, dprintf ("[%06lx] %s,%d: Unload EC failed",
12798 UnMapId (Id), (char *)(FILE_), __LINE__));
12799 Info = _FACILITY_NOT_SUPPORTED;
12800 break;
12801 }
12802 if (plci->internal_command)
12803 return;
12804 break;
12805 }
12806 break;
12807 }
12808 sendf (plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->number,
12809 "wws", Info, (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ?
12810 PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result);
12811 }
12812
12813
12814 static byte ec_request (dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg)
12815 {
12816 word Info;
12817 word opt;
12818 API_PARSE ec_parms[3];
12819 byte result[16];
12820
12821 dbug (1, dprintf ("[%06lx] %s,%d: ec_request",
12822 UnMapId (Id), (char *)(FILE_), __LINE__));
12823
12824 Info = GOOD;
12825 result[0] = 0;
12826 if (!(a->man_profile.private_options & (1L << PRIVATE_ECHO_CANCELLER)))
12827 {
12828 dbug (1, dprintf ("[%06lx] %s,%d: Facility not supported",
12829 UnMapId (Id), (char *)(FILE_), __LINE__));
12830 Info = _FACILITY_NOT_SUPPORTED;
12831 }
12832 else
12833 {
12834 if (appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC)
12835 {
12836 if (api_parse (&msg[1].info[1], msg[1].length, "w", ec_parms))
12837 {
12838 dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
12839 UnMapId (Id), (char *)(FILE_), __LINE__));
12840 Info = _WRONG_MESSAGE_FORMAT;
12841 }
12842 else
12843 {
12844 if (plci == NULL)
12845 {
12846 dbug (1, dprintf ("[%06lx] %s,%d: Wrong PLCI",
12847 UnMapId (Id), (char *)(FILE_), __LINE__));
12848 Info = _WRONG_IDENTIFIER;
12849 }
12850 else if (!plci->State || !plci->NL.Id || plci->nl_remove_id)
12851 {
12852 dbug (1, dprintf ("[%06lx] %s,%d: Wrong state",
12853 UnMapId (Id), (char *)(FILE_), __LINE__));
12854 Info = _WRONG_STATE;
12855 }
12856 else
12857 {
12858 plci->command = 0;
12859 plci->ec_cmd = GET_WORD (ec_parms[0].info);
12860 plci->ec_idi_options &= ~(LEC_MANUAL_DISABLE | LEC_RESET_COEFFICIENTS);
12861 result[0] = 2;
12862 PUT_WORD (&result[1], EC_SUCCESS);
12863 if (msg[1].length >= 4)
12864 {
12865 opt = GET_WORD (&ec_parms[0].info[2]);
12866 plci->ec_idi_options &= ~(LEC_ENABLE_NONLINEAR_PROCESSING |
12867 LEC_ENABLE_2100HZ_DETECTOR | LEC_REQUIRE_2100HZ_REVERSALS);
12868 if (!(opt & EC_DISABLE_NON_LINEAR_PROCESSING))
12869 plci->ec_idi_options |= LEC_ENABLE_NONLINEAR_PROCESSING;
12870 if (opt & EC_DETECT_DISABLE_TONE)
12871 plci->ec_idi_options |= LEC_ENABLE_2100HZ_DETECTOR;
12872 if (!(opt & EC_DO_NOT_REQUIRE_REVERSALS))
12873 plci->ec_idi_options |= LEC_REQUIRE_2100HZ_REVERSALS;
12874 if (msg[1].length >= 6)
12875 {
12876 plci->ec_tail_length = GET_WORD (&ec_parms[0].info[4]);
12877 }
12878 }
12879 switch (plci->ec_cmd)
12880 {
12881 case EC_ENABLE_OPERATION:
12882 plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS;
12883 start_internal_command (Id, plci, ec_command);
12884 return (false);
12885
12886 case EC_DISABLE_OPERATION:
12887 plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER |
12888 LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING |
12889 LEC_RESET_COEFFICIENTS;
12890 start_internal_command (Id, plci, ec_command);
12891 return (false);
12892
12893 case EC_FREEZE_COEFFICIENTS:
12894 plci->ec_idi_options |= LEC_FREEZE_COEFFICIENTS;
12895 start_internal_command (Id, plci, ec_command);
12896 return (false);
12897
12898 case EC_RESUME_COEFFICIENT_UPDATE:
12899 plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS;
12900 start_internal_command (Id, plci, ec_command);
12901 return (false);
12902
12903 case EC_RESET_COEFFICIENTS:
12904 plci->ec_idi_options |= LEC_RESET_COEFFICIENTS;
12905 start_internal_command (Id, plci, ec_command);
12906 return (false);
12907
12908 default:
12909 dbug (1, dprintf ("[%06lx] %s,%d: EC unknown request %04x",
12910 UnMapId (Id), (char *)(FILE_), __LINE__, plci->ec_cmd));
12911 PUT_WORD (&result[1], EC_UNSUPPORTED_OPERATION);
12912 }
12913 }
12914 }
12915 }
12916 else
12917 {
12918 if (api_parse (&msg[1].info[1], msg[1].length, "ws", ec_parms))
12919 {
12920 dbug (1, dprintf ("[%06lx] %s,%d: Wrong message format",
12921 UnMapId (Id), (char *)(FILE_), __LINE__));
12922 Info = _WRONG_MESSAGE_FORMAT;
12923 }
12924 else
12925 {
12926 if (GET_WORD (ec_parms[0].info) == EC_GET_SUPPORTED_SERVICES)
12927 {
12928 result[0] = 11;
12929 PUT_WORD (&result[1], EC_GET_SUPPORTED_SERVICES);
12930 result[3] = 8;
12931 PUT_WORD (&result[4], GOOD);
12932 PUT_WORD (&result[6], 0x0007);
12933 PUT_WORD (&result[8], LEC_MAX_SUPPORTED_TAIL_LENGTH);
12934 PUT_WORD (&result[10], 0);
12935 }
12936 else if (plci == NULL)
12937 {
12938 dbug (1, dprintf ("[%06lx] %s,%d: Wrong PLCI",
12939 UnMapId (Id), (char *)(FILE_), __LINE__));
12940 Info = _WRONG_IDENTIFIER;
12941 }
12942 else if (!plci->State || !plci->NL.Id || plci->nl_remove_id)
12943 {
12944 dbug (1, dprintf ("[%06lx] %s,%d: Wrong state",
12945 UnMapId (Id), (char *)(FILE_), __LINE__));
12946 Info = _WRONG_STATE;
12947 }
12948 else
12949 {
12950 plci->command = 0;
12951 plci->ec_cmd = GET_WORD (ec_parms[0].info);
12952 plci->ec_idi_options &= ~(LEC_MANUAL_DISABLE | LEC_RESET_COEFFICIENTS);
12953 result[0] = 5;
12954 PUT_WORD (&result[1], plci->ec_cmd);
12955 result[3] = 2;
12956 PUT_WORD (&result[4], GOOD);
12957 plci->ec_idi_options &= ~(LEC_ENABLE_NONLINEAR_PROCESSING |
12958 LEC_ENABLE_2100HZ_DETECTOR | LEC_REQUIRE_2100HZ_REVERSALS);
12959 plci->ec_tail_length = 0;
12960 if (ec_parms[1].length >= 2)
12961 {
12962 opt = GET_WORD (&ec_parms[1].info[1]);
12963 if (opt & EC_ENABLE_NON_LINEAR_PROCESSING)
12964 plci->ec_idi_options |= LEC_ENABLE_NONLINEAR_PROCESSING;
12965 if (opt & EC_DETECT_DISABLE_TONE)
12966 plci->ec_idi_options |= LEC_ENABLE_2100HZ_DETECTOR;
12967 if (!(opt & EC_DO_NOT_REQUIRE_REVERSALS))
12968 plci->ec_idi_options |= LEC_REQUIRE_2100HZ_REVERSALS;
12969 if (ec_parms[1].length >= 4)
12970 {
12971 plci->ec_tail_length = GET_WORD (&ec_parms[1].info[3]);
12972 }
12973 }
12974 switch (plci->ec_cmd)
12975 {
12976 case EC_ENABLE_OPERATION:
12977 plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS;
12978 start_internal_command (Id, plci, ec_command);
12979 return (false);
12980
12981 case EC_DISABLE_OPERATION:
12982 plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER |
12983 LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING |
12984 LEC_RESET_COEFFICIENTS;
12985 start_internal_command (Id, plci, ec_command);
12986 return (false);
12987
12988 default:
12989 dbug (1, dprintf ("[%06lx] %s,%d: EC unknown request %04x",
12990 UnMapId (Id), (char *)(FILE_), __LINE__, plci->ec_cmd));
12991 PUT_WORD (&result[4], _FACILITY_SPECIFIC_FUNCTION_NOT_SUPP);
12992 }
12993 }
12994 }
12995 }
12996 }
12997 sendf (appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
12998 "wws", Info, (appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ?
12999 PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result);
13000 return (false);
13001 }
13002
13003
13004 static void ec_indication (dword Id, PLCI *plci, byte *msg, word length)
13005 {
13006 byte result[8];
13007
13008 dbug (1, dprintf ("[%06lx] %s,%d: ec_indication",
13009 UnMapId (Id), (char *)(FILE_), __LINE__));
13010
13011 if (!(plci->ec_idi_options & LEC_MANUAL_DISABLE))
13012 {
13013 if (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC)
13014 {
13015 result[0] = 2;
13016 PUT_WORD (&result[1], 0);
13017 switch (msg[1])
13018 {
13019 case LEC_DISABLE_TYPE_CONTIGNUOUS_2100HZ:
13020 PUT_WORD (&result[1], EC_BYPASS_DUE_TO_CONTINUOUS_2100HZ);
13021 break;
13022 case LEC_DISABLE_TYPE_REVERSED_2100HZ:
13023 PUT_WORD (&result[1], EC_BYPASS_DUE_TO_REVERSED_2100HZ);
13024 break;
13025 case LEC_DISABLE_RELEASED:
13026 PUT_WORD (&result[1], EC_BYPASS_RELEASED);
13027 break;
13028 }
13029 }
13030 else
13031 {
13032 result[0] = 5;
13033 PUT_WORD (&result[1], EC_BYPASS_INDICATION);
13034 result[3] = 2;
13035 PUT_WORD (&result[4], 0);
13036 switch (msg[1])
13037 {
13038 case LEC_DISABLE_TYPE_CONTIGNUOUS_2100HZ:
13039 PUT_WORD (&result[4], EC_BYPASS_DUE_TO_CONTINUOUS_2100HZ);
13040 break;
13041 case LEC_DISABLE_TYPE_REVERSED_2100HZ:
13042 PUT_WORD (&result[4], EC_BYPASS_DUE_TO_REVERSED_2100HZ);
13043 break;
13044 case LEC_DISABLE_RELEASED:
13045 PUT_WORD (&result[4], EC_BYPASS_RELEASED);
13046 break;
13047 }
13048 }
13049 sendf (plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ?
13050 PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result);
13051 }
13052 }
13053
13054
13055
13056 /*------------------------------------------------------------------*/
13057 /* Advanced voice */
13058 /*------------------------------------------------------------------*/
13059
13060 static void adv_voice_write_coefs (PLCI *plci, word write_command)
13061 {
13062 DIVA_CAPI_ADAPTER *a;
13063 word i;
13064 byte *p;
13065
13066 word w, n, j, k;
13067 byte ch_map[MIXER_CHANNELS_BRI];
13068
13069 byte coef_buffer[ADV_VOICE_COEF_BUFFER_SIZE + 2];
13070
13071 dbug (1, dprintf ("[%06lx] %s,%d: adv_voice_write_coefs %d",
13072 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
13073 (char *)(FILE_), __LINE__, write_command));
13074
13075 a = plci->adapter;
13076 p = coef_buffer + 1;
13077 *(p++) = DSP_CTRL_OLD_SET_MIXER_COEFFICIENTS;
13078 i = 0;
13079 while (i + sizeof(word) <= a->adv_voice_coef_length)
13080 {
13081 PUT_WORD (p, GET_WORD (a->adv_voice_coef_buffer + i));
13082 p += 2;
13083 i += 2;
13084 }
13085 while (i < ADV_VOICE_OLD_COEF_COUNT * sizeof(word))
13086 {
13087 PUT_WORD (p, 0x8000);
13088 p += 2;
13089 i += 2;
13090 }
13091
13092 if (!a->li_pri && (plci->li_bchannel_id == 0))
13093 {
13094 if ((li_config_table[a->li_base].plci == NULL) && (li_config_table[a->li_base + 1].plci != NULL))
13095 {
13096 plci->li_bchannel_id = 1;
13097 li_config_table[a->li_base].plci = plci;
13098 dbug (1, dprintf ("[%06lx] %s,%d: adv_voice_set_bchannel_id %d",
13099 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
13100 (char *)(FILE_), __LINE__, plci->li_bchannel_id));
13101 }
13102 else if ((li_config_table[a->li_base].plci != NULL) && (li_config_table[a->li_base + 1].plci == NULL))
13103 {
13104 plci->li_bchannel_id = 2;
13105 li_config_table[a->li_base + 1].plci = plci;
13106 dbug (1, dprintf ("[%06lx] %s,%d: adv_voice_set_bchannel_id %d",
13107 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
13108 (char *)(FILE_), __LINE__, plci->li_bchannel_id));
13109 }
13110 }
13111 if (!a->li_pri && (plci->li_bchannel_id != 0)
13112 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
13113 {
13114 i = a->li_base + (plci->li_bchannel_id - 1);
13115 switch (write_command)
13116 {
13117 case ADV_VOICE_WRITE_ACTIVATION:
13118 j = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
13119 k = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
13120 if (!(plci->B1_facilities & B1_FACILITY_MIXER))
13121 {
13122 li_config_table[j].flag_table[i] |= LI_FLAG_CONFERENCE | LI_FLAG_MIX;
13123 li_config_table[i].flag_table[j] |= LI_FLAG_CONFERENCE | LI_FLAG_MONITOR;
13124 }
13125 if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13126 {
13127 li_config_table[k].flag_table[i] |= LI_FLAG_CONFERENCE | LI_FLAG_MIX;
13128 li_config_table[i].flag_table[k] |= LI_FLAG_CONFERENCE | LI_FLAG_MONITOR;
13129 li_config_table[k].flag_table[j] |= LI_FLAG_CONFERENCE;
13130 li_config_table[j].flag_table[k] |= LI_FLAG_CONFERENCE;
13131 }
13132 mixer_calculate_coefs (a);
13133 li_config_table[i].curchnl = li_config_table[i].channel;
13134 li_config_table[j].curchnl = li_config_table[j].channel;
13135 if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13136 li_config_table[k].curchnl = li_config_table[k].channel;
13137 break;
13138
13139 case ADV_VOICE_WRITE_DEACTIVATION:
13140 for (j = 0; j < li_total_channels; j++)
13141 {
13142 li_config_table[i].flag_table[j] = 0;
13143 li_config_table[j].flag_table[i] = 0;
13144 }
13145 k = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
13146 for (j = 0; j < li_total_channels; j++)
13147 {
13148 li_config_table[k].flag_table[j] = 0;
13149 li_config_table[j].flag_table[k] = 0;
13150 }
13151 if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13152 {
13153 k = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
13154 for (j = 0; j < li_total_channels; j++)
13155 {
13156 li_config_table[k].flag_table[j] = 0;
13157 li_config_table[j].flag_table[k] = 0;
13158 }
13159 }
13160 mixer_calculate_coefs (a);
13161 break;
13162 }
13163 if (plci->B1_facilities & B1_FACILITY_MIXER)
13164 {
13165 w = 0;
13166 if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length)
13167 w = GET_WORD (a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE);
13168 if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
13169 w |= MIXER_FEATURE_ENABLE_TX_DATA;
13170 if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
13171 w |= MIXER_FEATURE_ENABLE_RX_DATA;
13172 *(p++) = (byte) w;
13173 *(p++) = (byte)(w >> 8);
13174 for (j = 0; j < sizeof(ch_map); j += 2)
13175 {
13176 ch_map[j] = (byte)(j + (plci->li_bchannel_id - 1));
13177 ch_map[j+1] = (byte)(j + (2 - plci->li_bchannel_id));
13178 }
13179 for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++)
13180 {
13181 i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch];
13182 j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch];
13183 if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED)
13184 {
13185 *(p++) = ((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01);
13186 w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
13187 li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4;
13188 }
13189 else
13190 {
13191 *(p++) = (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + n < a->adv_voice_coef_length) ?
13192 a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + n] : 0x00;
13193 }
13194 }
13195 }
13196 else
13197 {
13198 for (i = ADV_VOICE_NEW_COEF_BASE; i < a->adv_voice_coef_length; i++)
13199 *(p++) = a->adv_voice_coef_buffer[i];
13200 }
13201 }
13202 else
13203
13204 {
13205 for (i = ADV_VOICE_NEW_COEF_BASE; i < a->adv_voice_coef_length; i++)
13206 *(p++) = a->adv_voice_coef_buffer[i];
13207 }
13208 coef_buffer[0] = (p - coef_buffer) - 1;
13209 add_p (plci, FTY, coef_buffer);
13210 sig_req (plci, TEL_CTRL, 0);
13211 send_req (plci);
13212 }
13213
13214
13215 static void adv_voice_clear_config (PLCI *plci)
13216 {
13217 DIVA_CAPI_ADAPTER *a;
13218
13219 word i, j;
13220
13221
13222 dbug (1, dprintf ("[%06lx] %s,%d: adv_voice_clear_config",
13223 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
13224 (char *)(FILE_), __LINE__));
13225
13226 a = plci->adapter;
13227 if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
13228 {
13229 a->adv_voice_coef_length = 0;
13230
13231 if (!a->li_pri && (plci->li_bchannel_id != 0)
13232 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
13233 {
13234 i = a->li_base + (plci->li_bchannel_id - 1);
13235 li_config_table[i].curchnl = 0;
13236 li_config_table[i].channel = 0;
13237 li_config_table[i].chflags = 0;
13238 for (j = 0; j < li_total_channels; j++)
13239 {
13240 li_config_table[i].flag_table[j] = 0;
13241 li_config_table[j].flag_table[i] = 0;
13242 li_config_table[i].coef_table[j] = 0;
13243 li_config_table[j].coef_table[i] = 0;
13244 }
13245 li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET;
13246 i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
13247 li_config_table[i].curchnl = 0;
13248 li_config_table[i].channel = 0;
13249 li_config_table[i].chflags = 0;
13250 for (j = 0; j < li_total_channels; j++)
13251 {
13252 li_config_table[i].flag_table[j] = 0;
13253 li_config_table[j].flag_table[i] = 0;
13254 li_config_table[i].coef_table[j] = 0;
13255 li_config_table[j].coef_table[i] = 0;
13256 }
13257 if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13258 {
13259 i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
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 }
13271 }
13272
13273 }
13274 }
13275
13276
13277 static void adv_voice_prepare_switch (dword Id, PLCI *plci)
13278 {
13279
13280 dbug (1, dprintf ("[%06lx] %s,%d: adv_voice_prepare_switch",
13281 UnMapId (Id), (char *)(FILE_), __LINE__));
13282
13283 }
13284
13285
13286 static word adv_voice_save_config (dword Id, PLCI *plci, byte Rc)
13287 {
13288
13289 dbug (1, dprintf ("[%06lx] %s,%d: adv_voice_save_config %02x %d",
13290 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
13291
13292 return (GOOD);
13293 }
13294
13295
13296 static word adv_voice_restore_config (dword Id, PLCI *plci, byte Rc)
13297 {
13298 DIVA_CAPI_ADAPTER *a;
13299 word Info;
13300
13301 dbug (1, dprintf ("[%06lx] %s,%d: adv_voice_restore_config %02x %d",
13302 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
13303
13304 Info = GOOD;
13305 a = plci->adapter;
13306 if ((plci->B1_facilities & B1_FACILITY_VOICE)
13307 && (plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
13308 {
13309 switch (plci->adjust_b_state)
13310 {
13311 case ADJUST_B_RESTORE_VOICE_1:
13312 plci->internal_command = plci->adjust_b_command;
13313 if (plci->sig_req)
13314 {
13315 plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_1;
13316 break;
13317 }
13318 adv_voice_write_coefs (plci, ADV_VOICE_WRITE_UPDATE);
13319 plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_2;
13320 break;
13321 case ADJUST_B_RESTORE_VOICE_2:
13322 if ((Rc != OK) && (Rc != OK_FC))
13323 {
13324 dbug (1, dprintf ("[%06lx] %s,%d: Restore voice config failed %02x",
13325 UnMapId (Id), (char *)(FILE_), __LINE__, Rc));
13326 Info = _WRONG_STATE;
13327 break;
13328 }
13329 break;
13330 }
13331 }
13332 return (Info);
13333 }
13334
13335
13336
13337
13338 /*------------------------------------------------------------------*/
13339 /* B1 resource switching */
13340 /*------------------------------------------------------------------*/
13341
13342 static byte b1_facilities_table[] =
13343 {
13344 0x00, /* 0 No bchannel resources */
13345 0x00, /* 1 Codec (automatic law) */
13346 0x00, /* 2 Codec (A-law) */
13347 0x00, /* 3 Codec (y-law) */
13348 0x00, /* 4 HDLC for X.21 */
13349 0x00, /* 5 HDLC */
13350 0x00, /* 6 External Device 0 */
13351 0x00, /* 7 External Device 1 */
13352 0x00, /* 8 HDLC 56k */
13353 0x00, /* 9 Transparent */
13354 0x00, /* 10 Loopback to network */
13355 0x00, /* 11 Test pattern to net */
13356 0x00, /* 12 Rate adaptation sync */
13357 0x00, /* 13 Rate adaptation async */
13358 0x00, /* 14 R-Interface */
13359 0x00, /* 15 HDLC 128k leased line */
13360 0x00, /* 16 FAX */
13361 0x00, /* 17 Modem async */
13362 0x00, /* 18 Modem sync HDLC */
13363 0x00, /* 19 V.110 async HDLC */
13364 0x12, /* 20 Adv voice (Trans,mixer) */
13365 0x00, /* 21 Codec connected to IC */
13366 0x0c, /* 22 Trans,DTMF */
13367 0x1e, /* 23 Trans,DTMF+mixer */
13368 0x1f, /* 24 Trans,DTMF+mixer+local */
13369 0x13, /* 25 Trans,mixer+local */
13370 0x12, /* 26 HDLC,mixer */
13371 0x12, /* 27 HDLC 56k,mixer */
13372 0x2c, /* 28 Trans,LEC+DTMF */
13373 0x3e, /* 29 Trans,LEC+DTMF+mixer */
13374 0x3f, /* 30 Trans,LEC+DTMF+mixer+local */
13375 0x2c, /* 31 RTP,LEC+DTMF */
13376 0x3e, /* 32 RTP,LEC+DTMF+mixer */
13377 0x3f, /* 33 RTP,LEC+DTMF+mixer+local */
13378 0x00, /* 34 Signaling task */
13379 0x00, /* 35 PIAFS */
13380 0x0c, /* 36 Trans,DTMF+TONE */
13381 0x1e, /* 37 Trans,DTMF+TONE+mixer */
13382 0x1f /* 38 Trans,DTMF+TONE+mixer+local*/
13383 };
13384
13385
13386 static word get_b1_facilities (PLCI * plci, byte b1_resource)
13387 {
13388 word b1_facilities;
13389
13390 b1_facilities = b1_facilities_table[b1_resource];
13391 if ((b1_resource == 9) || (b1_resource == 20) || (b1_resource == 25))
13392 {
13393
13394 if (!(((plci->requested_options_conn | plci->requested_options) & (1L << PRIVATE_DTMF_TONE))
13395 || (plci->appl && (plci->adapter->requested_options_table[plci->appl->Id-1] & (1L << PRIVATE_DTMF_TONE)))))
13396
13397 {
13398 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_SEND)
13399 b1_facilities |= B1_FACILITY_DTMFX;
13400 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE)
13401 b1_facilities |= B1_FACILITY_DTMFR;
13402 }
13403 }
13404 if ((b1_resource == 17) || (b1_resource == 18))
13405 {
13406 if (plci->adapter->manufacturer_features & (MANUFACTURER_FEATURE_V18 | MANUFACTURER_FEATURE_VOWN))
13407 b1_facilities |= B1_FACILITY_DTMFX | B1_FACILITY_DTMFR;
13408 }
13409 /*
13410 dbug (1, dprintf ("[%06lx] %s,%d: get_b1_facilities %d %04x",
13411 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
13412 (char far *)(FILE_), __LINE__, b1_resource, b1_facilites));
13413 */
13414 return (b1_facilities);
13415 }
13416
13417
13418 static byte add_b1_facilities (PLCI * plci, byte b1_resource, word b1_facilities)
13419 {
13420 byte b;
13421
13422 switch (b1_resource)
13423 {
13424 case 5:
13425 case 26:
13426 if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13427 b = 26;
13428 else
13429 b = 5;
13430 break;
13431
13432 case 8:
13433 case 27:
13434 if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13435 b = 27;
13436 else
13437 b = 8;
13438 break;
13439
13440 case 9:
13441 case 20:
13442 case 22:
13443 case 23:
13444 case 24:
13445 case 25:
13446 case 28:
13447 case 29:
13448 case 30:
13449 case 36:
13450 case 37:
13451 case 38:
13452 if (b1_facilities & B1_FACILITY_EC)
13453 {
13454 if (b1_facilities & B1_FACILITY_LOCAL)
13455 b = 30;
13456 else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13457 b = 29;
13458 else
13459 b = 28;
13460 }
13461
13462 else if ((b1_facilities & (B1_FACILITY_DTMFX | B1_FACILITY_DTMFR | B1_FACILITY_MIXER))
13463 && (((plci->requested_options_conn | plci->requested_options) & (1L << PRIVATE_DTMF_TONE))
13464 || (plci->appl && (plci->adapter->requested_options_table[plci->appl->Id-1] & (1L << PRIVATE_DTMF_TONE)))))
13465 {
13466 if (b1_facilities & B1_FACILITY_LOCAL)
13467 b = 38;
13468 else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13469 b = 37;
13470 else
13471 b = 36;
13472 }
13473
13474 else if (((plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_HARDDTMF)
13475 && !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE))
13476 || ((b1_facilities & B1_FACILITY_DTMFR)
13477 && ((b1_facilities & B1_FACILITY_MIXER)
13478 || !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE)))
13479 || ((b1_facilities & B1_FACILITY_DTMFX)
13480 && ((b1_facilities & B1_FACILITY_MIXER)
13481 || !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_SEND))))
13482 {
13483 if (b1_facilities & B1_FACILITY_LOCAL)
13484 b = 24;
13485 else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13486 b = 23;
13487 else
13488 b = 22;
13489 }
13490 else
13491 {
13492 if (b1_facilities & B1_FACILITY_LOCAL)
13493 b = 25;
13494 else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13495 b = 20;
13496 else
13497 b = 9;
13498 }
13499 break;
13500
13501 case 31:
13502 case 32:
13503 case 33:
13504 if (b1_facilities & B1_FACILITY_LOCAL)
13505 b = 33;
13506 else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13507 b = 32;
13508 else
13509 b = 31;
13510 break;
13511
13512 default:
13513 b = b1_resource;
13514 }
13515 dbug (1, dprintf ("[%06lx] %s,%d: add_b1_facilities %d %04x %d %04x",
13516 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
13517 (char *)(FILE_), __LINE__,
13518 b1_resource, b1_facilities, b, get_b1_facilities (plci, b)));
13519 return (b);
13520 }
13521
13522
13523 static void adjust_b1_facilities (PLCI *plci, byte new_b1_resource, word new_b1_facilities)
13524 {
13525 word removed_facilities;
13526
13527 dbug (1, dprintf ("[%06lx] %s,%d: adjust_b1_facilities %d %04x %04x",
13528 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
13529 (char *)(FILE_), __LINE__, new_b1_resource, new_b1_facilities,
13530 new_b1_facilities & get_b1_facilities (plci, new_b1_resource)));
13531
13532 new_b1_facilities &= get_b1_facilities (plci, new_b1_resource);
13533 removed_facilities = plci->B1_facilities & ~new_b1_facilities;
13534
13535 if (removed_facilities & B1_FACILITY_EC)
13536 ec_clear_config (plci);
13537
13538
13539 if (removed_facilities & B1_FACILITY_DTMFR)
13540 {
13541 dtmf_rec_clear_config (plci);
13542 dtmf_parameter_clear_config (plci);
13543 }
13544 if (removed_facilities & B1_FACILITY_DTMFX)
13545 dtmf_send_clear_config (plci);
13546
13547
13548 if (removed_facilities & B1_FACILITY_MIXER)
13549 mixer_clear_config (plci);
13550
13551 if (removed_facilities & B1_FACILITY_VOICE)
13552 adv_voice_clear_config (plci);
13553 plci->B1_facilities = new_b1_facilities;
13554 }
13555
13556
13557 static void adjust_b_clear (PLCI *plci)
13558 {
13559
13560 dbug (1, dprintf ("[%06lx] %s,%d: adjust_b_clear",
13561 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
13562 (char *)(FILE_), __LINE__));
13563
13564 plci->adjust_b_restore = false;
13565 }
13566
13567
13568 static word adjust_b_process (dword Id, PLCI *plci, byte Rc)
13569 {
13570 word Info;
13571 byte b1_resource;
13572 NCCI * ncci_ptr;
13573 API_PARSE bp[2];
13574
13575 dbug (1, dprintf ("[%06lx] %s,%d: adjust_b_process %02x %d",
13576 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
13577
13578 Info = GOOD;
13579 switch (plci->adjust_b_state)
13580 {
13581 case ADJUST_B_START:
13582 if ((plci->adjust_b_parms_msg == NULL)
13583 && (plci->adjust_b_mode & ADJUST_B_MODE_SWITCH_L1)
13584 && ((plci->adjust_b_mode & ~(ADJUST_B_MODE_SAVE | ADJUST_B_MODE_SWITCH_L1 |
13585 ADJUST_B_MODE_NO_RESOURCE | ADJUST_B_MODE_RESTORE)) == 0))
13586 {
13587 b1_resource = (plci->adjust_b_mode == ADJUST_B_MODE_NO_RESOURCE) ?
13588 0 : add_b1_facilities (plci, plci->B1_resource, plci->adjust_b_facilities);
13589 if (b1_resource == plci->B1_resource)
13590 {
13591 adjust_b1_facilities (plci, b1_resource, plci->adjust_b_facilities);
13592 break;
13593 }
13594 if (plci->adjust_b_facilities & ~get_b1_facilities (plci, b1_resource))
13595 {
13596 dbug (1, dprintf ("[%06lx] %s,%d: Adjust B nonsupported facilities %d %d %04x",
13597 UnMapId (Id), (char *)(FILE_), __LINE__,
13598 plci->B1_resource, b1_resource, plci->adjust_b_facilities));
13599 Info = _WRONG_STATE;
13600 break;
13601 }
13602 }
13603 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13604 {
13605
13606 mixer_prepare_switch (Id, plci);
13607
13608
13609 dtmf_prepare_switch (Id, plci);
13610 dtmf_parameter_prepare_switch (Id, plci);
13611
13612
13613 ec_prepare_switch (Id, plci);
13614
13615 adv_voice_prepare_switch (Id, plci);
13616 }
13617 plci->adjust_b_state = ADJUST_B_SAVE_MIXER_1;
13618 Rc = OK;
13619 case ADJUST_B_SAVE_MIXER_1:
13620 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13621 {
13622
13623 Info = mixer_save_config (Id, plci, Rc);
13624 if ((Info != GOOD) || plci->internal_command)
13625 break;
13626
13627 }
13628 plci->adjust_b_state = ADJUST_B_SAVE_DTMF_1;
13629 Rc = OK;
13630 case ADJUST_B_SAVE_DTMF_1:
13631 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13632 {
13633
13634 Info = dtmf_save_config (Id, plci, Rc);
13635 if ((Info != GOOD) || plci->internal_command)
13636 break;
13637
13638 }
13639 plci->adjust_b_state = ADJUST_B_REMOVE_L23_1;
13640 case ADJUST_B_REMOVE_L23_1:
13641 if ((plci->adjust_b_mode & ADJUST_B_MODE_REMOVE_L23)
13642 && plci->NL.Id && !plci->nl_remove_id)
13643 {
13644 plci->internal_command = plci->adjust_b_command;
13645 if (plci->adjust_b_ncci != 0)
13646 {
13647 ncci_ptr = &(plci->adapter->ncci[plci->adjust_b_ncci]);
13648 while (ncci_ptr->data_pending)
13649 {
13650 plci->data_sent_ptr = ncci_ptr->DBuffer[ncci_ptr->data_out].P;
13651 data_rc (plci, plci->adapter->ncci_ch[plci->adjust_b_ncci]);
13652 }
13653 while (ncci_ptr->data_ack_pending)
13654 data_ack (plci, plci->adapter->ncci_ch[plci->adjust_b_ncci]);
13655 }
13656 nl_req_ncci (plci, REMOVE,
13657 (byte)((plci->adjust_b_mode & ADJUST_B_MODE_CONNECT) ? plci->adjust_b_ncci : 0));
13658 send_req (plci);
13659 plci->adjust_b_state = ADJUST_B_REMOVE_L23_2;
13660 break;
13661 }
13662 plci->adjust_b_state = ADJUST_B_REMOVE_L23_2;
13663 Rc = OK;
13664 case ADJUST_B_REMOVE_L23_2:
13665 if ((Rc != OK) && (Rc != OK_FC))
13666 {
13667 dbug (1, dprintf ("[%06lx] %s,%d: Adjust B remove failed %02x",
13668 UnMapId (Id), (char *)(FILE_), __LINE__, Rc));
13669 Info = _WRONG_STATE;
13670 break;
13671 }
13672 if (plci->adjust_b_mode & ADJUST_B_MODE_REMOVE_L23)
13673 {
13674 if (plci_nl_busy (plci))
13675 {
13676 plci->internal_command = plci->adjust_b_command;
13677 break;
13678 }
13679 }
13680 plci->adjust_b_state = ADJUST_B_SAVE_EC_1;
13681 Rc = OK;
13682 case ADJUST_B_SAVE_EC_1:
13683 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13684 {
13685
13686 Info = ec_save_config (Id, plci, Rc);
13687 if ((Info != GOOD) || plci->internal_command)
13688 break;
13689
13690 }
13691 plci->adjust_b_state = ADJUST_B_SAVE_DTMF_PARAMETER_1;
13692 Rc = OK;
13693 case ADJUST_B_SAVE_DTMF_PARAMETER_1:
13694 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13695 {
13696
13697 Info = dtmf_parameter_save_config (Id, plci, Rc);
13698 if ((Info != GOOD) || plci->internal_command)
13699 break;
13700
13701 }
13702 plci->adjust_b_state = ADJUST_B_SAVE_VOICE_1;
13703 Rc = OK;
13704 case ADJUST_B_SAVE_VOICE_1:
13705 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13706 {
13707 Info = adv_voice_save_config (Id, plci, Rc);
13708 if ((Info != GOOD) || plci->internal_command)
13709 break;
13710 }
13711 plci->adjust_b_state = ADJUST_B_SWITCH_L1_1;
13712 case ADJUST_B_SWITCH_L1_1:
13713 if (plci->adjust_b_mode & ADJUST_B_MODE_SWITCH_L1)
13714 {
13715 if (plci->sig_req)
13716 {
13717 plci->internal_command = plci->adjust_b_command;
13718 break;
13719 }
13720 if (plci->adjust_b_parms_msg != NULL)
13721 api_load_msg (plci->adjust_b_parms_msg, bp);
13722 else
13723 api_load_msg (&plci->B_protocol, bp);
13724 Info = add_b1 (plci, bp,
13725 (word)((plci->adjust_b_mode & ADJUST_B_MODE_NO_RESOURCE) ? 2 : 0),
13726 plci->adjust_b_facilities);
13727 if (Info != GOOD)
13728 {
13729 dbug (1, dprintf ("[%06lx] %s,%d: Adjust B invalid L1 parameters %d %04x",
13730 UnMapId (Id), (char *)(FILE_), __LINE__,
13731 plci->B1_resource, plci->adjust_b_facilities));
13732 break;
13733 }
13734 plci->internal_command = plci->adjust_b_command;
13735 sig_req (plci, RESOURCES, 0);
13736 send_req (plci);
13737 plci->adjust_b_state = ADJUST_B_SWITCH_L1_2;
13738 break;
13739 }
13740 plci->adjust_b_state = ADJUST_B_SWITCH_L1_2;
13741 Rc = OK;
13742 case ADJUST_B_SWITCH_L1_2:
13743 if ((Rc != OK) && (Rc != OK_FC))
13744 {
13745 dbug (1, dprintf ("[%06lx] %s,%d: Adjust B switch failed %02x %d %04x",
13746 UnMapId (Id), (char *)(FILE_), __LINE__,
13747 Rc, plci->B1_resource, plci->adjust_b_facilities));
13748 Info = _WRONG_STATE;
13749 break;
13750 }
13751 plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_1;
13752 Rc = OK;
13753 case ADJUST_B_RESTORE_VOICE_1:
13754 case ADJUST_B_RESTORE_VOICE_2:
13755 if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13756 {
13757 Info = adv_voice_restore_config (Id, plci, Rc);
13758 if ((Info != GOOD) || plci->internal_command)
13759 break;
13760 }
13761 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_1;
13762 Rc = OK;
13763 case ADJUST_B_RESTORE_DTMF_PARAMETER_1:
13764 case ADJUST_B_RESTORE_DTMF_PARAMETER_2:
13765 if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13766 {
13767
13768 Info = dtmf_parameter_restore_config (Id, plci, Rc);
13769 if ((Info != GOOD) || plci->internal_command)
13770 break;
13771
13772 }
13773 plci->adjust_b_state = ADJUST_B_RESTORE_EC_1;
13774 Rc = OK;
13775 case ADJUST_B_RESTORE_EC_1:
13776 case ADJUST_B_RESTORE_EC_2:
13777 if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13778 {
13779
13780 Info = ec_restore_config (Id, plci, Rc);
13781 if ((Info != GOOD) || plci->internal_command)
13782 break;
13783
13784 }
13785 plci->adjust_b_state = ADJUST_B_ASSIGN_L23_1;
13786 case ADJUST_B_ASSIGN_L23_1:
13787 if (plci->adjust_b_mode & ADJUST_B_MODE_ASSIGN_L23)
13788 {
13789 if (plci_nl_busy (plci))
13790 {
13791 plci->internal_command = plci->adjust_b_command;
13792 break;
13793 }
13794 if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT)
13795 plci->call_dir |= CALL_DIR_FORCE_OUTG_NL;
13796 if (plci->adjust_b_parms_msg != NULL)
13797 api_load_msg (plci->adjust_b_parms_msg, bp);
13798 else
13799 api_load_msg (&plci->B_protocol, bp);
13800 Info = add_b23 (plci, bp);
13801 if (Info != GOOD)
13802 {
13803 dbug (1, dprintf ("[%06lx] %s,%d: Adjust B invalid L23 parameters %04x",
13804 UnMapId (Id), (char *)(FILE_), __LINE__, Info));
13805 break;
13806 }
13807 plci->internal_command = plci->adjust_b_command;
13808 nl_req_ncci (plci, ASSIGN, 0);
13809 send_req (plci);
13810 plci->adjust_b_state = ADJUST_B_ASSIGN_L23_2;
13811 break;
13812 }
13813 plci->adjust_b_state = ADJUST_B_ASSIGN_L23_2;
13814 Rc = ASSIGN_OK;
13815 case ADJUST_B_ASSIGN_L23_2:
13816 if ((Rc != OK) && (Rc != OK_FC) && (Rc != ASSIGN_OK))
13817 {
13818 dbug (1, dprintf ("[%06lx] %s,%d: Adjust B assign failed %02x",
13819 UnMapId (Id), (char *)(FILE_), __LINE__, Rc));
13820 Info = _WRONG_STATE;
13821 break;
13822 }
13823 if (plci->adjust_b_mode & ADJUST_B_MODE_ASSIGN_L23)
13824 {
13825 if (Rc != ASSIGN_OK)
13826 {
13827 plci->internal_command = plci->adjust_b_command;
13828 break;
13829 }
13830 }
13831 if (plci->adjust_b_mode & ADJUST_B_MODE_USER_CONNECT)
13832 {
13833 plci->adjust_b_restore = true;
13834 break;
13835 }
13836 plci->adjust_b_state = ADJUST_B_CONNECT_1;
13837 case ADJUST_B_CONNECT_1:
13838 if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT)
13839 {
13840 plci->internal_command = plci->adjust_b_command;
13841 if (plci_nl_busy (plci))
13842 break;
13843 nl_req_ncci (plci, N_CONNECT, 0);
13844 send_req (plci);
13845 plci->adjust_b_state = ADJUST_B_CONNECT_2;
13846 break;
13847 }
13848 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
13849 Rc = OK;
13850 case ADJUST_B_CONNECT_2:
13851 case ADJUST_B_CONNECT_3:
13852 case ADJUST_B_CONNECT_4:
13853 if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0))
13854 {
13855 dbug (1, dprintf ("[%06lx] %s,%d: Adjust B connect failed %02x",
13856 UnMapId (Id), (char *)(FILE_), __LINE__, Rc));
13857 Info = _WRONG_STATE;
13858 break;
13859 }
13860 if (Rc == OK)
13861 {
13862 if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT)
13863 {
13864 get_ncci (plci, (byte)(Id >> 16), plci->adjust_b_ncci);
13865 Id = (Id & 0xffff) | (((dword)(plci->adjust_b_ncci)) << 16);
13866 }
13867 if (plci->adjust_b_state == ADJUST_B_CONNECT_2)
13868 plci->adjust_b_state = ADJUST_B_CONNECT_3;
13869 else if (plci->adjust_b_state == ADJUST_B_CONNECT_4)
13870 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
13871 }
13872 else if (Rc == 0)
13873 {
13874 if (plci->adjust_b_state == ADJUST_B_CONNECT_2)
13875 plci->adjust_b_state = ADJUST_B_CONNECT_4;
13876 else if (plci->adjust_b_state == ADJUST_B_CONNECT_3)
13877 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
13878 }
13879 if (plci->adjust_b_state != ADJUST_B_RESTORE_DTMF_1)
13880 {
13881 plci->internal_command = plci->adjust_b_command;
13882 break;
13883 }
13884 Rc = OK;
13885 case ADJUST_B_RESTORE_DTMF_1:
13886 case ADJUST_B_RESTORE_DTMF_2:
13887 if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13888 {
13889
13890 Info = dtmf_restore_config (Id, plci, Rc);
13891 if ((Info != GOOD) || plci->internal_command)
13892 break;
13893
13894 }
13895 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_1;
13896 Rc = OK;
13897 case ADJUST_B_RESTORE_MIXER_1:
13898 case ADJUST_B_RESTORE_MIXER_2:
13899 case ADJUST_B_RESTORE_MIXER_3:
13900 case ADJUST_B_RESTORE_MIXER_4:
13901 case ADJUST_B_RESTORE_MIXER_5:
13902 case ADJUST_B_RESTORE_MIXER_6:
13903 case ADJUST_B_RESTORE_MIXER_7:
13904 if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13905 {
13906
13907 Info = mixer_restore_config (Id, plci, Rc);
13908 if ((Info != GOOD) || plci->internal_command)
13909 break;
13910
13911 }
13912 plci->adjust_b_state = ADJUST_B_END;
13913 case ADJUST_B_END:
13914 break;
13915 }
13916 return (Info);
13917 }
13918
13919
13920 static void adjust_b1_resource (dword Id, PLCI *plci, API_SAVE *bp_msg, word b1_facilities, word internal_command)
13921 {
13922
13923 dbug (1, dprintf ("[%06lx] %s,%d: adjust_b1_resource %d %04x",
13924 UnMapId (Id), (char *)(FILE_), __LINE__,
13925 plci->B1_resource, b1_facilities));
13926
13927 plci->adjust_b_parms_msg = bp_msg;
13928 plci->adjust_b_facilities = b1_facilities;
13929 plci->adjust_b_command = internal_command;
13930 plci->adjust_b_ncci = (word)(Id >> 16);
13931 if ((bp_msg == NULL) && (plci->B1_resource == 0))
13932 plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_NO_RESOURCE | ADJUST_B_MODE_SWITCH_L1;
13933 else
13934 plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_SWITCH_L1 | ADJUST_B_MODE_RESTORE;
13935 plci->adjust_b_state = ADJUST_B_START;
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
13941
13942 static void adjust_b_restore (dword Id, PLCI *plci, byte Rc)
13943 {
13944 word internal_command;
13945
13946 dbug (1, dprintf ("[%06lx] %s,%d: adjust_b_restore %02x %04x",
13947 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
13948
13949 internal_command = plci->internal_command;
13950 plci->internal_command = 0;
13951 switch (internal_command)
13952 {
13953 default:
13954 plci->command = 0;
13955 if (plci->req_in != 0)
13956 {
13957 plci->internal_command = ADJUST_B_RESTORE_1;
13958 break;
13959 }
13960 Rc = OK;
13961 case ADJUST_B_RESTORE_1:
13962 if ((Rc != OK) && (Rc != OK_FC))
13963 {
13964 dbug (1, dprintf ("[%06lx] %s,%d: Adjust B enqueued failed %02x",
13965 UnMapId (Id), (char *)(FILE_), __LINE__, Rc));
13966 }
13967 plci->adjust_b_parms_msg = NULL;
13968 plci->adjust_b_facilities = plci->B1_facilities;
13969 plci->adjust_b_command = ADJUST_B_RESTORE_2;
13970 plci->adjust_b_ncci = (word)(Id >> 16);
13971 plci->adjust_b_mode = ADJUST_B_MODE_RESTORE;
13972 plci->adjust_b_state = ADJUST_B_START;
13973 dbug (1, dprintf ("[%06lx] %s,%d: Adjust B restore...",
13974 UnMapId (Id), (char *)(FILE_), __LINE__));
13975 case ADJUST_B_RESTORE_2:
13976 if (adjust_b_process (Id, plci, Rc) != GOOD)
13977 {
13978 dbug (1, dprintf ("[%06lx] %s,%d: Adjust B restore failed",
13979 UnMapId (Id), (char *)(FILE_), __LINE__));
13980 }
13981 if (plci->internal_command)
13982 break;
13983 break;
13984 }
13985 }
13986
13987
13988 static void reset_b3_command (dword Id, PLCI *plci, byte Rc)
13989 {
13990 word Info;
13991 word internal_command;
13992
13993 dbug (1, dprintf ("[%06lx] %s,%d: reset_b3_command %02x %04x",
13994 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
13995
13996 Info = GOOD;
13997 internal_command = plci->internal_command;
13998 plci->internal_command = 0;
13999 switch (internal_command)
14000 {
14001 default:
14002 plci->command = 0;
14003 plci->adjust_b_parms_msg = NULL;
14004 plci->adjust_b_facilities = plci->B1_facilities;
14005 plci->adjust_b_command = RESET_B3_COMMAND_1;
14006 plci->adjust_b_ncci = (word)(Id >> 16);
14007 plci->adjust_b_mode = ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_CONNECT;
14008 plci->adjust_b_state = ADJUST_B_START;
14009 dbug (1, dprintf ("[%06lx] %s,%d: Reset B3...",
14010 UnMapId (Id), (char *)(FILE_), __LINE__));
14011 case RESET_B3_COMMAND_1:
14012 Info = adjust_b_process (Id, plci, Rc);
14013 if (Info != GOOD)
14014 {
14015 dbug (1, dprintf ("[%06lx] %s,%d: Reset failed",
14016 UnMapId (Id), (char *)(FILE_), __LINE__));
14017 break;
14018 }
14019 if (plci->internal_command)
14020 return;
14021 break;
14022 }
14023 /* sendf (plci->appl, _RESET_B3_R | CONFIRM, Id, plci->number, "w", Info);*/
14024 sendf(plci->appl,_RESET_B3_I,Id,0,"s","");
14025 }
14026
14027
14028 static void select_b_command (dword Id, PLCI *plci, byte Rc)
14029 {
14030 word Info;
14031 word internal_command;
14032 byte esc_chi[3];
14033
14034 dbug (1, dprintf ("[%06lx] %s,%d: select_b_command %02x %04x",
14035 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14036
14037 Info = GOOD;
14038 internal_command = plci->internal_command;
14039 plci->internal_command = 0;
14040 switch (internal_command)
14041 {
14042 default:
14043 plci->command = 0;
14044 plci->adjust_b_parms_msg = &plci->saved_msg;
14045 if ((plci->tel == ADV_VOICE) && (plci == plci->adapter->AdvSignalPLCI))
14046 plci->adjust_b_facilities = plci->B1_facilities | B1_FACILITY_VOICE;
14047 else
14048 plci->adjust_b_facilities = plci->B1_facilities & ~B1_FACILITY_VOICE;
14049 plci->adjust_b_command = SELECT_B_COMMAND_1;
14050 plci->adjust_b_ncci = (word)(Id >> 16);
14051 if (plci->saved_msg.parms[0].length == 0)
14052 {
14053 plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_SWITCH_L1 |
14054 ADJUST_B_MODE_NO_RESOURCE;
14055 }
14056 else
14057 {
14058 plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_SWITCH_L1 |
14059 ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_USER_CONNECT | ADJUST_B_MODE_RESTORE;
14060 }
14061 plci->adjust_b_state = ADJUST_B_START;
14062 dbug (1, dprintf ("[%06lx] %s,%d: Select B protocol...",
14063 UnMapId (Id), (char *)(FILE_), __LINE__));
14064 case SELECT_B_COMMAND_1:
14065 Info = adjust_b_process (Id, plci, Rc);
14066 if (Info != GOOD)
14067 {
14068 dbug (1, dprintf ("[%06lx] %s,%d: Select B protocol failed",
14069 UnMapId (Id), (char *)(FILE_), __LINE__));
14070 break;
14071 }
14072 if (plci->internal_command)
14073 return;
14074 if (plci->tel == ADV_VOICE)
14075 {
14076 esc_chi[0] = 0x02;
14077 esc_chi[1] = 0x18;
14078 esc_chi[2] = plci->b_channel;
14079 SetVoiceChannel (plci->adapter->AdvCodecPLCI, esc_chi, plci->adapter);
14080 }
14081 break;
14082 }
14083 sendf (plci->appl, _SELECT_B_REQ | CONFIRM, Id, plci->number, "w", Info);
14084 }
14085
14086
14087 static void fax_connect_ack_command (dword Id, PLCI *plci, byte Rc)
14088 {
14089 word Info;
14090 word internal_command;
14091
14092 dbug (1, dprintf ("[%06lx] %s,%d: fax_connect_ack_command %02x %04x",
14093 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14094
14095 Info = GOOD;
14096 internal_command = plci->internal_command;
14097 plci->internal_command = 0;
14098 switch (internal_command)
14099 {
14100 default:
14101 plci->command = 0;
14102 case FAX_CONNECT_ACK_COMMAND_1:
14103 if (plci_nl_busy (plci))
14104 {
14105 plci->internal_command = FAX_CONNECT_ACK_COMMAND_1;
14106 return;
14107 }
14108 plci->internal_command = FAX_CONNECT_ACK_COMMAND_2;
14109 plci->NData[0].P = plci->fax_connect_info_buffer;
14110 plci->NData[0].PLength = plci->fax_connect_info_length;
14111 plci->NL.X = plci->NData;
14112 plci->NL.ReqCh = 0;
14113 plci->NL.Req = plci->nl_req = (byte) N_CONNECT_ACK;
14114 plci->adapter->request (&plci->NL);
14115 return;
14116 case FAX_CONNECT_ACK_COMMAND_2:
14117 if ((Rc != OK) && (Rc != OK_FC))
14118 {
14119 dbug (1, dprintf ("[%06lx] %s,%d: FAX issue CONNECT ACK failed %02x",
14120 UnMapId (Id), (char *)(FILE_), __LINE__, Rc));
14121 break;
14122 }
14123 }
14124 if ((plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
14125 && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
14126 {
14127 if (plci->B3_prot == 4)
14128 sendf(plci->appl,_CONNECT_B3_ACTIVE_I,Id,0,"s","");
14129 else
14130 sendf(plci->appl,_CONNECT_B3_ACTIVE_I,Id,0,"S",plci->ncpi_buffer);
14131 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
14132 }
14133 }
14134
14135
14136 static void fax_edata_ack_command (dword Id, PLCI *plci, byte Rc)
14137 {
14138 word Info;
14139 word internal_command;
14140
14141 dbug (1, dprintf ("[%06lx] %s,%d: fax_edata_ack_command %02x %04x",
14142 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14143
14144 Info = GOOD;
14145 internal_command = plci->internal_command;
14146 plci->internal_command = 0;
14147 switch (internal_command)
14148 {
14149 default:
14150 plci->command = 0;
14151 case FAX_EDATA_ACK_COMMAND_1:
14152 if (plci_nl_busy (plci))
14153 {
14154 plci->internal_command = FAX_EDATA_ACK_COMMAND_1;
14155 return;
14156 }
14157 plci->internal_command = FAX_EDATA_ACK_COMMAND_2;
14158 plci->NData[0].P = plci->fax_connect_info_buffer;
14159 plci->NData[0].PLength = plci->fax_edata_ack_length;
14160 plci->NL.X = plci->NData;
14161 plci->NL.ReqCh = 0;
14162 plci->NL.Req = plci->nl_req = (byte) N_EDATA;
14163 plci->adapter->request (&plci->NL);
14164 return;
14165 case FAX_EDATA_ACK_COMMAND_2:
14166 if ((Rc != OK) && (Rc != OK_FC))
14167 {
14168 dbug (1, dprintf ("[%06lx] %s,%d: FAX issue EDATA ACK failed %02x",
14169 UnMapId (Id), (char *)(FILE_), __LINE__, Rc));
14170 break;
14171 }
14172 }
14173 }
14174
14175
14176 static void fax_connect_info_command (dword Id, PLCI *plci, byte Rc)
14177 {
14178 word Info;
14179 word internal_command;
14180
14181 dbug (1, dprintf ("[%06lx] %s,%d: fax_connect_info_command %02x %04x",
14182 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14183
14184 Info = GOOD;
14185 internal_command = plci->internal_command;
14186 plci->internal_command = 0;
14187 switch (internal_command)
14188 {
14189 default:
14190 plci->command = 0;
14191 case FAX_CONNECT_INFO_COMMAND_1:
14192 if (plci_nl_busy (plci))
14193 {
14194 plci->internal_command = FAX_CONNECT_INFO_COMMAND_1;
14195 return;
14196 }
14197 plci->internal_command = FAX_CONNECT_INFO_COMMAND_2;
14198 plci->NData[0].P = plci->fax_connect_info_buffer;
14199 plci->NData[0].PLength = plci->fax_connect_info_length;
14200 plci->NL.X = plci->NData;
14201 plci->NL.ReqCh = 0;
14202 plci->NL.Req = plci->nl_req = (byte) N_EDATA;
14203 plci->adapter->request (&plci->NL);
14204 return;
14205 case FAX_CONNECT_INFO_COMMAND_2:
14206 if ((Rc != OK) && (Rc != OK_FC))
14207 {
14208 dbug (1, dprintf ("[%06lx] %s,%d: FAX setting connect info failed %02x",
14209 UnMapId (Id), (char *)(FILE_), __LINE__, Rc));
14210 Info = _WRONG_STATE;
14211 break;
14212 }
14213 if (plci_nl_busy (plci))
14214 {
14215 plci->internal_command = FAX_CONNECT_INFO_COMMAND_2;
14216 return;
14217 }
14218 plci->command = _CONNECT_B3_R;
14219 nl_req_ncci (plci, N_CONNECT, 0);
14220 send_req (plci);
14221 return;
14222 }
14223 sendf (plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info);
14224 }
14225
14226
14227 static void fax_adjust_b23_command (dword Id, PLCI *plci, byte Rc)
14228 {
14229 word Info;
14230 word internal_command;
14231
14232 dbug (1, dprintf ("[%06lx] %s,%d: fax_adjust_b23_command %02x %04x",
14233 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14234
14235 Info = GOOD;
14236 internal_command = plci->internal_command;
14237 plci->internal_command = 0;
14238 switch (internal_command)
14239 {
14240 default:
14241 plci->command = 0;
14242 plci->adjust_b_parms_msg = NULL;
14243 plci->adjust_b_facilities = plci->B1_facilities;
14244 plci->adjust_b_command = FAX_ADJUST_B23_COMMAND_1;
14245 plci->adjust_b_ncci = (word)(Id >> 16);
14246 plci->adjust_b_mode = ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_ASSIGN_L23;
14247 plci->adjust_b_state = ADJUST_B_START;
14248 dbug (1, dprintf ("[%06lx] %s,%d: FAX adjust B23...",
14249 UnMapId (Id), (char *)(FILE_), __LINE__));
14250 case FAX_ADJUST_B23_COMMAND_1:
14251 Info = adjust_b_process (Id, plci, Rc);
14252 if (Info != GOOD)
14253 {
14254 dbug (1, dprintf ("[%06lx] %s,%d: FAX adjust failed",
14255 UnMapId (Id), (char *)(FILE_), __LINE__));
14256 break;
14257 }
14258 if (plci->internal_command)
14259 return;
14260 case FAX_ADJUST_B23_COMMAND_2:
14261 if (plci_nl_busy (plci))
14262 {
14263 plci->internal_command = FAX_ADJUST_B23_COMMAND_2;
14264 return;
14265 }
14266 plci->command = _CONNECT_B3_R;
14267 nl_req_ncci (plci, N_CONNECT, 0);
14268 send_req (plci);
14269 return;
14270 }
14271 sendf (plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info);
14272 }
14273
14274
14275 static void fax_disconnect_command (dword Id, PLCI *plci, byte Rc)
14276 {
14277 word internal_command;
14278
14279 dbug (1, dprintf ("[%06lx] %s,%d: fax_disconnect_command %02x %04x",
14280 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14281
14282 internal_command = plci->internal_command;
14283 plci->internal_command = 0;
14284 switch (internal_command)
14285 {
14286 default:
14287 plci->command = 0;
14288 plci->internal_command = FAX_DISCONNECT_COMMAND_1;
14289 return;
14290 case FAX_DISCONNECT_COMMAND_1:
14291 case FAX_DISCONNECT_COMMAND_2:
14292 case FAX_DISCONNECT_COMMAND_3:
14293 if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0))
14294 {
14295 dbug (1, dprintf ("[%06lx] %s,%d: FAX disconnect EDATA failed %02x",
14296 UnMapId (Id), (char *)(FILE_), __LINE__, Rc));
14297 break;
14298 }
14299 if (Rc == OK)
14300 {
14301 if ((internal_command == FAX_DISCONNECT_COMMAND_1)
14302 || (internal_command == FAX_DISCONNECT_COMMAND_2))
14303 {
14304 plci->internal_command = FAX_DISCONNECT_COMMAND_2;
14305 }
14306 }
14307 else if (Rc == 0)
14308 {
14309 if (internal_command == FAX_DISCONNECT_COMMAND_1)
14310 plci->internal_command = FAX_DISCONNECT_COMMAND_3;
14311 }
14312 return;
14313 }
14314 }
14315
14316
14317
14318 static void rtp_connect_b3_req_command (dword Id, PLCI *plci, byte Rc)
14319 {
14320 word Info;
14321 word internal_command;
14322
14323 dbug (1, dprintf ("[%06lx] %s,%d: rtp_connect_b3_req_command %02x %04x",
14324 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14325
14326 Info = GOOD;
14327 internal_command = plci->internal_command;
14328 plci->internal_command = 0;
14329 switch (internal_command)
14330 {
14331 default:
14332 plci->command = 0;
14333 case RTP_CONNECT_B3_REQ_COMMAND_1:
14334 if (plci_nl_busy (plci))
14335 {
14336 plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_1;
14337 return;
14338 }
14339 plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_2;
14340 nl_req_ncci (plci, N_CONNECT, 0);
14341 send_req (plci);
14342 return;
14343 case RTP_CONNECT_B3_REQ_COMMAND_2:
14344 if ((Rc != OK) && (Rc != OK_FC))
14345 {
14346 dbug (1, dprintf ("[%06lx] %s,%d: RTP setting connect info failed %02x",
14347 UnMapId (Id), (char *)(FILE_), __LINE__, Rc));
14348 Info = _WRONG_STATE;
14349 break;
14350 }
14351 if (plci_nl_busy (plci))
14352 {
14353 plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_2;
14354 return;
14355 }
14356 plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_3;
14357 plci->NData[0].PLength = plci->internal_req_buffer[0];
14358 plci->NData[0].P = plci->internal_req_buffer + 1;
14359 plci->NL.X = plci->NData;
14360 plci->NL.ReqCh = 0;
14361 plci->NL.Req = plci->nl_req = (byte) N_UDATA;
14362 plci->adapter->request (&plci->NL);
14363 break;
14364 case RTP_CONNECT_B3_REQ_COMMAND_3:
14365 return;
14366 }
14367 sendf (plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info);
14368 }
14369
14370
14371 static void rtp_connect_b3_res_command (dword Id, PLCI *plci, byte Rc)
14372 {
14373 word Info;
14374 word internal_command;
14375
14376 dbug (1, dprintf ("[%06lx] %s,%d: rtp_connect_b3_res_command %02x %04x",
14377 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14378
14379 Info = GOOD;
14380 internal_command = plci->internal_command;
14381 plci->internal_command = 0;
14382 switch (internal_command)
14383 {
14384 default:
14385 plci->command = 0;
14386 case RTP_CONNECT_B3_RES_COMMAND_1:
14387 if (plci_nl_busy (plci))
14388 {
14389 plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_1;
14390 return;
14391 }
14392 plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_2;
14393 nl_req_ncci (plci, N_CONNECT_ACK, (byte)(Id >> 16));
14394 send_req (plci);
14395 return;
14396 case RTP_CONNECT_B3_RES_COMMAND_2:
14397 if ((Rc != OK) && (Rc != OK_FC))
14398 {
14399 dbug (1, dprintf ("[%06lx] %s,%d: RTP setting connect resp info failed %02x",
14400 UnMapId (Id), (char *)(FILE_), __LINE__, Rc));
14401 Info = _WRONG_STATE;
14402 break;
14403 }
14404 if (plci_nl_busy (plci))
14405 {
14406 plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_2;
14407 return;
14408 }
14409 sendf (plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
14410 plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_3;
14411 plci->NData[0].PLength = plci->internal_req_buffer[0];
14412 plci->NData[0].P = plci->internal_req_buffer + 1;
14413 plci->NL.X = plci->NData;
14414 plci->NL.ReqCh = 0;
14415 plci->NL.Req = plci->nl_req = (byte) N_UDATA;
14416 plci->adapter->request (&plci->NL);
14417 return;
14418 case RTP_CONNECT_B3_RES_COMMAND_3:
14419 return;
14420 }
14421 }
14422
14423
14424
14425 static void hold_save_command (dword Id, PLCI *plci, byte Rc)
14426 {
14427 byte SS_Ind[] = "\x05\x02\x00\x02\x00\x00"; /* Hold_Ind struct*/
14428 word Info;
14429 word internal_command;
14430
14431 dbug (1, dprintf ("[%06lx] %s,%d: hold_save_command %02x %04x",
14432 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14433
14434 Info = GOOD;
14435 internal_command = plci->internal_command;
14436 plci->internal_command = 0;
14437 switch (internal_command)
14438 {
14439 default:
14440 if (!plci->NL.Id)
14441 break;
14442 plci->command = 0;
14443 plci->adjust_b_parms_msg = NULL;
14444 plci->adjust_b_facilities = plci->B1_facilities;
14445 plci->adjust_b_command = HOLD_SAVE_COMMAND_1;
14446 plci->adjust_b_ncci = (word)(Id >> 16);
14447 plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23;
14448 plci->adjust_b_state = ADJUST_B_START;
14449 dbug (1, dprintf ("[%06lx] %s,%d: HOLD save...",
14450 UnMapId (Id), (char *)(FILE_), __LINE__));
14451 case HOLD_SAVE_COMMAND_1:
14452 Info = adjust_b_process (Id, plci, Rc);
14453 if (Info != GOOD)
14454 {
14455 dbug (1, dprintf ("[%06lx] %s,%d: HOLD save failed",
14456 UnMapId (Id), (char *)(FILE_), __LINE__));
14457 break;
14458 }
14459 if (plci->internal_command)
14460 return;
14461 }
14462 sendf (plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", 3, SS_Ind);
14463 }
14464
14465
14466 static void retrieve_restore_command (dword Id, PLCI *plci, byte Rc)
14467 {
14468 byte SS_Ind[] = "\x05\x03\x00\x02\x00\x00"; /* Retrieve_Ind struct*/
14469 word Info;
14470 word internal_command;
14471
14472 dbug (1, dprintf ("[%06lx] %s,%d: retrieve_restore_command %02x %04x",
14473 UnMapId (Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14474
14475 Info = GOOD;
14476 internal_command = plci->internal_command;
14477 plci->internal_command = 0;
14478 switch (internal_command)
14479 {
14480 default:
14481 plci->command = 0;
14482 plci->adjust_b_parms_msg = NULL;
14483 plci->adjust_b_facilities = plci->B1_facilities;
14484 plci->adjust_b_command = RETRIEVE_RESTORE_COMMAND_1;
14485 plci->adjust_b_ncci = (word)(Id >> 16);
14486 plci->adjust_b_mode = ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_USER_CONNECT | ADJUST_B_MODE_RESTORE;
14487 plci->adjust_b_state = ADJUST_B_START;
14488 dbug (1, dprintf ("[%06lx] %s,%d: RETRIEVE restore...",
14489 UnMapId (Id), (char *)(FILE_), __LINE__));
14490 case RETRIEVE_RESTORE_COMMAND_1:
14491 Info = adjust_b_process (Id, plci, Rc);
14492 if (Info != GOOD)
14493 {
14494 dbug (1, dprintf ("[%06lx] %s,%d: RETRIEVE restore failed",
14495 UnMapId (Id), (char *)(FILE_), __LINE__));
14496 break;
14497 }
14498 if (plci->internal_command)
14499 return;
14500 }
14501 sendf (plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", 3, SS_Ind);
14502 }
14503
14504
14505 static void init_b1_config (PLCI *plci)
14506 {
14507
14508 dbug (1, dprintf ("[%06lx] %s,%d: init_b1_config",
14509 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
14510 (char *)(FILE_), __LINE__));
14511
14512 plci->B1_resource = 0;
14513 plci->B1_facilities = 0;
14514
14515 plci->li_bchannel_id = 0;
14516 mixer_clear_config (plci);
14517
14518
14519 ec_clear_config (plci);
14520
14521
14522 dtmf_rec_clear_config (plci);
14523 dtmf_send_clear_config (plci);
14524 dtmf_parameter_clear_config (plci);
14525
14526 adv_voice_clear_config (plci);
14527 adjust_b_clear (plci);
14528 }
14529
14530
14531 static void clear_b1_config (PLCI *plci)
14532 {
14533
14534 dbug (1, dprintf ("[%06lx] %s,%d: clear_b1_config",
14535 (dword)((plci->Id << 8) | UnMapController (plci->adapter->Id)),
14536 (char *)(FILE_), __LINE__));
14537
14538 adv_voice_clear_config (plci);
14539 adjust_b_clear (plci);
14540
14541 ec_clear_config (plci);
14542
14543
14544 dtmf_rec_clear_config (plci);
14545 dtmf_send_clear_config (plci);
14546 dtmf_parameter_clear_config (plci);
14547
14548
14549 if ((plci->li_bchannel_id != 0)
14550 && (li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci == plci))
14551 {
14552 mixer_clear_config (plci);
14553 li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci = NULL;
14554 plci->li_bchannel_id = 0;
14555 }
14556
14557 plci->B1_resource = 0;
14558 plci->B1_facilities = 0;
14559 }
14560
14561
14562 /* -----------------------------------------------------------------
14563 XON protocol local helpers
14564 ----------------------------------------------------------------- */
14565 static void channel_flow_control_remove (PLCI * plci) {
14566 DIVA_CAPI_ADAPTER * a = plci->adapter;
14567 word i;
14568 for(i=1;i<MAX_NL_CHANNEL+1;i++) {
14569 if (a->ch_flow_plci[i] == plci->Id) {
14570 a->ch_flow_plci[i] = 0;
14571 a->ch_flow_control[i] = 0;
14572 }
14573 }
14574 }
14575
14576 static void channel_x_on (PLCI * plci, byte ch) {
14577 DIVA_CAPI_ADAPTER * a = plci->adapter;
14578 if (a->ch_flow_control[ch] & N_XON_SENT) {
14579 a->ch_flow_control[ch] &= ~N_XON_SENT;
14580 }
14581 }
14582
14583 static void channel_x_off (PLCI * plci, byte ch, byte flag) {
14584 DIVA_CAPI_ADAPTER * a = plci->adapter;
14585 if ((a->ch_flow_control[ch] & N_RX_FLOW_CONTROL_MASK) == 0) {
14586 a->ch_flow_control[ch] |= (N_CH_XOFF | flag);
14587 a->ch_flow_plci[ch] = plci->Id;
14588 a->ch_flow_control_pending++;
14589 }
14590 }
14591
14592 static void channel_request_xon (PLCI * plci, byte ch) {
14593 DIVA_CAPI_ADAPTER * a = plci->adapter;
14594
14595 if (a->ch_flow_control[ch] & N_CH_XOFF) {
14596 a->ch_flow_control[ch] |= N_XON_REQ;
14597 a->ch_flow_control[ch] &= ~N_CH_XOFF;
14598 a->ch_flow_control[ch] &= ~N_XON_CONNECT_IND;
14599 }
14600 }
14601
14602 static void channel_xmit_extended_xon (PLCI * plci) {
14603 DIVA_CAPI_ADAPTER * a;
14604 int max_ch = ARRAY_SIZE(a->ch_flow_control);
14605 int i, one_requested = 0;
14606
14607 if ((!plci) || (!plci->Id) || ((a = plci->adapter) == 0)) {
14608 return;
14609 }
14610
14611 for (i = 0; i < max_ch; i++) {
14612 if ((a->ch_flow_control[i] & N_CH_XOFF) &&
14613 (a->ch_flow_control[i] & N_XON_CONNECT_IND) &&
14614 (plci->Id == a->ch_flow_plci[i])) {
14615 channel_request_xon (plci, (byte)i);
14616 one_requested = 1;
14617 }
14618 }
14619
14620 if (one_requested) {
14621 channel_xmit_xon (plci);
14622 }
14623 }
14624
14625 /*
14626 Try to xmit next X_ON
14627 */
14628 static int find_channel_with_pending_x_on (DIVA_CAPI_ADAPTER * a, PLCI * plci) {
14629 int max_ch = ARRAY_SIZE(a->ch_flow_control);
14630 int i;
14631
14632 if (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL)) {
14633 return (0);
14634 }
14635
14636 if (a->last_flow_control_ch >= max_ch) {
14637 a->last_flow_control_ch = 1;
14638 }
14639 for (i=a->last_flow_control_ch; i < max_ch; i++) {
14640 if ((a->ch_flow_control[i] & N_XON_REQ) &&
14641 (plci->Id == a->ch_flow_plci[i])) {
14642 a->last_flow_control_ch = i+1;
14643 return (i);
14644 }
14645 }
14646
14647 for (i = 1; i < a->last_flow_control_ch; i++) {
14648 if ((a->ch_flow_control[i] & N_XON_REQ) &&
14649 (plci->Id == a->ch_flow_plci[i])) {
14650 a->last_flow_control_ch = i+1;
14651 return (i);
14652 }
14653 }
14654
14655 return (0);
14656 }
14657
14658 static void channel_xmit_xon (PLCI * plci) {
14659 DIVA_CAPI_ADAPTER * a = plci->adapter;
14660 byte ch;
14661
14662 if (plci->nl_req || !plci->NL.Id || plci->nl_remove_id) {
14663 return;
14664 }
14665 if ((ch = (byte)find_channel_with_pending_x_on (a, plci)) == 0) {
14666 return;
14667 }
14668 a->ch_flow_control[ch] &= ~N_XON_REQ;
14669 a->ch_flow_control[ch] |= N_XON_SENT;
14670
14671 plci->NL.Req = plci->nl_req = (byte)N_XON;
14672 plci->NL.ReqCh = ch;
14673 plci->NL.X = plci->NData;
14674 plci->NL.XNum = 1;
14675 plci->NData[0].P = &plci->RBuffer[0];
14676 plci->NData[0].PLength = 0;
14677
14678 plci->adapter->request(&plci->NL);
14679 }
14680
14681 static int channel_can_xon (PLCI * plci, byte ch) {
14682 APPL * APPLptr;
14683 DIVA_CAPI_ADAPTER * a;
14684 word NCCIcode;
14685 dword count;
14686 word Num;
14687 word i;
14688
14689 APPLptr = plci->appl;
14690 a = plci->adapter;
14691
14692 if (!APPLptr)
14693 return (0);
14694
14695 NCCIcode = a->ch_ncci[ch] | (((word) a->Id) << 8);
14696
14697 /* count all buffers within the Application pool */
14698 /* belonging to the same NCCI. XON if a first is */
14699 /* used. */
14700 count = 0;
14701 Num = 0xffff;
14702 for(i=0; i<APPLptr->MaxBuffer; i++) {
14703 if(NCCIcode==APPLptr->DataNCCI[i]) count++;
14704 if(!APPLptr->DataNCCI[i] && Num==0xffff) Num = i;
14705 }
14706 if ((count > 2) || (Num == 0xffff)) {
14707 return (0);
14708 }
14709 return (1);
14710 }
14711
14712
14713 /*------------------------------------------------------------------*/
14714
14715 static word CPN_filter_ok(byte *cpn,DIVA_CAPI_ADAPTER * a,word offset)
14716 {
14717 return 1;
14718 }
14719
14720
14721
14722 /**********************************************************************************/
14723 /* function groups the listening applications according to the CIP mask and the */
14724 /* Info_Mask. Each group gets just one Connect_Ind. Some application manufacturer */
14725 /* are not multi-instance capable, so they start e.g. 30 applications what causes */
14726 /* big problems on application level (one call, 30 Connect_Ind, ect). The */
14727 /* function must be enabled by setting "a->group_optimization_enabled" from the */
14728 /* OS specific part (per adapter). */
14729 /**********************************************************************************/
14730 static void group_optimization(DIVA_CAPI_ADAPTER * a, PLCI * plci)
14731 {
14732 word i,j,k,busy,group_found;
14733 dword info_mask_group[MAX_CIP_TYPES];
14734 dword cip_mask_group[MAX_CIP_TYPES];
14735 word appl_number_group_type[MAX_APPL];
14736 PLCI *auxplci;
14737
14738 set_group_ind_mask (plci); /* all APPLs within this inc. call are allowed to dial in */
14739
14740 if(!a->group_optimization_enabled)
14741 {
14742 dbug(1,dprintf("No group optimization"));
14743 return;
14744 }
14745
14746 dbug(1,dprintf("Group optimization = 0x%x...", a->group_optimization_enabled));
14747
14748 for(i=0;i<MAX_CIP_TYPES;i++)
14749 {
14750 info_mask_group[i] = 0;
14751 cip_mask_group [i] = 0;
14752 }
14753 for(i=0;i<MAX_APPL;i++)
14754 {
14755 appl_number_group_type[i] = 0;
14756 }
14757 for(i=0; i<max_appl; i++) /* check if any multi instance capable application is present */
14758 { /* group_optimization set to 1 means not to optimize multi-instance capable applications (default) */
14759 if(application[i].Id && (application[i].MaxNCCI) > 1 && (a->CIP_Mask[i]) && (a->group_optimization_enabled ==1) )
14760 {
14761 dbug(1,dprintf("Multi-Instance capable, no optimization required"));
14762 return; /* allow good application unfiltered access */
14763 }
14764 }
14765 for(i=0; i<max_appl; i++) /* Build CIP Groups */
14766 {
14767 if(application[i].Id && a->CIP_Mask[i] )
14768 {
14769 for(k=0,busy=false; k<a->max_plci; k++)
14770 {
14771 if(a->plci[k].Id)
14772 {
14773 auxplci = &a->plci[k];
14774 if(auxplci->appl == &application[i]) /* application has a busy PLCI */
14775 {
14776 busy = true;
14777 dbug(1,dprintf("Appl 0x%x is busy",i+1));
14778 }
14779 else if(test_c_ind_mask_bit (auxplci, i)) /* application has an incoming call pending */
14780 {
14781 busy = true;
14782 dbug(1,dprintf("Appl 0x%x has inc. call pending",i+1));
14783 }
14784 }
14785 }
14786
14787 for(j=0,group_found=0; j<=(MAX_CIP_TYPES) && !busy &&!group_found; j++) /* build groups with free applications only */
14788 {
14789 if(j==MAX_CIP_TYPES) /* all groups are in use but group still not found */
14790 { /* the MAX_CIP_TYPES group enables all calls because of field overflow */
14791 appl_number_group_type[i] = MAX_CIP_TYPES;
14792 group_found=true;
14793 dbug(1,dprintf("Field overflow appl 0x%x",i+1));
14794 }
14795 else if( (info_mask_group[j]==a->CIP_Mask[i]) && (cip_mask_group[j]==a->Info_Mask[i]) )
14796 { /* is group already present ? */
14797 appl_number_group_type[i] = j|0x80; /* store the group number for each application */
14798 group_found=true;
14799 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]));
14800 }
14801 else if(!info_mask_group[j])
14802 { /* establish a new group */
14803 appl_number_group_type[i] = j|0x80; /* store the group number for each application */
14804 info_mask_group[j] = a->CIP_Mask[i]; /* store the new CIP mask for the new group */
14805 cip_mask_group[j] = a->Info_Mask[i]; /* store the new Info_Mask for this new group */
14806 group_found=true;
14807 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]));
14808 }
14809 }
14810 }
14811 }
14812
14813 for(i=0; i<max_appl; i++) /* Build group_optimization_mask_table */
14814 {
14815 if(appl_number_group_type[i]) /* application is free, has listens and is member of a group */
14816 {
14817 if(appl_number_group_type[i] == MAX_CIP_TYPES)
14818 {
14819 dbug(1,dprintf("OverflowGroup 0x%x, valid appl = 0x%x, call enabled",appl_number_group_type[i],i+1));
14820 }
14821 else
14822 {
14823 dbug(1,dprintf("Group 0x%x, valid appl = 0x%x",appl_number_group_type[i],i+1));
14824 for(j=i+1; j<max_appl; j++) /* search other group members and mark them as busy */
14825 {
14826 if(appl_number_group_type[i] == appl_number_group_type[j])
14827 {
14828 dbug(1,dprintf("Appl 0x%x is member of group 0x%x, no call",j+1,appl_number_group_type[j]));
14829 clear_group_ind_mask_bit (plci, j); /* disable call on other group members */
14830 appl_number_group_type[j] = 0; /* remove disabled group member from group list */
14831 }
14832 }
14833 }
14834 }
14835 else /* application should not get a call */
14836 {
14837 clear_group_ind_mask_bit (plci, i);
14838 }
14839 }
14840
14841 }
14842
14843
14844
14845 /* OS notifies the driver about a application Capi_Register */
14846 word CapiRegister(word id)
14847 {
14848 word i,j,appls_found;
14849
14850 PLCI *plci;
14851 DIVA_CAPI_ADAPTER *a;
14852
14853 for(i=0,appls_found=0; i<max_appl; i++)
14854 {
14855 if( application[i].Id && (application[i].Id!=id) )
14856 {
14857 appls_found++; /* an application has been found */
14858 }
14859 }
14860
14861 if(appls_found) return true;
14862 for(i=0; i<max_adapter; i++) /* scan all adapters... */
14863 {
14864 a = &adapter[i];
14865 if(a->request)
14866 {
14867 if(a->flag_dynamic_l1_down) /* remove adapter from L1 tristate (Huntgroup) */
14868 {
14869 if(!appls_found) /* first application does a capi register */
14870 {
14871 if((j=get_plci(a))) /* activate L1 of all adapters */
14872 {
14873 plci = &a->plci[j-1];
14874 plci->command = 0;
14875 add_p(plci,OAD,"\x01\xfd");
14876 add_p(plci,CAI,"\x01\x80");
14877 add_p(plci,UID,"\x06\x43\x61\x70\x69\x32\x30");
14878 add_p(plci,SHIFT|6,NULL);
14879 add_p(plci,SIN,"\x02\x00\x00");
14880 plci->internal_command = START_L1_SIG_ASSIGN_PEND;
14881 sig_req(plci,ASSIGN,DSIG_ID);
14882 add_p(plci,FTY,"\x02\xff\x07"); /* l1 start */
14883 sig_req(plci,SIG_CTRL,0);
14884 send_req(plci);
14885 }
14886 }
14887 }
14888 }
14889 }
14890 return false;
14891 }
14892
14893 /*------------------------------------------------------------------*/
14894
14895 /* Functions for virtual Switching e.g. Transfer by join, Conference */
14896
14897 static void VSwitchReqInd(PLCI *plci, dword Id, byte **parms)
14898 {
14899 word i;
14900 /* Format of vswitch_t:
14901 0 byte length
14902 1 byte VSWITCHIE
14903 2 byte VSWITCH_REQ/VSWITCH_IND
14904 3 byte reserved
14905 4 word VSwitchcommand
14906 6 word returnerror
14907 8... Params
14908 */
14909 if(!plci ||
14910 !plci->appl ||
14911 !plci->State ||
14912 plci->Sig.Ind==NCR_FACILITY
14913 )
14914 return;
14915
14916 for(i=0;i<MAX_MULTI_IE;i++)
14917 {
14918 if(!parms[i][0]) continue;
14919 if(parms[i][0]<7)
14920 {
14921 parms[i][0]=0; /* kill it */
14922 continue;
14923 }
14924 dbug(1,dprintf("VSwitchReqInd(%d)",parms[i][4]));
14925 switch(parms[i][4])
14926 {
14927 case VSJOIN:
14928 if(!plci->relatedPTYPLCI ||
14929 (plci->ptyState!=S_ECT && plci->relatedPTYPLCI->ptyState!=S_ECT))
14930 { /* Error */
14931 break;
14932 }
14933 /* remember all necessary informations */
14934 if(parms[i][0]!=11 || parms[i][8]!=3) /* Length Test */
14935 {
14936 break;
14937 }
14938 if(parms[i][2]==VSWITCH_IND && parms[i][9]==1)
14939 { /* first indication after ECT-Request on Consultation Call */
14940 plci->vswitchstate=parms[i][9];
14941 parms[i][9]=2; /* State */
14942 /* now ask first Call to join */
14943 }
14944 else if(parms[i][2]==VSWITCH_REQ && parms[i][9]==3)
14945 { /* Answer of VSWITCH_REQ from first Call */
14946 plci->vswitchstate=parms[i][9];
14947 /* tell consultation call to join
14948 and the protocol capabilities of the first call */
14949 }
14950 else
14951 { /* Error */
14952 break;
14953 }
14954 plci->vsprot=parms[i][10]; /* protocol */
14955 plci->vsprotdialect=parms[i][11]; /* protocoldialect */
14956 /* send join request to related PLCI */
14957 parms[i][1]=VSWITCHIE;
14958 parms[i][2]=VSWITCH_REQ;
14959
14960 plci->relatedPTYPLCI->command = 0;
14961 plci->relatedPTYPLCI->internal_command = VSWITCH_REQ_PEND;
14962 add_p(plci->relatedPTYPLCI,ESC,&parms[i][0]);
14963 sig_req(plci->relatedPTYPLCI,VSWITCH_REQ,0);
14964 send_req(plci->relatedPTYPLCI);
14965 break;
14966 case VSTRANSPORT:
14967 default:
14968 if(plci->relatedPTYPLCI &&
14969 plci->vswitchstate==3 &&
14970 plci->relatedPTYPLCI->vswitchstate==3)
14971 {
14972 add_p(plci->relatedPTYPLCI,ESC,&parms[i][0]);
14973 sig_req(plci->relatedPTYPLCI,VSWITCH_REQ,0);
14974 send_req(plci->relatedPTYPLCI);
14975 }
14976 break;
14977 }
14978 parms[i][0]=0; /* kill it */
14979 }
14980 }
14981
14982
14983 /*------------------------------------------------------------------*/
14984
14985 static int diva_get_dma_descriptor (PLCI *plci, dword *dma_magic) {
14986 ENTITY e;
14987 IDI_SYNC_REQ* pReq = (IDI_SYNC_REQ*)&e;
14988
14989 if (!(diva_xdi_extended_features & DIVA_CAPI_XDI_PROVIDES_RX_DMA)) {
14990 return (-1);
14991 }
14992
14993 pReq->xdi_dma_descriptor_operation.Req = 0;
14994 pReq->xdi_dma_descriptor_operation.Rc = IDI_SYNC_REQ_DMA_DESCRIPTOR_OPERATION;
14995
14996 pReq->xdi_dma_descriptor_operation.info.operation = IDI_SYNC_REQ_DMA_DESCRIPTOR_ALLOC;
14997 pReq->xdi_dma_descriptor_operation.info.descriptor_number = -1;
14998 pReq->xdi_dma_descriptor_operation.info.descriptor_address = NULL;
14999 pReq->xdi_dma_descriptor_operation.info.descriptor_magic = 0;
15000
15001 e.user[0] = plci->adapter->Id - 1;
15002 plci->adapter->request((ENTITY*)pReq);
15003
15004 if (!pReq->xdi_dma_descriptor_operation.info.operation &&
15005 (pReq->xdi_dma_descriptor_operation.info.descriptor_number >= 0) &&
15006 pReq->xdi_dma_descriptor_operation.info.descriptor_magic) {
15007 *dma_magic = pReq->xdi_dma_descriptor_operation.info.descriptor_magic;
15008 dbug(3,dprintf("dma_alloc, a:%d (%d-%08x)",
15009 plci->adapter->Id,
15010 pReq->xdi_dma_descriptor_operation.info.descriptor_number,
15011 *dma_magic));
15012 return (pReq->xdi_dma_descriptor_operation.info.descriptor_number);
15013 } else {
15014 dbug(1,dprintf("dma_alloc failed"));
15015 return (-1);
15016 }
15017 }
15018
15019 static void diva_free_dma_descriptor (PLCI *plci, int nr) {
15020 ENTITY e;
15021 IDI_SYNC_REQ* pReq = (IDI_SYNC_REQ*)&e;
15022
15023 if (nr < 0) {
15024 return;
15025 }
15026
15027 pReq->xdi_dma_descriptor_operation.Req = 0;
15028 pReq->xdi_dma_descriptor_operation.Rc = IDI_SYNC_REQ_DMA_DESCRIPTOR_OPERATION;
15029
15030 pReq->xdi_dma_descriptor_operation.info.operation = IDI_SYNC_REQ_DMA_DESCRIPTOR_FREE;
15031 pReq->xdi_dma_descriptor_operation.info.descriptor_number = nr;
15032 pReq->xdi_dma_descriptor_operation.info.descriptor_address = NULL;
15033 pReq->xdi_dma_descriptor_operation.info.descriptor_magic = 0;
15034
15035 e.user[0] = plci->adapter->Id - 1;
15036 plci->adapter->request((ENTITY*)pReq);
15037
15038 if (!pReq->xdi_dma_descriptor_operation.info.operation) {
15039 dbug(1,dprintf("dma_free(%d)", nr));
15040 } else {
15041 dbug(1,dprintf("dma_free failed (%d)", nr));
15042 }
15043 }
15044
15045 /*------------------------------------------------------------------*/
Mirror for ia64_pv_ops.git