?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost
[cris-mirror.git] / drivers / isdn / hardware / eicon / message.c
blobdef7992a38e68d8900853dad20205a6eece8376e
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 #include <linux/bitmap.h>
27
28 #include "platform.h"
29 #include "di_defs.h"
30 #include "pc.h"
31 #include "capi20.h"
32 #include "divacapi.h"
33 #include "mdm_msg.h"
34 #include "divasync.h"
35
36 #define FILE_ "MESSAGE.C"
37 #define dprintf
38
39 /*------------------------------------------------------------------*/
40 /* This is options supported for all adapters that are server by */
41 /* XDI driver. Allo it is not necessary to ask it from every adapter*/
42 /* and it is not necessary to save it separate for every adapter */
43 /* Macrose defined here have only local meaning */
44 /*------------------------------------------------------------------*/
45 static dword diva_xdi_extended_features = 0;
46
47 #define DIVA_CAPI_USE_CMA 0x00000001
48 #define DIVA_CAPI_XDI_PROVIDES_SDRAM_BAR 0x00000002
49 #define DIVA_CAPI_XDI_PROVIDES_NO_CANCEL 0x00000004
50 #define DIVA_CAPI_XDI_PROVIDES_RX_DMA 0x00000008
51
52 /*
53 CAPI can request to process all return codes self only if:
54 protocol code supports this && xdi supports this
55 */
56 #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))
57
58 /*------------------------------------------------------------------*/
59 /* local function prototypes */
60 /*------------------------------------------------------------------*/
61
62 static void group_optimization(DIVA_CAPI_ADAPTER *a, PLCI *plci);
63 void AutomaticLaw(DIVA_CAPI_ADAPTER *);
64 word CapiRelease(word);
65 word CapiRegister(word);
66 word api_put(APPL *, CAPI_MSG *);
67 static word api_parse(byte *, word, byte *, API_PARSE *);
68 static void api_save_msg(API_PARSE *in, byte *format, API_SAVE *out);
69 static void api_load_msg(API_SAVE *in, API_PARSE *out);
70
71 word api_remove_start(void);
72 void api_remove_complete(void);
73
74 static void plci_remove(PLCI *);
75 static void diva_get_extended_adapter_features(DIVA_CAPI_ADAPTER *a);
76 static void diva_ask_for_xdi_sdram_bar(DIVA_CAPI_ADAPTER *, IDI_SYNC_REQ *);
77
78 void callback(ENTITY *);
79
80 static void control_rc(PLCI *, byte, byte, byte, byte, byte);
81 static void data_rc(PLCI *, byte);
82 static void data_ack(PLCI *, byte);
83 static void sig_ind(PLCI *);
84 static void SendInfo(PLCI *, dword, byte **, byte);
85 static void SendSetupInfo(APPL *, PLCI *, dword, byte **, byte);
86 static void SendSSExtInd(APPL *, PLCI *plci, dword Id, byte **parms);
87
88 static void VSwitchReqInd(PLCI *plci, dword Id, byte **parms);
89
90 static void nl_ind(PLCI *);
91
92 static byte connect_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
93 static byte connect_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
94 static byte connect_a_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
95 static byte disconnect_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
96 static byte disconnect_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
97 static byte listen_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
98 static byte info_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
99 static byte info_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
100 static byte alert_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
101 static byte facility_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
102 static byte facility_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
103 static byte connect_b3_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
104 static byte connect_b3_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
105 static byte connect_b3_a_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
106 static byte disconnect_b3_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
107 static byte disconnect_b3_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
108 static byte data_b3_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
109 static byte data_b3_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
110 static byte reset_b3_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
111 static byte reset_b3_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
112 static byte connect_b3_t90_a_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
113 static byte select_b_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
114 static byte manufacturer_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
115 static byte manufacturer_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
116
117 static word get_plci(DIVA_CAPI_ADAPTER *);
118 static void add_p(PLCI *, byte, byte *);
119 static void add_s(PLCI *plci, byte code, API_PARSE *p);
120 static void add_ss(PLCI *plci, byte code, API_PARSE *p);
121 static void add_ie(PLCI *plci, byte code, byte *p, word p_length);
122 static void add_d(PLCI *, word, byte *);
123 static void add_ai(PLCI *, API_PARSE *);
124 static word add_b1(PLCI *, API_PARSE *, word, word);
125 static word add_b23(PLCI *, API_PARSE *);
126 static word add_modem_b23(PLCI *plci, API_PARSE *bp_parms);
127 static void sig_req(PLCI *, byte, byte);
128 static void nl_req_ncci(PLCI *, byte, byte);
129 static void send_req(PLCI *);
130 static void send_data(PLCI *);
131 static word plci_remove_check(PLCI *);
132 static void listen_check(DIVA_CAPI_ADAPTER *);
133 static byte AddInfo(byte **, byte **, byte *, byte *);
134 static byte getChannel(API_PARSE *);
135 static void IndParse(PLCI *, const word *, byte **, byte);
136 static byte ie_compare(byte *, byte *);
137 static word find_cip(DIVA_CAPI_ADAPTER *, byte *, byte *);
138 static word CPN_filter_ok(byte *cpn, DIVA_CAPI_ADAPTER *, word);
139
140 /*
141 XON protocol helpers
142 */
143 static void channel_flow_control_remove(PLCI *plci);
144 static void channel_x_off(PLCI *plci, byte ch, byte flag);
145 static void channel_x_on(PLCI *plci, byte ch);
146 static void channel_request_xon(PLCI *plci, byte ch);
147 static void channel_xmit_xon(PLCI *plci);
148 static int channel_can_xon(PLCI *plci, byte ch);
149 static void channel_xmit_extended_xon(PLCI *plci);
150
151 static byte SendMultiIE(PLCI *plci, dword Id, byte **parms, byte ie_type, dword info_mask, byte setupParse);
152 static word AdvCodecSupport(DIVA_CAPI_ADAPTER *, PLCI *, APPL *, byte);
153 static void CodecIdCheck(DIVA_CAPI_ADAPTER *, PLCI *);
154 static void SetVoiceChannel(PLCI *, byte *, DIVA_CAPI_ADAPTER *);
155 static void VoiceChannelOff(PLCI *plci);
156 static void adv_voice_write_coefs(PLCI *plci, word write_command);
157 static void adv_voice_clear_config(PLCI *plci);
158
159 static word get_b1_facilities(PLCI *plci, byte b1_resource);
160 static byte add_b1_facilities(PLCI *plci, byte b1_resource, word b1_facilities);
161 static void adjust_b1_facilities(PLCI *plci, byte new_b1_resource, word new_b1_facilities);
162 static word adjust_b_process(dword Id, PLCI *plci, byte Rc);
163 static void adjust_b1_resource(dword Id, PLCI *plci, API_SAVE *bp_msg, word b1_facilities, word internal_command);
164 static void adjust_b_restore(dword Id, PLCI *plci, byte Rc);
165 static void reset_b3_command(dword Id, PLCI *plci, byte Rc);
166 static void select_b_command(dword Id, PLCI *plci, byte Rc);
167 static void fax_connect_ack_command(dword Id, PLCI *plci, byte Rc);
168 static void fax_edata_ack_command(dword Id, PLCI *plci, byte Rc);
169 static void fax_connect_info_command(dword Id, PLCI *plci, byte Rc);
170 static void fax_adjust_b23_command(dword Id, PLCI *plci, byte Rc);
171 static void fax_disconnect_command(dword Id, PLCI *plci, byte Rc);
172 static void hold_save_command(dword Id, PLCI *plci, byte Rc);
173 static void retrieve_restore_command(dword Id, PLCI *plci, byte Rc);
174 static void init_b1_config(PLCI *plci);
175 static void clear_b1_config(PLCI *plci);
176
177 static void dtmf_command(dword Id, PLCI *plci, byte Rc);
178 static byte dtmf_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg);
179 static void dtmf_confirmation(dword Id, PLCI *plci);
180 static void dtmf_indication(dword Id, PLCI *plci, byte *msg, word length);
181 static void dtmf_parameter_write(PLCI *plci);
182
183
184 static void mixer_set_bchannel_id_esc(PLCI *plci, byte bchannel_id);
185 static void mixer_set_bchannel_id(PLCI *plci, byte *chi);
186 static void mixer_clear_config(PLCI *plci);
187 static void mixer_notify_update(PLCI *plci, byte others);
188 static void mixer_command(dword Id, PLCI *plci, byte Rc);
189 static byte mixer_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg);
190 static void mixer_indication_coefs_set(dword Id, PLCI *plci);
191 static void mixer_indication_xconnect_from(dword Id, PLCI *plci, byte *msg, word length);
192 static void mixer_indication_xconnect_to(dword Id, PLCI *plci, byte *msg, word length);
193 static void mixer_remove(PLCI *plci);
194
195
196 static void ec_command(dword Id, PLCI *plci, byte Rc);
197 static byte ec_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg);
198 static void ec_indication(dword Id, PLCI *plci, byte *msg, word length);
199
200
201 static void rtp_connect_b3_req_command(dword Id, PLCI *plci, byte Rc);
202 static void rtp_connect_b3_res_command(dword Id, PLCI *plci, byte Rc);
203
204
205 static int diva_get_dma_descriptor(PLCI *plci, dword *dma_magic);
206 static void diva_free_dma_descriptor(PLCI *plci, int nr);
207
208 /*------------------------------------------------------------------*/
209 /* external function prototypes */
210 /*------------------------------------------------------------------*/
211
212 extern byte MapController(byte);
213 extern byte UnMapController(byte);
214 #define MapId(Id)(((Id) & 0xffffff00L) | MapController((byte)(Id)))
215 #define UnMapId(Id)(((Id) & 0xffffff00L) | UnMapController((byte)(Id)))
216
217 void sendf(APPL *, word, dword, word, byte *, ...);
218 void *TransmitBufferSet(APPL *appl, dword ref);
219 void *TransmitBufferGet(APPL *appl, void *p);
220 void TransmitBufferFree(APPL *appl, void *p);
221 void *ReceiveBufferGet(APPL *appl, int Num);
222
223 int fax_head_line_time(char *buffer);
224
225
226 /*------------------------------------------------------------------*/
227 /* Global data definitions */
228 /*------------------------------------------------------------------*/
229 extern byte max_adapter;
230 extern byte max_appl;
231 extern DIVA_CAPI_ADAPTER *adapter;
232 extern APPL *application;
233
234
235
236
237
238
239
240 static byte remove_started = false;
241 static PLCI dummy_plci;
242
243
244 static struct _ftable {
245 word command;
246 byte *format;
247 byte (*function)(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
248 } ftable[] = {
249 {_DATA_B3_R, "dwww", data_b3_req},
250 {_DATA_B3_I | RESPONSE, "w", data_b3_res},
251 {_INFO_R, "ss", info_req},
252 {_INFO_I | RESPONSE, "", info_res},
253 {_CONNECT_R, "wsssssssss", connect_req},
254 {_CONNECT_I | RESPONSE, "wsssss", connect_res},
255 {_CONNECT_ACTIVE_I | RESPONSE, "", connect_a_res},
256 {_DISCONNECT_R, "s", disconnect_req},
257 {_DISCONNECT_I | RESPONSE, "", disconnect_res},
258 {_LISTEN_R, "dddss", listen_req},
259 {_ALERT_R, "s", alert_req},
260 {_FACILITY_R, "ws", facility_req},
261 {_FACILITY_I | RESPONSE, "ws", facility_res},
262 {_CONNECT_B3_R, "s", connect_b3_req},
263 {_CONNECT_B3_I | RESPONSE, "ws", connect_b3_res},
264 {_CONNECT_B3_ACTIVE_I | RESPONSE, "", connect_b3_a_res},
265 {_DISCONNECT_B3_R, "s", disconnect_b3_req},
266 {_DISCONNECT_B3_I | RESPONSE, "", disconnect_b3_res},
267 {_RESET_B3_R, "s", reset_b3_req},
268 {_RESET_B3_I | RESPONSE, "", reset_b3_res},
269 {_CONNECT_B3_T90_ACTIVE_I | RESPONSE, "ws", connect_b3_t90_a_res},
270 {_CONNECT_B3_T90_ACTIVE_I | RESPONSE, "", connect_b3_t90_a_res},
271 {_SELECT_B_REQ, "s", select_b_req},
272 {_MANUFACTURER_R, "dws", manufacturer_req},
273 {_MANUFACTURER_I | RESPONSE, "dws", manufacturer_res},
274 {_MANUFACTURER_I | RESPONSE, "", manufacturer_res}
275 };
276
277 static byte *cip_bc[29][2] = {
278 { "", "" }, /* 0 */
279 { "\x03\x80\x90\xa3", "\x03\x80\x90\xa2" }, /* 1 */
280 { "\x02\x88\x90", "\x02\x88\x90" }, /* 2 */
281 { "\x02\x89\x90", "\x02\x89\x90" }, /* 3 */
282 { "\x03\x90\x90\xa3", "\x03\x90\x90\xa2" }, /* 4 */
283 { "\x03\x91\x90\xa5", "\x03\x91\x90\xa5" }, /* 5 */
284 { "\x02\x98\x90", "\x02\x98\x90" }, /* 6 */
285 { "\x04\x88\xc0\xc6\xe6", "\x04\x88\xc0\xc6\xe6" }, /* 7 */
286 { "\x04\x88\x90\x21\x8f", "\x04\x88\x90\x21\x8f" }, /* 8 */
287 { "\x03\x91\x90\xa5", "\x03\x91\x90\xa5" }, /* 9 */
288 { "", "" }, /* 10 */
289 { "", "" }, /* 11 */
290 { "", "" }, /* 12 */
291 { "", "" }, /* 13 */
292 { "", "" }, /* 14 */
293 { "", "" }, /* 15 */
294
295 { "\x03\x80\x90\xa3", "\x03\x80\x90\xa2" }, /* 16 */
296 { "\x03\x90\x90\xa3", "\x03\x90\x90\xa2" }, /* 17 */
297 { "\x02\x88\x90", "\x02\x88\x90" }, /* 18 */
298 { "\x02\x88\x90", "\x02\x88\x90" }, /* 19 */
299 { "\x02\x88\x90", "\x02\x88\x90" }, /* 20 */
300 { "\x02\x88\x90", "\x02\x88\x90" }, /* 21 */
301 { "\x02\x88\x90", "\x02\x88\x90" }, /* 22 */
302 { "\x02\x88\x90", "\x02\x88\x90" }, /* 23 */
303 { "\x02\x88\x90", "\x02\x88\x90" }, /* 24 */
304 { "\x02\x88\x90", "\x02\x88\x90" }, /* 25 */
305 { "\x03\x91\x90\xa5", "\x03\x91\x90\xa5" }, /* 26 */
306 { "\x03\x91\x90\xa5", "\x03\x91\x90\xa5" }, /* 27 */
307 { "\x02\x88\x90", "\x02\x88\x90" } /* 28 */
308 };
309
310 static byte *cip_hlc[29] = {
311 "", /* 0 */
312 "", /* 1 */
313 "", /* 2 */
314 "", /* 3 */
315 "", /* 4 */
316 "", /* 5 */
317 "", /* 6 */
318 "", /* 7 */
319 "", /* 8 */
320 "", /* 9 */
321 "", /* 10 */
322 "", /* 11 */
323 "", /* 12 */
324 "", /* 13 */
325 "", /* 14 */
326 "", /* 15 */
327
328 "\x02\x91\x81", /* 16 */
329 "\x02\x91\x84", /* 17 */
330 "\x02\x91\xa1", /* 18 */
331 "\x02\x91\xa4", /* 19 */
332 "\x02\x91\xa8", /* 20 */
333 "\x02\x91\xb1", /* 21 */
334 "\x02\x91\xb2", /* 22 */
335 "\x02\x91\xb5", /* 23 */
336 "\x02\x91\xb8", /* 24 */
337 "\x02\x91\xc1", /* 25 */
338 "\x02\x91\x81", /* 26 */
339 "\x03\x91\xe0\x01", /* 27 */
340 "\x03\x91\xe0\x02" /* 28 */
341 };
342
343 /*------------------------------------------------------------------*/
344
345 #define V120_HEADER_LENGTH 1
346 #define V120_HEADER_EXTEND_BIT 0x80
347 #define V120_HEADER_BREAK_BIT 0x40
348 #define V120_HEADER_C1_BIT 0x04
349 #define V120_HEADER_C2_BIT 0x08
350 #define V120_HEADER_FLUSH_COND (V120_HEADER_BREAK_BIT | V120_HEADER_C1_BIT | V120_HEADER_C2_BIT)
351
352 static byte v120_default_header[] =
353 {
354
355 0x83 /* Ext, BR , res, res, C2 , C1 , B , F */
356
357 };
358
359 static byte v120_break_header[] =
360 {
361
362 0xc3 | V120_HEADER_BREAK_BIT /* Ext, BR , res, res, C2 , C1 , B , F */
363
364 };
365
366
367 /*------------------------------------------------------------------*/
368 /* API_PUT function */
369 /*------------------------------------------------------------------*/
370
371 word api_put(APPL *appl, CAPI_MSG *msg)
372 {
373 word i, j, k, l, n;
374 word ret;
375 byte c;
376 byte controller;
377 DIVA_CAPI_ADAPTER *a;
378 PLCI *plci;
379 NCCI *ncci_ptr;
380 word ncci;
381 CAPI_MSG *m;
382 API_PARSE msg_parms[MAX_MSG_PARMS + 1];
383
384 if (msg->header.length < sizeof(msg->header) ||
385 msg->header.length > MAX_MSG_SIZE) {
386 dbug(1, dprintf("bad len"));
387 return _BAD_MSG;
388 }
389
390 controller = (byte)((msg->header.controller & 0x7f) - 1);
391
392 /* controller starts with 0 up to (max_adapter - 1) */
393 if (controller >= max_adapter)
394 {
395 dbug(1, dprintf("invalid ctrl"));
396 return _BAD_MSG;
397 }
398
399 a = &adapter[controller];
400 plci = NULL;
401 if ((msg->header.plci != 0) && (msg->header.plci <= a->max_plci) && !a->adapter_disabled)
402 {
403 dbug(1, dprintf("plci=%x", msg->header.plci));
404 plci = &a->plci[msg->header.plci - 1];
405 ncci = GET_WORD(&msg->header.ncci);
406 if (plci->Id
407 && (plci->appl
408 || (plci->State == INC_CON_PENDING)
409 || (plci->State == INC_CON_ALERT)
410 || (msg->header.command == (_DISCONNECT_I | RESPONSE)))
411 && ((ncci == 0)
412 || (msg->header.command == (_DISCONNECT_B3_I | RESPONSE))
413 || ((ncci < MAX_NCCI + 1) && (a->ncci_plci[ncci] == plci->Id))))
414 {
415 i = plci->msg_in_read_pos;
416 j = plci->msg_in_write_pos;
417 if (j >= i)
418 {
419 if (j + msg->header.length + MSG_IN_OVERHEAD <= MSG_IN_QUEUE_SIZE)
420 i += MSG_IN_QUEUE_SIZE - j;
421 else
422 j = 0;
423 }
424 else
425 {
426
427 n = (((CAPI_MSG *)(plci->msg_in_queue))->header.length + MSG_IN_OVERHEAD + 3) & 0xfffc;
428
429 if (i > MSG_IN_QUEUE_SIZE - n)
430 i = MSG_IN_QUEUE_SIZE - n + 1;
431 i -= j;
432 }
433
434 if (i <= ((msg->header.length + MSG_IN_OVERHEAD + 3) & 0xfffc))
435
436 {
437 dbug(0, dprintf("Q-FULL1(msg) - len=%d write=%d read=%d wrap=%d free=%d",
438 msg->header.length, plci->msg_in_write_pos,
439 plci->msg_in_read_pos, plci->msg_in_wrap_pos, i));
440
441 return _QUEUE_FULL;
442 }
443 c = false;
444 if ((((byte *) msg) < ((byte *)(plci->msg_in_queue)))
445 || (((byte *) msg) >= ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
446 {
447 if (plci->msg_in_write_pos != plci->msg_in_read_pos)
448 c = true;
449 }
450 if (msg->header.command == _DATA_B3_R)
451 {
452 if (msg->header.length < 20)
453 {
454 dbug(1, dprintf("DATA_B3 REQ wrong length %d", msg->header.length));
455 return _BAD_MSG;
456 }
457 ncci_ptr = &(a->ncci[ncci]);
458 n = ncci_ptr->data_pending;
459 l = ncci_ptr->data_ack_pending;
460 k = plci->msg_in_read_pos;
461 while (k != plci->msg_in_write_pos)
462 {
463 if (k == plci->msg_in_wrap_pos)
464 k = 0;
465 if ((((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[k]))->header.command == _DATA_B3_R)
466 && (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[k]))->header.ncci == ncci))
467 {
468 n++;
469 if (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[k]))->info.data_b3_req.Flags & 0x0004)
470 l++;
471 }
472
473 k += (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[k]))->header.length +
474 MSG_IN_OVERHEAD + 3) & 0xfffc;
475
476 }
477 if ((n >= MAX_DATA_B3) || (l >= MAX_DATA_ACK))
478 {
479 dbug(0, dprintf("Q-FULL2(data) - pending=%d/%d ack_pending=%d/%d",
480 ncci_ptr->data_pending, n, ncci_ptr->data_ack_pending, l));
481
482 return _QUEUE_FULL;
483 }
484 if (plci->req_in || plci->internal_command)
485 {
486 if ((((byte *) msg) >= ((byte *)(plci->msg_in_queue)))
487 && (((byte *) msg) < ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
488 {
489 dbug(0, dprintf("Q-FULL3(requeue)"));
490
491 return _QUEUE_FULL;
492 }
493 c = true;
494 }
495 }
496 else
497 {
498 if (plci->req_in || plci->internal_command)
499 c = true;
500 else
501 {
502 plci->command = msg->header.command;
503 plci->number = msg->header.number;
504 }
505 }
506 if (c)
507 {
508 dbug(1, dprintf("enqueue msg(0x%04x,0x%x,0x%x) - len=%d write=%d read=%d wrap=%d free=%d",
509 msg->header.command, plci->req_in, plci->internal_command,
510 msg->header.length, plci->msg_in_write_pos,
511 plci->msg_in_read_pos, plci->msg_in_wrap_pos, i));
512 if (j == 0)
513 plci->msg_in_wrap_pos = plci->msg_in_write_pos;
514 m = (CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[j]);
515 for (i = 0; i < msg->header.length; i++)
516 ((byte *)(plci->msg_in_queue))[j++] = ((byte *) msg)[i];
517 if (m->header.command == _DATA_B3_R)
518 {
519
520 m->info.data_b3_req.Data = (dword)(long)(TransmitBufferSet(appl, m->info.data_b3_req.Data));
521
522 }
523
524 j = (j + 3) & 0xfffc;
525
526 *((APPL **)(&((byte *)(plci->msg_in_queue))[j])) = appl;
527 plci->msg_in_write_pos = j + MSG_IN_OVERHEAD;
528 return 0;
529 }
530 }
531 else
532 {
533 plci = NULL;
534 }
535 }
536 dbug(1, dprintf("com=%x", msg->header.command));
537
538 for (j = 0; j < MAX_MSG_PARMS + 1; j++) msg_parms[j].length = 0;
539 for (i = 0, ret = _BAD_MSG; i < ARRAY_SIZE(ftable); i++) {
540
541 if (ftable[i].command == msg->header.command) {
542 /* break loop if the message is correct, otherwise continue scan */
543 /* (for example: CONNECT_B3_T90_ACT_RES has two specifications) */
544 if (!api_parse(msg->info.b, (word)(msg->header.length - 12), ftable[i].format, msg_parms)) {
545 ret = 0;
546 break;
547 }
548 for (j = 0; j < MAX_MSG_PARMS + 1; j++) msg_parms[j].length = 0;
549 }
550 }
551 if (ret) {
552 dbug(1, dprintf("BAD_MSG"));
553 if (plci) plci->command = 0;
554 return ret;
555 }
556
557
558 c = ftable[i].function(GET_DWORD(&msg->header.controller),
559 msg->header.number,
560 a,
561 plci,
562 appl,
563 msg_parms);
564
565 channel_xmit_extended_xon(plci);
566
567 if (c == 1) send_req(plci);
568 if (c == 2 && plci) plci->req_in = plci->req_in_start = plci->req_out = 0;
569 if (plci && !plci->req_in) plci->command = 0;
570 return 0;
571 }
572
573
574 /*------------------------------------------------------------------*/
575 /* api_parse function, check the format of api messages */
576 /*------------------------------------------------------------------*/
577
578 static word api_parse(byte *msg, word length, byte *format, API_PARSE *parms)
579 {
580 word i;
581 word p;
582
583 for (i = 0, p = 0; format[i]; i++) {
584 if (parms)
585 {
586 parms[i].info = &msg[p];
587 }
588 switch (format[i]) {
589 case 'b':
590 p += 1;
591 break;
592 case 'w':
593 p += 2;
594 break;
595 case 'd':
596 p += 4;
597 break;
598 case 's':
599 if (msg[p] == 0xff) {
600 parms[i].info += 2;
601 parms[i].length = msg[p + 1] + (msg[p + 2] << 8);
602 p += (parms[i].length + 3);
603 }
604 else {
605 parms[i].length = msg[p];
606 p += (parms[i].length + 1);
607 }
608 break;
609 }
610
611 if (p > length) return true;
612 }
613 if (parms) parms[i].info = NULL;
614 return false;
615 }
616
617 static void api_save_msg(API_PARSE *in, byte *format, API_SAVE *out)
618 {
619 word i, j, n = 0;
620 byte *p;
621
622 p = out->info;
623 for (i = 0; format[i] != '\0'; i++)
624 {
625 out->parms[i].info = p;
626 out->parms[i].length = in[i].length;
627 switch (format[i])
628 {
629 case 'b':
630 n = 1;
631 break;
632 case 'w':
633 n = 2;
634 break;
635 case 'd':
636 n = 4;
637 break;
638 case 's':
639 n = in[i].length + 1;
640 break;
641 }
642 for (j = 0; j < n; j++)
643 *(p++) = in[i].info[j];
644 }
645 out->parms[i].info = NULL;
646 out->parms[i].length = 0;
647 }
648
649 static void api_load_msg(API_SAVE *in, API_PARSE *out)
650 {
651 word i;
652
653 i = 0;
654 do
655 {
656 out[i].info = in->parms[i].info;
657 out[i].length = in->parms[i].length;
658 } while (in->parms[i++].info);
659 }
660
661
662 /*------------------------------------------------------------------*/
663 /* CAPI remove function */
664 /*------------------------------------------------------------------*/
665
666 word api_remove_start(void)
667 {
668 word i;
669 word j;
670
671 if (!remove_started) {
672 remove_started = true;
673 for (i = 0; i < max_adapter; i++) {
674 if (adapter[i].request) {
675 for (j = 0; j < adapter[i].max_plci; j++) {
676 if (adapter[i].plci[j].Sig.Id) plci_remove(&adapter[i].plci[j]);
677 }
678 }
679 }
680 return 1;
681 }
682 else {
683 for (i = 0; i < max_adapter; i++) {
684 if (adapter[i].request) {
685 for (j = 0; j < adapter[i].max_plci; j++) {
686 if (adapter[i].plci[j].Sig.Id) return 1;
687 }
688 }
689 }
690 }
691 api_remove_complete();
692 return 0;
693 }
694
695
696 /*------------------------------------------------------------------*/
697 /* internal command queue */
698 /*------------------------------------------------------------------*/
699
700 static void init_internal_command_queue(PLCI *plci)
701 {
702 word i;
703
704 dbug(1, dprintf("%s,%d: init_internal_command_queue",
705 (char *)(FILE_), __LINE__));
706
707 plci->internal_command = 0;
708 for (i = 0; i < MAX_INTERNAL_COMMAND_LEVELS; i++)
709 plci->internal_command_queue[i] = NULL;
710 }
711
712
713 static void start_internal_command(dword Id, PLCI *plci, t_std_internal_command command_function)
714 {
715 word i;
716
717 dbug(1, dprintf("[%06lx] %s,%d: start_internal_command",
718 UnMapId(Id), (char *)(FILE_), __LINE__));
719
720 if (plci->internal_command == 0)
721 {
722 plci->internal_command_queue[0] = command_function;
723 (*command_function)(Id, plci, OK);
724 }
725 else
726 {
727 i = 1;
728 while (plci->internal_command_queue[i] != NULL)
729 i++;
730 plci->internal_command_queue[i] = command_function;
731 }
732 }
733
734
735 static void next_internal_command(dword Id, PLCI *plci)
736 {
737 word i;
738
739 dbug(1, dprintf("[%06lx] %s,%d: next_internal_command",
740 UnMapId(Id), (char *)(FILE_), __LINE__));
741
742 plci->internal_command = 0;
743 plci->internal_command_queue[0] = NULL;
744 while (plci->internal_command_queue[1] != NULL)
745 {
746 for (i = 0; i < MAX_INTERNAL_COMMAND_LEVELS - 1; i++)
747 plci->internal_command_queue[i] = plci->internal_command_queue[i + 1];
748 plci->internal_command_queue[MAX_INTERNAL_COMMAND_LEVELS - 1] = NULL;
749 (*(plci->internal_command_queue[0]))(Id, plci, OK);
750 if (plci->internal_command != 0)
751 return;
752 plci->internal_command_queue[0] = NULL;
753 }
754 }
755
756
757 /*------------------------------------------------------------------*/
758 /* NCCI allocate/remove function */
759 /*------------------------------------------------------------------*/
760
761 static dword ncci_mapping_bug = 0;
762
763 static word get_ncci(PLCI *plci, byte ch, word force_ncci)
764 {
765 DIVA_CAPI_ADAPTER *a;
766 word ncci, i, j, k;
767
768 a = plci->adapter;
769 if (!ch || a->ch_ncci[ch])
770 {
771 ncci_mapping_bug++;
772 dbug(1, dprintf("NCCI mapping exists %ld %02x %02x %02x-%02x",
773 ncci_mapping_bug, ch, force_ncci, a->ncci_ch[a->ch_ncci[ch]], a->ch_ncci[ch]));
774 ncci = ch;
775 }
776 else
777 {
778 if (force_ncci)
779 ncci = force_ncci;
780 else
781 {
782 if ((ch < MAX_NCCI + 1) && !a->ncci_ch[ch])
783 ncci = ch;
784 else
785 {
786 ncci = 1;
787 while ((ncci < MAX_NCCI + 1) && a->ncci_ch[ncci])
788 ncci++;
789 if (ncci == MAX_NCCI + 1)
790 {
791 ncci_mapping_bug++;
792 i = 1;
793 do
794 {
795 j = 1;
796 while ((j < MAX_NCCI + 1) && (a->ncci_ch[j] != i))
797 j++;
798 k = j;
799 if (j < MAX_NCCI + 1)
800 {
801 do
802 {
803 j++;
804 } while ((j < MAX_NCCI + 1) && (a->ncci_ch[j] != i));
805 }
806 } while ((i < MAX_NL_CHANNEL + 1) && (j < MAX_NCCI + 1));
807 if (i < MAX_NL_CHANNEL + 1)
808 {
809 dbug(1, dprintf("NCCI mapping overflow %ld %02x %02x %02x-%02x-%02x",
810 ncci_mapping_bug, ch, force_ncci, i, k, j));
811 }
812 else
813 {
814 dbug(1, dprintf("NCCI mapping overflow %ld %02x %02x",
815 ncci_mapping_bug, ch, force_ncci));
816 }
817 ncci = ch;
818 }
819 }
820 a->ncci_plci[ncci] = plci->Id;
821 a->ncci_state[ncci] = IDLE;
822 if (!plci->ncci_ring_list)
823 plci->ncci_ring_list = ncci;
824 else
825 a->ncci_next[ncci] = a->ncci_next[plci->ncci_ring_list];
826 a->ncci_next[plci->ncci_ring_list] = (byte) ncci;
827 }
828 a->ncci_ch[ncci] = ch;
829 a->ch_ncci[ch] = (byte) ncci;
830 dbug(1, dprintf("NCCI mapping established %ld %02x %02x %02x-%02x",
831 ncci_mapping_bug, ch, force_ncci, ch, ncci));
832 }
833 return (ncci);
834 }
835
836
837 static void ncci_free_receive_buffers(PLCI *plci, word ncci)
838 {
839 DIVA_CAPI_ADAPTER *a;
840 APPL *appl;
841 word i, ncci_code;
842 dword Id;
843
844 a = plci->adapter;
845 Id = (((dword) ncci) << 16) | (((word)(plci->Id)) << 8) | a->Id;
846 if (ncci)
847 {
848 if (a->ncci_plci[ncci] == plci->Id)
849 {
850 if (!plci->appl)
851 {
852 ncci_mapping_bug++;
853 dbug(1, dprintf("NCCI mapping appl expected %ld %08lx",
854 ncci_mapping_bug, Id));
855 }
856 else
857 {
858 appl = plci->appl;
859 ncci_code = ncci | (((word) a->Id) << 8);
860 for (i = 0; i < appl->MaxBuffer; i++)
861 {
862 if ((appl->DataNCCI[i] == ncci_code)
863 && (((byte)(appl->DataFlags[i] >> 8)) == plci->Id))
864 {
865 appl->DataNCCI[i] = 0;
866 }
867 }
868 }
869 }
870 }
871 else
872 {
873 for (ncci = 1; ncci < MAX_NCCI + 1; ncci++)
874 {
875 if (a->ncci_plci[ncci] == plci->Id)
876 {
877 if (!plci->appl)
878 {
879 ncci_mapping_bug++;
880 dbug(1, dprintf("NCCI mapping no appl %ld %08lx",
881 ncci_mapping_bug, Id));
882 }
883 else
884 {
885 appl = plci->appl;
886 ncci_code = ncci | (((word) a->Id) << 8);
887 for (i = 0; i < appl->MaxBuffer; i++)
888 {
889 if ((appl->DataNCCI[i] == ncci_code)
890 && (((byte)(appl->DataFlags[i] >> 8)) == plci->Id))
891 {
892 appl->DataNCCI[i] = 0;
893 }
894 }
895 }
896 }
897 }
898 }
899 }
900
901
902 static void cleanup_ncci_data(PLCI *plci, word ncci)
903 {
904 NCCI *ncci_ptr;
905
906 if (ncci && (plci->adapter->ncci_plci[ncci] == plci->Id))
907 {
908 ncci_ptr = &(plci->adapter->ncci[ncci]);
909 if (plci->appl)
910 {
911 while (ncci_ptr->data_pending != 0)
912 {
913 if (!plci->data_sent || (ncci_ptr->DBuffer[ncci_ptr->data_out].P != plci->data_sent_ptr))
914 TransmitBufferFree(plci->appl, ncci_ptr->DBuffer[ncci_ptr->data_out].P);
915 (ncci_ptr->data_out)++;
916 if (ncci_ptr->data_out == MAX_DATA_B3)
917 ncci_ptr->data_out = 0;
918 (ncci_ptr->data_pending)--;
919 }
920 }
921 ncci_ptr->data_out = 0;
922 ncci_ptr->data_pending = 0;
923 ncci_ptr->data_ack_out = 0;
924 ncci_ptr->data_ack_pending = 0;
925 }
926 }
927
928
929 static void ncci_remove(PLCI *plci, word ncci, byte preserve_ncci)
930 {
931 DIVA_CAPI_ADAPTER *a;
932 dword Id;
933 word i;
934
935 a = plci->adapter;
936 Id = (((dword) ncci) << 16) | (((word)(plci->Id)) << 8) | a->Id;
937 if (!preserve_ncci)
938 ncci_free_receive_buffers(plci, ncci);
939 if (ncci)
940 {
941 if (a->ncci_plci[ncci] != plci->Id)
942 {
943 ncci_mapping_bug++;
944 dbug(1, dprintf("NCCI mapping doesn't exist %ld %08lx %02x",
945 ncci_mapping_bug, Id, preserve_ncci));
946 }
947 else
948 {
949 cleanup_ncci_data(plci, ncci);
950 dbug(1, dprintf("NCCI mapping released %ld %08lx %02x %02x-%02x",
951 ncci_mapping_bug, Id, preserve_ncci, a->ncci_ch[ncci], ncci));
952 a->ch_ncci[a->ncci_ch[ncci]] = 0;
953 if (!preserve_ncci)
954 {
955 a->ncci_ch[ncci] = 0;
956 a->ncci_plci[ncci] = 0;
957 a->ncci_state[ncci] = IDLE;
958 i = plci->ncci_ring_list;
959 while ((i != 0) && (a->ncci_next[i] != plci->ncci_ring_list) && (a->ncci_next[i] != ncci))
960 i = a->ncci_next[i];
961 if ((i != 0) && (a->ncci_next[i] == ncci))
962 {
963 if (i == ncci)
964 plci->ncci_ring_list = 0;
965 else if (plci->ncci_ring_list == ncci)
966 plci->ncci_ring_list = i;
967 a->ncci_next[i] = a->ncci_next[ncci];
968 }
969 a->ncci_next[ncci] = 0;
970 }
971 }
972 }
973 else
974 {
975 for (ncci = 1; ncci < MAX_NCCI + 1; ncci++)
976 {
977 if (a->ncci_plci[ncci] == plci->Id)
978 {
979 cleanup_ncci_data(plci, ncci);
980 dbug(1, dprintf("NCCI mapping released %ld %08lx %02x %02x-%02x",
981 ncci_mapping_bug, Id, preserve_ncci, a->ncci_ch[ncci], ncci));
982 a->ch_ncci[a->ncci_ch[ncci]] = 0;
983 if (!preserve_ncci)
984 {
985 a->ncci_ch[ncci] = 0;
986 a->ncci_plci[ncci] = 0;
987 a->ncci_state[ncci] = IDLE;
988 a->ncci_next[ncci] = 0;
989 }
990 }
991 }
992 if (!preserve_ncci)
993 plci->ncci_ring_list = 0;
994 }
995 }
996
997
998 /*------------------------------------------------------------------*/
999 /* PLCI remove function */
1000 /*------------------------------------------------------------------*/
1001
1002 static void plci_free_msg_in_queue(PLCI *plci)
1003 {
1004 word i;
1005
1006 if (plci->appl)
1007 {
1008 i = plci->msg_in_read_pos;
1009 while (i != plci->msg_in_write_pos)
1010 {
1011 if (i == plci->msg_in_wrap_pos)
1012 i = 0;
1013 if (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[i]))->header.command == _DATA_B3_R)
1014 {
1015
1016 TransmitBufferFree(plci->appl,
1017 (byte *)(long)(((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[i]))->info.data_b3_req.Data));
1018
1019 }
1020
1021 i += (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[i]))->header.length +
1022 MSG_IN_OVERHEAD + 3) & 0xfffc;
1023
1024 }
1025 }
1026 plci->msg_in_write_pos = MSG_IN_QUEUE_SIZE;
1027 plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
1028 plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
1029 }
1030
1031
1032 static void plci_remove(PLCI *plci)
1033 {
1034
1035 if (!plci) {
1036 dbug(1, dprintf("plci_remove(no plci)"));
1037 return;
1038 }
1039 init_internal_command_queue(plci);
1040 dbug(1, dprintf("plci_remove(%x,tel=%x)", plci->Id, plci->tel));
1041 if (plci_remove_check(plci))
1042 {
1043 return;
1044 }
1045 if (plci->Sig.Id == 0xff)
1046 {
1047 dbug(1, dprintf("D-channel X.25 plci->NL.Id:%0x", plci->NL.Id));
1048 if (plci->NL.Id && !plci->nl_remove_id)
1049 {
1050 nl_req_ncci(plci, REMOVE, 0);
1051 send_req(plci);
1052 }
1053 }
1054 else
1055 {
1056 if (!plci->sig_remove_id
1057 && (plci->Sig.Id
1058 || (plci->req_in != plci->req_out)
1059 || (plci->nl_req || plci->sig_req)))
1060 {
1061 sig_req(plci, HANGUP, 0);
1062 send_req(plci);
1063 }
1064 }
1065 ncci_remove(plci, 0, false);
1066 plci_free_msg_in_queue(plci);
1067
1068 plci->channels = 0;
1069 plci->appl = NULL;
1070 if ((plci->State == INC_CON_PENDING) || (plci->State == INC_CON_ALERT))
1071 plci->State = OUTG_DIS_PENDING;
1072 }
1073
1074 /*------------------------------------------------------------------*/
1075 /* translation function for each message */
1076 /*------------------------------------------------------------------*/
1077
1078 static byte connect_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1079 PLCI *plci, APPL *appl, API_PARSE *parms)
1080 {
1081 word ch;
1082 word i;
1083 word Info;
1084 byte LinkLayer;
1085 API_PARSE *ai;
1086 API_PARSE *bp;
1087 API_PARSE ai_parms[5];
1088 word channel = 0;
1089 dword ch_mask;
1090 byte m;
1091 static byte esc_chi[35] = {0x02, 0x18, 0x01};
1092 static byte lli[2] = {0x01, 0x00};
1093 byte noCh = 0;
1094 word dir = 0;
1095 byte *p_chi = "";
1096
1097 for (i = 0; i < 5; i++) ai_parms[i].length = 0;
1098
1099 dbug(1, dprintf("connect_req(%d)", parms->length));
1100 Info = _WRONG_IDENTIFIER;
1101 if (a)
1102 {
1103 if (a->adapter_disabled)
1104 {
1105 dbug(1, dprintf("adapter disabled"));
1106 Id = ((word)1 << 8) | a->Id;
1107 sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", 0);
1108 sendf(appl, _DISCONNECT_I, Id, 0, "w", _L1_ERROR);
1109 return false;
1110 }
1111 Info = _OUT_OF_PLCI;
1112 if ((i = get_plci(a)))
1113 {
1114 Info = 0;
1115 plci = &a->plci[i - 1];
1116 plci->appl = appl;
1117 plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
1118 /* check 'external controller' bit for codec support */
1119 if (Id & EXT_CONTROLLER)
1120 {
1121 if (AdvCodecSupport(a, plci, appl, 0))
1122 {
1123 plci->Id = 0;
1124 sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", _WRONG_IDENTIFIER);
1125 return 2;
1126 }
1127 }
1128 ai = &parms[9];
1129 bp = &parms[5];
1130 ch = 0;
1131 if (bp->length)LinkLayer = bp->info[3];
1132 else LinkLayer = 0;
1133 if (ai->length)
1134 {
1135 ch = 0xffff;
1136 if (!api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms))
1137 {
1138 ch = 0;
1139 if (ai_parms[0].length)
1140 {
1141 ch = GET_WORD(ai_parms[0].info + 1);
1142 if (ch > 4) ch = 0; /* safety -> ignore ChannelID */
1143 if (ch == 4) /* explizit CHI in message */
1144 {
1145 /* check length of B-CH struct */
1146 if ((ai_parms[0].info)[3] >= 1)
1147 {
1148 if ((ai_parms[0].info)[4] == CHI)
1149 {
1150 p_chi = &((ai_parms[0].info)[5]);
1151 }
1152 else
1153 {
1154 p_chi = &((ai_parms[0].info)[3]);
1155 }
1156 if (p_chi[0] > 35) /* check length of channel ID */
1157 {
1158 Info = _WRONG_MESSAGE_FORMAT;
1159 }
1160 }
1161 else Info = _WRONG_MESSAGE_FORMAT;
1162 }
1163
1164 if (ch == 3 && ai_parms[0].length >= 7 && ai_parms[0].length <= 36)
1165 {
1166 dir = GET_WORD(ai_parms[0].info + 3);
1167 ch_mask = 0;
1168 m = 0x3f;
1169 for (i = 0; i + 5 <= ai_parms[0].length; i++)
1170 {
1171 if (ai_parms[0].info[i + 5] != 0)
1172 {
1173 if ((ai_parms[0].info[i + 5] | m) != 0xff)
1174 Info = _WRONG_MESSAGE_FORMAT;
1175 else
1176 {
1177 if (ch_mask == 0)
1178 channel = i;
1179 ch_mask |= 1L << i;
1180 }
1181 }
1182 m = 0;
1183 }
1184 if (ch_mask == 0)
1185 Info = _WRONG_MESSAGE_FORMAT;
1186 if (!Info)
1187 {
1188 if ((ai_parms[0].length == 36) || (ch_mask != ((dword)(1L << channel))))
1189 {
1190 esc_chi[0] = (byte)(ai_parms[0].length - 2);
1191 for (i = 0; i + 5 <= ai_parms[0].length; i++)
1192 esc_chi[i + 3] = ai_parms[0].info[i + 5];
1193 }
1194 else
1195 esc_chi[0] = 2;
1196 esc_chi[2] = (byte)channel;
1197 plci->b_channel = (byte)channel; /* not correct for ETSI ch 17..31 */
1198 add_p(plci, LLI, lli);
1199 add_p(plci, ESC, esc_chi);
1200 plci->State = LOCAL_CONNECT;
1201 if (!dir) plci->call_dir |= CALL_DIR_FORCE_OUTG_NL; /* dir 0=DTE, 1=DCE */
1202 }
1203 }
1204 }
1205 }
1206 else Info = _WRONG_MESSAGE_FORMAT;
1207 }
1208
1209 dbug(1, dprintf("ch=%x,dir=%x,p_ch=%d", ch, dir, channel));
1210 plci->command = _CONNECT_R;
1211 plci->number = Number;
1212 /* x.31 or D-ch free SAPI in LinkLayer? */
1213 if (ch == 1 && LinkLayer != 3 && LinkLayer != 12) noCh = true;
1214 if ((ch == 0 || ch == 2 || noCh || ch == 3 || ch == 4) && !Info)
1215 {
1216 /* B-channel used for B3 connections (ch==0), or no B channel */
1217 /* is used (ch==2) or perm. connection (3) is used do a CALL */
1218 if (noCh) Info = add_b1(plci, &parms[5], 2, 0); /* no resource */
1219 else Info = add_b1(plci, &parms[5], ch, 0);
1220 add_s(plci, OAD, &parms[2]);
1221 add_s(plci, OSA, &parms[4]);
1222 add_s(plci, BC, &parms[6]);
1223 add_s(plci, LLC, &parms[7]);
1224 add_s(plci, HLC, &parms[8]);
1225 if (a->Info_Mask[appl->Id - 1] & 0x200)
1226 {
1227 /* early B3 connect (CIP mask bit 9) no release after a disc */
1228 add_p(plci, LLI, "\x01\x01");
1229 }
1230 if (GET_WORD(parms[0].info) < 29) {
1231 add_p(plci, BC, cip_bc[GET_WORD(parms[0].info)][a->u_law]);
1232 add_p(plci, HLC, cip_hlc[GET_WORD(parms[0].info)]);
1233 }
1234 add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
1235 sig_req(plci, ASSIGN, DSIG_ID);
1236 }
1237 else if (ch == 1) {
1238
1239 /* D-Channel used for B3 connections */
1240 plci->Sig.Id = 0xff;
1241 Info = 0;
1242 }
1243
1244 if (!Info && ch != 2 && !noCh) {
1245 Info = add_b23(plci, &parms[5]);
1246 if (!Info) {
1247 if (!(plci->tel && !plci->adv_nl))nl_req_ncci(plci, ASSIGN, 0);
1248 }
1249 }
1250
1251 if (!Info)
1252 {
1253 if (ch == 0 || ch == 2 || ch == 3 || noCh || ch == 4)
1254 {
1255 if (plci->spoofed_msg == SPOOFING_REQUIRED)
1256 {
1257 api_save_msg(parms, "wsssssssss", &plci->saved_msg);
1258 plci->spoofed_msg = CALL_REQ;
1259 plci->internal_command = BLOCK_PLCI;
1260 plci->command = 0;
1261 dbug(1, dprintf("Spoof"));
1262 send_req(plci);
1263 return false;
1264 }
1265 if (ch == 4)add_p(plci, CHI, p_chi);
1266 add_s(plci, CPN, &parms[1]);
1267 add_s(plci, DSA, &parms[3]);
1268 if (noCh) add_p(plci, ESC, "\x02\x18\xfd"); /* D-channel, no B-L3 */
1269 add_ai(plci, &parms[9]);
1270 if (!dir)sig_req(plci, CALL_REQ, 0);
1271 else
1272 {
1273 plci->command = PERM_LIST_REQ;
1274 plci->appl = appl;
1275 sig_req(plci, LISTEN_REQ, 0);
1276 send_req(plci);
1277 return false;
1278 }
1279 }
1280 send_req(plci);
1281 return false;
1282 }
1283 plci->Id = 0;
1284 }
1285 }
1286 sendf(appl,
1287 _CONNECT_R | CONFIRM,
1288 Id,
1289 Number,
1290 "w", Info);
1291 return 2;
1292 }
1293
1294 static byte connect_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1295 PLCI *plci, APPL *appl, API_PARSE *parms)
1296 {
1297 word i, Info;
1298 word Reject;
1299 static byte cau_t[] = {0, 0, 0x90, 0x91, 0xac, 0x9d, 0x86, 0xd8, 0x9b};
1300 static byte esc_t[] = {0x03, 0x08, 0x00, 0x00};
1301 API_PARSE *ai;
1302 API_PARSE ai_parms[5];
1303 word ch = 0;
1304
1305 if (!plci) {
1306 dbug(1, dprintf("connect_res(no plci)"));
1307 return 0; /* no plci, no send */
1308 }
1309
1310 dbug(1, dprintf("connect_res(State=0x%x)", plci->State));
1311 for (i = 0; i < 5; i++) ai_parms[i].length = 0;
1312 ai = &parms[5];
1313 dbug(1, dprintf("ai->length=%d", ai->length));
1314
1315 if (ai->length)
1316 {
1317 if (!api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms))
1318 {
1319 dbug(1, dprintf("ai_parms[0].length=%d/0x%x", ai_parms[0].length, GET_WORD(ai_parms[0].info + 1)));
1320 ch = 0;
1321 if (ai_parms[0].length)
1322 {
1323 ch = GET_WORD(ai_parms[0].info + 1);
1324 dbug(1, dprintf("BCH-I=0x%x", ch));
1325 }
1326 }
1327 }
1328
1329 if (plci->State == INC_CON_CONNECTED_ALERT)
1330 {
1331 dbug(1, dprintf("Connected Alert Call_Res"));
1332 if (a->Info_Mask[appl->Id - 1] & 0x200)
1333 {
1334 /* early B3 connect (CIP mask bit 9) no release after a disc */
1335 add_p(plci, LLI, "\x01\x01");
1336 }
1337 add_s(plci, CONN_NR, &parms[2]);
1338 add_s(plci, LLC, &parms[4]);
1339 add_ai(plci, &parms[5]);
1340 plci->State = INC_CON_ACCEPT;
1341 sig_req(plci, CALL_RES, 0);
1342 return 1;
1343 }
1344 else if (plci->State == INC_CON_PENDING || plci->State == INC_CON_ALERT) {
1345 __clear_bit(appl->Id - 1, plci->c_ind_mask_table);
1346 dbug(1, dprintf("c_ind_mask =%*pb", MAX_APPL, plci->c_ind_mask_table));
1347 Reject = GET_WORD(parms[0].info);
1348 dbug(1, dprintf("Reject=0x%x", Reject));
1349 if (Reject)
1350 {
1351 if (bitmap_empty(plci->c_ind_mask_table, MAX_APPL))
1352 {
1353 if ((Reject & 0xff00) == 0x3400)
1354 {
1355 esc_t[2] = ((byte)(Reject & 0x00ff)) | 0x80;
1356 add_p(plci, ESC, esc_t);
1357 add_ai(plci, &parms[5]);
1358 sig_req(plci, REJECT, 0);
1359 }
1360 else if (Reject == 1 || Reject >= 9)
1361 {
1362 add_ai(plci, &parms[5]);
1363 sig_req(plci, HANGUP, 0);
1364 }
1365 else
1366 {
1367 esc_t[2] = cau_t[(Reject&0x000f)];
1368 add_p(plci, ESC, esc_t);
1369 add_ai(plci, &parms[5]);
1370 sig_req(plci, REJECT, 0);
1371 }
1372 plci->appl = appl;
1373 }
1374 else
1375 {
1376 sendf(appl, _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED);
1377 }
1378 }
1379 else {
1380 plci->appl = appl;
1381 if (Id & EXT_CONTROLLER) {
1382 if (AdvCodecSupport(a, plci, appl, 0)) {
1383 dbug(1, dprintf("connect_res(error from AdvCodecSupport)"));
1384 sig_req(plci, HANGUP, 0);
1385 return 1;
1386 }
1387 if (plci->tel == ADV_VOICE && a->AdvCodecPLCI)
1388 {
1389 Info = add_b23(plci, &parms[1]);
1390 if (Info)
1391 {
1392 dbug(1, dprintf("connect_res(error from add_b23)"));
1393 sig_req(plci, HANGUP, 0);
1394 return 1;
1395 }
1396 if (plci->adv_nl)
1397 {
1398 nl_req_ncci(plci, ASSIGN, 0);
1399 }
1400 }
1401 }
1402 else
1403 {
1404 plci->tel = 0;
1405 if (ch != 2)
1406 {
1407 Info = add_b23(plci, &parms[1]);
1408 if (Info)
1409 {
1410 dbug(1, dprintf("connect_res(error from add_b23 2)"));
1411 sig_req(plci, HANGUP, 0);
1412 return 1;
1413 }
1414 }
1415 nl_req_ncci(plci, ASSIGN, 0);
1416 }
1417
1418 if (plci->spoofed_msg == SPOOFING_REQUIRED)
1419 {
1420 api_save_msg(parms, "wsssss", &plci->saved_msg);
1421 plci->spoofed_msg = CALL_RES;
1422 plci->internal_command = BLOCK_PLCI;
1423 plci->command = 0;
1424 dbug(1, dprintf("Spoof"));
1425 }
1426 else
1427 {
1428 add_b1(plci, &parms[1], ch, plci->B1_facilities);
1429 if (a->Info_Mask[appl->Id - 1] & 0x200)
1430 {
1431 /* early B3 connect (CIP mask bit 9) no release after a disc */
1432 add_p(plci, LLI, "\x01\x01");
1433 }
1434 add_s(plci, CONN_NR, &parms[2]);
1435 add_s(plci, LLC, &parms[4]);
1436 add_ai(plci, &parms[5]);
1437 plci->State = INC_CON_ACCEPT;
1438 sig_req(plci, CALL_RES, 0);
1439 }
1440
1441 for_each_set_bit(i, plci->c_ind_mask_table, max_appl)
1442 sendf(&application[i], _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED);
1443 }
1444 }
1445 return 1;
1446 }
1447
1448 static byte connect_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1449 PLCI *plci, APPL *appl, API_PARSE *msg)
1450 {
1451 dbug(1, dprintf("connect_a_res"));
1452 return false;
1453 }
1454
1455 static byte disconnect_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1456 PLCI *plci, APPL *appl, API_PARSE *msg)
1457 {
1458 word Info;
1459 word i;
1460
1461 dbug(1, dprintf("disconnect_req"));
1462
1463 Info = _WRONG_IDENTIFIER;
1464
1465 if (plci)
1466 {
1467 if (plci->State == INC_CON_PENDING || plci->State == INC_CON_ALERT)
1468 {
1469 __clear_bit(appl->Id - 1, plci->c_ind_mask_table);
1470 plci->appl = appl;
1471 for_each_set_bit(i, plci->c_ind_mask_table, max_appl)
1472 sendf(&application[i], _DISCONNECT_I, Id, 0, "w", 0);
1473 plci->State = OUTG_DIS_PENDING;
1474 }
1475 if (plci->Sig.Id && plci->appl)
1476 {
1477 Info = 0;
1478 if (plci->Sig.Id != 0xff)
1479 {
1480 if (plci->State != INC_DIS_PENDING)
1481 {
1482 add_ai(plci, &msg[0]);
1483 sig_req(plci, HANGUP, 0);
1484 plci->State = OUTG_DIS_PENDING;
1485 return 1;
1486 }
1487 }
1488 else
1489 {
1490 if (plci->NL.Id && !plci->nl_remove_id)
1491 {
1492 mixer_remove(plci);
1493 nl_req_ncci(plci, REMOVE, 0);
1494 sendf(appl, _DISCONNECT_R | CONFIRM, Id, Number, "w", 0);
1495 sendf(appl, _DISCONNECT_I, Id, 0, "w", 0);
1496 plci->State = INC_DIS_PENDING;
1497 }
1498 return 1;
1499 }
1500 }
1501 }
1502
1503 if (!appl) return false;
1504 sendf(appl, _DISCONNECT_R | CONFIRM, Id, Number, "w", Info);
1505 return false;
1506 }
1507
1508 static byte disconnect_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1509 PLCI *plci, APPL *appl, API_PARSE *msg)
1510 {
1511 dbug(1, dprintf("disconnect_res"));
1512 if (plci)
1513 {
1514 /* clear ind mask bit, just in case of collsion of */
1515 /* DISCONNECT_IND and CONNECT_RES */
1516 __clear_bit(appl->Id - 1, plci->c_ind_mask_table);
1517 ncci_free_receive_buffers(plci, 0);
1518 if (plci_remove_check(plci))
1519 {
1520 return 0;
1521 }
1522 if (plci->State == INC_DIS_PENDING
1523 || plci->State == SUSPENDING) {
1524 if (bitmap_empty(plci->c_ind_mask_table, MAX_APPL)) {
1525 if (plci->State != SUSPENDING) plci->State = IDLE;
1526 dbug(1, dprintf("chs=%d", plci->channels));
1527 if (!plci->channels) {
1528 plci_remove(plci);
1529 }
1530 }
1531 }
1532 }
1533 return 0;
1534 }
1535
1536 static byte listen_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1537 PLCI *plci, APPL *appl, API_PARSE *parms)
1538 {
1539 word Info;
1540 byte i;
1541
1542 dbug(1, dprintf("listen_req(Appl=0x%x)", appl->Id));
1543
1544 Info = _WRONG_IDENTIFIER;
1545 if (a) {
1546 Info = 0;
1547 a->Info_Mask[appl->Id - 1] = GET_DWORD(parms[0].info);
1548 a->CIP_Mask[appl->Id - 1] = GET_DWORD(parms[1].info);
1549 dbug(1, dprintf("CIP_MASK=0x%lx", GET_DWORD(parms[1].info)));
1550 if (a->Info_Mask[appl->Id - 1] & 0x200) { /* early B3 connect provides */
1551 a->Info_Mask[appl->Id - 1] |= 0x10; /* call progression infos */
1552 }
1553
1554 /* check if external controller listen and switch listen on or off*/
1555 if (Id&EXT_CONTROLLER && GET_DWORD(parms[1].info)) {
1556 if (a->profile.Global_Options & ON_BOARD_CODEC) {
1557 dummy_plci.State = IDLE;
1558 a->codec_listen[appl->Id - 1] = &dummy_plci;
1559 a->TelOAD[0] = (byte)(parms[3].length);
1560 for (i = 1; parms[3].length >= i && i < 22; i++) {
1561 a->TelOAD[i] = parms[3].info[i];
1562 }
1563 a->TelOAD[i] = 0;
1564 a->TelOSA[0] = (byte)(parms[4].length);
1565 for (i = 1; parms[4].length >= i && i < 22; i++) {
1566 a->TelOSA[i] = parms[4].info[i];
1567 }
1568 a->TelOSA[i] = 0;
1569 }
1570 else Info = 0x2002; /* wrong controller, codec not supported */
1571 }
1572 else{ /* clear listen */
1573 a->codec_listen[appl->Id - 1] = (PLCI *)0;
1574 }
1575 }
1576 sendf(appl,
1577 _LISTEN_R | CONFIRM,
1578 Id,
1579 Number,
1580 "w", Info);
1581
1582 if (a) listen_check(a);
1583 return false;
1584 }
1585
1586 static byte info_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1587 PLCI *plci, APPL *appl, API_PARSE *msg)
1588 {
1589 word i;
1590 API_PARSE *ai;
1591 PLCI *rc_plci = NULL;
1592 API_PARSE ai_parms[5];
1593 word Info = 0;
1594
1595 dbug(1, dprintf("info_req"));
1596 for (i = 0; i < 5; i++) ai_parms[i].length = 0;
1597
1598 ai = &msg[1];
1599
1600 if (ai->length)
1601 {
1602 if (api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms))
1603 {
1604 dbug(1, dprintf("AddInfo wrong"));
1605 Info = _WRONG_MESSAGE_FORMAT;
1606 }
1607 }
1608 if (!a) Info = _WRONG_STATE;
1609
1610 if (!Info && plci)
1611 { /* no fac, with CPN, or KEY */
1612 rc_plci = plci;
1613 if (!ai_parms[3].length && plci->State && (msg[0].length || ai_parms[1].length))
1614 {
1615 /* overlap sending option */
1616 dbug(1, dprintf("OvlSnd"));
1617 add_s(plci, CPN, &msg[0]);
1618 add_s(plci, KEY, &ai_parms[1]);
1619 sig_req(plci, INFO_REQ, 0);
1620 send_req(plci);
1621 return false;
1622 }
1623
1624 if (plci->State && ai_parms[2].length)
1625 {
1626 /* User_Info option */
1627 dbug(1, dprintf("UUI"));
1628 add_s(plci, UUI, &ai_parms[2]);
1629 sig_req(plci, USER_DATA, 0);
1630 }
1631 else if (plci->State && ai_parms[3].length)
1632 {
1633 /* Facility option */
1634 dbug(1, dprintf("FAC"));
1635 add_s(plci, CPN, &msg[0]);
1636 add_ai(plci, &msg[1]);
1637 sig_req(plci, FACILITY_REQ, 0);
1638 }
1639 else
1640 {
1641 Info = _WRONG_STATE;
1642 }
1643 }
1644 else if ((ai_parms[1].length || ai_parms[2].length || ai_parms[3].length) && !Info)
1645 {
1646 /* NCR_Facility option -> send UUI and Keypad too */
1647 dbug(1, dprintf("NCR_FAC"));
1648 if ((i = get_plci(a)))
1649 {
1650 rc_plci = &a->plci[i - 1];
1651 appl->NullCREnable = true;
1652 rc_plci->internal_command = C_NCR_FAC_REQ;
1653 rc_plci->appl = appl;
1654 add_p(rc_plci, CAI, "\x01\x80");
1655 add_p(rc_plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
1656 sig_req(rc_plci, ASSIGN, DSIG_ID);
1657 send_req(rc_plci);
1658 }
1659 else
1660 {
1661 Info = _OUT_OF_PLCI;
1662 }
1663
1664 if (!Info)
1665 {
1666 add_s(rc_plci, CPN, &msg[0]);
1667 add_ai(rc_plci, &msg[1]);
1668 sig_req(rc_plci, NCR_FACILITY, 0);
1669 send_req(rc_plci);
1670 return false;
1671 /* for application controlled supplementary services */
1672 }
1673 }
1674
1675 if (!rc_plci)
1676 {
1677 Info = _WRONG_MESSAGE_FORMAT;
1678 }
1679
1680 if (!Info)
1681 {
1682 send_req(rc_plci);
1683 }
1684 else
1685 { /* appl is not assigned to a PLCI or error condition */
1686 dbug(1, dprintf("localInfoCon"));
1687 sendf(appl,
1688 _INFO_R | CONFIRM,
1689 Id,
1690 Number,
1691 "w", Info);
1692 }
1693 return false;
1694 }
1695
1696 static byte info_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1697 PLCI *plci, APPL *appl, API_PARSE *msg)
1698 {
1699 dbug(1, dprintf("info_res"));
1700 return false;
1701 }
1702
1703 static byte alert_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1704 PLCI *plci, APPL *appl, API_PARSE *msg)
1705 {
1706 word Info;
1707 byte ret;
1708
1709 dbug(1, dprintf("alert_req"));
1710
1711 Info = _WRONG_IDENTIFIER;
1712 ret = false;
1713 if (plci) {
1714 Info = _ALERT_IGNORED;
1715 if (plci->State != INC_CON_ALERT) {
1716 Info = _WRONG_STATE;
1717 if (plci->State == INC_CON_PENDING) {
1718 Info = 0;
1719 plci->State = INC_CON_ALERT;
1720 add_ai(plci, &msg[0]);
1721 sig_req(plci, CALL_ALERT, 0);
1722 ret = 1;
1723 }
1724 }
1725 }
1726 sendf(appl,
1727 _ALERT_R | CONFIRM,
1728 Id,
1729 Number,
1730 "w", Info);
1731 return ret;
1732 }
1733
1734 static byte facility_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1735 PLCI *plci, APPL *appl, API_PARSE *msg)
1736 {
1737 word Info = 0;
1738 word i = 0;
1739
1740 word selector;
1741 word SSreq;
1742 long relatedPLCIvalue;
1743 DIVA_CAPI_ADAPTER *relatedadapter;
1744 byte *SSparms = "";
1745 byte RCparms[] = "\x05\x00\x00\x02\x00\x00";
1746 byte SSstruct[] = "\x09\x00\x00\x06\x00\x00\x00\x00\x00\x00";
1747 API_PARSE *parms;
1748 API_PARSE ss_parms[11];
1749 PLCI *rplci;
1750 byte cai[15];
1751 dword d;
1752 API_PARSE dummy;
1753
1754 dbug(1, dprintf("facility_req"));
1755 for (i = 0; i < 9; i++) ss_parms[i].length = 0;
1756
1757 parms = &msg[1];
1758
1759 if (!a)
1760 {
1761 dbug(1, dprintf("wrong Ctrl"));
1762 Info = _WRONG_IDENTIFIER;
1763 }
1764
1765 selector = GET_WORD(msg[0].info);
1766
1767 if (!Info)
1768 {
1769 switch (selector)
1770 {
1771 case SELECTOR_HANDSET:
1772 Info = AdvCodecSupport(a, plci, appl, HOOK_SUPPORT);
1773 break;
1774
1775 case SELECTOR_SU_SERV:
1776 if (!msg[1].length)
1777 {
1778 Info = _WRONG_MESSAGE_FORMAT;
1779 break;
1780 }
1781 SSreq = GET_WORD(&(msg[1].info[1]));
1782 PUT_WORD(&RCparms[1], SSreq);
1783 SSparms = RCparms;
1784 switch (SSreq)
1785 {
1786 case S_GET_SUPPORTED_SERVICES:
1787 if ((i = get_plci(a)))
1788 {
1789 rplci = &a->plci[i - 1];
1790 rplci->appl = appl;
1791 add_p(rplci, CAI, "\x01\x80");
1792 add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
1793 sig_req(rplci, ASSIGN, DSIG_ID);
1794 send_req(rplci);
1795 }
1796 else
1797 {
1798 PUT_DWORD(&SSstruct[6], MASK_TERMINAL_PORTABILITY);
1799 SSparms = (byte *)SSstruct;
1800 break;
1801 }
1802 rplci->internal_command = GETSERV_REQ_PEND;
1803 rplci->number = Number;
1804 rplci->appl = appl;
1805 sig_req(rplci, S_SUPPORTED, 0);
1806 send_req(rplci);
1807 return false;
1808 break;
1809
1810 case S_LISTEN:
1811 if (parms->length == 7)
1812 {
1813 if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms))
1814 {
1815 dbug(1, dprintf("format wrong"));
1816 Info = _WRONG_MESSAGE_FORMAT;
1817 break;
1818 }
1819 }
1820 else
1821 {
1822 Info = _WRONG_MESSAGE_FORMAT;
1823 break;
1824 }
1825 a->Notification_Mask[appl->Id - 1] = GET_DWORD(ss_parms[2].info);
1826 if (a->Notification_Mask[appl->Id - 1] & SMASK_MWI) /* MWI active? */
1827 {
1828 if ((i = get_plci(a)))
1829 {
1830 rplci = &a->plci[i - 1];
1831 rplci->appl = appl;
1832 add_p(rplci, CAI, "\x01\x80");
1833 add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
1834 sig_req(rplci, ASSIGN, DSIG_ID);
1835 send_req(rplci);
1836 }
1837 else
1838 {
1839 break;
1840 }
1841 rplci->internal_command = GET_MWI_STATE;
1842 rplci->number = Number;
1843 sig_req(rplci, MWI_POLL, 0);
1844 send_req(rplci);
1845 }
1846 break;
1847
1848 case S_HOLD:
1849 api_parse(&parms->info[1], (word)parms->length, "ws", ss_parms);
1850 if (plci && plci->State && plci->SuppState == IDLE)
1851 {
1852 plci->SuppState = HOLD_REQUEST;
1853 plci->command = C_HOLD_REQ;
1854 add_s(plci, CAI, &ss_parms[1]);
1855 sig_req(plci, CALL_HOLD, 0);
1856 send_req(plci);
1857 return false;
1858 }
1859 else Info = 0x3010; /* wrong state */
1860 break;
1861 case S_RETRIEVE:
1862 if (plci && plci->State && plci->SuppState == CALL_HELD)
1863 {
1864 if (Id & EXT_CONTROLLER)
1865 {
1866 if (AdvCodecSupport(a, plci, appl, 0))
1867 {
1868 Info = 0x3010; /* wrong state */
1869 break;
1870 }
1871 }
1872 else plci->tel = 0;
1873
1874 plci->SuppState = RETRIEVE_REQUEST;
1875 plci->command = C_RETRIEVE_REQ;
1876 if (plci->spoofed_msg == SPOOFING_REQUIRED)
1877 {
1878 plci->spoofed_msg = CALL_RETRIEVE;
1879 plci->internal_command = BLOCK_PLCI;
1880 plci->command = 0;
1881 dbug(1, dprintf("Spoof"));
1882 return false;
1883 }
1884 else
1885 {
1886 sig_req(plci, CALL_RETRIEVE, 0);
1887 send_req(plci);
1888 return false;
1889 }
1890 }
1891 else Info = 0x3010; /* wrong state */
1892 break;
1893 case S_SUSPEND:
1894 if (parms->length)
1895 {
1896 if (api_parse(&parms->info[1], (word)parms->length, "wbs", ss_parms))
1897 {
1898 dbug(1, dprintf("format wrong"));
1899 Info = _WRONG_MESSAGE_FORMAT;
1900 break;
1901 }
1902 }
1903 if (plci && plci->State)
1904 {
1905 add_s(plci, CAI, &ss_parms[2]);
1906 plci->command = SUSPEND_REQ;
1907 sig_req(plci, SUSPEND, 0);
1908 plci->State = SUSPENDING;
1909 send_req(plci);
1910 }
1911 else Info = 0x3010; /* wrong state */
1912 break;
1913
1914 case S_RESUME:
1915 if (!(i = get_plci(a)))
1916 {
1917 Info = _OUT_OF_PLCI;
1918 break;
1919 }
1920 rplci = &a->plci[i - 1];
1921 rplci->appl = appl;
1922 rplci->number = Number;
1923 rplci->tel = 0;
1924 rplci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
1925 /* check 'external controller' bit for codec support */
1926 if (Id & EXT_CONTROLLER)
1927 {
1928 if (AdvCodecSupport(a, rplci, appl, 0))
1929 {
1930 rplci->Id = 0;
1931 Info = 0x300A;
1932 break;
1933 }
1934 }
1935 if (parms->length)
1936 {
1937 if (api_parse(&parms->info[1], (word)parms->length, "wbs", ss_parms))
1938 {
1939 dbug(1, dprintf("format wrong"));
1940 rplci->Id = 0;
1941 Info = _WRONG_MESSAGE_FORMAT;
1942 break;
1943 }
1944 }
1945 dummy.length = 0;
1946 dummy.info = "\x00";
1947 add_b1(rplci, &dummy, 0, 0);
1948 if (a->Info_Mask[appl->Id - 1] & 0x200)
1949 {
1950 /* early B3 connect (CIP mask bit 9) no release after a disc */
1951 add_p(rplci, LLI, "\x01\x01");
1952 }
1953 add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
1954 sig_req(rplci, ASSIGN, DSIG_ID);
1955 send_req(rplci);
1956 add_s(rplci, CAI, &ss_parms[2]);
1957 rplci->command = RESUME_REQ;
1958 sig_req(rplci, RESUME, 0);
1959 rplci->State = RESUMING;
1960 send_req(rplci);
1961 break;
1962
1963 case S_CONF_BEGIN: /* Request */
1964 case S_CONF_DROP:
1965 case S_CONF_ISOLATE:
1966 case S_CONF_REATTACH:
1967 if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms))
1968 {
1969 dbug(1, dprintf("format wrong"));
1970 Info = _WRONG_MESSAGE_FORMAT;
1971 break;
1972 }
1973 if (plci && plci->State && ((plci->SuppState == IDLE) || (plci->SuppState == CALL_HELD)))
1974 {
1975 d = GET_DWORD(ss_parms[2].info);
1976 if (d >= 0x80)
1977 {
1978 dbug(1, dprintf("format wrong"));
1979 Info = _WRONG_MESSAGE_FORMAT;
1980 break;
1981 }
1982 plci->ptyState = (byte)SSreq;
1983 plci->command = 0;
1984 cai[0] = 2;
1985 switch (SSreq)
1986 {
1987 case S_CONF_BEGIN:
1988 cai[1] = CONF_BEGIN;
1989 plci->internal_command = CONF_BEGIN_REQ_PEND;
1990 break;
1991 case S_CONF_DROP:
1992 cai[1] = CONF_DROP;
1993 plci->internal_command = CONF_DROP_REQ_PEND;
1994 break;
1995 case S_CONF_ISOLATE:
1996 cai[1] = CONF_ISOLATE;
1997 plci->internal_command = CONF_ISOLATE_REQ_PEND;
1998 break;
1999 case S_CONF_REATTACH:
2000 cai[1] = CONF_REATTACH;
2001 plci->internal_command = CONF_REATTACH_REQ_PEND;
2002 break;
2003 }
2004 cai[2] = (byte)d; /* Conference Size resp. PartyId */
2005 add_p(plci, CAI, cai);
2006 sig_req(plci, S_SERVICE, 0);
2007 send_req(plci);
2008 return false;
2009 }
2010 else Info = 0x3010; /* wrong state */
2011 break;
2012
2013 case S_ECT:
2014 case S_3PTY_BEGIN:
2015 case S_3PTY_END:
2016 case S_CONF_ADD:
2017 if (parms->length == 7)
2018 {
2019 if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms))
2020 {
2021 dbug(1, dprintf("format wrong"));
2022 Info = _WRONG_MESSAGE_FORMAT;
2023 break;
2024 }
2025 }
2026 else if (parms->length == 8) /* workaround for the T-View-S */
2027 {
2028 if (api_parse(&parms->info[1], (word)parms->length, "wbdb", ss_parms))
2029 {
2030 dbug(1, dprintf("format wrong"));
2031 Info = _WRONG_MESSAGE_FORMAT;
2032 break;
2033 }
2034 }
2035 else
2036 {
2037 Info = _WRONG_MESSAGE_FORMAT;
2038 break;
2039 }
2040 if (!msg[1].length)
2041 {
2042 Info = _WRONG_MESSAGE_FORMAT;
2043 break;
2044 }
2045 if (!plci)
2046 {
2047 Info = _WRONG_IDENTIFIER;
2048 break;
2049 }
2050 relatedPLCIvalue = GET_DWORD(ss_parms[2].info);
2051 relatedPLCIvalue &= 0x0000FFFF;
2052 dbug(1, dprintf("PTY/ECT/addCONF,relPLCI=%lx", relatedPLCIvalue));
2053 /* controller starts with 0 up to (max_adapter - 1) */
2054 if (((relatedPLCIvalue & 0x7f) == 0)
2055 || (MapController((byte)(relatedPLCIvalue & 0x7f)) == 0)
2056 || (MapController((byte)(relatedPLCIvalue & 0x7f)) > max_adapter))
2057 {
2058 if (SSreq == S_3PTY_END)
2059 {
2060 dbug(1, dprintf("wrong Controller use 2nd PLCI=PLCI"));
2061 rplci = plci;
2062 }
2063 else
2064 {
2065 Info = 0x3010; /* wrong state */
2066 break;
2067 }
2068 }
2069 else
2070 {
2071 relatedadapter = &adapter[MapController((byte)(relatedPLCIvalue & 0x7f)) - 1];
2072 relatedPLCIvalue >>= 8;
2073 /* find PLCI PTR*/
2074 for (i = 0, rplci = NULL; i < relatedadapter->max_plci; i++)
2075 {
2076 if (relatedadapter->plci[i].Id == (byte)relatedPLCIvalue)
2077 {
2078 rplci = &relatedadapter->plci[i];
2079 }
2080 }
2081 if (!rplci || !relatedPLCIvalue)
2082 {
2083 if (SSreq == S_3PTY_END)
2084 {
2085 dbug(1, dprintf("use 2nd PLCI=PLCI"));
2086 rplci = plci;
2087 }
2088 else
2089 {
2090 Info = 0x3010; /* wrong state */
2091 break;
2092 }
2093 }
2094 }
2095 /*
2096 dbug(1, dprintf("rplci:%x", rplci));
2097 dbug(1, dprintf("plci:%x", plci));
2098 dbug(1, dprintf("rplci->ptyState:%x", rplci->ptyState));
2099 dbug(1, dprintf("plci->ptyState:%x", plci->ptyState));
2100 dbug(1, dprintf("SSreq:%x", SSreq));
2101 dbug(1, dprintf("rplci->internal_command:%x", rplci->internal_command));
2102 dbug(1, dprintf("rplci->appl:%x", rplci->appl));
2103 dbug(1, dprintf("rplci->Id:%x", rplci->Id));
2104 */
2105 /* send PTY/ECT req, cannot check all states because of US stuff */
2106 if (!rplci->internal_command && rplci->appl)
2107 {
2108 plci->command = 0;
2109 rplci->relatedPTYPLCI = plci;
2110 plci->relatedPTYPLCI = rplci;
2111 rplci->ptyState = (byte)SSreq;
2112 if (SSreq == S_ECT)
2113 {
2114 rplci->internal_command = ECT_REQ_PEND;
2115 cai[1] = ECT_EXECUTE;
2116
2117 rplci->vswitchstate = 0;
2118 rplci->vsprot = 0;
2119 rplci->vsprotdialect = 0;
2120 plci->vswitchstate = 0;
2121 plci->vsprot = 0;
2122 plci->vsprotdialect = 0;
2123
2124 }
2125 else if (SSreq == S_CONF_ADD)
2126 {
2127 rplci->internal_command = CONF_ADD_REQ_PEND;
2128 cai[1] = CONF_ADD;
2129 }
2130 else
2131 {
2132 rplci->internal_command = PTY_REQ_PEND;
2133 cai[1] = (byte)(SSreq - 3);
2134 }
2135 rplci->number = Number;
2136 if (plci != rplci) /* explicit invocation */
2137 {
2138 cai[0] = 2;
2139 cai[2] = plci->Sig.Id;
2140 dbug(1, dprintf("explicit invocation"));
2141 }
2142 else
2143 {
2144 dbug(1, dprintf("implicit invocation"));
2145 cai[0] = 1;
2146 }
2147 add_p(rplci, CAI, cai);
2148 sig_req(rplci, S_SERVICE, 0);
2149 send_req(rplci);
2150 return false;
2151 }
2152 else
2153 {
2154 dbug(0, dprintf("Wrong line"));
2155 Info = 0x3010; /* wrong state */
2156 break;
2157 }
2158 break;
2159
2160 case S_CALL_DEFLECTION:
2161 if (api_parse(&parms->info[1], (word)parms->length, "wbwss", ss_parms))
2162 {
2163 dbug(1, dprintf("format wrong"));
2164 Info = _WRONG_MESSAGE_FORMAT;
2165 break;
2166 }
2167 if (!plci)
2168 {
2169 Info = _WRONG_IDENTIFIER;
2170 break;
2171 }
2172 /* reuse unused screening indicator */
2173 ss_parms[3].info[3] = (byte)GET_WORD(&(ss_parms[2].info[0]));
2174 plci->command = 0;
2175 plci->internal_command = CD_REQ_PEND;
2176 appl->CDEnable = true;
2177 cai[0] = 1;
2178 cai[1] = CALL_DEFLECTION;
2179 add_p(plci, CAI, cai);
2180 add_p(plci, CPN, ss_parms[3].info);
2181 sig_req(plci, S_SERVICE, 0);
2182 send_req(plci);
2183 return false;
2184 break;
2185
2186 case S_CALL_FORWARDING_START:
2187 if (api_parse(&parms->info[1], (word)parms->length, "wbdwwsss", ss_parms))
2188 {
2189 dbug(1, dprintf("format wrong"));
2190 Info = _WRONG_MESSAGE_FORMAT;
2191 break;
2192 }
2193
2194 if ((i = get_plci(a)))
2195 {
2196 rplci = &a->plci[i - 1];
2197 rplci->appl = appl;
2198 add_p(rplci, CAI, "\x01\x80");
2199 add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
2200 sig_req(rplci, ASSIGN, DSIG_ID);
2201 send_req(rplci);
2202 }
2203 else
2204 {
2205 Info = _OUT_OF_PLCI;
2206 break;
2207 }
2208
2209 /* reuse unused screening indicator */
2210 rplci->internal_command = CF_START_PEND;
2211 rplci->appl = appl;
2212 rplci->number = Number;
2213 appl->S_Handle = GET_DWORD(&(ss_parms[2].info[0]));
2214 cai[0] = 2;
2215 cai[1] = 0x70 | (byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */
2216 cai[2] = (byte)GET_WORD(&(ss_parms[4].info[0])); /* Basic Service */
2217 add_p(rplci, CAI, cai);
2218 add_p(rplci, OAD, ss_parms[5].info);
2219 add_p(rplci, CPN, ss_parms[6].info);
2220 sig_req(rplci, S_SERVICE, 0);
2221 send_req(rplci);
2222 return false;
2223 break;
2224
2225 case S_INTERROGATE_DIVERSION:
2226 case S_INTERROGATE_NUMBERS:
2227 case S_CALL_FORWARDING_STOP:
2228 case S_CCBS_REQUEST:
2229 case S_CCBS_DEACTIVATE:
2230 case S_CCBS_INTERROGATE:
2231 switch (SSreq)
2232 {
2233 case S_INTERROGATE_NUMBERS:
2234 if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms))
2235 {
2236 dbug(0, dprintf("format wrong"));
2237 Info = _WRONG_MESSAGE_FORMAT;
2238 }
2239 break;
2240 case S_CCBS_REQUEST:
2241 case S_CCBS_DEACTIVATE:
2242 if (api_parse(&parms->info[1], (word)parms->length, "wbdw", ss_parms))
2243 {
2244 dbug(0, dprintf("format wrong"));
2245 Info = _WRONG_MESSAGE_FORMAT;
2246 }
2247 break;
2248 case S_CCBS_INTERROGATE:
2249 if (api_parse(&parms->info[1], (word)parms->length, "wbdws", ss_parms))
2250 {
2251 dbug(0, dprintf("format wrong"));
2252 Info = _WRONG_MESSAGE_FORMAT;
2253 }
2254 break;
2255 default:
2256 if (api_parse(&parms->info[1], (word)parms->length, "wbdwws", ss_parms))
2257 {
2258 dbug(0, dprintf("format wrong"));
2259 Info = _WRONG_MESSAGE_FORMAT;
2260 break;
2261 }
2262 break;
2263 }
2264
2265 if (Info) break;
2266 if ((i = get_plci(a)))
2267 {
2268 rplci = &a->plci[i - 1];
2269 switch (SSreq)
2270 {
2271 case S_INTERROGATE_DIVERSION: /* use cai with S_SERVICE below */
2272 cai[1] = 0x60 | (byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */
2273 rplci->internal_command = INTERR_DIVERSION_REQ_PEND; /* move to rplci if assigned */
2274 break;
2275 case S_INTERROGATE_NUMBERS: /* use cai with S_SERVICE below */
2276 cai[1] = DIVERSION_INTERROGATE_NUM; /* Function */
2277 rplci->internal_command = INTERR_NUMBERS_REQ_PEND; /* move to rplci if assigned */
2278 break;
2279 case S_CALL_FORWARDING_STOP:
2280 rplci->internal_command = CF_STOP_PEND;
2281 cai[1] = 0x80 | (byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */
2282 break;
2283 case S_CCBS_REQUEST:
2284 cai[1] = CCBS_REQUEST;
2285 rplci->internal_command = CCBS_REQUEST_REQ_PEND;
2286 break;
2287 case S_CCBS_DEACTIVATE:
2288 cai[1] = CCBS_DEACTIVATE;
2289 rplci->internal_command = CCBS_DEACTIVATE_REQ_PEND;
2290 break;
2291 case S_CCBS_INTERROGATE:
2292 cai[1] = CCBS_INTERROGATE;
2293 rplci->internal_command = CCBS_INTERROGATE_REQ_PEND;
2294 break;
2295 default:
2296 cai[1] = 0;
2297 break;
2298 }
2299 rplci->appl = appl;
2300 rplci->number = Number;
2301 add_p(rplci, CAI, "\x01\x80");
2302 add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
2303 sig_req(rplci, ASSIGN, DSIG_ID);
2304 send_req(rplci);
2305 }
2306 else
2307 {
2308 Info = _OUT_OF_PLCI;
2309 break;
2310 }
2311
2312 appl->S_Handle = GET_DWORD(&(ss_parms[2].info[0]));
2313 switch (SSreq)
2314 {
2315 case S_INTERROGATE_NUMBERS:
2316 cai[0] = 1;
2317 add_p(rplci, CAI, cai);
2318 break;
2319 case S_CCBS_REQUEST:
2320 case S_CCBS_DEACTIVATE:
2321 cai[0] = 3;
2322 PUT_WORD(&cai[2], GET_WORD(&(ss_parms[3].info[0])));
2323 add_p(rplci, CAI, cai);
2324 break;
2325 case S_CCBS_INTERROGATE:
2326 cai[0] = 3;
2327 PUT_WORD(&cai[2], GET_WORD(&(ss_parms[3].info[0])));
2328 add_p(rplci, CAI, cai);
2329 add_p(rplci, OAD, ss_parms[4].info);
2330 break;
2331 default:
2332 cai[0] = 2;
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 break;
2337 }
2338
2339 sig_req(rplci, S_SERVICE, 0);
2340 send_req(rplci);
2341 return false;
2342 break;
2343
2344 case S_MWI_ACTIVATE:
2345 if (api_parse(&parms->info[1], (word)parms->length, "wbwdwwwssss", ss_parms))
2346 {
2347 dbug(1, dprintf("format wrong"));
2348 Info = _WRONG_MESSAGE_FORMAT;
2349 break;
2350 }
2351 if (!plci)
2352 {
2353 if ((i = get_plci(a)))
2354 {
2355 rplci = &a->plci[i - 1];
2356 rplci->appl = appl;
2357 rplci->cr_enquiry = true;
2358 add_p(rplci, CAI, "\x01\x80");
2359 add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
2360 sig_req(rplci, ASSIGN, DSIG_ID);
2361 send_req(rplci);
2362 }
2363 else
2364 {
2365 Info = _OUT_OF_PLCI;
2366 break;
2367 }
2368 }
2369 else
2370 {
2371 rplci = plci;
2372 rplci->cr_enquiry = false;
2373 }
2374
2375 rplci->command = 0;
2376 rplci->internal_command = MWI_ACTIVATE_REQ_PEND;
2377 rplci->appl = appl;
2378 rplci->number = Number;
2379
2380 cai[0] = 13;
2381 cai[1] = ACTIVATION_MWI; /* Function */
2382 PUT_WORD(&cai[2], GET_WORD(&(ss_parms[2].info[0]))); /* Basic Service */
2383 PUT_DWORD(&cai[4], GET_DWORD(&(ss_parms[3].info[0]))); /* Number of Messages */
2384 PUT_WORD(&cai[8], GET_WORD(&(ss_parms[4].info[0]))); /* Message Status */
2385 PUT_WORD(&cai[10], GET_WORD(&(ss_parms[5].info[0]))); /* Message Reference */
2386 PUT_WORD(&cai[12], GET_WORD(&(ss_parms[6].info[0]))); /* Invocation Mode */
2387 add_p(rplci, CAI, cai);
2388 add_p(rplci, CPN, ss_parms[7].info); /* Receiving User Number */
2389 add_p(rplci, OAD, ss_parms[8].info); /* Controlling User Number */
2390 add_p(rplci, OSA, ss_parms[9].info); /* Controlling User Provided Number */
2391 add_p(rplci, UID, ss_parms[10].info); /* Time */
2392 sig_req(rplci, S_SERVICE, 0);
2393 send_req(rplci);
2394 return false;
2395
2396 case S_MWI_DEACTIVATE:
2397 if (api_parse(&parms->info[1], (word)parms->length, "wbwwss", ss_parms))
2398 {
2399 dbug(1, dprintf("format wrong"));
2400 Info = _WRONG_MESSAGE_FORMAT;
2401 break;
2402 }
2403 if (!plci)
2404 {
2405 if ((i = get_plci(a)))
2406 {
2407 rplci = &a->plci[i - 1];
2408 rplci->appl = appl;
2409 rplci->cr_enquiry = true;
2410 add_p(rplci, CAI, "\x01\x80");
2411 add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
2412 sig_req(rplci, ASSIGN, DSIG_ID);
2413 send_req(rplci);
2414 }
2415 else
2416 {
2417 Info = _OUT_OF_PLCI;
2418 break;
2419 }
2420 }
2421 else
2422 {
2423 rplci = plci;
2424 rplci->cr_enquiry = false;
2425 }
2426
2427 rplci->command = 0;
2428 rplci->internal_command = MWI_DEACTIVATE_REQ_PEND;
2429 rplci->appl = appl;
2430 rplci->number = Number;
2431
2432 cai[0] = 5;
2433 cai[1] = DEACTIVATION_MWI; /* Function */
2434 PUT_WORD(&cai[2], GET_WORD(&(ss_parms[2].info[0]))); /* Basic Service */
2435 PUT_WORD(&cai[4], GET_WORD(&(ss_parms[3].info[0]))); /* Invocation Mode */
2436 add_p(rplci, CAI, cai);
2437 add_p(rplci, CPN, ss_parms[4].info); /* Receiving User Number */
2438 add_p(rplci, OAD, ss_parms[5].info); /* Controlling User Number */
2439 sig_req(rplci, S_SERVICE, 0);
2440 send_req(rplci);
2441 return false;
2442
2443 default:
2444 Info = 0x300E; /* not supported */
2445 break;
2446 }
2447 break; /* case SELECTOR_SU_SERV: end */
2448
2449
2450 case SELECTOR_DTMF:
2451 return (dtmf_request(Id, Number, a, plci, appl, msg));
2452
2453
2454
2455 case SELECTOR_LINE_INTERCONNECT:
2456 return (mixer_request(Id, Number, a, plci, appl, msg));
2457
2458
2459
2460 case PRIV_SELECTOR_ECHO_CANCELLER:
2461 appl->appl_flags |= APPL_FLAG_PRIV_EC_SPEC;
2462 return (ec_request(Id, Number, a, plci, appl, msg));
2463
2464 case SELECTOR_ECHO_CANCELLER:
2465 appl->appl_flags &= ~APPL_FLAG_PRIV_EC_SPEC;
2466 return (ec_request(Id, Number, a, plci, appl, msg));
2467
2468
2469 case SELECTOR_V42BIS:
2470 default:
2471 Info = _FACILITY_NOT_SUPPORTED;
2472 break;
2473 } /* end of switch (selector) */
2474 }
2475
2476 dbug(1, dprintf("SendFacRc"));
2477 sendf(appl,
2478 _FACILITY_R | CONFIRM,
2479 Id,
2480 Number,
2481 "wws", Info, selector, SSparms);
2482 return false;
2483 }
2484
2485 static byte facility_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2486 PLCI *plci, APPL *appl, API_PARSE *msg)
2487 {
2488 dbug(1, dprintf("facility_res"));
2489 return false;
2490 }
2491
2492 static byte connect_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2493 PLCI *plci, APPL *appl, API_PARSE *parms)
2494 {
2495 word Info = 0;
2496 byte req;
2497 byte len;
2498 word w;
2499 word fax_control_bits, fax_feature_bits, fax_info_change;
2500 API_PARSE *ncpi;
2501 byte pvc[2];
2502
2503 API_PARSE fax_parms[9];
2504 word i;
2505
2506
2507 dbug(1, dprintf("connect_b3_req"));
2508 if (plci)
2509 {
2510 if ((plci->State == IDLE) || (plci->State == OUTG_DIS_PENDING)
2511 || (plci->State == INC_DIS_PENDING) || (plci->SuppState != IDLE))
2512 {
2513 Info = _WRONG_STATE;
2514 }
2515 else
2516 {
2517 /* local reply if assign unsuccessful
2518 or B3 protocol allows only one layer 3 connection
2519 and already connected
2520 or B2 protocol not any LAPD
2521 and connect_b3_req contradicts originate/answer direction */
2522 if (!plci->NL.Id
2523 || (((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE))
2524 && ((plci->channels != 0)
2525 || (((plci->B2_prot != B2_SDLC) && (plci->B2_prot != B2_LAPD) && (plci->B2_prot != B2_LAPD_FREE_SAPI_SEL))
2526 && ((plci->call_dir & CALL_DIR_ANSWER) && !(plci->call_dir & CALL_DIR_FORCE_OUTG_NL))))))
2527 {
2528 dbug(1, dprintf("B3 already connected=%d or no NL.Id=0x%x, dir=%d sstate=0x%x",
2529 plci->channels, plci->NL.Id, plci->call_dir, plci->SuppState));
2530 Info = _WRONG_STATE;
2531 sendf(appl,
2532 _CONNECT_B3_R | CONFIRM,
2533 Id,
2534 Number,
2535 "w", Info);
2536 return false;
2537 }
2538 plci->requested_options_conn = 0;
2539
2540 req = N_CONNECT;
2541 ncpi = &parms[0];
2542 if (plci->B3_prot == 2 || plci->B3_prot == 3)
2543 {
2544 if (ncpi->length > 2)
2545 {
2546 /* check for PVC */
2547 if (ncpi->info[2] || ncpi->info[3])
2548 {
2549 pvc[0] = ncpi->info[3];
2550 pvc[1] = ncpi->info[2];
2551 add_d(plci, 2, pvc);
2552 req = N_RESET;
2553 }
2554 else
2555 {
2556 if (ncpi->info[1] & 1) req = N_CONNECT | N_D_BIT;
2557 add_d(plci, (word)(ncpi->length - 3), &ncpi->info[4]);
2558 }
2559 }
2560 }
2561 else if (plci->B3_prot == 5)
2562 {
2563 if (plci->NL.Id && !plci->nl_remove_id)
2564 {
2565 fax_control_bits = GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low);
2566 fax_feature_bits = GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->feature_bits_low);
2567 if (!(fax_control_bits & T30_CONTROL_BIT_MORE_DOCUMENTS)
2568 || (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS))
2569 {
2570 len = offsetof(T30_INFO, universal_6);
2571 fax_info_change = false;
2572 if (ncpi->length >= 4)
2573 {
2574 w = GET_WORD(&ncpi->info[3]);
2575 if ((w & 0x0001) != ((word)(((T30_INFO *)(plci->fax_connect_info_buffer))->resolution & 0x0001)))
2576 {
2577 ((T30_INFO *)(plci->fax_connect_info_buffer))->resolution =
2578 (byte)((((T30_INFO *)(plci->fax_connect_info_buffer))->resolution & ~T30_RESOLUTION_R8_0770_OR_200) |
2579 ((w & 0x0001) ? T30_RESOLUTION_R8_0770_OR_200 : 0));
2580 fax_info_change = true;
2581 }
2582 fax_control_bits &= ~(T30_CONTROL_BIT_REQUEST_POLLING | T30_CONTROL_BIT_MORE_DOCUMENTS);
2583 if (w & 0x0002) /* Fax-polling request */
2584 fax_control_bits |= T30_CONTROL_BIT_REQUEST_POLLING;
2585 if ((w & 0x0004) /* Request to send / poll another document */
2586 && (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_MORE_DOCUMENTS))
2587 {
2588 fax_control_bits |= T30_CONTROL_BIT_MORE_DOCUMENTS;
2589 }
2590 if (ncpi->length >= 6)
2591 {
2592 w = GET_WORD(&ncpi->info[5]);
2593 if (((byte) w) != ((T30_INFO *)(plci->fax_connect_info_buffer))->data_format)
2594 {
2595 ((T30_INFO *)(plci->fax_connect_info_buffer))->data_format = (byte) w;
2596 fax_info_change = true;
2597 }
2598
2599 if ((a->man_profile.private_options & (1L << PRIVATE_FAX_SUB_SEP_PWD))
2600 && (GET_WORD(&ncpi->info[5]) & 0x8000)) /* Private SEP/SUB/PWD enable */
2601 {
2602 plci->requested_options_conn |= (1L << PRIVATE_FAX_SUB_SEP_PWD);
2603 }
2604 if ((a->man_profile.private_options & (1L << PRIVATE_FAX_NONSTANDARD))
2605 && (GET_WORD(&ncpi->info[5]) & 0x4000)) /* Private non-standard facilities enable */
2606 {
2607 plci->requested_options_conn |= (1L << PRIVATE_FAX_NONSTANDARD);
2608 }
2609 fax_control_bits &= ~(T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_SEL_POLLING |
2610 T30_CONTROL_BIT_ACCEPT_PASSWORD);
2611 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id - 1])
2612 & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
2613 {
2614 if (api_parse(&ncpi->info[1], ncpi->length, "wwwwsss", fax_parms))
2615 Info = _WRONG_MESSAGE_FORMAT;
2616 else
2617 {
2618 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id - 1])
2619 & (1L << PRIVATE_FAX_SUB_SEP_PWD))
2620 {
2621 fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_PASSWORD;
2622 if (fax_control_bits & T30_CONTROL_BIT_ACCEPT_POLLING)
2623 fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SEL_POLLING;
2624 }
2625 w = fax_parms[4].length;
2626 if (w > 20)
2627 w = 20;
2628 ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id_len = (byte) w;
2629 for (i = 0; i < w; i++)
2630 ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id[i] = fax_parms[4].info[1 + i];
2631 ((T30_INFO *)(plci->fax_connect_info_buffer))->head_line_len = 0;
2632 len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
2633 w = fax_parms[5].length;
2634 if (w > 20)
2635 w = 20;
2636 plci->fax_connect_info_buffer[len++] = (byte) w;
2637 for (i = 0; i < w; i++)
2638 plci->fax_connect_info_buffer[len++] = fax_parms[5].info[1 + i];
2639 w = fax_parms[6].length;
2640 if (w > 20)
2641 w = 20;
2642 plci->fax_connect_info_buffer[len++] = (byte) w;
2643 for (i = 0; i < w; i++)
2644 plci->fax_connect_info_buffer[len++] = fax_parms[6].info[1 + i];
2645 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id - 1])
2646 & (1L << PRIVATE_FAX_NONSTANDARD))
2647 {
2648 if (api_parse(&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms))
2649 {
2650 dbug(1, dprintf("non-standard facilities info missing or wrong format"));
2651 plci->fax_connect_info_buffer[len++] = 0;
2652 }
2653 else
2654 {
2655 if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2))
2656 plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]);
2657 plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length);
2658 for (i = 0; i < fax_parms[7].length; i++)
2659 plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1 + i];
2660 }
2661 }
2662 }
2663 }
2664 else
2665 {
2666 len = offsetof(T30_INFO, universal_6);
2667 }
2668 fax_info_change = true;
2669
2670 }
2671 if (fax_control_bits != GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low))
2672 {
2673 PUT_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low, fax_control_bits);
2674 fax_info_change = true;
2675 }
2676 }
2677 if (Info == GOOD)
2678 {
2679 plci->fax_connect_info_length = len;
2680 if (fax_info_change)
2681 {
2682 if (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS)
2683 {
2684 start_internal_command(Id, plci, fax_connect_info_command);
2685 return false;
2686 }
2687 else
2688 {
2689 start_internal_command(Id, plci, fax_adjust_b23_command);
2690 return false;
2691 }
2692 }
2693 }
2694 }
2695 else Info = _WRONG_STATE;
2696 }
2697 else Info = _WRONG_STATE;
2698 }
2699
2700 else if (plci->B3_prot == B3_RTP)
2701 {
2702 plci->internal_req_buffer[0] = ncpi->length + 1;
2703 plci->internal_req_buffer[1] = UDATA_REQUEST_RTP_RECONFIGURE;
2704 for (w = 0; w < ncpi->length; w++)
2705 plci->internal_req_buffer[2 + w] = ncpi->info[1 + w];
2706 start_internal_command(Id, plci, rtp_connect_b3_req_command);
2707 return false;
2708 }
2709
2710 if (!Info)
2711 {
2712 nl_req_ncci(plci, req, 0);
2713 return 1;
2714 }
2715 }
2716 }
2717 else Info = _WRONG_IDENTIFIER;
2718
2719 sendf(appl,
2720 _CONNECT_B3_R | CONFIRM,
2721 Id,
2722 Number,
2723 "w", Info);
2724 return false;
2725 }
2726
2727 static byte connect_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2728 PLCI *plci, APPL *appl, API_PARSE *parms)
2729 {
2730 word ncci;
2731 API_PARSE *ncpi;
2732 byte req;
2733
2734 word w;
2735
2736
2737 API_PARSE fax_parms[9];
2738 word i;
2739 byte len;
2740
2741
2742 dbug(1, dprintf("connect_b3_res"));
2743
2744 ncci = (word)(Id >> 16);
2745 if (plci && ncci) {
2746 if (a->ncci_state[ncci] == INC_CON_PENDING) {
2747 if (GET_WORD(&parms[0].info[0]) != 0)
2748 {
2749 a->ncci_state[ncci] = OUTG_REJ_PENDING;
2750 channel_request_xon(plci, a->ncci_ch[ncci]);
2751 channel_xmit_xon(plci);
2752 cleanup_ncci_data(plci, ncci);
2753 nl_req_ncci(plci, N_DISC, (byte)ncci);
2754 return 1;
2755 }
2756 a->ncci_state[ncci] = INC_ACT_PENDING;
2757
2758 req = N_CONNECT_ACK;
2759 ncpi = &parms[1];
2760 if ((plci->B3_prot == 4) || (plci->B3_prot == 5) || (plci->B3_prot == 7))
2761 {
2762
2763 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id - 1])
2764 & (1L << PRIVATE_FAX_NONSTANDARD))
2765 {
2766 if (((plci->B3_prot == 4) || (plci->B3_prot == 5))
2767 && (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF)
2768 && (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP))
2769 {
2770 len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
2771 if (plci->fax_connect_info_length < len)
2772 {
2773 ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id_len = 0;
2774 ((T30_INFO *)(plci->fax_connect_info_buffer))->head_line_len = 0;
2775 }
2776 if (api_parse(&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms))
2777 {
2778 dbug(1, dprintf("non-standard facilities info missing or wrong format"));
2779 }
2780 else
2781 {
2782 if (plci->fax_connect_info_length <= len)
2783 plci->fax_connect_info_buffer[len] = 0;
2784 len += 1 + plci->fax_connect_info_buffer[len];
2785 if (plci->fax_connect_info_length <= len)
2786 plci->fax_connect_info_buffer[len] = 0;
2787 len += 1 + plci->fax_connect_info_buffer[len];
2788 if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2))
2789 plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]);
2790 plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length);
2791 for (i = 0; i < fax_parms[7].length; i++)
2792 plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1 + i];
2793 }
2794 plci->fax_connect_info_length = len;
2795 ((T30_INFO *)(plci->fax_connect_info_buffer))->code = 0;
2796 start_internal_command(Id, plci, fax_connect_ack_command);
2797 return false;
2798 }
2799 }
2800
2801 nl_req_ncci(plci, req, (byte)ncci);
2802 if ((plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
2803 && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
2804 {
2805 if (plci->B3_prot == 4)
2806 sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
2807 else
2808 sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
2809 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
2810 }
2811 }
2812
2813 else if (plci->B3_prot == B3_RTP)
2814 {
2815 plci->internal_req_buffer[0] = ncpi->length + 1;
2816 plci->internal_req_buffer[1] = UDATA_REQUEST_RTP_RECONFIGURE;
2817 for (w = 0; w < ncpi->length; w++)
2818 plci->internal_req_buffer[2 + w] = ncpi->info[1+w];
2819 start_internal_command(Id, plci, rtp_connect_b3_res_command);
2820 return false;
2821 }
2822
2823 else
2824 {
2825 if (ncpi->length > 2) {
2826 if (ncpi->info[1] & 1) req = N_CONNECT_ACK | N_D_BIT;
2827 add_d(plci, (word)(ncpi->length - 3), &ncpi->info[4]);
2828 }
2829 nl_req_ncci(plci, req, (byte)ncci);
2830 sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
2831 if (plci->adjust_b_restore)
2832 {
2833 plci->adjust_b_restore = false;
2834 start_internal_command(Id, plci, adjust_b_restore);
2835 }
2836 }
2837 return 1;
2838 }
2839 }
2840 return false;
2841 }
2842
2843 static byte connect_b3_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2844 PLCI *plci, APPL *appl, API_PARSE *parms)
2845 {
2846 word ncci;
2847
2848 ncci = (word)(Id >> 16);
2849 dbug(1, dprintf("connect_b3_a_res(ncci=0x%x)", ncci));
2850
2851 if (plci && ncci && (plci->State != IDLE) && (plci->State != INC_DIS_PENDING)
2852 && (plci->State != OUTG_DIS_PENDING))
2853 {
2854 if (a->ncci_state[ncci] == INC_ACT_PENDING) {
2855 a->ncci_state[ncci] = CONNECTED;
2856 if (plci->State != INC_CON_CONNECTED_ALERT) plci->State = CONNECTED;
2857 channel_request_xon(plci, a->ncci_ch[ncci]);
2858 channel_xmit_xon(plci);
2859 }
2860 }
2861 return false;
2862 }
2863
2864 static byte disconnect_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2865 PLCI *plci, APPL *appl, API_PARSE *parms)
2866 {
2867 word Info;
2868 word ncci;
2869 API_PARSE *ncpi;
2870
2871 dbug(1, dprintf("disconnect_b3_req"));
2872
2873 Info = _WRONG_IDENTIFIER;
2874 ncci = (word)(Id >> 16);
2875 if (plci && ncci)
2876 {
2877 Info = _WRONG_STATE;
2878 if ((a->ncci_state[ncci] == CONNECTED)
2879 || (a->ncci_state[ncci] == OUTG_CON_PENDING)
2880 || (a->ncci_state[ncci] == INC_CON_PENDING)
2881 || (a->ncci_state[ncci] == INC_ACT_PENDING))
2882 {
2883 a->ncci_state[ncci] = OUTG_DIS_PENDING;
2884 channel_request_xon(plci, a->ncci_ch[ncci]);
2885 channel_xmit_xon(plci);
2886
2887 if (a->ncci[ncci].data_pending
2888 && ((plci->B3_prot == B3_TRANSPARENT)
2889 || (plci->B3_prot == B3_T30)
2890 || (plci->B3_prot == B3_T30_WITH_EXTENSIONS)))
2891 {
2892 plci->send_disc = (byte)ncci;
2893 plci->command = 0;
2894 return false;
2895 }
2896 else
2897 {
2898 cleanup_ncci_data(plci, ncci);
2899
2900 if (plci->B3_prot == 2 || plci->B3_prot == 3)
2901 {
2902 ncpi = &parms[0];
2903 if (ncpi->length > 3)
2904 {
2905 add_d(plci, (word)(ncpi->length - 3), (byte *)&(ncpi->info[4]));
2906 }
2907 }
2908 nl_req_ncci(plci, N_DISC, (byte)ncci);
2909 }
2910 return 1;
2911 }
2912 }
2913 sendf(appl,
2914 _DISCONNECT_B3_R | CONFIRM,
2915 Id,
2916 Number,
2917 "w", Info);
2918 return false;
2919 }
2920
2921 static byte disconnect_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2922 PLCI *plci, APPL *appl, API_PARSE *parms)
2923 {
2924 word ncci;
2925 word i;
2926
2927 ncci = (word)(Id >> 16);
2928 dbug(1, dprintf("disconnect_b3_res(ncci=0x%x", ncci));
2929 if (plci && ncci) {
2930 plci->requested_options_conn = 0;
2931 plci->fax_connect_info_length = 0;
2932 plci->ncpi_state = 0x00;
2933 if (((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE))
2934 && ((plci->B2_prot != B2_LAPD) && (plci->B2_prot != B2_LAPD_FREE_SAPI_SEL)))
2935 {
2936 plci->call_dir |= CALL_DIR_FORCE_OUTG_NL;
2937 }
2938 for (i = 0; i < MAX_CHANNELS_PER_PLCI && plci->inc_dis_ncci_table[i] != (byte)ncci; i++);
2939 if (i < MAX_CHANNELS_PER_PLCI) {
2940 if (plci->channels)plci->channels--;
2941 for (; i < MAX_CHANNELS_PER_PLCI - 1; i++) plci->inc_dis_ncci_table[i] = plci->inc_dis_ncci_table[i + 1];
2942 plci->inc_dis_ncci_table[MAX_CHANNELS_PER_PLCI - 1] = 0;
2943
2944 ncci_free_receive_buffers(plci, ncci);
2945
2946 if ((plci->State == IDLE || plci->State == SUSPENDING) && !plci->channels) {
2947 if (plci->State == SUSPENDING) {
2948 sendf(plci->appl,
2949 _FACILITY_I,
2950 Id & 0xffffL,
2951 0,
2952 "ws", (word)3, "\x03\x04\x00\x00");
2953 sendf(plci->appl, _DISCONNECT_I, Id & 0xffffL, 0, "w", 0);
2954 }
2955 plci_remove(plci);
2956 plci->State = IDLE;
2957 }
2958 }
2959 else
2960 {
2961 if ((a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
2962 && ((plci->B3_prot == 4) || (plci->B3_prot == 5))
2963 && (a->ncci_state[ncci] == INC_DIS_PENDING))
2964 {
2965 ncci_free_receive_buffers(plci, ncci);
2966
2967 nl_req_ncci(plci, N_EDATA, (byte)ncci);
2968
2969 plci->adapter->ncci_state[ncci] = IDLE;
2970 start_internal_command(Id, plci, fax_disconnect_command);
2971 return 1;
2972 }
2973 }
2974 }
2975 return false;
2976 }
2977
2978 static byte data_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2979 PLCI *plci, APPL *appl, API_PARSE *parms)
2980 {
2981 NCCI *ncci_ptr;
2982 DATA_B3_DESC *data;
2983 word Info;
2984 word ncci;
2985 word i;
2986
2987 dbug(1, dprintf("data_b3_req"));
2988
2989 Info = _WRONG_IDENTIFIER;
2990 ncci = (word)(Id >> 16);
2991 dbug(1, dprintf("ncci=0x%x, plci=0x%x", ncci, plci));
2992
2993 if (plci && ncci)
2994 {
2995 Info = _WRONG_STATE;
2996 if ((a->ncci_state[ncci] == CONNECTED)
2997 || (a->ncci_state[ncci] == INC_ACT_PENDING))
2998 {
2999 /* queue data */
3000 ncci_ptr = &(a->ncci[ncci]);
3001 i = ncci_ptr->data_out + ncci_ptr->data_pending;
3002 if (i >= MAX_DATA_B3)
3003 i -= MAX_DATA_B3;
3004 data = &(ncci_ptr->DBuffer[i]);
3005 data->Number = Number;
3006 if ((((byte *)(parms[0].info)) >= ((byte *)(plci->msg_in_queue)))
3007 && (((byte *)(parms[0].info)) < ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
3008 {
3009
3010 data->P = (byte *)(long)(*((dword *)(parms[0].info)));
3011
3012 }
3013 else
3014 data->P = TransmitBufferSet(appl, *(dword *)parms[0].info);
3015 data->Length = GET_WORD(parms[1].info);
3016 data->Handle = GET_WORD(parms[2].info);
3017 data->Flags = GET_WORD(parms[3].info);
3018 (ncci_ptr->data_pending)++;
3019
3020 /* check for delivery confirmation */
3021 if (data->Flags & 0x0004)
3022 {
3023 i = ncci_ptr->data_ack_out + ncci_ptr->data_ack_pending;
3024 if (i >= MAX_DATA_ACK)
3025 i -= MAX_DATA_ACK;
3026 ncci_ptr->DataAck[i].Number = data->Number;
3027 ncci_ptr->DataAck[i].Handle = data->Handle;
3028 (ncci_ptr->data_ack_pending)++;
3029 }
3030
3031 send_data(plci);
3032 return false;
3033 }
3034 }
3035 if (appl)
3036 {
3037 if (plci)
3038 {
3039 if ((((byte *)(parms[0].info)) >= ((byte *)(plci->msg_in_queue)))
3040 && (((byte *)(parms[0].info)) < ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
3041 {
3042
3043 TransmitBufferFree(appl, (byte *)(long)(*((dword *)(parms[0].info))));
3044
3045 }
3046 }
3047 sendf(appl,
3048 _DATA_B3_R | CONFIRM,
3049 Id,
3050 Number,
3051 "ww", GET_WORD(parms[2].info), Info);
3052 }
3053 return false;
3054 }
3055
3056 static byte data_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3057 PLCI *plci, APPL *appl, API_PARSE *parms)
3058 {
3059 word n;
3060 word ncci;
3061 word NCCIcode;
3062
3063 dbug(1, dprintf("data_b3_res"));
3064
3065 ncci = (word)(Id >> 16);
3066 if (plci && ncci) {
3067 n = GET_WORD(parms[0].info);
3068 dbug(1, dprintf("free(%d)", n));
3069 NCCIcode = ncci | (((word) a->Id) << 8);
3070 if (n < appl->MaxBuffer &&
3071 appl->DataNCCI[n] == NCCIcode &&
3072 (byte)(appl->DataFlags[n] >> 8) == plci->Id) {
3073 dbug(1, dprintf("found"));
3074 appl->DataNCCI[n] = 0;
3075
3076 if (channel_can_xon(plci, a->ncci_ch[ncci])) {
3077 channel_request_xon(plci, a->ncci_ch[ncci]);
3078 }
3079 channel_xmit_xon(plci);
3080
3081 if (appl->DataFlags[n] & 4) {
3082 nl_req_ncci(plci, N_DATA_ACK, (byte)ncci);
3083 return 1;
3084 }
3085 }
3086 }
3087 return false;
3088 }
3089
3090 static byte reset_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3091 PLCI *plci, APPL *appl, API_PARSE *parms)
3092 {
3093 word Info;
3094 word ncci;
3095
3096 dbug(1, dprintf("reset_b3_req"));
3097
3098 Info = _WRONG_IDENTIFIER;
3099 ncci = (word)(Id >> 16);
3100 if (plci && ncci)
3101 {
3102 Info = _WRONG_STATE;
3103 switch (plci->B3_prot)
3104 {
3105 case B3_ISO8208:
3106 case B3_X25_DCE:
3107 if (a->ncci_state[ncci] == CONNECTED)
3108 {
3109 nl_req_ncci(plci, N_RESET, (byte)ncci);
3110 send_req(plci);
3111 Info = GOOD;
3112 }
3113 break;
3114 case B3_TRANSPARENT:
3115 if (a->ncci_state[ncci] == CONNECTED)
3116 {
3117 start_internal_command(Id, plci, reset_b3_command);
3118 Info = GOOD;
3119 }
3120 break;
3121 }
3122 }
3123 /* reset_b3 must result in a reset_b3_con & reset_b3_Ind */
3124 sendf(appl,
3125 _RESET_B3_R | CONFIRM,
3126 Id,
3127 Number,
3128 "w", Info);
3129 return false;
3130 }
3131
3132 static byte reset_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3133 PLCI *plci, APPL *appl, API_PARSE *parms)
3134 {
3135 word ncci;
3136
3137 dbug(1, dprintf("reset_b3_res"));
3138
3139 ncci = (word)(Id >> 16);
3140 if (plci && ncci) {
3141 switch (plci->B3_prot)
3142 {
3143 case B3_ISO8208:
3144 case B3_X25_DCE:
3145 if (a->ncci_state[ncci] == INC_RES_PENDING)
3146 {
3147 a->ncci_state[ncci] = CONNECTED;
3148 nl_req_ncci(plci, N_RESET_ACK, (byte)ncci);
3149 return true;
3150 }
3151 break;
3152 }
3153 }
3154 return false;
3155 }
3156
3157 static byte connect_b3_t90_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3158 PLCI *plci, APPL *appl, API_PARSE *parms)
3159 {
3160 word ncci;
3161 API_PARSE *ncpi;
3162 byte req;
3163
3164 dbug(1, dprintf("connect_b3_t90_a_res"));
3165
3166 ncci = (word)(Id >> 16);
3167 if (plci && ncci) {
3168 if (a->ncci_state[ncci] == INC_ACT_PENDING) {
3169 a->ncci_state[ncci] = CONNECTED;
3170 }
3171 else if (a->ncci_state[ncci] == INC_CON_PENDING) {
3172 a->ncci_state[ncci] = CONNECTED;
3173
3174 req = N_CONNECT_ACK;
3175
3176 /* parms[0]==0 for CAPI original message definition! */
3177 if (parms[0].info) {
3178 ncpi = &parms[1];
3179 if (ncpi->length > 2) {
3180 if (ncpi->info[1] & 1) req = N_CONNECT_ACK | N_D_BIT;
3181 add_d(plci, (word)(ncpi->length - 3), &ncpi->info[4]);
3182 }
3183 }
3184 nl_req_ncci(plci, req, (byte)ncci);
3185 return 1;
3186 }
3187 }
3188 return false;
3189 }
3190
3191
3192 static byte select_b_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3193 PLCI *plci, APPL *appl, API_PARSE *msg)
3194 {
3195 word Info = 0;
3196 word i;
3197 byte tel;
3198 API_PARSE bp_parms[7];
3199
3200 if (!plci || !msg)
3201 {
3202 Info = _WRONG_IDENTIFIER;
3203 }
3204 else
3205 {
3206 dbug(1, dprintf("select_b_req[%d],PLCI=0x%x,Tel=0x%x,NL=0x%x,appl=0x%x,sstate=0x%x",
3207 msg->length, plci->Id, plci->tel, plci->NL.Id, plci->appl, plci->SuppState));
3208 dbug(1, dprintf("PlciState=0x%x", plci->State));
3209 for (i = 0; i < 7; i++) bp_parms[i].length = 0;
3210
3211 /* check if no channel is open, no B3 connected only */
3212 if ((plci->State == IDLE) || (plci->State == OUTG_DIS_PENDING) || (plci->State == INC_DIS_PENDING)
3213 || (plci->SuppState != IDLE) || plci->channels || plci->nl_remove_id)
3214 {
3215 Info = _WRONG_STATE;
3216 }
3217 /* check message format and fill bp_parms pointer */
3218 else if (msg->length && api_parse(&msg->info[1], (word)msg->length, "wwwsss", bp_parms))
3219 {
3220 Info = _WRONG_MESSAGE_FORMAT;
3221 }
3222 else
3223 {
3224 if ((plci->State == INC_CON_PENDING) || (plci->State == INC_CON_ALERT)) /* send alert tone inband to the network, */
3225 { /* e.g. Qsig or RBS or Cornet-N or xess PRI */
3226 if (Id & EXT_CONTROLLER)
3227 {
3228 sendf(appl, _SELECT_B_REQ | CONFIRM, Id, Number, "w", 0x2002); /* wrong controller */
3229 return 0;
3230 }
3231 plci->State = INC_CON_CONNECTED_ALERT;
3232 plci->appl = appl;
3233 __clear_bit(appl->Id - 1, plci->c_ind_mask_table);
3234 dbug(1, dprintf("c_ind_mask =%*pb", MAX_APPL, plci->c_ind_mask_table));
3235 /* disconnect the other appls its quasi a connect */
3236 for_each_set_bit(i, plci->c_ind_mask_table, max_appl)
3237 sendf(&application[i], _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED);
3238 }
3239
3240 api_save_msg(msg, "s", &plci->saved_msg);
3241 tel = plci->tel;
3242 if (Id & EXT_CONTROLLER)
3243 {
3244 if (tel) /* external controller in use by this PLCI */
3245 {
3246 if (a->AdvSignalAppl && a->AdvSignalAppl != appl)
3247 {
3248 dbug(1, dprintf("Ext_Ctrl in use 1"));
3249 Info = _WRONG_STATE;
3250 }
3251 }
3252 else /* external controller NOT in use by this PLCI ? */
3253 {
3254 if (a->AdvSignalPLCI)
3255 {
3256 dbug(1, dprintf("Ext_Ctrl in use 2"));
3257 Info = _WRONG_STATE;
3258 }
3259 else /* activate the codec */
3260 {
3261 dbug(1, dprintf("Ext_Ctrl start"));
3262 if (AdvCodecSupport(a, plci, appl, 0))
3263 {
3264 dbug(1, dprintf("Error in codec procedures"));
3265 Info = _WRONG_STATE;
3266 }
3267 else if (plci->spoofed_msg == SPOOFING_REQUIRED) /* wait until codec is active */
3268 {
3269 plci->spoofed_msg = AWAITING_SELECT_B;
3270 plci->internal_command = BLOCK_PLCI; /* lock other commands */
3271 plci->command = 0;
3272 dbug(1, dprintf("continue if codec loaded"));
3273 return false;
3274 }
3275 }
3276 }
3277 }
3278 else /* external controller bit is OFF */
3279 {
3280 if (tel) /* external controller in use, need to switch off */
3281 {
3282 if (a->AdvSignalAppl == appl)
3283 {
3284 CodecIdCheck(a, plci);
3285 plci->tel = 0;
3286 plci->adv_nl = 0;
3287 dbug(1, dprintf("Ext_Ctrl disable"));
3288 }
3289 else
3290 {
3291 dbug(1, dprintf("Ext_Ctrl not requested"));
3292 }
3293 }
3294 }
3295 if (!Info)
3296 {
3297 if (plci->call_dir & CALL_DIR_OUT)
3298 plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
3299 else if (plci->call_dir & CALL_DIR_IN)
3300 plci->call_dir = CALL_DIR_IN | CALL_DIR_ANSWER;
3301 start_internal_command(Id, plci, select_b_command);
3302 return false;
3303 }
3304 }
3305 }
3306 sendf(appl, _SELECT_B_REQ | CONFIRM, Id, Number, "w", Info);
3307 return false;
3308 }
3309
3310 static byte manufacturer_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3311 PLCI *plci, APPL *appl, API_PARSE *parms)
3312 {
3313 word command;
3314 word i;
3315 word ncci;
3316 API_PARSE *m;
3317 API_PARSE m_parms[5];
3318 word codec;
3319 byte req;
3320 byte ch;
3321 byte dir;
3322 static byte chi[2] = {0x01, 0x00};
3323 static byte lli[2] = {0x01, 0x00};
3324 static byte codec_cai[2] = {0x01, 0x01};
3325 static byte null_msg = {0};
3326 static API_PARSE null_parms = { 0, &null_msg };
3327 PLCI *v_plci;
3328 word Info = 0;
3329
3330 dbug(1, dprintf("manufacturer_req"));
3331 for (i = 0; i < 5; i++) m_parms[i].length = 0;
3332
3333 if (GET_DWORD(parms[0].info) != _DI_MANU_ID) {
3334 Info = _WRONG_MESSAGE_FORMAT;
3335 }
3336 command = GET_WORD(parms[1].info);
3337 m = &parms[2];
3338 if (!Info)
3339 {
3340 switch (command) {
3341 case _DI_ASSIGN_PLCI:
3342 if (api_parse(&m->info[1], (word)m->length, "wbbs", m_parms)) {
3343 Info = _WRONG_MESSAGE_FORMAT;
3344 break;
3345 }
3346 codec = GET_WORD(m_parms[0].info);
3347 ch = m_parms[1].info[0];
3348 dir = m_parms[2].info[0];
3349 if ((i = get_plci(a))) {
3350 plci = &a->plci[i - 1];
3351 plci->appl = appl;
3352 plci->command = _MANUFACTURER_R;
3353 plci->m_command = command;
3354 plci->number = Number;
3355 plci->State = LOCAL_CONNECT;
3356 Id = (((word)plci->Id << 8) | plci->adapter->Id | 0x80);
3357 dbug(1, dprintf("ManCMD,plci=0x%x", Id));
3358
3359 if ((ch == 1 || ch == 2) && (dir <= 2)) {
3360 chi[1] = (byte)(0x80 | ch);
3361 lli[1] = 0;
3362 plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
3363 switch (codec)
3364 {
3365 case 0:
3366 Info = add_b1(plci, &m_parms[3], 0, 0);
3367 break;
3368 case 1:
3369 add_p(plci, CAI, codec_cai);
3370 break;
3371 /* manual 'swich on' to the codec support without signalling */
3372 /* first 'assign plci' with this function, then use */
3373 case 2:
3374 if (AdvCodecSupport(a, plci, appl, 0)) {
3375 Info = _RESOURCE_ERROR;
3376 }
3377 else {
3378 Info = add_b1(plci, &null_parms, 0, B1_FACILITY_LOCAL);
3379 lli[1] = 0x10; /* local call codec stream */
3380 }
3381 break;
3382 }
3383
3384 plci->State = LOCAL_CONNECT;
3385 plci->manufacturer = true;
3386 plci->command = _MANUFACTURER_R;
3387 plci->m_command = command;
3388 plci->number = Number;
3389
3390 if (!Info)
3391 {
3392 add_p(plci, LLI, lli);
3393 add_p(plci, CHI, chi);
3394 add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
3395 sig_req(plci, ASSIGN, DSIG_ID);
3396
3397 if (!codec)
3398 {
3399 Info = add_b23(plci, &m_parms[3]);
3400 if (!Info)
3401 {
3402 nl_req_ncci(plci, ASSIGN, 0);
3403 send_req(plci);
3404 }
3405 }
3406 if (!Info)
3407 {
3408 dbug(1, dprintf("dir=0x%x,spoof=0x%x", dir, plci->spoofed_msg));
3409 if (plci->spoofed_msg == SPOOFING_REQUIRED)
3410 {
3411 api_save_msg(m_parms, "wbbs", &plci->saved_msg);
3412 plci->spoofed_msg = AWAITING_MANUF_CON;
3413 plci->internal_command = BLOCK_PLCI; /* reject other req meanwhile */
3414 plci->command = 0;
3415 send_req(plci);
3416 return false;
3417 }
3418 if (dir == 1) {
3419 sig_req(plci, CALL_REQ, 0);
3420 }
3421 else if (!dir) {
3422 sig_req(plci, LISTEN_REQ, 0);
3423 }
3424 send_req(plci);
3425 }
3426 else
3427 {
3428 sendf(appl,
3429 _MANUFACTURER_R | CONFIRM,
3430 Id,
3431 Number,
3432 "dww", _DI_MANU_ID, command, Info);
3433 return 2;
3434 }
3435 }
3436 }
3437 }
3438 else Info = _OUT_OF_PLCI;
3439 break;
3440
3441 case _DI_IDI_CTRL:
3442 if (!plci)
3443 {
3444 Info = _WRONG_IDENTIFIER;
3445 break;
3446 }
3447 if (api_parse(&m->info[1], (word)m->length, "bs", m_parms)) {
3448 Info = _WRONG_MESSAGE_FORMAT;
3449 break;
3450 }
3451 req = m_parms[0].info[0];
3452 plci->command = _MANUFACTURER_R;
3453 plci->m_command = command;
3454 plci->number = Number;
3455 if (req == CALL_REQ)
3456 {
3457 plci->b_channel = getChannel(&m_parms[1]);
3458 mixer_set_bchannel_id_esc(plci, plci->b_channel);
3459 if (plci->spoofed_msg == SPOOFING_REQUIRED)
3460 {
3461 plci->spoofed_msg = CALL_REQ | AWAITING_MANUF_CON;
3462 plci->internal_command = BLOCK_PLCI; /* reject other req meanwhile */
3463 plci->command = 0;
3464 break;
3465 }
3466 }
3467 else if (req == LAW_REQ)
3468 {
3469 plci->cr_enquiry = true;
3470 }
3471 add_ss(plci, FTY, &m_parms[1]);
3472 sig_req(plci, req, 0);
3473 send_req(plci);
3474 if (req == HANGUP)
3475 {
3476 if (plci->NL.Id && !plci->nl_remove_id)
3477 {
3478 if (plci->channels)
3479 {
3480 for (ncci = 1; ncci < MAX_NCCI + 1; ncci++)
3481 {
3482 if ((a->ncci_plci[ncci] == plci->Id) && (a->ncci_state[ncci] == CONNECTED))
3483 {
3484 a->ncci_state[ncci] = OUTG_DIS_PENDING;
3485 cleanup_ncci_data(plci, ncci);
3486 nl_req_ncci(plci, N_DISC, (byte)ncci);
3487 }
3488 }
3489 }
3490 mixer_remove(plci);
3491 nl_req_ncci(plci, REMOVE, 0);
3492 send_req(plci);
3493 }
3494 }
3495 break;
3496
3497 case _DI_SIG_CTRL:
3498 /* signalling control for loop activation B-channel */
3499 if (!plci)
3500 {
3501 Info = _WRONG_IDENTIFIER;
3502 break;
3503 }
3504 if (m->length) {
3505 plci->command = _MANUFACTURER_R;
3506 plci->number = Number;
3507 add_ss(plci, FTY, m);
3508 sig_req(plci, SIG_CTRL, 0);
3509 send_req(plci);
3510 }
3511 else Info = _WRONG_MESSAGE_FORMAT;
3512 break;
3513
3514 case _DI_RXT_CTRL:
3515 /* activation control for receiver/transmitter B-channel */
3516 if (!plci)
3517 {
3518 Info = _WRONG_IDENTIFIER;
3519 break;
3520 }
3521 if (m->length) {
3522 plci->command = _MANUFACTURER_R;
3523 plci->number = Number;
3524 add_ss(plci, FTY, m);
3525 sig_req(plci, DSP_CTRL, 0);
3526 send_req(plci);
3527 }
3528 else Info = _WRONG_MESSAGE_FORMAT;
3529 break;
3530
3531 case _DI_ADV_CODEC:
3532 case _DI_DSP_CTRL:
3533 /* TEL_CTRL commands to support non standard adjustments: */
3534 /* Ring on/off, Handset micro volume, external micro vol. */
3535 /* handset+external speaker volume, receiver+transm. gain,*/
3536 /* handsfree on (hookinfo off), set mixer command */
3537
3538 if (command == _DI_ADV_CODEC)
3539 {
3540 if (!a->AdvCodecPLCI) {
3541 Info = _WRONG_STATE;
3542 break;
3543 }
3544 v_plci = a->AdvCodecPLCI;
3545 }
3546 else
3547 {
3548 if (plci
3549 && (m->length >= 3)
3550 && (m->info[1] == 0x1c)
3551 && (m->info[2] >= 1))
3552 {
3553 if (m->info[3] == DSP_CTRL_OLD_SET_MIXER_COEFFICIENTS)
3554 {
3555 if ((plci->tel != ADV_VOICE) || (plci != a->AdvSignalPLCI))
3556 {
3557 Info = _WRONG_STATE;
3558 break;
3559 }
3560 a->adv_voice_coef_length = m->info[2] - 1;
3561 if (a->adv_voice_coef_length > m->length - 3)
3562 a->adv_voice_coef_length = (byte)(m->length - 3);
3563 if (a->adv_voice_coef_length > ADV_VOICE_COEF_BUFFER_SIZE)
3564 a->adv_voice_coef_length = ADV_VOICE_COEF_BUFFER_SIZE;
3565 for (i = 0; i < a->adv_voice_coef_length; i++)
3566 a->adv_voice_coef_buffer[i] = m->info[4 + i];
3567 if (plci->B1_facilities & B1_FACILITY_VOICE)
3568 adv_voice_write_coefs(plci, ADV_VOICE_WRITE_UPDATE);
3569 break;
3570 }
3571 else if (m->info[3] == DSP_CTRL_SET_DTMF_PARAMETERS)
3572 {
3573 if (!(a->manufacturer_features & MANUFACTURER_FEATURE_DTMF_PARAMETERS))
3574 {
3575 Info = _FACILITY_NOT_SUPPORTED;
3576 break;
3577 }
3578
3579 plci->dtmf_parameter_length = m->info[2] - 1;
3580 if (plci->dtmf_parameter_length > m->length - 3)
3581 plci->dtmf_parameter_length = (byte)(m->length - 3);
3582 if (plci->dtmf_parameter_length > DTMF_PARAMETER_BUFFER_SIZE)
3583 plci->dtmf_parameter_length = DTMF_PARAMETER_BUFFER_SIZE;
3584 for (i = 0; i < plci->dtmf_parameter_length; i++)
3585 plci->dtmf_parameter_buffer[i] = m->info[4 + i];
3586 if (plci->B1_facilities & B1_FACILITY_DTMFR)
3587 dtmf_parameter_write(plci);
3588 break;
3589
3590 }
3591 }
3592 v_plci = plci;
3593 }
3594
3595 if (!v_plci)
3596 {
3597 Info = _WRONG_IDENTIFIER;
3598 break;
3599 }
3600 if (m->length) {
3601 add_ss(v_plci, FTY, m);
3602 sig_req(v_plci, TEL_CTRL, 0);
3603 send_req(v_plci);
3604 }
3605 else Info = _WRONG_MESSAGE_FORMAT;
3606
3607 break;
3608
3609 case _DI_OPTIONS_REQUEST:
3610 if (api_parse(&m->info[1], (word)m->length, "d", m_parms)) {
3611 Info = _WRONG_MESSAGE_FORMAT;
3612 break;
3613 }
3614 if (GET_DWORD(m_parms[0].info) & ~a->man_profile.private_options)
3615 {
3616 Info = _FACILITY_NOT_SUPPORTED;
3617 break;
3618 }
3619 a->requested_options_table[appl->Id - 1] = GET_DWORD(m_parms[0].info);
3620 break;
3621
3622
3623
3624 default:
3625 Info = _WRONG_MESSAGE_FORMAT;
3626 break;
3627 }
3628 }
3629
3630 sendf(appl,
3631 _MANUFACTURER_R | CONFIRM,
3632 Id,
3633 Number,
3634 "dww", _DI_MANU_ID, command, Info);
3635 return false;
3636 }
3637
3638
3639 static byte manufacturer_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3640 PLCI *plci, APPL *appl, API_PARSE *msg)
3641 {
3642 word indication;
3643
3644 API_PARSE m_parms[3];
3645 API_PARSE *ncpi;
3646 API_PARSE fax_parms[9];
3647 word i;
3648 byte len;
3649
3650
3651 dbug(1, dprintf("manufacturer_res"));
3652
3653 if ((msg[0].length == 0)
3654 || (msg[1].length == 0)
3655 || (GET_DWORD(msg[0].info) != _DI_MANU_ID))
3656 {
3657 return false;
3658 }
3659 indication = GET_WORD(msg[1].info);
3660 switch (indication)
3661 {
3662
3663 case _DI_NEGOTIATE_B3:
3664 if (!plci)
3665 break;
3666 if (((plci->B3_prot != 4) && (plci->B3_prot != 5))
3667 || !(plci->ncpi_state & NCPI_NEGOTIATE_B3_SENT))
3668 {
3669 dbug(1, dprintf("wrong state for NEGOTIATE_B3 parameters"));
3670 break;
3671 }
3672 if (api_parse(&msg[2].info[1], msg[2].length, "ws", m_parms))
3673 {
3674 dbug(1, dprintf("wrong format in NEGOTIATE_B3 parameters"));
3675 break;
3676 }
3677 ncpi = &m_parms[1];
3678 len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
3679 if (plci->fax_connect_info_length < len)
3680 {
3681 ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id_len = 0;
3682 ((T30_INFO *)(plci->fax_connect_info_buffer))->head_line_len = 0;
3683 }
3684 if (api_parse(&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms))
3685 {
3686 dbug(1, dprintf("non-standard facilities info missing or wrong format"));
3687 }
3688 else
3689 {
3690 if (plci->fax_connect_info_length <= len)
3691 plci->fax_connect_info_buffer[len] = 0;
3692 len += 1 + plci->fax_connect_info_buffer[len];
3693 if (plci->fax_connect_info_length <= len)
3694 plci->fax_connect_info_buffer[len] = 0;
3695 len += 1 + plci->fax_connect_info_buffer[len];
3696 if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2))
3697 plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]);
3698 plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length);
3699 for (i = 0; i < fax_parms[7].length; i++)
3700 plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1 + i];
3701 }
3702 plci->fax_connect_info_length = len;
3703 plci->fax_edata_ack_length = plci->fax_connect_info_length;
3704 start_internal_command(Id, plci, fax_edata_ack_command);
3705 break;
3706
3707 }
3708 return false;
3709 }
3710
3711 /*------------------------------------------------------------------*/
3712 /* IDI callback function */
3713 /*------------------------------------------------------------------*/
3714
3715 void callback(ENTITY *e)
3716 {
3717 DIVA_CAPI_ADAPTER *a;
3718 APPL *appl;
3719 PLCI *plci;
3720 CAPI_MSG *m;
3721 word i, j;
3722 byte rc;
3723 byte ch;
3724 byte req;
3725 byte global_req;
3726 int no_cancel_rc;
3727
3728 dbug(1, dprintf("%x:CB(%x:Req=%x,Rc=%x,Ind=%x)",
3729 (e->user[0] + 1) & 0x7fff, e->Id, e->Req, e->Rc, e->Ind));
3730
3731 a = &(adapter[(byte)e->user[0]]);
3732 plci = &(a->plci[e->user[1]]);
3733 no_cancel_rc = DIVA_CAPI_SUPPORTS_NO_CANCEL(a);
3734
3735 /*
3736 If new protocol code and new XDI is used then CAPI should work
3737 fully in accordance with IDI cpec an look on callback field instead
3738 of Rc field for return codes.
3739 */
3740 if (((e->complete == 0xff) && no_cancel_rc) ||
3741 (e->Rc && !no_cancel_rc)) {
3742 rc = e->Rc;
3743 ch = e->RcCh;
3744 req = e->Req;
3745 e->Rc = 0;
3746
3747 if (e->user[0] & 0x8000)
3748 {
3749 /*
3750 If REMOVE request was sent then we have to wait until
3751 return code with Id set to zero arrives.
3752 All other return codes should be ignored.
3753 */
3754 if (req == REMOVE)
3755 {
3756 if (e->Id)
3757 {
3758 dbug(1, dprintf("cancel RC in REMOVE state"));
3759 return;
3760 }
3761 channel_flow_control_remove(plci);
3762 for (i = 0; i < 256; i++)
3763 {
3764 if (a->FlowControlIdTable[i] == plci->nl_remove_id)
3765 a->FlowControlIdTable[i] = 0;
3766 }
3767 plci->nl_remove_id = 0;
3768 if (plci->rx_dma_descriptor > 0) {
3769 diva_free_dma_descriptor(plci, plci->rx_dma_descriptor - 1);
3770 plci->rx_dma_descriptor = 0;
3771 }
3772 }
3773 if (rc == OK_FC)
3774 {
3775 a->FlowControlIdTable[ch] = e->Id;
3776 a->FlowControlSkipTable[ch] = 0;
3777
3778 a->ch_flow_control[ch] |= N_OK_FC_PENDING;
3779 a->ch_flow_plci[ch] = plci->Id;
3780 plci->nl_req = 0;
3781 }
3782 else
3783 {
3784 /*
3785 Cancel return codes self, if feature was requested
3786 */
3787 if (no_cancel_rc && (a->FlowControlIdTable[ch] == e->Id) && e->Id) {
3788 a->FlowControlIdTable[ch] = 0;
3789 if ((rc == OK) && a->FlowControlSkipTable[ch]) {
3790 dbug(3, dprintf("XDI CAPI: RC cancelled Id:0x02, Ch:%02x", e->Id, ch));
3791 return;
3792 }
3793 }
3794
3795 if (a->ch_flow_control[ch] & N_OK_FC_PENDING)
3796 {
3797 a->ch_flow_control[ch] &= ~N_OK_FC_PENDING;
3798 if (ch == e->ReqCh)
3799 plci->nl_req = 0;
3800 }
3801 else
3802 plci->nl_req = 0;
3803 }
3804 if (plci->nl_req)
3805 control_rc(plci, 0, rc, ch, 0, true);
3806 else
3807 {
3808 if (req == N_XON)
3809 {
3810 channel_x_on(plci, ch);
3811 if (plci->internal_command)
3812 control_rc(plci, req, rc, ch, 0, true);
3813 }
3814 else
3815 {
3816 if (plci->nl_global_req)
3817 {
3818 global_req = plci->nl_global_req;
3819 plci->nl_global_req = 0;
3820 if (rc != ASSIGN_OK) {
3821 e->Id = 0;
3822 if (plci->rx_dma_descriptor > 0) {
3823 diva_free_dma_descriptor(plci, plci->rx_dma_descriptor - 1);
3824 plci->rx_dma_descriptor = 0;
3825 }
3826 }
3827 channel_xmit_xon(plci);
3828 control_rc(plci, 0, rc, ch, global_req, true);
3829 }
3830 else if (plci->data_sent)
3831 {
3832 channel_xmit_xon(plci);
3833 plci->data_sent = false;
3834 plci->NL.XNum = 1;
3835 data_rc(plci, ch);
3836 if (plci->internal_command)
3837 control_rc(plci, req, rc, ch, 0, true);
3838 }
3839 else
3840 {
3841 channel_xmit_xon(plci);
3842 control_rc(plci, req, rc, ch, 0, true);
3843 }
3844 }
3845 }
3846 }
3847 else
3848 {
3849 /*
3850 If REMOVE request was sent then we have to wait until
3851 return code with Id set to zero arrives.
3852 All other return codes should be ignored.
3853 */
3854 if (req == REMOVE)
3855 {
3856 if (e->Id)
3857 {
3858 dbug(1, dprintf("cancel RC in REMOVE state"));
3859 return;
3860 }
3861 plci->sig_remove_id = 0;
3862 }
3863 plci->sig_req = 0;
3864 if (plci->sig_global_req)
3865 {
3866 global_req = plci->sig_global_req;
3867 plci->sig_global_req = 0;
3868 if (rc != ASSIGN_OK)
3869 e->Id = 0;
3870 channel_xmit_xon(plci);
3871 control_rc(plci, 0, rc, ch, global_req, false);
3872 }
3873 else
3874 {
3875 channel_xmit_xon(plci);
3876 control_rc(plci, req, rc, ch, 0, false);
3877 }
3878 }
3879 /*
3880 Again: in accordance with IDI spec Rc and Ind can't be delivered in the
3881 same callback. Also if new XDI and protocol code used then jump
3882 direct to finish.
3883 */
3884 if (no_cancel_rc) {
3885 channel_xmit_xon(plci);
3886 goto capi_callback_suffix;
3887 }
3888 }
3889
3890 channel_xmit_xon(plci);
3891
3892 if (e->Ind) {
3893 if (e->user[0] & 0x8000) {
3894 byte Ind = e->Ind & 0x0f;
3895 byte Ch = e->IndCh;
3896 if (((Ind == N_DISC) || (Ind == N_DISC_ACK)) &&
3897 (a->ch_flow_plci[Ch] == plci->Id)) {
3898 if (a->ch_flow_control[Ch] & N_RX_FLOW_CONTROL_MASK) {
3899 dbug(3, dprintf("XDI CAPI: I: pending N-XON Ch:%02x", Ch));
3900 }
3901 a->ch_flow_control[Ch] &= ~N_RX_FLOW_CONTROL_MASK;
3902 }
3903 nl_ind(plci);
3904 if ((e->RNR != 1) &&
3905 (a->ch_flow_plci[Ch] == plci->Id) &&
3906 (a->ch_flow_control[Ch] & N_RX_FLOW_CONTROL_MASK)) {
3907 a->ch_flow_control[Ch] &= ~N_RX_FLOW_CONTROL_MASK;
3908 dbug(3, dprintf("XDI CAPI: I: remove faked N-XON Ch:%02x", Ch));
3909 }
3910 } else {
3911 sig_ind(plci);
3912 }
3913 e->Ind = 0;
3914 }
3915
3916 capi_callback_suffix:
3917
3918 while (!plci->req_in
3919 && !plci->internal_command
3920 && (plci->msg_in_write_pos != plci->msg_in_read_pos))
3921 {
3922 j = (plci->msg_in_read_pos == plci->msg_in_wrap_pos) ? 0 : plci->msg_in_read_pos;
3923
3924 i = (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[j]))->header.length + 3) & 0xfffc;
3925
3926 m = (CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[j]);
3927 appl = *((APPL **)(&((byte *)(plci->msg_in_queue))[j + i]));
3928 dbug(1, dprintf("dequeue msg(0x%04x) - write=%d read=%d wrap=%d",
3929 m->header.command, plci->msg_in_write_pos, plci->msg_in_read_pos, plci->msg_in_wrap_pos));
3930 if (plci->msg_in_read_pos == plci->msg_in_wrap_pos)
3931 {
3932 plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
3933 plci->msg_in_read_pos = i + MSG_IN_OVERHEAD;
3934 }
3935 else
3936 {
3937 plci->msg_in_read_pos = j + i + MSG_IN_OVERHEAD;
3938 }
3939 if (plci->msg_in_read_pos == plci->msg_in_write_pos)
3940 {
3941 plci->msg_in_write_pos = MSG_IN_QUEUE_SIZE;
3942 plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
3943 }
3944 else if (plci->msg_in_read_pos == plci->msg_in_wrap_pos)
3945 {
3946 plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
3947 plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
3948 }
3949 i = api_put(appl, m);
3950 if (i != 0)
3951 {
3952 if (m->header.command == _DATA_B3_R)
3953
3954 TransmitBufferFree(appl, (byte *)(long)(m->info.data_b3_req.Data));
3955
3956 dbug(1, dprintf("Error 0x%04x from msg(0x%04x)", i, m->header.command));
3957 break;
3958 }
3959
3960 if (plci->li_notify_update)
3961 {
3962 plci->li_notify_update = false;
3963 mixer_notify_update(plci, false);
3964 }
3965
3966 }
3967 send_data(plci);
3968 send_req(plci);
3969 }
3970
3971
3972 static void control_rc(PLCI *plci, byte req, byte rc, byte ch, byte global_req,
3973 byte nl_rc)
3974 {
3975 dword Id;
3976 dword rId;
3977 word Number;
3978 word Info = 0;
3979 word i;
3980 word ncci;
3981 DIVA_CAPI_ADAPTER *a;
3982 APPL *appl;
3983 PLCI *rplci;
3984 byte SSparms[] = "\x05\x00\x00\x02\x00\x00";
3985 byte SSstruct[] = "\x09\x00\x00\x06\x00\x00\x00\x00\x00\x00";
3986
3987 if (!plci) {
3988 dbug(0, dprintf("A: control_rc, no plci %02x:%02x:%02x:%02x:%02x", req, rc, ch, global_req, nl_rc));
3989 return;
3990 }
3991 dbug(1, dprintf("req0_in/out=%d/%d", plci->req_in, plci->req_out));
3992 if (plci->req_in != plci->req_out)
3993 {
3994 if (nl_rc || (global_req != ASSIGN) || (rc == ASSIGN_OK))
3995 {
3996 dbug(1, dprintf("req_1return"));
3997 return;
3998 }
3999 /* cancel outstanding request on the PLCI after SIG ASSIGN failure */
4000 }
4001 plci->req_in = plci->req_in_start = plci->req_out = 0;
4002 dbug(1, dprintf("control_rc"));
4003
4004 appl = plci->appl;
4005 a = plci->adapter;
4006 ncci = a->ch_ncci[ch];
4007 if (appl)
4008 {
4009 Id = (((dword)(ncci ? ncci : ch)) << 16) | ((word)plci->Id << 8) | a->Id;
4010 if (plci->tel && plci->SuppState != CALL_HELD) Id |= EXT_CONTROLLER;
4011 Number = plci->number;
4012 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));
4013 dbug(1, dprintf("channels=0x%x", plci->channels));
4014 if (plci_remove_check(plci))
4015 return;
4016 if (req == REMOVE && rc == ASSIGN_OK)
4017 {
4018 sig_req(plci, HANGUP, 0);
4019 sig_req(plci, REMOVE, 0);
4020 send_req(plci);
4021 }
4022 if (plci->command)
4023 {
4024 switch (plci->command)
4025 {
4026 case C_HOLD_REQ:
4027 dbug(1, dprintf("HoldRC=0x%x", rc));
4028 SSparms[1] = (byte)S_HOLD;
4029 if (rc != OK)
4030 {
4031 plci->SuppState = IDLE;
4032 Info = 0x2001;
4033 }
4034 sendf(appl, _FACILITY_R | CONFIRM, Id, Number, "wws", Info, 3, SSparms);
4035 break;
4036
4037 case C_RETRIEVE_REQ:
4038 dbug(1, dprintf("RetrieveRC=0x%x", rc));
4039 SSparms[1] = (byte)S_RETRIEVE;
4040 if (rc != OK)
4041 {
4042 plci->SuppState = CALL_HELD;
4043 Info = 0x2001;
4044 }
4045 sendf(appl, _FACILITY_R | CONFIRM, Id, Number, "wws", Info, 3, SSparms);
4046 break;
4047
4048 case _INFO_R:
4049 dbug(1, dprintf("InfoRC=0x%x", rc));
4050 if (rc != OK) Info = _WRONG_STATE;
4051 sendf(appl, _INFO_R | CONFIRM, Id, Number, "w", Info);
4052 break;
4053
4054 case _CONNECT_R:
4055 dbug(1, dprintf("Connect_R=0x%x/0x%x/0x%x/0x%x", req, rc, global_req, nl_rc));
4056 if (plci->State == INC_DIS_PENDING)
4057 break;
4058 if (plci->Sig.Id != 0xff)
4059 {
4060 if (((global_req == ASSIGN) && (rc != ASSIGN_OK))
4061 || (!nl_rc && (req == CALL_REQ) && (rc != OK)))
4062 {
4063 dbug(1, dprintf("No more IDs/Call_Req failed"));
4064 sendf(appl, _CONNECT_R | CONFIRM, Id & 0xffL, Number, "w", _OUT_OF_PLCI);
4065 plci_remove(plci);
4066 plci->State = IDLE;
4067 break;
4068 }
4069 if (plci->State != LOCAL_CONNECT) plci->State = OUTG_CON_PENDING;
4070 sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", 0);
4071 }
4072 else /* D-ch activation */
4073 {
4074 if (rc != ASSIGN_OK)
4075 {
4076 dbug(1, dprintf("No more IDs/X.25 Call_Req failed"));
4077 sendf(appl, _CONNECT_R | CONFIRM, Id & 0xffL, Number, "w", _OUT_OF_PLCI);
4078 plci_remove(plci);
4079 plci->State = IDLE;
4080 break;
4081 }
4082 sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", 0);
4083 sendf(plci->appl, _CONNECT_ACTIVE_I, Id, 0, "sss", "", "", "");
4084 plci->State = INC_ACT_PENDING;
4085 }
4086 break;
4087
4088 case _CONNECT_I | RESPONSE:
4089 if (plci->State != INC_DIS_PENDING)
4090 plci->State = INC_CON_ACCEPT;
4091 break;
4092
4093 case _DISCONNECT_R:
4094 if (plci->State == INC_DIS_PENDING)
4095 break;
4096 if (plci->Sig.Id != 0xff)
4097 {
4098 plci->State = OUTG_DIS_PENDING;
4099 sendf(appl, _DISCONNECT_R | CONFIRM, Id, Number, "w", 0);
4100 }
4101 break;
4102
4103 case SUSPEND_REQ:
4104 break;
4105
4106 case RESUME_REQ:
4107 break;
4108
4109 case _CONNECT_B3_R:
4110 if (rc != OK)
4111 {
4112 sendf(appl, _CONNECT_B3_R | CONFIRM, Id, Number, "w", _WRONG_IDENTIFIER);
4113 break;
4114 }
4115 ncci = get_ncci(plci, ch, 0);
4116 Id = (Id & 0xffff) | (((dword) ncci) << 16);
4117 plci->channels++;
4118 if (req == N_RESET)
4119 {
4120 a->ncci_state[ncci] = INC_ACT_PENDING;
4121 sendf(appl, _CONNECT_B3_R | CONFIRM, Id, Number, "w", 0);
4122 sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
4123 }
4124 else
4125 {
4126 a->ncci_state[ncci] = OUTG_CON_PENDING;
4127 sendf(appl, _CONNECT_B3_R | CONFIRM, Id, Number, "w", 0);
4128 }
4129 break;
4130
4131 case _CONNECT_B3_I | RESPONSE:
4132 break;
4133
4134 case _RESET_B3_R:
4135 /* sendf(appl, _RESET_B3_R | CONFIRM, Id, Number, "w", 0);*/
4136 break;
4137
4138 case _DISCONNECT_B3_R:
4139 sendf(appl, _DISCONNECT_B3_R | CONFIRM, Id, Number, "w", 0);
4140 break;
4141
4142 case _MANUFACTURER_R:
4143 break;
4144
4145 case PERM_LIST_REQ:
4146 if (rc != OK)
4147 {
4148 Info = _WRONG_IDENTIFIER;
4149 sendf(plci->appl, _CONNECT_R | CONFIRM, Id, Number, "w", Info);
4150 plci_remove(plci);
4151 }
4152 else
4153 sendf(plci->appl, _CONNECT_R | CONFIRM, Id, Number, "w", Info);
4154 break;
4155
4156 default:
4157 break;
4158 }
4159 plci->command = 0;
4160 }
4161 else if (plci->internal_command)
4162 {
4163 switch (plci->internal_command)
4164 {
4165 case BLOCK_PLCI:
4166 return;
4167
4168 case GET_MWI_STATE:
4169 if (rc == OK) /* command supported, wait for indication */
4170 {
4171 return;
4172 }
4173 plci_remove(plci);
4174 break;
4175
4176 /* Get Supported Services */
4177 case GETSERV_REQ_PEND:
4178 if (rc == OK) /* command supported, wait for indication */
4179 {
4180 break;
4181 }
4182 PUT_DWORD(&SSstruct[6], MASK_TERMINAL_PORTABILITY);
4183 sendf(appl, _FACILITY_R | CONFIRM, Id, Number, "wws", 0, 3, SSstruct);
4184 plci_remove(plci);
4185 break;
4186
4187 case INTERR_DIVERSION_REQ_PEND: /* Interrogate Parameters */
4188 case INTERR_NUMBERS_REQ_PEND:
4189 case CF_START_PEND: /* Call Forwarding Start pending */
4190 case CF_STOP_PEND: /* Call Forwarding Stop pending */
4191 case CCBS_REQUEST_REQ_PEND:
4192 case CCBS_DEACTIVATE_REQ_PEND:
4193 case CCBS_INTERROGATE_REQ_PEND:
4194 switch (plci->internal_command)
4195 {
4196 case INTERR_DIVERSION_REQ_PEND:
4197 SSparms[1] = S_INTERROGATE_DIVERSION;
4198 break;
4199 case INTERR_NUMBERS_REQ_PEND:
4200 SSparms[1] = S_INTERROGATE_NUMBERS;
4201 break;
4202 case CF_START_PEND:
4203 SSparms[1] = S_CALL_FORWARDING_START;
4204 break;
4205 case CF_STOP_PEND:
4206 SSparms[1] = S_CALL_FORWARDING_STOP;
4207 break;
4208 case CCBS_REQUEST_REQ_PEND:
4209 SSparms[1] = S_CCBS_REQUEST;
4210 break;
4211 case CCBS_DEACTIVATE_REQ_PEND:
4212 SSparms[1] = S_CCBS_DEACTIVATE;
4213 break;
4214 case CCBS_INTERROGATE_REQ_PEND:
4215 SSparms[1] = S_CCBS_INTERROGATE;
4216 break;
4217 }
4218 if (global_req == ASSIGN)
4219 {
4220 dbug(1, dprintf("AssignDiversion_RC=0x%x/0x%x", req, rc));
4221 return;
4222 }
4223 if (!plci->appl) break;
4224 if (rc == ISDN_GUARD_REJ)
4225 {
4226 Info = _CAPI_GUARD_ERROR;
4227 }
4228 else if (rc != OK)
4229 {
4230 Info = _SUPPLEMENTARY_SERVICE_NOT_SUPPORTED;
4231 }
4232 sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0x7,
4233 plci->number, "wws", Info, (word)3, SSparms);
4234 if (Info) plci_remove(plci);
4235 break;
4236
4237 /* 3pty conference pending */
4238 case PTY_REQ_PEND:
4239 if (!plci->relatedPTYPLCI) break;
4240 rplci = plci->relatedPTYPLCI;
4241 SSparms[1] = plci->ptyState;
4242 rId = ((word)rplci->Id << 8) | rplci->adapter->Id;
4243 if (rplci->tel) rId |= EXT_CONTROLLER;
4244 if (rc != OK)
4245 {
4246 Info = 0x300E; /* not supported */
4247 plci->relatedPTYPLCI = NULL;
4248 plci->ptyState = 0;
4249 }
4250 sendf(rplci->appl,
4251 _FACILITY_R | CONFIRM,
4252 rId,
4253 plci->number,
4254 "wws", Info, (word)3, SSparms);
4255 break;
4256
4257 /* Explicit Call Transfer pending */
4258 case ECT_REQ_PEND:
4259 dbug(1, dprintf("ECT_RC=0x%x/0x%x", req, rc));
4260 if (!plci->relatedPTYPLCI) break;
4261 rplci = plci->relatedPTYPLCI;
4262 SSparms[1] = S_ECT;
4263 rId = ((word)rplci->Id << 8) | rplci->adapter->Id;
4264 if (rplci->tel) rId |= EXT_CONTROLLER;
4265 if (rc != OK)
4266 {
4267 Info = 0x300E; /* not supported */
4268 plci->relatedPTYPLCI = NULL;
4269 plci->ptyState = 0;
4270 }
4271 sendf(rplci->appl,
4272 _FACILITY_R | CONFIRM,
4273 rId,
4274 plci->number,
4275 "wws", Info, (word)3, SSparms);
4276 break;
4277
4278 case _MANUFACTURER_R:
4279 dbug(1, dprintf("_Manufacturer_R=0x%x/0x%x", req, rc));
4280 if ((global_req == ASSIGN) && (rc != ASSIGN_OK))
4281 {
4282 dbug(1, dprintf("No more IDs"));
4283 sendf(appl, _MANUFACTURER_R | CONFIRM, Id, Number, "dww", _DI_MANU_ID, _MANUFACTURER_R, _OUT_OF_PLCI);
4284 plci_remove(plci); /* after codec init, internal codec commands pending */
4285 }
4286 break;
4287
4288 case _CONNECT_R:
4289 dbug(1, dprintf("_Connect_R=0x%x/0x%x", req, rc));
4290 if ((global_req == ASSIGN) && (rc != ASSIGN_OK))
4291 {
4292 dbug(1, dprintf("No more IDs"));
4293 sendf(appl, _CONNECT_R | CONFIRM, Id & 0xffL, Number, "w", _OUT_OF_PLCI);
4294 plci_remove(plci); /* after codec init, internal codec commands pending */
4295 }
4296 break;
4297
4298 case PERM_COD_HOOK: /* finished with Hook_Ind */
4299 return;
4300
4301 case PERM_COD_CALL:
4302 dbug(1, dprintf("***Codec Connect_Pending A, Rc = 0x%x", rc));
4303 plci->internal_command = PERM_COD_CONN_PEND;
4304 return;
4305
4306 case PERM_COD_ASSIGN:
4307 dbug(1, dprintf("***Codec Assign A, Rc = 0x%x", rc));
4308 if (rc != ASSIGN_OK) break;
4309 sig_req(plci, CALL_REQ, 0);
4310 send_req(plci);
4311 plci->internal_command = PERM_COD_CALL;
4312 return;
4313
4314 /* Null Call Reference Request pending */
4315 case C_NCR_FAC_REQ:
4316 dbug(1, dprintf("NCR_FAC=0x%x/0x%x", req, rc));
4317 if (global_req == ASSIGN)
4318 {
4319 if (rc == ASSIGN_OK)
4320 {
4321 return;
4322 }
4323 else
4324 {
4325 sendf(appl, _INFO_R | CONFIRM, Id & 0xf, Number, "w", _WRONG_STATE);
4326 appl->NullCREnable = false;
4327 plci_remove(plci);
4328 }
4329 }
4330 else if (req == NCR_FACILITY)
4331 {
4332 if (rc == OK)
4333 {
4334 sendf(appl, _INFO_R | CONFIRM, Id & 0xf, Number, "w", 0);
4335 }
4336 else
4337 {
4338 sendf(appl, _INFO_R | CONFIRM, Id & 0xf, Number, "w", _WRONG_STATE);
4339 appl->NullCREnable = false;
4340 }
4341 plci_remove(plci);
4342 }
4343 break;
4344
4345 case HOOK_ON_REQ:
4346 if (plci->channels)
4347 {
4348 if (a->ncci_state[ncci] == CONNECTED)
4349 {
4350 a->ncci_state[ncci] = OUTG_DIS_PENDING;
4351 cleanup_ncci_data(plci, ncci);
4352 nl_req_ncci(plci, N_DISC, (byte)ncci);
4353 }
4354 break;
4355 }
4356 break;
4357
4358 case HOOK_OFF_REQ:
4359 if (plci->State == INC_DIS_PENDING)
4360 break;
4361 sig_req(plci, CALL_REQ, 0);
4362 send_req(plci);
4363 plci->State = OUTG_CON_PENDING;
4364 break;
4365
4366
4367 case MWI_ACTIVATE_REQ_PEND:
4368 case MWI_DEACTIVATE_REQ_PEND:
4369 if (global_req == ASSIGN && rc == ASSIGN_OK)
4370 {
4371 dbug(1, dprintf("MWI_REQ assigned"));
4372 return;
4373 }
4374 else if (rc != OK)
4375 {
4376 if (rc == WRONG_IE)
4377 {
4378 Info = 0x2007; /* Illegal message parameter coding */
4379 dbug(1, dprintf("MWI_REQ invalid parameter"));
4380 }
4381 else
4382 {
4383 Info = 0x300B; /* not supported */
4384 dbug(1, dprintf("MWI_REQ not supported"));
4385 }
4386 /* 0x3010: Request not allowed in this state */
4387 PUT_WORD(&SSparms[4], 0x300E); /* SS not supported */
4388
4389 }
4390 if (plci->internal_command == MWI_ACTIVATE_REQ_PEND)
4391 {
4392 PUT_WORD(&SSparms[1], S_MWI_ACTIVATE);
4393 }
4394 else PUT_WORD(&SSparms[1], S_MWI_DEACTIVATE);
4395
4396 if (plci->cr_enquiry)
4397 {
4398 sendf(plci->appl,
4399 _FACILITY_R | CONFIRM,
4400 Id & 0xf,
4401 plci->number,
4402 "wws", Info, (word)3, SSparms);
4403 if (rc != OK) plci_remove(plci);
4404 }
4405 else
4406 {
4407 sendf(plci->appl,
4408 _FACILITY_R | CONFIRM,
4409 Id,
4410 plci->number,
4411 "wws", Info, (word)3, SSparms);
4412 }
4413 break;
4414
4415 case CONF_BEGIN_REQ_PEND:
4416 case CONF_ADD_REQ_PEND:
4417 case CONF_SPLIT_REQ_PEND:
4418 case CONF_DROP_REQ_PEND:
4419 case CONF_ISOLATE_REQ_PEND:
4420 case CONF_REATTACH_REQ_PEND:
4421 dbug(1, dprintf("CONF_RC=0x%x/0x%x", req, rc));
4422 if ((plci->internal_command == CONF_ADD_REQ_PEND) && (!plci->relatedPTYPLCI)) break;
4423 rplci = plci;
4424 rId = Id;
4425 switch (plci->internal_command)
4426 {
4427 case CONF_BEGIN_REQ_PEND:
4428 SSparms[1] = S_CONF_BEGIN;
4429 break;
4430 case CONF_ADD_REQ_PEND:
4431 SSparms[1] = S_CONF_ADD;
4432 rplci = plci->relatedPTYPLCI;
4433 rId = ((word)rplci->Id << 8) | rplci->adapter->Id;
4434 break;
4435 case CONF_SPLIT_REQ_PEND:
4436 SSparms[1] = S_CONF_SPLIT;
4437 break;
4438 case CONF_DROP_REQ_PEND:
4439 SSparms[1] = S_CONF_DROP;
4440 break;
4441 case CONF_ISOLATE_REQ_PEND:
4442 SSparms[1] = S_CONF_ISOLATE;
4443 break;
4444 case CONF_REATTACH_REQ_PEND:
4445 SSparms[1] = S_CONF_REATTACH;
4446 break;
4447 }
4448
4449 if (rc != OK)
4450 {
4451 Info = 0x300E; /* not supported */
4452 plci->relatedPTYPLCI = NULL;
4453 plci->ptyState = 0;
4454 }
4455 sendf(rplci->appl,
4456 _FACILITY_R | CONFIRM,
4457 rId,
4458 plci->number,
4459 "wws", Info, (word)3, SSparms);
4460 break;
4461
4462 case VSWITCH_REQ_PEND:
4463 if (rc != OK)
4464 {
4465 if (plci->relatedPTYPLCI)
4466 {
4467 plci->relatedPTYPLCI->vswitchstate = 0;
4468 plci->relatedPTYPLCI->vsprot = 0;
4469 plci->relatedPTYPLCI->vsprotdialect = 0;
4470 }
4471 plci->vswitchstate = 0;
4472 plci->vsprot = 0;
4473 plci->vsprotdialect = 0;
4474 }
4475 else
4476 {
4477 if (plci->relatedPTYPLCI &&
4478 plci->vswitchstate == 1 &&
4479 plci->relatedPTYPLCI->vswitchstate == 3) /* join complete */
4480 plci->vswitchstate = 3;
4481 }
4482 break;
4483
4484 /* Call Deflection Request pending (SSCT) */
4485 case CD_REQ_PEND:
4486 SSparms[1] = S_CALL_DEFLECTION;
4487 if (rc != OK)
4488 {
4489 Info = 0x300E; /* not supported */
4490 plci->appl->CDEnable = 0;
4491 }
4492 sendf(plci->appl, _FACILITY_R | CONFIRM, Id,
4493 plci->number, "wws", Info, (word)3, SSparms);
4494 break;
4495
4496 case RTP_CONNECT_B3_REQ_COMMAND_2:
4497 if (rc == OK)
4498 {
4499 ncci = get_ncci(plci, ch, 0);
4500 Id = (Id & 0xffff) | (((dword) ncci) << 16);
4501 plci->channels++;
4502 a->ncci_state[ncci] = OUTG_CON_PENDING;
4503 }
4504 /* fall through */
4505
4506 default:
4507 if (plci->internal_command_queue[0])
4508 {
4509 (*(plci->internal_command_queue[0]))(Id, plci, rc);
4510 if (plci->internal_command)
4511 return;
4512 }
4513 break;
4514 }
4515 next_internal_command(Id, plci);
4516 }
4517 }
4518 else /* appl==0 */
4519 {
4520 Id = ((word)plci->Id << 8) | plci->adapter->Id;
4521 if (plci->tel) Id |= EXT_CONTROLLER;
4522
4523 switch (plci->internal_command)
4524 {
4525 case BLOCK_PLCI:
4526 return;
4527
4528 case START_L1_SIG_ASSIGN_PEND:
4529 case REM_L1_SIG_ASSIGN_PEND:
4530 if (global_req == ASSIGN)
4531 {
4532 break;
4533 }
4534 else
4535 {
4536 dbug(1, dprintf("***L1 Req rem PLCI"));
4537 plci->internal_command = 0;
4538 sig_req(plci, REMOVE, 0);
4539 send_req(plci);
4540 }
4541 break;
4542
4543 /* Call Deflection Request pending, just no appl ptr assigned */
4544 case CD_REQ_PEND:
4545 SSparms[1] = S_CALL_DEFLECTION;
4546 if (rc != OK)
4547 {
4548 Info = 0x300E; /* not supported */
4549 }
4550 for (i = 0; i < max_appl; i++)
4551 {
4552 if (application[i].CDEnable)
4553 {
4554 if (!application[i].Id) application[i].CDEnable = 0;
4555 else
4556 {
4557 sendf(&application[i], _FACILITY_R | CONFIRM, Id,
4558 plci->number, "wws", Info, (word)3, SSparms);
4559 if (Info) application[i].CDEnable = 0;
4560 }
4561 }
4562 }
4563 plci->internal_command = 0;
4564 break;
4565
4566 case PERM_COD_HOOK: /* finished with Hook_Ind */
4567 return;
4568
4569 case PERM_COD_CALL:
4570 plci->internal_command = PERM_COD_CONN_PEND;
4571 dbug(1, dprintf("***Codec Connect_Pending, Rc = 0x%x", rc));
4572 return;
4573
4574 case PERM_COD_ASSIGN:
4575 dbug(1, dprintf("***Codec Assign, Rc = 0x%x", rc));
4576 plci->internal_command = 0;
4577 if (rc != ASSIGN_OK) break;
4578 plci->internal_command = PERM_COD_CALL;
4579 sig_req(plci, CALL_REQ, 0);
4580 send_req(plci);
4581 return;
4582
4583 case LISTEN_SIG_ASSIGN_PEND:
4584 if (rc == ASSIGN_OK)
4585 {
4586 plci->internal_command = 0;
4587 dbug(1, dprintf("ListenCheck, new SIG_ID = 0x%x", plci->Sig.Id));
4588 add_p(plci, ESC, "\x02\x18\x00"); /* support call waiting */
4589 sig_req(plci, INDICATE_REQ, 0);
4590 send_req(plci);
4591 }
4592 else
4593 {
4594 dbug(1, dprintf("ListenCheck failed (assignRc=0x%x)", rc));
4595 a->listen_active--;
4596 plci_remove(plci);
4597 plci->State = IDLE;
4598 }
4599 break;
4600
4601 case USELAW_REQ:
4602 if (global_req == ASSIGN)
4603 {
4604 if (rc == ASSIGN_OK)
4605 {
4606 sig_req(plci, LAW_REQ, 0);
4607 send_req(plci);
4608 dbug(1, dprintf("Auto-Law assigned"));
4609 }
4610 else
4611 {
4612 dbug(1, dprintf("Auto-Law assign failed"));
4613 a->automatic_law = 3;
4614 plci->internal_command = 0;
4615 a->automatic_lawPLCI = NULL;
4616 }
4617 break;
4618 }
4619 else if (req == LAW_REQ && rc == OK)
4620 {
4621 dbug(1, dprintf("Auto-Law initiated"));
4622 a->automatic_law = 2;
4623 plci->internal_command = 0;
4624 }
4625 else
4626 {
4627 dbug(1, dprintf("Auto-Law not supported"));
4628 a->automatic_law = 3;
4629 plci->internal_command = 0;
4630 sig_req(plci, REMOVE, 0);
4631 send_req(plci);
4632 a->automatic_lawPLCI = NULL;
4633 }
4634 break;
4635 }
4636 plci_remove_check(plci);
4637 }
4638 }
4639
4640 static void data_rc(PLCI *plci, byte ch)
4641 {
4642 dword Id;
4643 DIVA_CAPI_ADAPTER *a;
4644 NCCI *ncci_ptr;
4645 DATA_B3_DESC *data;
4646 word ncci;
4647
4648 if (plci->appl)
4649 {
4650 TransmitBufferFree(plci->appl, plci->data_sent_ptr);
4651 a = plci->adapter;
4652 ncci = a->ch_ncci[ch];
4653 if (ncci && (a->ncci_plci[ncci] == plci->Id))
4654 {
4655 ncci_ptr = &(a->ncci[ncci]);
4656 dbug(1, dprintf("data_out=%d, data_pending=%d", ncci_ptr->data_out, ncci_ptr->data_pending));
4657 if (ncci_ptr->data_pending)
4658 {
4659 data = &(ncci_ptr->DBuffer[ncci_ptr->data_out]);
4660 if (!(data->Flags & 4) && a->ncci_state[ncci])
4661 {
4662 Id = (((dword)ncci) << 16) | ((word)plci->Id << 8) | a->Id;
4663 if (plci->tel) Id |= EXT_CONTROLLER;
4664 sendf(plci->appl, _DATA_B3_R | CONFIRM, Id, data->Number,
4665 "ww", data->Handle, 0);
4666 }
4667 (ncci_ptr->data_out)++;
4668 if (ncci_ptr->data_out == MAX_DATA_B3)
4669 ncci_ptr->data_out = 0;
4670 (ncci_ptr->data_pending)--;
4671 }
4672 }
4673 }
4674 }
4675
4676 static void data_ack(PLCI *plci, byte ch)
4677 {
4678 dword Id;
4679 DIVA_CAPI_ADAPTER *a;
4680 NCCI *ncci_ptr;
4681 word ncci;
4682
4683 a = plci->adapter;
4684 ncci = a->ch_ncci[ch];
4685 ncci_ptr = &(a->ncci[ncci]);
4686 if (ncci_ptr->data_ack_pending)
4687 {
4688 if (a->ncci_state[ncci] && (a->ncci_plci[ncci] == plci->Id))
4689 {
4690 Id = (((dword)ncci) << 16) | ((word)plci->Id << 8) | a->Id;
4691 if (plci->tel) Id |= EXT_CONTROLLER;
4692 sendf(plci->appl, _DATA_B3_R | CONFIRM, Id, ncci_ptr->DataAck[ncci_ptr->data_ack_out].Number,
4693 "ww", ncci_ptr->DataAck[ncci_ptr->data_ack_out].Handle, 0);
4694 }
4695 (ncci_ptr->data_ack_out)++;
4696 if (ncci_ptr->data_ack_out == MAX_DATA_ACK)
4697 ncci_ptr->data_ack_out = 0;
4698 (ncci_ptr->data_ack_pending)--;
4699 }
4700 }
4701
4702 static void sig_ind(PLCI *plci)
4703 {
4704 dword x_Id;
4705 dword Id;
4706 dword rId;
4707 word i;
4708 word cip;
4709 dword cip_mask;
4710 byte *ie;
4711 DIVA_CAPI_ADAPTER *a;
4712 API_PARSE saved_parms[MAX_MSG_PARMS + 1];
4713 #define MAXPARMSIDS 31
4714 byte *parms[MAXPARMSIDS];
4715 byte *add_i[4];
4716 byte *multi_fac_parms[MAX_MULTI_IE];
4717 byte *multi_pi_parms[MAX_MULTI_IE];
4718 byte *multi_ssext_parms[MAX_MULTI_IE];
4719 byte *multi_CiPN_parms[MAX_MULTI_IE];
4720
4721 byte *multi_vswitch_parms[MAX_MULTI_IE];
4722
4723 byte ai_len;
4724 byte *esc_chi = "";
4725 byte *esc_law = "";
4726 byte *pty_cai = "";
4727 byte *esc_cr = "";
4728 byte *esc_profile = "";
4729
4730 byte facility[256];
4731 PLCI *tplci = NULL;
4732 byte chi[] = "\x02\x18\x01";
4733 byte voice_cai[] = "\x06\x14\x00\x00\x00\x00\x08";
4734 byte resume_cau[] = "\x05\x05\x00\x02\x00\x00";
4735 /* ESC_MSGTYPE must be the last but one message, a new IE has to be */
4736 /* included before the ESC_MSGTYPE and MAXPARMSIDS has to be incremented */
4737 /* SMSG is situated at the end because its 0 (for compatibility reasons */
4738 /* (see Info_Mask Bit 4, first IE. then the message type) */
4739 static const word parms_id[] =
4740 {MAXPARMSIDS, CPN, 0xff, DSA, OSA, BC, LLC, HLC, ESC_CAUSE, DSP, DT, CHA,
4741 UUI, CONG_RR, CONG_RNR, ESC_CHI, KEY, CHI, CAU, ESC_LAW,
4742 RDN, RDX, CONN_NR, RIN, NI, CAI, ESC_CR,
4743 CST, ESC_PROFILE, 0xff, ESC_MSGTYPE, SMSG};
4744 /* 14 FTY repl by ESC_CHI */
4745 /* 18 PI repl by ESC_LAW */
4746 /* removed OAD changed to 0xff for future use, OAD is multiIE now */
4747 static const word multi_fac_id[] = {1, FTY};
4748 static const word multi_pi_id[] = {1, PI};
4749 static const word multi_CiPN_id[] = {1, OAD};
4750 static const word multi_ssext_id[] = {1, ESC_SSEXT};
4751
4752 static const word multi_vswitch_id[] = {1, ESC_VSWITCH};
4753
4754 byte *cau;
4755 word ncci;
4756 byte SS_Ind[] = "\x05\x02\x00\x02\x00\x00"; /* Hold_Ind struct*/
4757 byte CF_Ind[] = "\x09\x02\x00\x06\x00\x00\x00\x00\x00\x00";
4758 byte Interr_Err_Ind[] = "\x0a\x02\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
4759 byte CONF_Ind[] = "\x09\x16\x00\x06\x00\x00\x00\x00\x00\x00";
4760 byte force_mt_info = false;
4761 byte dir;
4762 dword d;
4763 word w;
4764
4765 a = plci->adapter;
4766 Id = ((word)plci->Id << 8) | a->Id;
4767 PUT_WORD(&SS_Ind[4], 0x0000);
4768
4769 if (plci->sig_remove_id)
4770 {
4771 plci->Sig.RNR = 2; /* discard */
4772 dbug(1, dprintf("SIG discard while remove pending"));
4773 return;
4774 }
4775 if (plci->tel && plci->SuppState != CALL_HELD) Id |= EXT_CONTROLLER;
4776 dbug(1, dprintf("SigInd-Id=%08lx,plci=%x,tel=%x,state=0x%x,channels=%d,Discflowcl=%d",
4777 Id, plci->Id, plci->tel, plci->State, plci->channels, plci->hangup_flow_ctrl_timer));
4778 if (plci->Sig.Ind == CALL_HOLD_ACK && plci->channels)
4779 {
4780 plci->Sig.RNR = 1;
4781 return;
4782 }
4783 if (plci->Sig.Ind == HANGUP && plci->channels)
4784 {
4785 plci->Sig.RNR = 1;
4786 plci->hangup_flow_ctrl_timer++;
4787 /* recover the network layer after timeout */
4788 if (plci->hangup_flow_ctrl_timer == 100)
4789 {
4790 dbug(1, dprintf("Exceptional disc"));
4791 plci->Sig.RNR = 0;
4792 plci->hangup_flow_ctrl_timer = 0;
4793 for (ncci = 1; ncci < MAX_NCCI + 1; ncci++)
4794 {
4795 if (a->ncci_plci[ncci] == plci->Id)
4796 {
4797 cleanup_ncci_data(plci, ncci);
4798 if (plci->channels)plci->channels--;
4799 if (plci->appl)
4800 sendf(plci->appl, _DISCONNECT_B3_I, (((dword) ncci) << 16) | Id, 0, "ws", 0, "");
4801 }
4802 }
4803 if (plci->appl)
4804 sendf(plci->appl, _DISCONNECT_I, Id, 0, "w", 0);
4805 plci_remove(plci);
4806 plci->State = IDLE;
4807 }
4808 return;
4809 }
4810
4811 /* do first parse the info with no OAD in, because OAD will be converted */
4812 /* first the multiple facility IE, then mult. progress ind. */
4813 /* then the parameters for the info_ind + conn_ind */
4814 IndParse(plci, multi_fac_id, multi_fac_parms, MAX_MULTI_IE);
4815 IndParse(plci, multi_pi_id, multi_pi_parms, MAX_MULTI_IE);
4816 IndParse(plci, multi_ssext_id, multi_ssext_parms, MAX_MULTI_IE);
4817
4818 IndParse(plci, multi_vswitch_id, multi_vswitch_parms, MAX_MULTI_IE);
4819
4820 IndParse(plci, parms_id, parms, 0);
4821 IndParse(plci, multi_CiPN_id, multi_CiPN_parms, MAX_MULTI_IE);
4822 esc_chi = parms[14];
4823 esc_law = parms[18];
4824 pty_cai = parms[24];
4825 esc_cr = parms[25];
4826 esc_profile = parms[27];
4827 if (esc_cr[0] && plci)
4828 {
4829 if (plci->cr_enquiry && plci->appl)
4830 {
4831 plci->cr_enquiry = false;
4832 /* d = MANU_ID */
4833 /* w = m_command */
4834 /* b = total length */
4835 /* b = indication type */
4836 /* b = length of all IEs */
4837 /* b = IE1 */
4838 /* S = IE1 length + cont. */
4839 /* b = IE2 */
4840 /* S = IE2 length + cont. */
4841 sendf(plci->appl,
4842 _MANUFACTURER_I,
4843 Id,
4844 0,
4845 "dwbbbbSbS", _DI_MANU_ID, plci->m_command,
4846 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);
4847 }
4848 }
4849 /* create the additional info structure */
4850 add_i[1] = parms[15]; /* KEY of additional info */
4851 add_i[2] = parms[11]; /* UUI of additional info */
4852 ai_len = AddInfo(add_i, multi_fac_parms, esc_chi, facility);
4853
4854 /* the ESC_LAW indicates if u-Law or a-Law is actually used by the card */
4855 /* indication returns by the card if requested by the function */
4856 /* AutomaticLaw() after driver init */
4857 if (a->automatic_law < 4)
4858 {
4859 if (esc_law[0]) {
4860 if (esc_law[2]) {
4861 dbug(0, dprintf("u-Law selected"));
4862 a->u_law = 1;
4863 }
4864 else {
4865 dbug(0, dprintf("a-Law selected"));
4866 a->u_law = 0;
4867 }
4868 a->automatic_law = 4;
4869 if (plci == a->automatic_lawPLCI) {
4870 plci->internal_command = 0;
4871 sig_req(plci, REMOVE, 0);
4872 send_req(plci);
4873 a->automatic_lawPLCI = NULL;
4874 }
4875 }
4876 if (esc_profile[0])
4877 {
4878 dbug(1, dprintf("[%06x] CardProfile: %lx %lx %lx %lx %lx",
4879 UnMapController(a->Id), GET_DWORD(&esc_profile[6]),
4880 GET_DWORD(&esc_profile[10]), GET_DWORD(&esc_profile[14]),
4881 GET_DWORD(&esc_profile[18]), GET_DWORD(&esc_profile[46])));
4882
4883 a->profile.Global_Options &= 0x000000ffL;
4884 a->profile.B1_Protocols &= 0x000003ffL;
4885 a->profile.B2_Protocols &= 0x00001fdfL;
4886 a->profile.B3_Protocols &= 0x000000b7L;
4887
4888 a->profile.Global_Options &= GET_DWORD(&esc_profile[6]) |
4889 GL_BCHANNEL_OPERATION_SUPPORTED;
4890 a->profile.B1_Protocols &= GET_DWORD(&esc_profile[10]);
4891 a->profile.B2_Protocols &= GET_DWORD(&esc_profile[14]);
4892 a->profile.B3_Protocols &= GET_DWORD(&esc_profile[18]);
4893 a->manufacturer_features = GET_DWORD(&esc_profile[46]);
4894 a->man_profile.private_options = 0;
4895
4896 if (a->manufacturer_features & MANUFACTURER_FEATURE_ECHO_CANCELLER)
4897 {
4898 a->man_profile.private_options |= 1L << PRIVATE_ECHO_CANCELLER;
4899 a->profile.Global_Options |= GL_ECHO_CANCELLER_SUPPORTED;
4900 }
4901
4902
4903 if (a->manufacturer_features & MANUFACTURER_FEATURE_RTP)
4904 a->man_profile.private_options |= 1L << PRIVATE_RTP;
4905 a->man_profile.rtp_primary_payloads = GET_DWORD(&esc_profile[50]);
4906 a->man_profile.rtp_additional_payloads = GET_DWORD(&esc_profile[54]);
4907
4908
4909 if (a->manufacturer_features & MANUFACTURER_FEATURE_T38)
4910 a->man_profile.private_options |= 1L << PRIVATE_T38;
4911
4912
4913 if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_SUB_SEP_PWD)
4914 a->man_profile.private_options |= 1L << PRIVATE_FAX_SUB_SEP_PWD;
4915
4916
4917 if (a->manufacturer_features & MANUFACTURER_FEATURE_V18)
4918 a->man_profile.private_options |= 1L << PRIVATE_V18;
4919
4920
4921 if (a->manufacturer_features & MANUFACTURER_FEATURE_DTMF_TONE)
4922 a->man_profile.private_options |= 1L << PRIVATE_DTMF_TONE;
4923
4924
4925 if (a->manufacturer_features & MANUFACTURER_FEATURE_PIAFS)
4926 a->man_profile.private_options |= 1L << PRIVATE_PIAFS;
4927
4928
4929 if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
4930 a->man_profile.private_options |= 1L << PRIVATE_FAX_PAPER_FORMATS;
4931
4932
4933 if (a->manufacturer_features & MANUFACTURER_FEATURE_VOWN)
4934 a->man_profile.private_options |= 1L << PRIVATE_VOWN;
4935
4936
4937 if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_NONSTANDARD)
4938 a->man_profile.private_options |= 1L << PRIVATE_FAX_NONSTANDARD;
4939
4940 }
4941 else
4942 {
4943 a->profile.Global_Options &= 0x0000007fL;
4944 a->profile.B1_Protocols &= 0x000003dfL;
4945 a->profile.B2_Protocols &= 0x00001adfL;
4946 a->profile.B3_Protocols &= 0x000000b7L;
4947 a->manufacturer_features &= MANUFACTURER_FEATURE_HARDDTMF;
4948 }
4949 if (a->manufacturer_features & (MANUFACTURER_FEATURE_HARDDTMF |
4950 MANUFACTURER_FEATURE_SOFTDTMF_SEND | MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE))
4951 {
4952 a->profile.Global_Options |= GL_DTMF_SUPPORTED;
4953 }
4954 a->manufacturer_features &= ~MANUFACTURER_FEATURE_OOB_CHANNEL;
4955 dbug(1, dprintf("[%06x] Profile: %lx %lx %lx %lx %lx",
4956 UnMapController(a->Id), a->profile.Global_Options,
4957 a->profile.B1_Protocols, a->profile.B2_Protocols,
4958 a->profile.B3_Protocols, a->manufacturer_features));
4959 }
4960 /* codec plci for the handset/hook state support is just an internal id */
4961 if (plci != a->AdvCodecPLCI)
4962 {
4963 force_mt_info = SendMultiIE(plci, Id, multi_fac_parms, FTY, 0x20, 0);
4964 force_mt_info |= SendMultiIE(plci, Id, multi_pi_parms, PI, 0x210, 0);
4965 SendSSExtInd(NULL, plci, Id, multi_ssext_parms);
4966 SendInfo(plci, Id, parms, force_mt_info);
4967
4968 VSwitchReqInd(plci, Id, multi_vswitch_parms);
4969
4970 }
4971
4972 /* switch the codec to the b-channel */
4973 if (esc_chi[0] && plci && !plci->SuppState) {
4974 plci->b_channel = esc_chi[esc_chi[0]]&0x1f;
4975 mixer_set_bchannel_id_esc(plci, plci->b_channel);
4976 dbug(1, dprintf("storeChannel=0x%x", plci->b_channel));
4977 if (plci->tel == ADV_VOICE && plci->appl) {
4978 SetVoiceChannel(a->AdvCodecPLCI, esc_chi, a);
4979 }
4980 }
4981
4982 if (plci->appl) plci->appl->Number++;
4983
4984 switch (plci->Sig.Ind) {
4985 /* Response to Get_Supported_Services request */
4986 case S_SUPPORTED:
4987 dbug(1, dprintf("S_Supported"));
4988 if (!plci->appl) break;
4989 if (pty_cai[0] == 4)
4990 {
4991 PUT_DWORD(&CF_Ind[6], GET_DWORD(&pty_cai[1]));
4992 }
4993 else
4994 {
4995 PUT_DWORD(&CF_Ind[6], MASK_TERMINAL_PORTABILITY | MASK_HOLD_RETRIEVE);
4996 }
4997 PUT_WORD(&CF_Ind[1], 0);
4998 PUT_WORD(&CF_Ind[4], 0);
4999 sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0x7, plci->number, "wws", 0, 3, CF_Ind);
5000 plci_remove(plci);
5001 break;
5002
5003 /* Supplementary Service rejected */
5004 case S_SERVICE_REJ:
5005 dbug(1, dprintf("S_Reject=0x%x", pty_cai[5]));
5006 if (!pty_cai[0]) break;
5007 switch (pty_cai[5])
5008 {
5009 case ECT_EXECUTE:
5010 case THREE_PTY_END:
5011 case THREE_PTY_BEGIN:
5012 if (!plci->relatedPTYPLCI) break;
5013 tplci = plci->relatedPTYPLCI;
5014 rId = ((word)tplci->Id << 8) | tplci->adapter->Id;
5015 if (tplci->tel) rId |= EXT_CONTROLLER;
5016 if (pty_cai[5] == ECT_EXECUTE)
5017 {
5018 PUT_WORD(&SS_Ind[1], S_ECT);
5019
5020 plci->vswitchstate = 0;
5021 plci->relatedPTYPLCI->vswitchstate = 0;
5022
5023 }
5024 else
5025 {
5026 PUT_WORD(&SS_Ind[1], pty_cai[5] + 3);
5027 }
5028 if (pty_cai[2] != 0xff)
5029 {
5030 PUT_WORD(&SS_Ind[4], 0x3600 | (word)pty_cai[2]);
5031 }
5032 else
5033 {
5034 PUT_WORD(&SS_Ind[4], 0x300E);
5035 }
5036 plci->relatedPTYPLCI = NULL;
5037 plci->ptyState = 0;
5038 sendf(tplci->appl, _FACILITY_I, rId, 0, "ws", 3, SS_Ind);
5039 break;
5040
5041 case CALL_DEFLECTION:
5042 if (pty_cai[2] != 0xff)
5043 {
5044 PUT_WORD(&SS_Ind[4], 0x3600 | (word)pty_cai[2]);
5045 }
5046 else
5047 {
5048 PUT_WORD(&SS_Ind[4], 0x300E);
5049 }
5050 PUT_WORD(&SS_Ind[1], pty_cai[5]);
5051 for (i = 0; i < max_appl; i++)
5052 {
5053 if (application[i].CDEnable)
5054 {
5055 if (application[i].Id) sendf(&application[i], _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5056 application[i].CDEnable = false;
5057 }
5058 }
5059 break;
5060
5061 case DEACTIVATION_DIVERSION:
5062 case ACTIVATION_DIVERSION:
5063 case DIVERSION_INTERROGATE_CFU:
5064 case DIVERSION_INTERROGATE_CFB:
5065 case DIVERSION_INTERROGATE_CFNR:
5066 case DIVERSION_INTERROGATE_NUM:
5067 case CCBS_REQUEST:
5068 case CCBS_DEACTIVATE:
5069 case CCBS_INTERROGATE:
5070 if (!plci->appl) break;
5071 if (pty_cai[2] != 0xff)
5072 {
5073 PUT_WORD(&Interr_Err_Ind[4], 0x3600 | (word)pty_cai[2]);
5074 }
5075 else
5076 {
5077 PUT_WORD(&Interr_Err_Ind[4], 0x300E);
5078 }
5079 switch (pty_cai[5])
5080 {
5081 case DEACTIVATION_DIVERSION:
5082 dbug(1, dprintf("Deact_Div"));
5083 Interr_Err_Ind[0] = 0x9;
5084 Interr_Err_Ind[3] = 0x6;
5085 PUT_WORD(&Interr_Err_Ind[1], S_CALL_FORWARDING_STOP);
5086 break;
5087 case ACTIVATION_DIVERSION:
5088 dbug(1, dprintf("Act_Div"));
5089 Interr_Err_Ind[0] = 0x9;
5090 Interr_Err_Ind[3] = 0x6;
5091 PUT_WORD(&Interr_Err_Ind[1], S_CALL_FORWARDING_START);
5092 break;
5093 case DIVERSION_INTERROGATE_CFU:
5094 case DIVERSION_INTERROGATE_CFB:
5095 case DIVERSION_INTERROGATE_CFNR:
5096 dbug(1, dprintf("Interr_Div"));
5097 Interr_Err_Ind[0] = 0xa;
5098 Interr_Err_Ind[3] = 0x7;
5099 PUT_WORD(&Interr_Err_Ind[1], S_INTERROGATE_DIVERSION);
5100 break;
5101 case DIVERSION_INTERROGATE_NUM:
5102 dbug(1, dprintf("Interr_Num"));
5103 Interr_Err_Ind[0] = 0xa;
5104 Interr_Err_Ind[3] = 0x7;
5105 PUT_WORD(&Interr_Err_Ind[1], S_INTERROGATE_NUMBERS);
5106 break;
5107 case CCBS_REQUEST:
5108 dbug(1, dprintf("CCBS Request"));
5109 Interr_Err_Ind[0] = 0xd;
5110 Interr_Err_Ind[3] = 0xa;
5111 PUT_WORD(&Interr_Err_Ind[1], S_CCBS_REQUEST);
5112 break;
5113 case CCBS_DEACTIVATE:
5114 dbug(1, dprintf("CCBS Deactivate"));
5115 Interr_Err_Ind[0] = 0x9;
5116 Interr_Err_Ind[3] = 0x6;
5117 PUT_WORD(&Interr_Err_Ind[1], S_CCBS_DEACTIVATE);
5118 break;
5119 case CCBS_INTERROGATE:
5120 dbug(1, dprintf("CCBS Interrogate"));
5121 Interr_Err_Ind[0] = 0xb;
5122 Interr_Err_Ind[3] = 0x8;
5123 PUT_WORD(&Interr_Err_Ind[1], S_CCBS_INTERROGATE);
5124 break;
5125 }
5126 PUT_DWORD(&Interr_Err_Ind[6], plci->appl->S_Handle);
5127 sendf(plci->appl, _FACILITY_I, Id & 0x7, 0, "ws", 3, Interr_Err_Ind);
5128 plci_remove(plci);
5129 break;
5130 case ACTIVATION_MWI:
5131 case DEACTIVATION_MWI:
5132 if (pty_cai[5] == ACTIVATION_MWI)
5133 {
5134 PUT_WORD(&SS_Ind[1], S_MWI_ACTIVATE);
5135 }
5136 else PUT_WORD(&SS_Ind[1], S_MWI_DEACTIVATE);
5137
5138 if (pty_cai[2] != 0xff)
5139 {
5140 PUT_WORD(&SS_Ind[4], 0x3600 | (word)pty_cai[2]);
5141 }
5142 else
5143 {
5144 PUT_WORD(&SS_Ind[4], 0x300E);
5145 }
5146
5147 if (plci->cr_enquiry)
5148 {
5149 sendf(plci->appl, _FACILITY_I, Id & 0xf, 0, "ws", 3, SS_Ind);
5150 plci_remove(plci);
5151 }
5152 else
5153 {
5154 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5155 }
5156 break;
5157 case CONF_ADD: /* ERROR */
5158 case CONF_BEGIN:
5159 case CONF_DROP:
5160 case CONF_ISOLATE:
5161 case CONF_REATTACH:
5162 CONF_Ind[0] = 9;
5163 CONF_Ind[3] = 6;
5164 switch (pty_cai[5])
5165 {
5166 case CONF_BEGIN:
5167 PUT_WORD(&CONF_Ind[1], S_CONF_BEGIN);
5168 plci->ptyState = 0;
5169 break;
5170 case CONF_DROP:
5171 CONF_Ind[0] = 5;
5172 CONF_Ind[3] = 2;
5173 PUT_WORD(&CONF_Ind[1], S_CONF_DROP);
5174 plci->ptyState = CONNECTED;
5175 break;
5176 case CONF_ISOLATE:
5177 CONF_Ind[0] = 5;
5178 CONF_Ind[3] = 2;
5179 PUT_WORD(&CONF_Ind[1], S_CONF_ISOLATE);
5180 plci->ptyState = CONNECTED;
5181 break;
5182 case CONF_REATTACH:
5183 CONF_Ind[0] = 5;
5184 CONF_Ind[3] = 2;
5185 PUT_WORD(&CONF_Ind[1], S_CONF_REATTACH);
5186 plci->ptyState = CONNECTED;
5187 break;
5188 case CONF_ADD:
5189 PUT_WORD(&CONF_Ind[1], S_CONF_ADD);
5190 plci->relatedPTYPLCI = NULL;
5191 tplci = plci->relatedPTYPLCI;
5192 if (tplci) tplci->ptyState = CONNECTED;
5193 plci->ptyState = CONNECTED;
5194 break;
5195 }
5196
5197 if (pty_cai[2] != 0xff)
5198 {
5199 PUT_WORD(&CONF_Ind[4], 0x3600 | (word)pty_cai[2]);
5200 }
5201 else
5202 {
5203 PUT_WORD(&CONF_Ind[4], 0x3303); /* Time-out: network did not respond
5204 within the required time */
5205 }
5206
5207 PUT_DWORD(&CONF_Ind[6], 0x0);
5208 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, CONF_Ind);
5209 break;
5210 }
5211 break;
5212
5213 /* Supplementary Service indicates success */
5214 case S_SERVICE:
5215 dbug(1, dprintf("Service_Ind"));
5216 PUT_WORD(&CF_Ind[4], 0);
5217 switch (pty_cai[5])
5218 {
5219 case THREE_PTY_END:
5220 case THREE_PTY_BEGIN:
5221 case ECT_EXECUTE:
5222 if (!plci->relatedPTYPLCI) break;
5223 tplci = plci->relatedPTYPLCI;
5224 rId = ((word)tplci->Id << 8) | tplci->adapter->Id;
5225 if (tplci->tel) rId |= EXT_CONTROLLER;
5226 if (pty_cai[5] == ECT_EXECUTE)
5227 {
5228 PUT_WORD(&SS_Ind[1], S_ECT);
5229
5230 if (plci->vswitchstate != 3)
5231 {
5232
5233 plci->ptyState = IDLE;
5234 plci->relatedPTYPLCI = NULL;
5235 plci->ptyState = 0;
5236
5237 }
5238
5239 dbug(1, dprintf("ECT OK"));
5240 sendf(tplci->appl, _FACILITY_I, rId, 0, "ws", 3, SS_Ind);
5241
5242
5243
5244 }
5245 else
5246 {
5247 switch (plci->ptyState)
5248 {
5249 case S_3PTY_BEGIN:
5250 plci->ptyState = CONNECTED;
5251 dbug(1, dprintf("3PTY ON"));
5252 break;
5253
5254 case S_3PTY_END:
5255 plci->ptyState = IDLE;
5256 plci->relatedPTYPLCI = NULL;
5257 plci->ptyState = 0;
5258 dbug(1, dprintf("3PTY OFF"));
5259 break;
5260 }
5261 PUT_WORD(&SS_Ind[1], pty_cai[5] + 3);
5262 sendf(tplci->appl, _FACILITY_I, rId, 0, "ws", 3, SS_Ind);
5263 }
5264 break;
5265
5266 case CALL_DEFLECTION:
5267 PUT_WORD(&SS_Ind[1], pty_cai[5]);
5268 for (i = 0; i < max_appl; i++)
5269 {
5270 if (application[i].CDEnable)
5271 {
5272 if (application[i].Id) sendf(&application[i], _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5273 application[i].CDEnable = false;
5274 }
5275 }
5276 break;
5277
5278 case DEACTIVATION_DIVERSION:
5279 case ACTIVATION_DIVERSION:
5280 if (!plci->appl) break;
5281 PUT_WORD(&CF_Ind[1], pty_cai[5] + 2);
5282 PUT_DWORD(&CF_Ind[6], plci->appl->S_Handle);
5283 sendf(plci->appl, _FACILITY_I, Id & 0x7, 0, "ws", 3, CF_Ind);
5284 plci_remove(plci);
5285 break;
5286
5287 case DIVERSION_INTERROGATE_CFU:
5288 case DIVERSION_INTERROGATE_CFB:
5289 case DIVERSION_INTERROGATE_CFNR:
5290 case DIVERSION_INTERROGATE_NUM:
5291 case CCBS_REQUEST:
5292 case CCBS_DEACTIVATE:
5293 case CCBS_INTERROGATE:
5294 if (!plci->appl) break;
5295 switch (pty_cai[5])
5296 {
5297 case DIVERSION_INTERROGATE_CFU:
5298 case DIVERSION_INTERROGATE_CFB:
5299 case DIVERSION_INTERROGATE_CFNR:
5300 dbug(1, dprintf("Interr_Div"));
5301 PUT_WORD(&pty_cai[1], S_INTERROGATE_DIVERSION);
5302 pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
5303 break;
5304 case DIVERSION_INTERROGATE_NUM:
5305 dbug(1, dprintf("Interr_Num"));
5306 PUT_WORD(&pty_cai[1], S_INTERROGATE_NUMBERS);
5307 pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
5308 break;
5309 case CCBS_REQUEST:
5310 dbug(1, dprintf("CCBS Request"));
5311 PUT_WORD(&pty_cai[1], S_CCBS_REQUEST);
5312 pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
5313 break;
5314 case CCBS_DEACTIVATE:
5315 dbug(1, dprintf("CCBS Deactivate"));
5316 PUT_WORD(&pty_cai[1], S_CCBS_DEACTIVATE);
5317 pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
5318 break;
5319 case CCBS_INTERROGATE:
5320 dbug(1, dprintf("CCBS Interrogate"));
5321 PUT_WORD(&pty_cai[1], S_CCBS_INTERROGATE);
5322 pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
5323 break;
5324 }
5325 PUT_WORD(&pty_cai[4], 0); /* Supplementary Service Reason */
5326 PUT_DWORD(&pty_cai[6], plci->appl->S_Handle);
5327 sendf(plci->appl, _FACILITY_I, Id & 0x7, 0, "wS", 3, pty_cai);
5328 plci_remove(plci);
5329 break;
5330
5331 case ACTIVATION_MWI:
5332 case DEACTIVATION_MWI:
5333 if (pty_cai[5] == ACTIVATION_MWI)
5334 {
5335 PUT_WORD(&SS_Ind[1], S_MWI_ACTIVATE);
5336 }
5337 else PUT_WORD(&SS_Ind[1], S_MWI_DEACTIVATE);
5338 if (plci->cr_enquiry)
5339 {
5340 sendf(plci->appl, _FACILITY_I, Id & 0xf, 0, "ws", 3, SS_Ind);
5341 plci_remove(plci);
5342 }
5343 else
5344 {
5345 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5346 }
5347 break;
5348 case MWI_INDICATION:
5349 if (pty_cai[0] >= 0x12)
5350 {
5351 PUT_WORD(&pty_cai[3], S_MWI_INDICATE);
5352 pty_cai[2] = pty_cai[0] - 2; /* len Parameter */
5353 pty_cai[5] = pty_cai[0] - 5; /* Supplementary Service-specific parameter len */
5354 if (plci->appl && (a->Notification_Mask[plci->appl->Id - 1] & SMASK_MWI))
5355 {
5356 if (plci->internal_command == GET_MWI_STATE) /* result on Message Waiting Listen */
5357 {
5358 sendf(plci->appl, _FACILITY_I, Id & 0xf, 0, "wS", 3, &pty_cai[2]);
5359 plci_remove(plci);
5360 return;
5361 }
5362 else sendf(plci->appl, _FACILITY_I, Id, 0, "wS", 3, &pty_cai[2]);
5363 pty_cai[0] = 0;
5364 }
5365 else
5366 {
5367 for (i = 0; i < max_appl; i++)
5368 {
5369 if (a->Notification_Mask[i]&SMASK_MWI)
5370 {
5371 sendf(&application[i], _FACILITY_I, Id & 0x7, 0, "wS", 3, &pty_cai[2]);
5372 pty_cai[0] = 0;
5373 }
5374 }
5375 }
5376
5377 if (!pty_cai[0])
5378 { /* acknowledge */
5379 facility[2] = 0; /* returncode */
5380 }
5381 else facility[2] = 0xff;
5382 }
5383 else
5384 {
5385 /* reject */
5386 facility[2] = 0xff; /* returncode */
5387 }
5388 facility[0] = 2;
5389 facility[1] = MWI_RESPONSE; /* Function */
5390 add_p(plci, CAI, facility);
5391 add_p(plci, ESC, multi_ssext_parms[0]); /* remembered parameter -> only one possible */
5392 sig_req(plci, S_SERVICE, 0);
5393 send_req(plci);
5394 plci->command = 0;
5395 next_internal_command(Id, plci);
5396 break;
5397 case CONF_ADD: /* OK */
5398 case CONF_BEGIN:
5399 case CONF_DROP:
5400 case CONF_ISOLATE:
5401 case CONF_REATTACH:
5402 case CONF_PARTYDISC:
5403 CONF_Ind[0] = 9;
5404 CONF_Ind[3] = 6;
5405 switch (pty_cai[5])
5406 {
5407 case CONF_BEGIN:
5408 PUT_WORD(&CONF_Ind[1], S_CONF_BEGIN);
5409 if (pty_cai[0] == 6)
5410 {
5411 d = pty_cai[6];
5412 PUT_DWORD(&CONF_Ind[6], d); /* PartyID */
5413 }
5414 else
5415 {
5416 PUT_DWORD(&CONF_Ind[6], 0x0);
5417 }
5418 break;
5419 case CONF_ISOLATE:
5420 PUT_WORD(&CONF_Ind[1], S_CONF_ISOLATE);
5421 CONF_Ind[0] = 5;
5422 CONF_Ind[3] = 2;
5423 break;
5424 case CONF_REATTACH:
5425 PUT_WORD(&CONF_Ind[1], S_CONF_REATTACH);
5426 CONF_Ind[0] = 5;
5427 CONF_Ind[3] = 2;
5428 break;
5429 case CONF_DROP:
5430 PUT_WORD(&CONF_Ind[1], S_CONF_DROP);
5431 CONF_Ind[0] = 5;
5432 CONF_Ind[3] = 2;
5433 break;
5434 case CONF_ADD:
5435 PUT_WORD(&CONF_Ind[1], S_CONF_ADD);
5436 d = pty_cai[6];
5437 PUT_DWORD(&CONF_Ind[6], d); /* PartyID */
5438 tplci = plci->relatedPTYPLCI;
5439 if (tplci) tplci->ptyState = CONNECTED;
5440 break;
5441 case CONF_PARTYDISC:
5442 CONF_Ind[0] = 7;
5443 CONF_Ind[3] = 4;
5444 PUT_WORD(&CONF_Ind[1], S_CONF_PARTYDISC);
5445 d = pty_cai[6];
5446 PUT_DWORD(&CONF_Ind[4], d); /* PartyID */
5447 break;
5448 }
5449 plci->ptyState = CONNECTED;
5450 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, CONF_Ind);
5451 break;
5452 case CCBS_INFO_RETAIN:
5453 case CCBS_ERASECALLLINKAGEID:
5454 case CCBS_STOP_ALERTING:
5455 CONF_Ind[0] = 5;
5456 CONF_Ind[3] = 2;
5457 switch (pty_cai[5])
5458 {
5459 case CCBS_INFO_RETAIN:
5460 PUT_WORD(&CONF_Ind[1], S_CCBS_INFO_RETAIN);
5461 break;
5462 case CCBS_STOP_ALERTING:
5463 PUT_WORD(&CONF_Ind[1], S_CCBS_STOP_ALERTING);
5464 break;
5465 case CCBS_ERASECALLLINKAGEID:
5466 PUT_WORD(&CONF_Ind[1], S_CCBS_ERASECALLLINKAGEID);
5467 CONF_Ind[0] = 7;
5468 CONF_Ind[3] = 4;
5469 CONF_Ind[6] = 0;
5470 CONF_Ind[7] = 0;
5471 break;
5472 }
5473 w = pty_cai[6];
5474 PUT_WORD(&CONF_Ind[4], w); /* PartyID */
5475
5476 if (plci->appl && (a->Notification_Mask[plci->appl->Id - 1] & SMASK_CCBS))
5477 {
5478 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, CONF_Ind);
5479 }
5480 else
5481 {
5482 for (i = 0; i < max_appl; i++)
5483 if (a->Notification_Mask[i] & SMASK_CCBS)
5484 sendf(&application[i], _FACILITY_I, Id & 0x7, 0, "ws", 3, CONF_Ind);
5485 }
5486 break;
5487 }
5488 break;
5489 case CALL_HOLD_REJ:
5490 cau = parms[7];
5491 if (cau)
5492 {
5493 i = _L3_CAUSE | cau[2];
5494 if (cau[2] == 0) i = 0x3603;
5495 }
5496 else
5497 {
5498 i = 0x3603;
5499 }
5500 PUT_WORD(&SS_Ind[1], S_HOLD);
5501 PUT_WORD(&SS_Ind[4], i);
5502 if (plci->SuppState == HOLD_REQUEST)
5503 {
5504 plci->SuppState = IDLE;
5505 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5506 }
5507 break;
5508
5509 case CALL_HOLD_ACK:
5510 if (plci->SuppState == HOLD_REQUEST)
5511 {
5512 plci->SuppState = CALL_HELD;
5513 CodecIdCheck(a, plci);
5514 start_internal_command(Id, plci, hold_save_command);
5515 }
5516 break;
5517
5518 case CALL_RETRIEVE_REJ:
5519 cau = parms[7];
5520 if (cau)
5521 {
5522 i = _L3_CAUSE | cau[2];
5523 if (cau[2] == 0) i = 0x3603;
5524 }
5525 else
5526 {
5527 i = 0x3603;
5528 }
5529 PUT_WORD(&SS_Ind[1], S_RETRIEVE);
5530 PUT_WORD(&SS_Ind[4], i);
5531 if (plci->SuppState == RETRIEVE_REQUEST)
5532 {
5533 plci->SuppState = CALL_HELD;
5534 CodecIdCheck(a, plci);
5535 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5536 }
5537 break;
5538
5539 case CALL_RETRIEVE_ACK:
5540 PUT_WORD(&SS_Ind[1], S_RETRIEVE);
5541 if (plci->SuppState == RETRIEVE_REQUEST)
5542 {
5543 plci->SuppState = IDLE;
5544 plci->call_dir |= CALL_DIR_FORCE_OUTG_NL;
5545 plci->b_channel = esc_chi[esc_chi[0]]&0x1f;
5546 if (plci->tel)
5547 {
5548 mixer_set_bchannel_id_esc(plci, plci->b_channel);
5549 dbug(1, dprintf("RetrChannel=0x%x", plci->b_channel));
5550 SetVoiceChannel(a->AdvCodecPLCI, esc_chi, a);
5551 if (plci->B2_prot == B2_TRANSPARENT && plci->B3_prot == B3_TRANSPARENT)
5552 {
5553 dbug(1, dprintf("Get B-ch"));
5554 start_internal_command(Id, plci, retrieve_restore_command);
5555 }
5556 else
5557 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5558 }
5559 else
5560 start_internal_command(Id, plci, retrieve_restore_command);
5561 }
5562 break;
5563
5564 case INDICATE_IND:
5565 if (plci->State != LISTENING) {
5566 sig_req(plci, HANGUP, 0);
5567 send_req(plci);
5568 break;
5569 }
5570 cip = find_cip(a, parms[4], parms[6]);
5571 cip_mask = 1L << cip;
5572 dbug(1, dprintf("cip=%d,cip_mask=%lx", cip, cip_mask));
5573 bitmap_zero(plci->c_ind_mask_table, MAX_APPL);
5574 if (!remove_started && !a->adapter_disabled)
5575 {
5576 group_optimization(a, plci);
5577 for_each_set_bit(i, plci->group_optimization_mask_table, max_appl) {
5578 if (application[i].Id
5579 && (a->CIP_Mask[i] & 1 || a->CIP_Mask[i] & cip_mask)
5580 && CPN_filter_ok(parms[0], a, i)) {
5581 dbug(1, dprintf("storedcip_mask[%d]=0x%lx", i, a->CIP_Mask[i]));
5582 __set_bit(i, plci->c_ind_mask_table);
5583 dbug(1, dprintf("c_ind_mask =%*pb", MAX_APPL, plci->c_ind_mask_table));
5584 plci->State = INC_CON_PENDING;
5585 plci->call_dir = (plci->call_dir & ~(CALL_DIR_OUT | CALL_DIR_ORIGINATE)) |
5586 CALL_DIR_IN | CALL_DIR_ANSWER;
5587 if (esc_chi[0]) {
5588 plci->b_channel = esc_chi[esc_chi[0]] & 0x1f;
5589 mixer_set_bchannel_id_esc(plci, plci->b_channel);
5590 }
5591 /* if a listen on the ext controller is done, check if hook states */
5592 /* are supported or if just a on board codec must be activated */
5593 if (a->codec_listen[i] && !a->AdvSignalPLCI) {
5594 if (a->profile.Global_Options & HANDSET)
5595 plci->tel = ADV_VOICE;
5596 else if (a->profile.Global_Options & ON_BOARD_CODEC)
5597 plci->tel = CODEC;
5598 if (plci->tel) Id |= EXT_CONTROLLER;
5599 a->codec_listen[i] = plci;
5600 }
5601
5602 sendf(&application[i], _CONNECT_I, Id, 0,
5603 "wSSSSSSSbSSSSS", cip, /* CIP */
5604 parms[0], /* CalledPartyNumber */
5605 multi_CiPN_parms[0], /* CallingPartyNumber */
5606 parms[2], /* CalledPartySubad */
5607 parms[3], /* CallingPartySubad */
5608 parms[4], /* BearerCapability */
5609 parms[5], /* LowLC */
5610 parms[6], /* HighLC */
5611 ai_len, /* nested struct add_i */
5612 add_i[0], /* B channel info */
5613 add_i[1], /* keypad facility */
5614 add_i[2], /* user user data */
5615 add_i[3], /* nested facility */
5616 multi_CiPN_parms[1] /* second CiPN(SCR) */
5617 );
5618 SendSSExtInd(&application[i],
5619 plci,
5620 Id,
5621 multi_ssext_parms);
5622 SendSetupInfo(&application[i],
5623 plci,
5624 Id,
5625 parms,
5626 SendMultiIE(plci, Id, multi_pi_parms, PI, 0x210, true));
5627 }
5628 }
5629 dbug(1, dprintf("c_ind_mask =%*pb", MAX_APPL, plci->c_ind_mask_table));
5630 }
5631 if (bitmap_empty(plci->c_ind_mask_table, MAX_APPL)) {
5632 sig_req(plci, HANGUP, 0);
5633 send_req(plci);
5634 plci->State = IDLE;
5635 }
5636 plci->notifiedcall = 0;
5637 a->listen_active--;
5638 listen_check(a);
5639 break;
5640
5641 case CALL_PEND_NOTIFY:
5642 plci->notifiedcall = 1;
5643 listen_check(a);
5644 break;
5645
5646 case CALL_IND:
5647 case CALL_CON:
5648 if (plci->State == ADVANCED_VOICE_SIG || plci->State == ADVANCED_VOICE_NOSIG)
5649 {
5650 if (plci->internal_command == PERM_COD_CONN_PEND)
5651 {
5652 if (plci->State == ADVANCED_VOICE_NOSIG)
5653 {
5654 dbug(1, dprintf("***Codec OK"));
5655 if (a->AdvSignalPLCI)
5656 {
5657 tplci = a->AdvSignalPLCI;
5658 if (tplci->spoofed_msg)
5659 {
5660 dbug(1, dprintf("***Spoofed Msg(0x%x)", tplci->spoofed_msg));
5661 tplci->command = 0;
5662 tplci->internal_command = 0;
5663 x_Id = ((word)tplci->Id << 8) | tplci->adapter->Id | 0x80;
5664 switch (tplci->spoofed_msg)
5665 {
5666 case CALL_RES:
5667 tplci->command = _CONNECT_I | RESPONSE;
5668 api_load_msg(&tplci->saved_msg, saved_parms);
5669 add_b1(tplci, &saved_parms[1], 0, tplci->B1_facilities);
5670 if (tplci->adapter->Info_Mask[tplci->appl->Id - 1] & 0x200)
5671 {
5672 /* early B3 connect (CIP mask bit 9) no release after a disc */
5673 add_p(tplci, LLI, "\x01\x01");
5674 }
5675 add_s(tplci, CONN_NR, &saved_parms[2]);
5676 add_s(tplci, LLC, &saved_parms[4]);
5677 add_ai(tplci, &saved_parms[5]);
5678 tplci->State = INC_CON_ACCEPT;
5679 sig_req(tplci, CALL_RES, 0);
5680 send_req(tplci);
5681 break;
5682
5683 case AWAITING_SELECT_B:
5684 dbug(1, dprintf("Select_B continue"));
5685 start_internal_command(x_Id, tplci, select_b_command);
5686 break;
5687
5688 case AWAITING_MANUF_CON: /* Get_Plci per Manufacturer_Req to ext controller */
5689 if (!tplci->Sig.Id)
5690 {
5691 dbug(1, dprintf("No SigID!"));
5692 sendf(tplci->appl, _MANUFACTURER_R | CONFIRM, x_Id, tplci->number, "dww", _DI_MANU_ID, _MANUFACTURER_R, _OUT_OF_PLCI);
5693 plci_remove(tplci);
5694 break;
5695 }
5696 tplci->command = _MANUFACTURER_R;
5697 api_load_msg(&tplci->saved_msg, saved_parms);
5698 dir = saved_parms[2].info[0];
5699 if (dir == 1) {
5700 sig_req(tplci, CALL_REQ, 0);
5701 }
5702 else if (!dir) {
5703 sig_req(tplci, LISTEN_REQ, 0);
5704 }
5705 send_req(tplci);
5706 sendf(tplci->appl, _MANUFACTURER_R | CONFIRM, x_Id, tplci->number, "dww", _DI_MANU_ID, _MANUFACTURER_R, 0);
5707 break;
5708
5709 case (CALL_REQ | AWAITING_MANUF_CON):
5710 sig_req(tplci, CALL_REQ, 0);
5711 send_req(tplci);
5712 break;
5713
5714 case CALL_REQ:
5715 if (!tplci->Sig.Id)
5716 {
5717 dbug(1, dprintf("No SigID!"));
5718 sendf(tplci->appl, _CONNECT_R | CONFIRM, tplci->adapter->Id, 0, "w", _OUT_OF_PLCI);
5719 plci_remove(tplci);
5720 break;
5721 }
5722 tplci->command = _CONNECT_R;
5723 api_load_msg(&tplci->saved_msg, saved_parms);
5724 add_s(tplci, CPN, &saved_parms[1]);
5725 add_s(tplci, DSA, &saved_parms[3]);
5726 add_ai(tplci, &saved_parms[9]);
5727 sig_req(tplci, CALL_REQ, 0);
5728 send_req(tplci);
5729 break;
5730
5731 case CALL_RETRIEVE:
5732 tplci->command = C_RETRIEVE_REQ;
5733 sig_req(tplci, CALL_RETRIEVE, 0);
5734 send_req(tplci);
5735 break;
5736 }
5737 tplci->spoofed_msg = 0;
5738 if (tplci->internal_command == 0)
5739 next_internal_command(x_Id, tplci);
5740 }
5741 }
5742 next_internal_command(Id, plci);
5743 break;
5744 }
5745 dbug(1, dprintf("***Codec Hook Init Req"));
5746 plci->internal_command = PERM_COD_HOOK;
5747 add_p(plci, FTY, "\x01\x09"); /* Get Hook State*/
5748 sig_req(plci, TEL_CTRL, 0);
5749 send_req(plci);
5750 }
5751 }
5752 else if (plci->command != _MANUFACTURER_R /* old style permanent connect */
5753 && plci->State != INC_ACT_PENDING)
5754 {
5755 mixer_set_bchannel_id_esc(plci, plci->b_channel);
5756 if (plci->tel == ADV_VOICE && plci->SuppState == IDLE) /* with permanent codec switch on immediately */
5757 {
5758 chi[2] = plci->b_channel;
5759 SetVoiceChannel(a->AdvCodecPLCI, chi, a);
5760 }
5761 sendf(plci->appl, _CONNECT_ACTIVE_I, Id, 0, "Sss", parms[21], "", "");
5762 plci->State = INC_ACT_PENDING;
5763 }
5764 break;
5765
5766 case TEL_CTRL:
5767 ie = multi_fac_parms[0]; /* inspect the facility hook indications */
5768 if (plci->State == ADVANCED_VOICE_SIG && ie[0]) {
5769 switch (ie[1] & 0x91) {
5770 case 0x80: /* hook off */
5771 case 0x81:
5772 if (plci->internal_command == PERM_COD_HOOK)
5773 {
5774 dbug(1, dprintf("init:hook_off"));
5775 plci->hook_state = ie[1];
5776 next_internal_command(Id, plci);
5777 break;
5778 }
5779 else /* ignore doubled hook indications */
5780 {
5781 if (((plci->hook_state) & 0xf0) == 0x80)
5782 {
5783 dbug(1, dprintf("ignore hook"));
5784 break;
5785 }
5786 plci->hook_state = ie[1]&0x91;
5787 }
5788 /* check for incoming call pending */
5789 /* and signal '+'.Appl must decide */
5790 /* with connect_res if call must */
5791 /* accepted or not */
5792 for (i = 0, tplci = NULL; i < max_appl; i++) {
5793 if (a->codec_listen[i]
5794 && (a->codec_listen[i]->State == INC_CON_PENDING
5795 || a->codec_listen[i]->State == INC_CON_ALERT)) {
5796 tplci = a->codec_listen[i];
5797 tplci->appl = &application[i];
5798 }
5799 }
5800 /* no incoming call, do outgoing call */
5801 /* and signal '+' if outg. setup */
5802 if (!a->AdvSignalPLCI && !tplci) {
5803 if ((i = get_plci(a))) {
5804 a->AdvSignalPLCI = &a->plci[i - 1];
5805 tplci = a->AdvSignalPLCI;
5806 tplci->tel = ADV_VOICE;
5807 PUT_WORD(&voice_cai[5], a->AdvSignalAppl->MaxDataLength);
5808 if (a->Info_Mask[a->AdvSignalAppl->Id - 1] & 0x200) {
5809 /* early B3 connect (CIP mask bit 9) no release after a disc */
5810 add_p(tplci, LLI, "\x01\x01");
5811 }
5812 add_p(tplci, CAI, voice_cai);
5813 add_p(tplci, OAD, a->TelOAD);
5814 add_p(tplci, OSA, a->TelOSA);
5815 add_p(tplci, SHIFT | 6, NULL);
5816 add_p(tplci, SIN, "\x02\x01\x00");
5817 add_p(tplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
5818 sig_req(tplci, ASSIGN, DSIG_ID);
5819 a->AdvSignalPLCI->internal_command = HOOK_OFF_REQ;
5820 a->AdvSignalPLCI->command = 0;
5821 tplci->appl = a->AdvSignalAppl;
5822 tplci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
5823 send_req(tplci);
5824 }
5825
5826 }
5827
5828 if (!tplci) break;
5829 Id = ((word)tplci->Id << 8) | a->Id;
5830 Id |= EXT_CONTROLLER;
5831 sendf(tplci->appl,
5832 _FACILITY_I,
5833 Id,
5834 0,
5835 "ws", (word)0, "\x01+");
5836 break;
5837
5838 case 0x90: /* hook on */
5839 case 0x91:
5840 if (plci->internal_command == PERM_COD_HOOK)
5841 {
5842 dbug(1, dprintf("init:hook_on"));
5843 plci->hook_state = ie[1] & 0x91;
5844 next_internal_command(Id, plci);
5845 break;
5846 }
5847 else /* ignore doubled hook indications */
5848 {
5849 if (((plci->hook_state) & 0xf0) == 0x90) break;
5850 plci->hook_state = ie[1] & 0x91;
5851 }
5852 /* hangup the adv. voice call and signal '-' to the appl */
5853 if (a->AdvSignalPLCI) {
5854 Id = ((word)a->AdvSignalPLCI->Id << 8) | a->Id;
5855 if (plci->tel) Id |= EXT_CONTROLLER;
5856 sendf(a->AdvSignalAppl,
5857 _FACILITY_I,
5858 Id,
5859 0,
5860 "ws", (word)0, "\x01-");
5861 a->AdvSignalPLCI->internal_command = HOOK_ON_REQ;
5862 a->AdvSignalPLCI->command = 0;
5863 sig_req(a->AdvSignalPLCI, HANGUP, 0);
5864 send_req(a->AdvSignalPLCI);
5865 }
5866 break;
5867 }
5868 }
5869 break;
5870
5871 case RESUME:
5872 __clear_bit(plci->appl->Id - 1, plci->c_ind_mask_table);
5873 PUT_WORD(&resume_cau[4], GOOD);
5874 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", (word)3, resume_cau);
5875 break;
5876
5877 case SUSPEND:
5878 bitmap_zero(plci->c_ind_mask_table, MAX_APPL);
5879
5880 if (plci->NL.Id && !plci->nl_remove_id) {
5881 mixer_remove(plci);
5882 nl_req_ncci(plci, REMOVE, 0);
5883 }
5884 if (!plci->sig_remove_id) {
5885 plci->internal_command = 0;
5886 sig_req(plci, REMOVE, 0);
5887 }
5888 send_req(plci);
5889 if (!plci->channels) {
5890 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", (word)3, "\x05\x04\x00\x02\x00\x00");
5891 sendf(plci->appl, _DISCONNECT_I, Id, 0, "w", 0);
5892 }
5893 break;
5894
5895 case SUSPEND_REJ:
5896 break;
5897
5898 case HANGUP:
5899 plci->hangup_flow_ctrl_timer = 0;
5900 if (plci->manufacturer && plci->State == LOCAL_CONNECT) break;
5901 cau = parms[7];
5902 if (cau) {
5903 i = _L3_CAUSE | cau[2];
5904 if (cau[2] == 0) i = 0;
5905 else if (cau[2] == 8) i = _L1_ERROR;
5906 else if (cau[2] == 9 || cau[2] == 10) i = _L2_ERROR;
5907 else if (cau[2] == 5) i = _CAPI_GUARD_ERROR;
5908 }
5909 else {
5910 i = _L3_ERROR;
5911 }
5912
5913 if (plci->State == INC_CON_PENDING || plci->State == INC_CON_ALERT)
5914 {
5915 for_each_set_bit(i, plci->c_ind_mask_table, max_appl)
5916 sendf(&application[i], _DISCONNECT_I, Id, 0, "w", 0);
5917 }
5918 else
5919 {
5920 bitmap_zero(plci->c_ind_mask_table, MAX_APPL);
5921 }
5922 if (!plci->appl)
5923 {
5924 if (plci->State == LISTENING)
5925 {
5926 plci->notifiedcall = 0;
5927 a->listen_active--;
5928 }
5929 plci->State = INC_DIS_PENDING;
5930 if (bitmap_empty(plci->c_ind_mask_table, MAX_APPL))
5931 {
5932 plci->State = IDLE;
5933 if (plci->NL.Id && !plci->nl_remove_id)
5934 {
5935 mixer_remove(plci);
5936 nl_req_ncci(plci, REMOVE, 0);
5937 }
5938 if (!plci->sig_remove_id)
5939 {
5940 plci->internal_command = 0;
5941 sig_req(plci, REMOVE, 0);
5942 }
5943 send_req(plci);
5944 }
5945 }
5946 else
5947 {
5948 /* collision of DISCONNECT or CONNECT_RES with HANGUP can */
5949 /* result in a second HANGUP! Don't generate another */
5950 /* DISCONNECT */
5951 if (plci->State != IDLE && plci->State != INC_DIS_PENDING)
5952 {
5953 if (plci->State == RESUMING)
5954 {
5955 PUT_WORD(&resume_cau[4], i);
5956 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", (word)3, resume_cau);
5957 }
5958 plci->State = INC_DIS_PENDING;
5959 sendf(plci->appl, _DISCONNECT_I, Id, 0, "w", i);
5960 }
5961 }
5962 break;
5963
5964 case SSEXT_IND:
5965 SendSSExtInd(NULL, plci, Id, multi_ssext_parms);
5966 break;
5967
5968 case VSWITCH_REQ:
5969 VSwitchReqInd(plci, Id, multi_vswitch_parms);
5970 break;
5971 case VSWITCH_IND:
5972 if (plci->relatedPTYPLCI &&
5973 plci->vswitchstate == 3 &&
5974 plci->relatedPTYPLCI->vswitchstate == 3 &&
5975 parms[MAXPARMSIDS - 1][0])
5976 {
5977 add_p(plci->relatedPTYPLCI, SMSG, parms[MAXPARMSIDS - 1]);
5978 sig_req(plci->relatedPTYPLCI, VSWITCH_REQ, 0);
5979 send_req(plci->relatedPTYPLCI);
5980 }
5981 else VSwitchReqInd(plci, Id, multi_vswitch_parms);
5982 break;
5983
5984 }
5985 }
5986
5987
5988 static void SendSetupInfo(APPL *appl, PLCI *plci, dword Id, byte **parms, byte Info_Sent_Flag)
5989 {
5990 word i;
5991 byte *ie;
5992 word Info_Number;
5993 byte *Info_Element;
5994 word Info_Mask = 0;
5995
5996 dbug(1, dprintf("SetupInfo"));
5997
5998 for (i = 0; i < MAXPARMSIDS; i++) {
5999 ie = parms[i];
6000 Info_Number = 0;
6001 Info_Element = ie;
6002 if (ie[0]) {
6003 switch (i) {
6004 case 0:
6005 dbug(1, dprintf("CPN "));
6006 Info_Number = 0x0070;
6007 Info_Mask = 0x80;
6008 Info_Sent_Flag = true;
6009 break;
6010 case 8: /* display */
6011 dbug(1, dprintf("display(%d)", i));
6012 Info_Number = 0x0028;
6013 Info_Mask = 0x04;
6014 Info_Sent_Flag = true;
6015 break;
6016 case 16: /* Channel Id */
6017 dbug(1, dprintf("CHI"));
6018 Info_Number = 0x0018;
6019 Info_Mask = 0x100;
6020 Info_Sent_Flag = true;
6021 mixer_set_bchannel_id(plci, Info_Element);
6022 break;
6023 case 19: /* Redirected Number */
6024 dbug(1, dprintf("RDN"));
6025 Info_Number = 0x0074;
6026 Info_Mask = 0x400;
6027 Info_Sent_Flag = true;
6028 break;
6029 case 20: /* Redirected Number extended */
6030 dbug(1, dprintf("RDX"));
6031 Info_Number = 0x0073;
6032 Info_Mask = 0x400;
6033 Info_Sent_Flag = true;
6034 break;
6035 case 22: /* Redirecing Number */
6036 dbug(1, dprintf("RIN"));
6037 Info_Number = 0x0076;
6038 Info_Mask = 0x400;
6039 Info_Sent_Flag = true;
6040 break;
6041 default:
6042 Info_Number = 0;
6043 break;
6044 }
6045 }
6046
6047 if (i == MAXPARMSIDS - 2) { /* to indicate the message type "Setup" */
6048 Info_Number = 0x8000 | 5;
6049 Info_Mask = 0x10;
6050 Info_Element = "";
6051 }
6052
6053 if (Info_Sent_Flag && Info_Number) {
6054 if (plci->adapter->Info_Mask[appl->Id - 1] & Info_Mask) {
6055 sendf(appl, _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
6056 }
6057 }
6058 }
6059 }
6060
6061
6062 static void SendInfo(PLCI *plci, dword Id, byte **parms, byte iesent)
6063 {
6064 word i;
6065 word j;
6066 word k;
6067 byte *ie;
6068 word Info_Number;
6069 byte *Info_Element;
6070 word Info_Mask = 0;
6071 static byte charges[5] = {4, 0, 0, 0, 0};
6072 static byte cause[] = {0x02, 0x80, 0x00};
6073 APPL *appl;
6074
6075 dbug(1, dprintf("InfoParse "));
6076
6077 if (
6078 !plci->appl
6079 && !plci->State
6080 && plci->Sig.Ind != NCR_FACILITY
6081 )
6082 {
6083 dbug(1, dprintf("NoParse "));
6084 return;
6085 }
6086 cause[2] = 0;
6087 for (i = 0; i < MAXPARMSIDS; i++) {
6088 ie = parms[i];
6089 Info_Number = 0;
6090 Info_Element = ie;
6091 if (ie[0]) {
6092 switch (i) {
6093 case 0:
6094 dbug(1, dprintf("CPN "));
6095 Info_Number = 0x0070;
6096 Info_Mask = 0x80;
6097 break;
6098 case 7: /* ESC_CAU */
6099 dbug(1, dprintf("cau(0x%x)", ie[2]));
6100 Info_Number = 0x0008;
6101 Info_Mask = 0x00;
6102 cause[2] = ie[2];
6103 Info_Element = NULL;
6104 break;
6105 case 8: /* display */
6106 dbug(1, dprintf("display(%d)", i));
6107 Info_Number = 0x0028;
6108 Info_Mask = 0x04;
6109 break;
6110 case 9: /* Date display */
6111 dbug(1, dprintf("date(%d)", i));
6112 Info_Number = 0x0029;
6113 Info_Mask = 0x02;
6114 break;
6115 case 10: /* charges */
6116 for (j = 0; j < 4; j++) charges[1 + j] = 0;
6117 for (j = 0; j < ie[0] && !(ie[1 + j] & 0x80); j++);
6118 for (k = 1, j++; j < ie[0] && k <= 4; j++, k++) charges[k] = ie[1 + j];
6119 Info_Number = 0x4000;
6120 Info_Mask = 0x40;
6121 Info_Element = charges;
6122 break;
6123 case 11: /* user user info */
6124 dbug(1, dprintf("uui"));
6125 Info_Number = 0x007E;
6126 Info_Mask = 0x08;
6127 break;
6128 case 12: /* congestion receiver ready */
6129 dbug(1, dprintf("clRDY"));
6130 Info_Number = 0x00B0;
6131 Info_Mask = 0x08;
6132 Info_Element = "";
6133 break;
6134 case 13: /* congestion receiver not ready */
6135 dbug(1, dprintf("clNRDY"));
6136 Info_Number = 0x00BF;
6137 Info_Mask = 0x08;
6138 Info_Element = "";
6139 break;
6140 case 15: /* Keypad Facility */
6141 dbug(1, dprintf("KEY"));
6142 Info_Number = 0x002C;
6143 Info_Mask = 0x20;
6144 break;
6145 case 16: /* Channel Id */
6146 dbug(1, dprintf("CHI"));
6147 Info_Number = 0x0018;
6148 Info_Mask = 0x100;
6149 mixer_set_bchannel_id(plci, Info_Element);
6150 break;
6151 case 17: /* if no 1tr6 cause, send full cause, else esc_cause */
6152 dbug(1, dprintf("q9cau(0x%x)", ie[2]));
6153 if (!cause[2] || cause[2] < 0x80) break; /* eg. layer 1 error */
6154 Info_Number = 0x0008;
6155 Info_Mask = 0x01;
6156 if (cause[2] != ie[2]) Info_Element = cause;
6157 break;
6158 case 19: /* Redirected Number */
6159 dbug(1, dprintf("RDN"));
6160 Info_Number = 0x0074;
6161 Info_Mask = 0x400;
6162 break;
6163 case 22: /* Redirecing Number */
6164 dbug(1, dprintf("RIN"));
6165 Info_Number = 0x0076;
6166 Info_Mask = 0x400;
6167 break;
6168 case 23: /* Notification Indicator */
6169 dbug(1, dprintf("NI"));
6170 Info_Number = (word)NI;
6171 Info_Mask = 0x210;
6172 break;
6173 case 26: /* Call State */
6174 dbug(1, dprintf("CST"));
6175 Info_Number = (word)CST;
6176 Info_Mask = 0x01; /* do with cause i.e. for now */
6177 break;
6178 case MAXPARMSIDS - 2: /* Escape Message Type, must be the last indication */
6179 dbug(1, dprintf("ESC/MT[0x%x]", ie[3]));
6180 Info_Number = 0x8000 | ie[3];
6181 if (iesent) Info_Mask = 0xffff;
6182 else Info_Mask = 0x10;
6183 Info_Element = "";
6184 break;
6185 default:
6186 Info_Number = 0;
6187 Info_Mask = 0;
6188 Info_Element = "";
6189 break;
6190 }
6191 }
6192
6193 if (plci->Sig.Ind == NCR_FACILITY) /* check controller broadcast */
6194 {
6195 for (j = 0; j < max_appl; j++)
6196 {
6197 appl = &application[j];
6198 if (Info_Number
6199 && appl->Id
6200 && plci->adapter->Info_Mask[appl->Id - 1] & Info_Mask)
6201 {
6202 dbug(1, dprintf("NCR_Ind"));
6203 iesent = true;
6204 sendf(&application[j], _INFO_I, Id & 0x0f, 0, "wS", Info_Number, Info_Element);
6205 }
6206 }
6207 }
6208 else if (!plci->appl)
6209 { /* overlap receiving broadcast */
6210 if (Info_Number == CPN
6211 || Info_Number == KEY
6212 || Info_Number == NI
6213 || Info_Number == DSP
6214 || Info_Number == UUI)
6215 {
6216 for_each_set_bit(j, plci->c_ind_mask_table, max_appl) {
6217 dbug(1, dprintf("Ovl_Ind"));
6218 iesent = true;
6219 sendf(&application[j], _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
6220 }
6221 }
6222 } /* all other signalling states */
6223 else if (Info_Number
6224 && plci->adapter->Info_Mask[plci->appl->Id - 1] & Info_Mask)
6225 {
6226 dbug(1, dprintf("Std_Ind"));
6227 iesent = true;
6228 sendf(plci->appl, _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
6229 }
6230 }
6231 }
6232
6233
6234 static byte SendMultiIE(PLCI *plci, dword Id, byte **parms, byte ie_type,
6235 dword info_mask, byte setupParse)
6236 {
6237 word i;
6238 word j;
6239 byte *ie;
6240 word Info_Number;
6241 byte *Info_Element;
6242 APPL *appl;
6243 word Info_Mask = 0;
6244 byte iesent = 0;
6245
6246 if (
6247 !plci->appl
6248 && !plci->State
6249 && plci->Sig.Ind != NCR_FACILITY
6250 && !setupParse
6251 )
6252 {
6253 dbug(1, dprintf("NoM-IEParse "));
6254 return 0;
6255 }
6256 dbug(1, dprintf("M-IEParse "));
6257
6258 for (i = 0; i < MAX_MULTI_IE; i++)
6259 {
6260 ie = parms[i];
6261 Info_Number = 0;
6262 Info_Element = ie;
6263 if (ie[0])
6264 {
6265 dbug(1, dprintf("[Ind0x%x]:IE=0x%x", plci->Sig.Ind, ie_type));
6266 Info_Number = (word)ie_type;
6267 Info_Mask = (word)info_mask;
6268 }
6269
6270 if (plci->Sig.Ind == NCR_FACILITY) /* check controller broadcast */
6271 {
6272 for (j = 0; j < max_appl; j++)
6273 {
6274 appl = &application[j];
6275 if (Info_Number
6276 && appl->Id
6277 && plci->adapter->Info_Mask[appl->Id - 1] & Info_Mask)
6278 {
6279 iesent = true;
6280 dbug(1, dprintf("Mlt_NCR_Ind"));
6281 sendf(&application[j], _INFO_I, Id & 0x0f, 0, "wS", Info_Number, Info_Element);
6282 }
6283 }
6284 }
6285 else if (!plci->appl && Info_Number)
6286 { /* overlap receiving broadcast */
6287 for_each_set_bit(j, plci->c_ind_mask_table, max_appl) {
6288 iesent = true;
6289 dbug(1, dprintf("Mlt_Ovl_Ind"));
6290 sendf(&application[j] , _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
6291 }
6292 } /* all other signalling states */
6293 else if (Info_Number
6294 && plci->adapter->Info_Mask[plci->appl->Id - 1] & Info_Mask)
6295 {
6296 iesent = true;
6297 dbug(1, dprintf("Mlt_Std_Ind"));
6298 sendf(plci->appl, _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
6299 }
6300 }
6301 return iesent;
6302 }
6303
6304 static void SendSSExtInd(APPL *appl, PLCI *plci, dword Id, byte **parms)
6305 {
6306 word i;
6307 /* Format of multi_ssext_parms[i][]:
6308 0 byte length
6309 1 byte SSEXTIE
6310 2 byte SSEXT_REQ/SSEXT_IND
6311 3 byte length
6312 4 word SSExtCommand
6313 6... Params
6314 */
6315 if (
6316 plci
6317 && plci->State
6318 && plci->Sig.Ind != NCR_FACILITY
6319 )
6320 for (i = 0; i < MAX_MULTI_IE; i++)
6321 {
6322 if (parms[i][0] < 6) continue;
6323 if (parms[i][2] == SSEXT_REQ) continue;
6324
6325 if (appl)
6326 {
6327 parms[i][0] = 0; /* kill it */
6328 sendf(appl, _MANUFACTURER_I,
6329 Id,
6330 0,
6331 "dwS",
6332 _DI_MANU_ID,
6333 _DI_SSEXT_CTRL,
6334 &parms[i][3]);
6335 }
6336 else if (plci->appl)
6337 {
6338 parms[i][0] = 0; /* kill it */
6339 sendf(plci->appl, _MANUFACTURER_I,
6340 Id,
6341 0,
6342 "dwS",
6343 _DI_MANU_ID,
6344 _DI_SSEXT_CTRL,
6345 &parms[i][3]);
6346 }
6347 }
6348 };
6349
6350 static void nl_ind(PLCI *plci)
6351 {
6352 byte ch;
6353 word ncci;
6354 dword Id;
6355 DIVA_CAPI_ADAPTER *a;
6356 word NCCIcode;
6357 APPL *APPLptr;
6358 word count;
6359 word Num;
6360 word i, ncpi_state;
6361 byte len, ncci_state;
6362 word msg;
6363 word info = 0;
6364 word fax_feature_bits;
6365 byte fax_send_edata_ack;
6366 static byte v120_header_buffer[2 + 3];
6367 static word fax_info[] = {
6368 0, /* T30_SUCCESS */
6369 _FAX_NO_CONNECTION, /* T30_ERR_NO_DIS_RECEIVED */
6370 _FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_NO_RESPONSE */
6371 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_RESPONSE */
6372 _FAX_PROTOCOL_ERROR, /* T30_ERR_TOO_MANY_REPEATS */
6373 _FAX_PROTOCOL_ERROR, /* T30_ERR_UNEXPECTED_MESSAGE */
6374 _FAX_REMOTE_ABORT, /* T30_ERR_UNEXPECTED_DCN */
6375 _FAX_LOCAL_ABORT, /* T30_ERR_DTC_UNSUPPORTED */
6376 _FAX_TRAINING_ERROR, /* T30_ERR_ALL_RATES_FAILED */
6377 _FAX_TRAINING_ERROR, /* T30_ERR_TOO_MANY_TRAINS */
6378 _FAX_PARAMETER_ERROR, /* T30_ERR_RECEIVE_CORRUPTED */
6379 _FAX_REMOTE_ABORT, /* T30_ERR_UNEXPECTED_DISC */
6380 _FAX_LOCAL_ABORT, /* T30_ERR_APPLICATION_DISC */
6381 _FAX_REMOTE_REJECT, /* T30_ERR_INCOMPATIBLE_DIS */
6382 _FAX_LOCAL_ABORT, /* T30_ERR_INCOMPATIBLE_DCS */
6383 _FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_NO_COMMAND */
6384 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_COMMAND */
6385 _FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_COMMAND_TOO_LONG */
6386 _FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_RESPONSE_TOO_LONG */
6387 _FAX_NO_CONNECTION, /* T30_ERR_NOT_IDENTIFIED */
6388 _FAX_PROTOCOL_ERROR, /* T30_ERR_SUPERVISORY_TIMEOUT */
6389 _FAX_PARAMETER_ERROR, /* T30_ERR_TOO_LONG_SCAN_LINE */
6390 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_PAGE_AFTER_MPS */
6391 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_PAGE_AFTER_CFR */
6392 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCS_AFTER_FTT */
6393 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCS_AFTER_EOM */
6394 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCS_AFTER_MPS */
6395 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCN_AFTER_MCF */
6396 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCN_AFTER_RTN */
6397 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_CFR */
6398 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_MCF_AFTER_EOP */
6399 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_MCF_AFTER_EOM */
6400 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_MCF_AFTER_MPS */
6401 0x331d, /* T30_ERR_SUB_SEP_UNSUPPORTED */
6402 0x331e, /* T30_ERR_PWD_UNSUPPORTED */
6403 0x331f, /* T30_ERR_SUB_SEP_PWD_UNSUPPORTED */
6404 _FAX_PROTOCOL_ERROR, /* T30_ERR_INVALID_COMMAND_FRAME */
6405 _FAX_PARAMETER_ERROR, /* T30_ERR_UNSUPPORTED_PAGE_CODING */
6406 _FAX_PARAMETER_ERROR, /* T30_ERR_INVALID_PAGE_CODING */
6407 _FAX_REMOTE_REJECT, /* T30_ERR_INCOMPATIBLE_PAGE_CONFIG */
6408 _FAX_LOCAL_ABORT, /* T30_ERR_TIMEOUT_FROM_APPLICATION */
6409 _FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_NO_REACTION_ON_MARK */
6410 _FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_TRAINING_TIMEOUT */
6411 _FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_UNEXPECTED_V21 */
6412 _FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_PRIMARY_CTS_ON */
6413 _FAX_LOCAL_ABORT, /* T30_ERR_V34FAX_TURNAROUND_POLLING */
6414 _FAX_LOCAL_ABORT /* T30_ERR_V34FAX_V8_INCOMPATIBILITY */
6415 };
6416
6417 byte dtmf_code_buffer[CAPIDTMF_RECV_DIGIT_BUFFER_SIZE + 1];
6418
6419
6420 static word rtp_info[] = {
6421 GOOD, /* RTP_SUCCESS */
6422 0x3600 /* RTP_ERR_SSRC_OR_PAYLOAD_CHANGE */
6423 };
6424
6425 static dword udata_forwarding_table[0x100 / sizeof(dword)] =
6426 {
6427 0x0020301e, 0x00000000, 0x00000000, 0x00000000,
6428 0x00000000, 0x00000000, 0x00000000, 0x00000000
6429 };
6430
6431 ch = plci->NL.IndCh;
6432 a = plci->adapter;
6433 ncci = a->ch_ncci[ch];
6434 Id = (((dword)(ncci ? ncci : ch)) << 16) | (((word) plci->Id) << 8) | a->Id;
6435 if (plci->tel) Id |= EXT_CONTROLLER;
6436 APPLptr = plci->appl;
6437 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",
6438 plci->NL.Id, Id, plci->Id, plci->tel, plci->State, ch, plci->channels, plci->NL.Ind & 0x0f));
6439
6440 /* in the case if no connect_active_Ind was sent to the appl we wait for */
6441
6442 if (plci->nl_remove_id)
6443 {
6444 plci->NL.RNR = 2; /* discard */
6445 dbug(1, dprintf("NL discard while remove pending"));
6446 return;
6447 }
6448 if ((plci->NL.Ind & 0x0f) == N_CONNECT)
6449 {
6450 if (plci->State == INC_DIS_PENDING
6451 || plci->State == OUTG_DIS_PENDING
6452 || plci->State == IDLE)
6453 {
6454 plci->NL.RNR = 2; /* discard */
6455 dbug(1, dprintf("discard n_connect"));
6456 return;
6457 }
6458 if (plci->State < INC_ACT_PENDING)
6459 {
6460 plci->NL.RNR = 1; /* flow control */
6461 channel_x_off(plci, ch, N_XON_CONNECT_IND);
6462 return;
6463 }
6464 }
6465
6466 if (!APPLptr) /* no application or invalid data */
6467 { /* while reloading the DSP */
6468 dbug(1, dprintf("discard1"));
6469 plci->NL.RNR = 2;
6470 return;
6471 }
6472
6473 if (((plci->NL.Ind & 0x0f) == N_UDATA)
6474 && (((plci->B2_prot != B2_SDLC) && ((plci->B1_resource == 17) || (plci->B1_resource == 18)))
6475 || (plci->B2_prot == 7)
6476 || (plci->B3_prot == 7)))
6477 {
6478 plci->ncpi_buffer[0] = 0;
6479
6480 ncpi_state = plci->ncpi_state;
6481 if (plci->NL.complete == 1)
6482 {
6483 byte *data = &plci->NL.RBuffer->P[0];
6484
6485 if ((plci->NL.RBuffer->length >= 12)
6486 && ((*data == DSP_UDATA_INDICATION_DCD_ON)
6487 || (*data == DSP_UDATA_INDICATION_CTS_ON)))
6488 {
6489 word conn_opt, ncpi_opt = 0x00;
6490 /* HexDump ("MDM N_UDATA:", plci->NL.RBuffer->length, data); */
6491
6492 if (*data == DSP_UDATA_INDICATION_DCD_ON)
6493 plci->ncpi_state |= NCPI_MDM_DCD_ON_RECEIVED;
6494 if (*data == DSP_UDATA_INDICATION_CTS_ON)
6495 plci->ncpi_state |= NCPI_MDM_CTS_ON_RECEIVED;
6496
6497 data++; /* indication code */
6498 data += 2; /* timestamp */
6499 if ((*data == DSP_CONNECTED_NORM_V18) || (*data == DSP_CONNECTED_NORM_VOWN))
6500 ncpi_state &= ~(NCPI_MDM_DCD_ON_RECEIVED | NCPI_MDM_CTS_ON_RECEIVED);
6501 data++; /* connected norm */
6502 conn_opt = GET_WORD(data);
6503 data += 2; /* connected options */
6504
6505 PUT_WORD(&(plci->ncpi_buffer[1]), (word)(GET_DWORD(data) & 0x0000FFFF));
6506
6507 if (conn_opt & DSP_CONNECTED_OPTION_MASK_V42)
6508 {
6509 ncpi_opt |= MDM_NCPI_ECM_V42;
6510 }
6511 else if (conn_opt & DSP_CONNECTED_OPTION_MASK_MNP)
6512 {
6513 ncpi_opt |= MDM_NCPI_ECM_MNP;
6514 }
6515 else
6516 {
6517 ncpi_opt |= MDM_NCPI_TRANSPARENT;
6518 }
6519 if (conn_opt & DSP_CONNECTED_OPTION_MASK_COMPRESSION)
6520 {
6521 ncpi_opt |= MDM_NCPI_COMPRESSED;
6522 }
6523 PUT_WORD(&(plci->ncpi_buffer[3]), ncpi_opt);
6524 plci->ncpi_buffer[0] = 4;
6525
6526 plci->ncpi_state |= NCPI_VALID_CONNECT_B3_IND | NCPI_VALID_CONNECT_B3_ACT | NCPI_VALID_DISC_B3_IND;
6527 }
6528 }
6529 if (plci->B3_prot == 7)
6530 {
6531 if (((a->ncci_state[ncci] == INC_ACT_PENDING) || (a->ncci_state[ncci] == OUTG_CON_PENDING))
6532 && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6533 && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6534 {
6535 a->ncci_state[ncci] = INC_ACT_PENDING;
6536 sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
6537 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6538 }
6539 }
6540
6541 if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
6542 & ((1L << PRIVATE_V18) | (1L << PRIVATE_VOWN)))
6543 || !(ncpi_state & NCPI_MDM_DCD_ON_RECEIVED)
6544 || !(ncpi_state & NCPI_MDM_CTS_ON_RECEIVED))
6545
6546 {
6547 plci->NL.RNR = 2;
6548 return;
6549 }
6550 }
6551
6552 if (plci->NL.complete == 2)
6553 {
6554 if (((plci->NL.Ind & 0x0f) == N_UDATA)
6555 && !(udata_forwarding_table[plci->RData[0].P[0] >> 5] & (1L << (plci->RData[0].P[0] & 0x1f))))
6556 {
6557 switch (plci->RData[0].P[0])
6558 {
6559
6560 case DTMF_UDATA_INDICATION_FAX_CALLING_TONE:
6561 if (plci->dtmf_rec_active & DTMF_LISTEN_ACTIVE_FLAG)
6562 sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", SELECTOR_DTMF, "\x01X");
6563 break;
6564 case DTMF_UDATA_INDICATION_ANSWER_TONE:
6565 if (plci->dtmf_rec_active & DTMF_LISTEN_ACTIVE_FLAG)
6566 sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", SELECTOR_DTMF, "\x01Y");
6567 break;
6568 case DTMF_UDATA_INDICATION_DIGITS_RECEIVED:
6569 dtmf_indication(Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6570 break;
6571 case DTMF_UDATA_INDICATION_DIGITS_SENT:
6572 dtmf_confirmation(Id, plci);
6573 break;
6574
6575
6576 case UDATA_INDICATION_MIXER_TAP_DATA:
6577 capidtmf_recv_process_block(&(plci->capidtmf_state), plci->RData[0].P + 1, (word)(plci->RData[0].PLength - 1));
6578 i = capidtmf_indication(&(plci->capidtmf_state), dtmf_code_buffer + 1);
6579 if (i != 0)
6580 {
6581 dtmf_code_buffer[0] = DTMF_UDATA_INDICATION_DIGITS_RECEIVED;
6582 dtmf_indication(Id, plci, dtmf_code_buffer, (word)(i + 1));
6583 }
6584 break;
6585
6586
6587 case UDATA_INDICATION_MIXER_COEFS_SET:
6588 mixer_indication_coefs_set(Id, plci);
6589 break;
6590 case UDATA_INDICATION_XCONNECT_FROM:
6591 mixer_indication_xconnect_from(Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6592 break;
6593 case UDATA_INDICATION_XCONNECT_TO:
6594 mixer_indication_xconnect_to(Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6595 break;
6596
6597
6598 case LEC_UDATA_INDICATION_DISABLE_DETECT:
6599 ec_indication(Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6600 break;
6601
6602
6603
6604 default:
6605 break;
6606 }
6607 }
6608 else
6609 {
6610 if ((plci->RData[0].PLength != 0)
6611 && ((plci->B2_prot == B2_V120_ASYNC)
6612 || (plci->B2_prot == B2_V120_ASYNC_V42BIS)
6613 || (plci->B2_prot == B2_V120_BIT_TRANSPARENT)))
6614 {
6615
6616 sendf(plci->appl, _DATA_B3_I, Id, 0,
6617 "dwww",
6618 plci->RData[1].P,
6619 (plci->NL.RNum < 2) ? 0 : plci->RData[1].PLength,
6620 plci->RNum,
6621 plci->RFlags);
6622
6623 }
6624 else
6625 {
6626
6627 sendf(plci->appl, _DATA_B3_I, Id, 0,
6628 "dwww",
6629 plci->RData[0].P,
6630 plci->RData[0].PLength,
6631 plci->RNum,
6632 plci->RFlags);
6633
6634 }
6635 }
6636 return;
6637 }
6638
6639 fax_feature_bits = 0;
6640 if ((plci->NL.Ind & 0x0f) == N_CONNECT ||
6641 (plci->NL.Ind & 0x0f) == N_CONNECT_ACK ||
6642 (plci->NL.Ind & 0x0f) == N_DISC ||
6643 (plci->NL.Ind & 0x0f) == N_EDATA ||
6644 (plci->NL.Ind & 0x0f) == N_DISC_ACK)
6645 {
6646 info = 0;
6647 plci->ncpi_buffer[0] = 0;
6648 switch (plci->B3_prot) {
6649 case 0: /*XPARENT*/
6650 case 1: /*T.90 NL*/
6651 break; /* no network control protocol info - jfr */
6652 case 2: /*ISO8202*/
6653 case 3: /*X25 DCE*/
6654 for (i = 0; i < plci->NL.RLength; i++) plci->ncpi_buffer[4 + i] = plci->NL.RBuffer->P[i];
6655 plci->ncpi_buffer[0] = (byte)(i + 3);
6656 plci->ncpi_buffer[1] = (byte)(plci->NL.Ind & N_D_BIT ? 1 : 0);
6657 plci->ncpi_buffer[2] = 0;
6658 plci->ncpi_buffer[3] = 0;
6659 break;
6660 case 4: /*T.30 - FAX*/
6661 case 5: /*T.30 - FAX*/
6662 if (plci->NL.RLength >= sizeof(T30_INFO))
6663 {
6664 dbug(1, dprintf("FaxStatus %04x", ((T30_INFO *)plci->NL.RBuffer->P)->code));
6665 len = 9;
6666 PUT_WORD(&(plci->ncpi_buffer[1]), ((T30_INFO *)plci->NL.RBuffer->P)->rate_div_2400 * 2400);
6667 fax_feature_bits = GET_WORD(&((T30_INFO *)plci->NL.RBuffer->P)->feature_bits_low);
6668 i = (((T30_INFO *)plci->NL.RBuffer->P)->resolution & T30_RESOLUTION_R8_0770_OR_200) ? 0x0001 : 0x0000;
6669 if (plci->B3_prot == 5)
6670 {
6671 if (!(fax_feature_bits & T30_FEATURE_BIT_ECM))
6672 i |= 0x8000; /* This is not an ECM connection */
6673 if (fax_feature_bits & T30_FEATURE_BIT_T6_CODING)
6674 i |= 0x4000; /* This is a connection with MMR compression */
6675 if (fax_feature_bits & T30_FEATURE_BIT_2D_CODING)
6676 i |= 0x2000; /* This is a connection with MR compression */
6677 if (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS)
6678 i |= 0x0004; /* More documents */
6679 if (fax_feature_bits & T30_FEATURE_BIT_POLLING)
6680 i |= 0x0002; /* Fax-polling indication */
6681 }
6682 dbug(1, dprintf("FAX Options %04x %04x", fax_feature_bits, i));
6683 PUT_WORD(&(plci->ncpi_buffer[3]), i);
6684 PUT_WORD(&(plci->ncpi_buffer[5]), ((T30_INFO *)plci->NL.RBuffer->P)->data_format);
6685 plci->ncpi_buffer[7] = ((T30_INFO *)plci->NL.RBuffer->P)->pages_low;
6686 plci->ncpi_buffer[8] = ((T30_INFO *)plci->NL.RBuffer->P)->pages_high;
6687 plci->ncpi_buffer[len] = 0;
6688 if (((T30_INFO *)plci->NL.RBuffer->P)->station_id_len)
6689 {
6690 plci->ncpi_buffer[len] = 20;
6691 for (i = 0; i < T30_MAX_STATION_ID_LENGTH; i++)
6692 plci->ncpi_buffer[++len] = ((T30_INFO *)plci->NL.RBuffer->P)->station_id[i];
6693 }
6694 if (((plci->NL.Ind & 0x0f) == N_DISC) || ((plci->NL.Ind & 0x0f) == N_DISC_ACK))
6695 {
6696 if (((T30_INFO *)plci->NL.RBuffer->P)->code < ARRAY_SIZE(fax_info))
6697 info = fax_info[((T30_INFO *)plci->NL.RBuffer->P)->code];
6698 else
6699 info = _FAX_PROTOCOL_ERROR;
6700 }
6701
6702 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id - 1])
6703 & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
6704 {
6705 i = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + ((T30_INFO *)plci->NL.RBuffer->P)->head_line_len;
6706 while (i < plci->NL.RBuffer->length)
6707 plci->ncpi_buffer[++len] = plci->NL.RBuffer->P[i++];
6708 }
6709
6710 plci->ncpi_buffer[0] = len;
6711 fax_feature_bits = GET_WORD(&((T30_INFO *)plci->NL.RBuffer->P)->feature_bits_low);
6712 PUT_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->feature_bits_low, fax_feature_bits);
6713
6714 plci->ncpi_state |= NCPI_VALID_CONNECT_B3_IND;
6715 if (((plci->NL.Ind & 0x0f) == N_CONNECT_ACK)
6716 || (((plci->NL.Ind & 0x0f) == N_CONNECT)
6717 && (fax_feature_bits & T30_FEATURE_BIT_POLLING))
6718 || (((plci->NL.Ind & 0x0f) == N_EDATA)
6719 && ((((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_TRAIN_OK)
6720 || (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_DIS)
6721 || (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_DTC))))
6722 {
6723 plci->ncpi_state |= NCPI_VALID_CONNECT_B3_ACT;
6724 }
6725 if (((plci->NL.Ind & 0x0f) == N_DISC)
6726 || ((plci->NL.Ind & 0x0f) == N_DISC_ACK)
6727 || (((plci->NL.Ind & 0x0f) == N_EDATA)
6728 && (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_EOP_CAPI)))
6729 {
6730 plci->ncpi_state |= NCPI_VALID_CONNECT_B3_ACT | NCPI_VALID_DISC_B3_IND;
6731 }
6732 }
6733 break;
6734
6735 case B3_RTP:
6736 if (((plci->NL.Ind & 0x0f) == N_DISC) || ((plci->NL.Ind & 0x0f) == N_DISC_ACK))
6737 {
6738 if (plci->NL.RLength != 0)
6739 {
6740 info = rtp_info[plci->NL.RBuffer->P[0]];
6741 plci->ncpi_buffer[0] = plci->NL.RLength - 1;
6742 for (i = 1; i < plci->NL.RLength; i++)
6743 plci->ncpi_buffer[i] = plci->NL.RBuffer->P[i];
6744 }
6745 }
6746 break;
6747
6748 }
6749 plci->NL.RNR = 2;
6750 }
6751 switch (plci->NL.Ind & 0x0f) {
6752 case N_EDATA:
6753 if ((plci->B3_prot == 4) || (plci->B3_prot == 5))
6754 {
6755 dbug(1, dprintf("EDATA ncci=0x%x state=%d code=%02x", ncci, a->ncci_state[ncci],
6756 ((T30_INFO *)plci->NL.RBuffer->P)->code));
6757 fax_send_edata_ack = (((T30_INFO *)(plci->fax_connect_info_buffer))->operating_mode == T30_OPERATING_MODE_CAPI_NEG);
6758
6759 if ((plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF)
6760 && (plci->nsf_control_bits & (T30_NSF_CONTROL_BIT_NEGOTIATE_IND | T30_NSF_CONTROL_BIT_NEGOTIATE_RESP))
6761 && (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_DIS)
6762 && (a->ncci_state[ncci] == OUTG_CON_PENDING)
6763 && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6764 && !(plci->ncpi_state & NCPI_NEGOTIATE_B3_SENT))
6765 {
6766 ((T30_INFO *)(plci->fax_connect_info_buffer))->code = ((T30_INFO *)plci->NL.RBuffer->P)->code;
6767 sendf(plci->appl, _MANUFACTURER_I, Id, 0, "dwbS", _DI_MANU_ID, _DI_NEGOTIATE_B3,
6768 (byte)(plci->ncpi_buffer[0] + 1), plci->ncpi_buffer);
6769 plci->ncpi_state |= NCPI_NEGOTIATE_B3_SENT;
6770 if (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP)
6771 fax_send_edata_ack = false;
6772 }
6773
6774 if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
6775 {
6776 switch (((T30_INFO *)plci->NL.RBuffer->P)->code)
6777 {
6778 case EDATA_T30_DIS:
6779 if ((a->ncci_state[ncci] == OUTG_CON_PENDING)
6780 && !(GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low) & T30_CONTROL_BIT_REQUEST_POLLING)
6781 && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6782 && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6783 {
6784 a->ncci_state[ncci] = INC_ACT_PENDING;
6785 if (plci->B3_prot == 4)
6786 sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
6787 else
6788 sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
6789 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6790 }
6791 break;
6792
6793 case EDATA_T30_TRAIN_OK:
6794 if ((a->ncci_state[ncci] == INC_ACT_PENDING)
6795 && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6796 && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6797 {
6798 if (plci->B3_prot == 4)
6799 sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
6800 else
6801 sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
6802 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6803 }
6804 break;
6805
6806 case EDATA_T30_EOP_CAPI:
6807 if (a->ncci_state[ncci] == CONNECTED)
6808 {
6809 sendf(plci->appl, _DISCONNECT_B3_I, Id, 0, "wS", GOOD, plci->ncpi_buffer);
6810 a->ncci_state[ncci] = INC_DIS_PENDING;
6811 plci->ncpi_state = 0;
6812 fax_send_edata_ack = false;
6813 }
6814 break;
6815 }
6816 }
6817 else
6818 {
6819 switch (((T30_INFO *)plci->NL.RBuffer->P)->code)
6820 {
6821 case EDATA_T30_TRAIN_OK:
6822 if ((a->ncci_state[ncci] == INC_ACT_PENDING)
6823 && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6824 && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6825 {
6826 if (plci->B3_prot == 4)
6827 sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
6828 else
6829 sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
6830 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6831 }
6832 break;
6833 }
6834 }
6835 if (fax_send_edata_ack)
6836 {
6837 ((T30_INFO *)(plci->fax_connect_info_buffer))->code = ((T30_INFO *)plci->NL.RBuffer->P)->code;
6838 plci->fax_edata_ack_length = 1;
6839 start_internal_command(Id, plci, fax_edata_ack_command);
6840 }
6841 }
6842 else
6843 {
6844 dbug(1, dprintf("EDATA ncci=0x%x state=%d", ncci, a->ncci_state[ncci]));
6845 }
6846 break;
6847 case N_CONNECT:
6848 if (!a->ch_ncci[ch])
6849 {
6850 ncci = get_ncci(plci, ch, 0);
6851 Id = (Id & 0xffff) | (((dword) ncci) << 16);
6852 }
6853 dbug(1, dprintf("N_CONNECT: ch=%d state=%d plci=%lx plci_Id=%lx plci_State=%d",
6854 ch, a->ncci_state[ncci], a->ncci_plci[ncci], plci->Id, plci->State));
6855
6856 msg = _CONNECT_B3_I;
6857 if (a->ncci_state[ncci] == IDLE)
6858 plci->channels++;
6859 else if (plci->B3_prot == 1)
6860 msg = _CONNECT_B3_T90_ACTIVE_I;
6861
6862 a->ncci_state[ncci] = INC_CON_PENDING;
6863 if (plci->B3_prot == 4)
6864 sendf(plci->appl, msg, Id, 0, "s", "");
6865 else
6866 sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer);
6867 break;
6868 case N_CONNECT_ACK:
6869 dbug(1, dprintf("N_connect_Ack"));
6870 if (plci->internal_command_queue[0]
6871 && ((plci->adjust_b_state == ADJUST_B_CONNECT_2)
6872 || (plci->adjust_b_state == ADJUST_B_CONNECT_3)
6873 || (plci->adjust_b_state == ADJUST_B_CONNECT_4)))
6874 {
6875 (*(plci->internal_command_queue[0]))(Id, plci, 0);
6876 if (!plci->internal_command)
6877 next_internal_command(Id, plci);
6878 break;
6879 }
6880 msg = _CONNECT_B3_ACTIVE_I;
6881 if (plci->B3_prot == 1)
6882 {
6883 if (a->ncci_state[ncci] != OUTG_CON_PENDING)
6884 msg = _CONNECT_B3_T90_ACTIVE_I;
6885 a->ncci_state[ncci] = INC_ACT_PENDING;
6886 sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer);
6887 }
6888 else if ((plci->B3_prot == 4) || (plci->B3_prot == 5) || (plci->B3_prot == 7))
6889 {
6890 if ((a->ncci_state[ncci] == OUTG_CON_PENDING)
6891 && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6892 && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6893 {
6894 a->ncci_state[ncci] = INC_ACT_PENDING;
6895 if (plci->B3_prot == 4)
6896 sendf(plci->appl, msg, Id, 0, "s", "");
6897 else
6898 sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer);
6899 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6900 }
6901 }
6902 else
6903 {
6904 a->ncci_state[ncci] = INC_ACT_PENDING;
6905 sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer);
6906 }
6907 if (plci->adjust_b_restore)
6908 {
6909 plci->adjust_b_restore = false;
6910 start_internal_command(Id, plci, adjust_b_restore);
6911 }
6912 break;
6913 case N_DISC:
6914 case N_DISC_ACK:
6915 if (plci->internal_command_queue[0]
6916 && ((plci->internal_command == FAX_DISCONNECT_COMMAND_1)
6917 || (plci->internal_command == FAX_DISCONNECT_COMMAND_2)
6918 || (plci->internal_command == FAX_DISCONNECT_COMMAND_3)))
6919 {
6920 (*(plci->internal_command_queue[0]))(Id, plci, 0);
6921 if (!plci->internal_command)
6922 next_internal_command(Id, plci);
6923 }
6924 ncci_state = a->ncci_state[ncci];
6925 ncci_remove(plci, ncci, false);
6926
6927 /* with N_DISC or N_DISC_ACK the IDI frees the respective */
6928 /* channel, so we cannot store the state in ncci_state! The */
6929 /* information which channel we received a N_DISC is thus */
6930 /* stored in the inc_dis_ncci_table buffer. */
6931 for (i = 0; plci->inc_dis_ncci_table[i]; i++);
6932 plci->inc_dis_ncci_table[i] = (byte) ncci;
6933
6934 /* need a connect_b3_ind before a disconnect_b3_ind with FAX */
6935 if (!plci->channels
6936 && (plci->B1_resource == 16)
6937 && (plci->State <= CONNECTED))
6938 {
6939 len = 9;
6940 i = ((T30_INFO *)plci->fax_connect_info_buffer)->rate_div_2400 * 2400;
6941 PUT_WORD(&plci->ncpi_buffer[1], i);
6942 PUT_WORD(&plci->ncpi_buffer[3], 0);
6943 i = ((T30_INFO *)plci->fax_connect_info_buffer)->data_format;
6944 PUT_WORD(&plci->ncpi_buffer[5], i);
6945 PUT_WORD(&plci->ncpi_buffer[7], 0);
6946 plci->ncpi_buffer[len] = 0;
6947 plci->ncpi_buffer[0] = len;
6948 if (plci->B3_prot == 4)
6949 sendf(plci->appl, _CONNECT_B3_I, Id, 0, "s", "");
6950 else
6951 {
6952
6953 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id - 1])
6954 & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
6955 {
6956 plci->ncpi_buffer[++len] = 0;
6957 plci->ncpi_buffer[++len] = 0;
6958 plci->ncpi_buffer[++len] = 0;
6959 plci->ncpi_buffer[0] = len;
6960 }
6961
6962 sendf(plci->appl, _CONNECT_B3_I, Id, 0, "S", plci->ncpi_buffer);
6963 }
6964 sendf(plci->appl, _DISCONNECT_B3_I, Id, 0, "wS", info, plci->ncpi_buffer);
6965 plci->ncpi_state = 0;
6966 sig_req(plci, HANGUP, 0);
6967 send_req(plci);
6968 plci->State = OUTG_DIS_PENDING;
6969 /* disc here */
6970 }
6971 else if ((a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
6972 && ((plci->B3_prot == 4) || (plci->B3_prot == 5))
6973 && ((ncci_state == INC_DIS_PENDING) || (ncci_state == IDLE)))
6974 {
6975 if (ncci_state == IDLE)
6976 {
6977 if (plci->channels)
6978 plci->channels--;
6979 if ((plci->State == IDLE || plci->State == SUSPENDING) && !plci->channels) {
6980 if (plci->State == SUSPENDING) {
6981 sendf(plci->appl,
6982 _FACILITY_I,
6983 Id & 0xffffL,
6984 0,
6985 "ws", (word)3, "\x03\x04\x00\x00");
6986 sendf(plci->appl, _DISCONNECT_I, Id & 0xffffL, 0, "w", 0);
6987 }
6988 plci_remove(plci);
6989 plci->State = IDLE;
6990 }
6991 }
6992 }
6993 else if (plci->channels)
6994 {
6995 sendf(plci->appl, _DISCONNECT_B3_I, Id, 0, "wS", info, plci->ncpi_buffer);
6996 plci->ncpi_state = 0;
6997 if ((ncci_state == OUTG_REJ_PENDING)
6998 && ((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE)))
6999 {
7000 sig_req(plci, HANGUP, 0);
7001 send_req(plci);
7002 plci->State = OUTG_DIS_PENDING;
7003 }
7004 }
7005 break;
7006 case N_RESET:
7007 a->ncci_state[ncci] = INC_RES_PENDING;
7008 sendf(plci->appl, _RESET_B3_I, Id, 0, "S", plci->ncpi_buffer);
7009 break;
7010 case N_RESET_ACK:
7011 a->ncci_state[ncci] = CONNECTED;
7012 sendf(plci->appl, _RESET_B3_I, Id, 0, "S", plci->ncpi_buffer);
7013 break;
7014
7015 case N_UDATA:
7016 if (!(udata_forwarding_table[plci->NL.RBuffer->P[0] >> 5] & (1L << (plci->NL.RBuffer->P[0] & 0x1f))))
7017 {
7018 plci->RData[0].P = plci->internal_ind_buffer + (-((int)(long)(plci->internal_ind_buffer)) & 3);
7019 plci->RData[0].PLength = INTERNAL_IND_BUFFER_SIZE;
7020 plci->NL.R = plci->RData;
7021 plci->NL.RNum = 1;
7022 return;
7023 }
7024 /* fall through */
7025 case N_BDATA:
7026 case N_DATA:
7027 if (((a->ncci_state[ncci] != CONNECTED) && (plci->B2_prot == 1)) /* transparent */
7028 || (a->ncci_state[ncci] == IDLE)
7029 || (a->ncci_state[ncci] == INC_DIS_PENDING))
7030 {
7031 plci->NL.RNR = 2;
7032 break;
7033 }
7034 if ((a->ncci_state[ncci] != CONNECTED)
7035 && (a->ncci_state[ncci] != OUTG_DIS_PENDING)
7036 && (a->ncci_state[ncci] != OUTG_REJ_PENDING))
7037 {
7038 dbug(1, dprintf("flow control"));
7039 plci->NL.RNR = 1; /* flow control */
7040 channel_x_off(plci, ch, 0);
7041 break;
7042 }
7043
7044 NCCIcode = ncci | (((word)a->Id) << 8);
7045
7046 /* count all buffers within the Application pool */
7047 /* belonging to the same NCCI. If this is below the */
7048 /* number of buffers available per NCCI we accept */
7049 /* this packet, otherwise we reject it */
7050 count = 0;
7051 Num = 0xffff;
7052 for (i = 0; i < APPLptr->MaxBuffer; i++) {
7053 if (NCCIcode == APPLptr->DataNCCI[i]) count++;
7054 if (!APPLptr->DataNCCI[i] && Num == 0xffff) Num = i;
7055 }
7056
7057 if (count >= APPLptr->MaxNCCIData || Num == 0xffff)
7058 {
7059 dbug(3, dprintf("Flow-Control"));
7060 plci->NL.RNR = 1;
7061 if (++(APPLptr->NCCIDataFlowCtrlTimer) >=
7062 (word)((a->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL) ? 40 : 2000))
7063 {
7064 plci->NL.RNR = 2;
7065 dbug(3, dprintf("DiscardData"));
7066 } else {
7067 channel_x_off(plci, ch, 0);
7068 }
7069 break;
7070 }
7071 else
7072 {
7073 APPLptr->NCCIDataFlowCtrlTimer = 0;
7074 }
7075
7076 plci->RData[0].P = ReceiveBufferGet(APPLptr, Num);
7077 if (!plci->RData[0].P) {
7078 plci->NL.RNR = 1;
7079 channel_x_off(plci, ch, 0);
7080 break;
7081 }
7082
7083 APPLptr->DataNCCI[Num] = NCCIcode;
7084 APPLptr->DataFlags[Num] = (plci->Id << 8) | (plci->NL.Ind >> 4);
7085 dbug(3, dprintf("Buffer(%d), Max = %d", Num, APPLptr->MaxBuffer));
7086
7087 plci->RNum = Num;
7088 plci->RFlags = plci->NL.Ind >> 4;
7089 plci->RData[0].PLength = APPLptr->MaxDataLength;
7090 plci->NL.R = plci->RData;
7091 if ((plci->NL.RLength != 0)
7092 && ((plci->B2_prot == B2_V120_ASYNC)
7093 || (plci->B2_prot == B2_V120_ASYNC_V42BIS)
7094 || (plci->B2_prot == B2_V120_BIT_TRANSPARENT)))
7095 {
7096 plci->RData[1].P = plci->RData[0].P;
7097 plci->RData[1].PLength = plci->RData[0].PLength;
7098 plci->RData[0].P = v120_header_buffer + (-((unsigned long)v120_header_buffer) & 3);
7099 if ((plci->NL.RBuffer->P[0] & V120_HEADER_EXTEND_BIT) || (plci->NL.RLength == 1))
7100 plci->RData[0].PLength = 1;
7101 else
7102 plci->RData[0].PLength = 2;
7103 if (plci->NL.RBuffer->P[0] & V120_HEADER_BREAK_BIT)
7104 plci->RFlags |= 0x0010;
7105 if (plci->NL.RBuffer->P[0] & (V120_HEADER_C1_BIT | V120_HEADER_C2_BIT))
7106 plci->RFlags |= 0x8000;
7107 plci->NL.RNum = 2;
7108 }
7109 else
7110 {
7111 if ((plci->NL.Ind & 0x0f) == N_UDATA)
7112 plci->RFlags |= 0x0010;
7113
7114 else if ((plci->B3_prot == B3_RTP) && ((plci->NL.Ind & 0x0f) == N_BDATA))
7115 plci->RFlags |= 0x0001;
7116
7117 plci->NL.RNum = 1;
7118 }
7119 break;
7120 case N_DATA_ACK:
7121 data_ack(plci, ch);
7122 break;
7123 default:
7124 plci->NL.RNR = 2;
7125 break;
7126 }
7127 }
7128
7129 /*------------------------------------------------------------------*/
7130 /* find a free PLCI */
7131 /*------------------------------------------------------------------*/
7132
7133 static word get_plci(DIVA_CAPI_ADAPTER *a)
7134 {
7135 word i, j;
7136 PLCI *plci;
7137
7138 for (i = 0; i < a->max_plci && a->plci[i].Id; i++);
7139 if (i == a->max_plci) {
7140 dbug(1, dprintf("get_plci: out of PLCIs"));
7141 return 0;
7142 }
7143 plci = &a->plci[i];
7144 plci->Id = (byte)(i + 1);
7145
7146 plci->Sig.Id = 0;
7147 plci->NL.Id = 0;
7148 plci->sig_req = 0;
7149 plci->nl_req = 0;
7150
7151 plci->appl = NULL;
7152 plci->relatedPTYPLCI = NULL;
7153 plci->State = IDLE;
7154 plci->SuppState = IDLE;
7155 plci->channels = 0;
7156 plci->tel = 0;
7157 plci->B1_resource = 0;
7158 plci->B2_prot = 0;
7159 plci->B3_prot = 0;
7160
7161 plci->command = 0;
7162 plci->m_command = 0;
7163 init_internal_command_queue(plci);
7164 plci->number = 0;
7165 plci->req_in_start = 0;
7166 plci->req_in = 0;
7167 plci->req_out = 0;
7168 plci->msg_in_write_pos = MSG_IN_QUEUE_SIZE;
7169 plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
7170 plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
7171
7172 plci->data_sent = false;
7173 plci->send_disc = 0;
7174 plci->sig_global_req = 0;
7175 plci->sig_remove_id = 0;
7176 plci->nl_global_req = 0;
7177 plci->nl_remove_id = 0;
7178 plci->adv_nl = 0;
7179 plci->manufacturer = false;
7180 plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
7181 plci->spoofed_msg = 0;
7182 plci->ptyState = 0;
7183 plci->cr_enquiry = false;
7184 plci->hangup_flow_ctrl_timer = 0;
7185
7186 plci->ncci_ring_list = 0;
7187 for (j = 0; j < MAX_CHANNELS_PER_PLCI; j++) plci->inc_dis_ncci_table[j] = 0;
7188 bitmap_zero(plci->c_ind_mask_table, MAX_APPL);
7189 bitmap_fill(plci->group_optimization_mask_table, MAX_APPL);
7190 plci->fax_connect_info_length = 0;
7191 plci->nsf_control_bits = 0;
7192 plci->ncpi_state = 0x00;
7193 plci->ncpi_buffer[0] = 0;
7194
7195 plci->requested_options_conn = 0;
7196 plci->requested_options = 0;
7197 plci->notifiedcall = 0;
7198 plci->vswitchstate = 0;
7199 plci->vsprot = 0;
7200 plci->vsprotdialect = 0;
7201 init_b1_config(plci);
7202 dbug(1, dprintf("get_plci(%x)", plci->Id));
7203 return i + 1;
7204 }
7205
7206 /*------------------------------------------------------------------*/
7207 /* put a parameter in the parameter buffer */
7208 /*------------------------------------------------------------------*/
7209
7210 static void add_p(PLCI *plci, byte code, byte *p)
7211 {
7212 word p_length;
7213
7214 p_length = 0;
7215 if (p) p_length = p[0];
7216 add_ie(plci, code, p, p_length);
7217 }
7218
7219 /*------------------------------------------------------------------*/
7220 /* put a structure in the parameter buffer */
7221 /*------------------------------------------------------------------*/
7222 static void add_s(PLCI *plci, byte code, API_PARSE *p)
7223 {
7224 if (p) add_ie(plci, code, p->info, (word)p->length);
7225 }
7226
7227 /*------------------------------------------------------------------*/
7228 /* put multiple structures in the parameter buffer */
7229 /*------------------------------------------------------------------*/
7230 static void add_ss(PLCI *plci, byte code, API_PARSE *p)
7231 {
7232 byte i;
7233
7234 if (p) {
7235 dbug(1, dprintf("add_ss(%x,len=%d)", code, p->length));
7236 for (i = 2; i < (byte)p->length; i += p->info[i] + 2) {
7237 dbug(1, dprintf("add_ss_ie(%x,len=%d)", p->info[i - 1], p->info[i]));
7238 add_ie(plci, p->info[i - 1], (byte *)&(p->info[i]), (word)p->info[i]);
7239 }
7240 }
7241 }
7242
7243 /*------------------------------------------------------------------*/
7244 /* return the channel number sent by the application in a esc_chi */
7245 /*------------------------------------------------------------------*/
7246 static byte getChannel(API_PARSE *p)
7247 {
7248 byte i;
7249
7250 if (p) {
7251 for (i = 2; i < (byte)p->length; i += p->info[i] + 2) {
7252 if (p->info[i] == 2) {
7253 if (p->info[i - 1] == ESC && p->info[i + 1] == CHI) return (p->info[i + 2]);
7254 }
7255 }
7256 }
7257 return 0;
7258 }
7259
7260
7261 /*------------------------------------------------------------------*/
7262 /* put an information element in the parameter buffer */
7263 /*------------------------------------------------------------------*/
7264
7265 static void add_ie(PLCI *plci, byte code, byte *p, word p_length)
7266 {
7267 word i;
7268
7269 if (!(code & 0x80) && !p_length) return;
7270
7271 if (plci->req_in == plci->req_in_start) {
7272 plci->req_in += 2;
7273 }
7274 else {
7275 plci->req_in--;
7276 }
7277 plci->RBuffer[plci->req_in++] = code;
7278
7279 if (p) {
7280 plci->RBuffer[plci->req_in++] = (byte)p_length;
7281 for (i = 0; i < p_length; i++) plci->RBuffer[plci->req_in++] = p[1 + i];
7282 }
7283
7284 plci->RBuffer[plci->req_in++] = 0;
7285 }
7286
7287 /*------------------------------------------------------------------*/
7288 /* put a unstructured data into the buffer */
7289 /*------------------------------------------------------------------*/
7290
7291 static void add_d(PLCI *plci, word length, byte *p)
7292 {
7293 word i;
7294
7295 if (plci->req_in == plci->req_in_start) {
7296 plci->req_in += 2;
7297 }
7298 else {
7299 plci->req_in--;
7300 }
7301 for (i = 0; i < length; i++) plci->RBuffer[plci->req_in++] = p[i];
7302 }
7303
7304 /*------------------------------------------------------------------*/
7305 /* put parameters from the Additional Info parameter in the */
7306 /* parameter buffer */
7307 /*------------------------------------------------------------------*/
7308
7309 static void add_ai(PLCI *plci, API_PARSE *ai)
7310 {
7311 word i;
7312 API_PARSE ai_parms[5];
7313
7314 for (i = 0; i < 5; i++) ai_parms[i].length = 0;
7315
7316 if (!ai->length)
7317 return;
7318 if (api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms))
7319 return;
7320
7321 add_s(plci, KEY, &ai_parms[1]);
7322 add_s(plci, UUI, &ai_parms[2]);
7323 add_ss(plci, FTY, &ai_parms[3]);
7324 }
7325
7326 /*------------------------------------------------------------------*/
7327 /* put parameter for b1 protocol in the parameter buffer */
7328 /*------------------------------------------------------------------*/
7329
7330 static word add_b1(PLCI *plci, API_PARSE *bp, word b_channel_info,
7331 word b1_facilities)
7332 {
7333 API_PARSE bp_parms[8];
7334 API_PARSE mdm_cfg[9];
7335 API_PARSE global_config[2];
7336 byte cai[256];
7337 byte resource[] = {5, 9, 13, 12, 16, 39, 9, 17, 17, 18};
7338 byte voice_cai[] = "\x06\x14\x00\x00\x00\x00\x08";
7339 word i;
7340
7341 API_PARSE mdm_cfg_v18[4];
7342 word j, n, w;
7343 dword d;
7344
7345
7346 for (i = 0; i < 8; i++) bp_parms[i].length = 0;
7347 for (i = 0; i < 2; i++) global_config[i].length = 0;
7348
7349 dbug(1, dprintf("add_b1"));
7350 api_save_msg(bp, "s", &plci->B_protocol);
7351
7352 if (b_channel_info == 2) {
7353 plci->B1_resource = 0;
7354 adjust_b1_facilities(plci, plci->B1_resource, b1_facilities);
7355 add_p(plci, CAI, "\x01\x00");
7356 dbug(1, dprintf("Cai=1,0 (no resource)"));
7357 return 0;
7358 }
7359
7360 if (plci->tel == CODEC_PERMANENT) return 0;
7361 else if (plci->tel == CODEC) {
7362 plci->B1_resource = 1;
7363 adjust_b1_facilities(plci, plci->B1_resource, b1_facilities);
7364 add_p(plci, CAI, "\x01\x01");
7365 dbug(1, dprintf("Cai=1,1 (Codec)"));
7366 return 0;
7367 }
7368 else if (plci->tel == ADV_VOICE) {
7369 plci->B1_resource = add_b1_facilities(plci, 9, (word)(b1_facilities | B1_FACILITY_VOICE));
7370 adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities | B1_FACILITY_VOICE));
7371 voice_cai[1] = plci->B1_resource;
7372 PUT_WORD(&voice_cai[5], plci->appl->MaxDataLength);
7373 add_p(plci, CAI, voice_cai);
7374 dbug(1, dprintf("Cai=1,0x%x (AdvVoice)", voice_cai[1]));
7375 return 0;
7376 }
7377 plci->call_dir &= ~(CALL_DIR_ORIGINATE | CALL_DIR_ANSWER);
7378 if (plci->call_dir & CALL_DIR_OUT)
7379 plci->call_dir |= CALL_DIR_ORIGINATE;
7380 else if (plci->call_dir & CALL_DIR_IN)
7381 plci->call_dir |= CALL_DIR_ANSWER;
7382
7383 if (!bp->length) {
7384 plci->B1_resource = 0x5;
7385 adjust_b1_facilities(plci, plci->B1_resource, b1_facilities);
7386 add_p(plci, CAI, "\x01\x05");
7387 return 0;
7388 }
7389
7390 dbug(1, dprintf("b_prot_len=%d", (word)bp->length));
7391 if (bp->length > 256) return _WRONG_MESSAGE_FORMAT;
7392 if (api_parse(&bp->info[1], (word)bp->length, "wwwsssb", bp_parms))
7393 {
7394 bp_parms[6].length = 0;
7395 if (api_parse(&bp->info[1], (word)bp->length, "wwwsss", bp_parms))
7396 {
7397 dbug(1, dprintf("b-form.!"));
7398 return _WRONG_MESSAGE_FORMAT;
7399 }
7400 }
7401 else if (api_parse(&bp->info[1], (word)bp->length, "wwwssss", bp_parms))
7402 {
7403 dbug(1, dprintf("b-form.!"));
7404 return _WRONG_MESSAGE_FORMAT;
7405 }
7406
7407 if (bp_parms[6].length)
7408 {
7409 if (api_parse(&bp_parms[6].info[1], (word)bp_parms[6].length, "w", global_config))
7410 {
7411 return _WRONG_MESSAGE_FORMAT;
7412 }
7413 switch (GET_WORD(global_config[0].info))
7414 {
7415 case 1:
7416 plci->call_dir = (plci->call_dir & ~CALL_DIR_ANSWER) | CALL_DIR_ORIGINATE;
7417 break;
7418 case 2:
7419 plci->call_dir = (plci->call_dir & ~CALL_DIR_ORIGINATE) | CALL_DIR_ANSWER;
7420 break;
7421 }
7422 }
7423 dbug(1, dprintf("call_dir=%04x", plci->call_dir));
7424
7425
7426 if ((GET_WORD(bp_parms[0].info) == B1_RTP)
7427 && (plci->adapter->man_profile.private_options & (1L << PRIVATE_RTP)))
7428 {
7429 plci->B1_resource = add_b1_facilities(plci, 31, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7430 adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7431 cai[1] = plci->B1_resource;
7432 cai[2] = 0;
7433 cai[3] = 0;
7434 cai[4] = 0;
7435 PUT_WORD(&cai[5], plci->appl->MaxDataLength);
7436 for (i = 0; i < bp_parms[3].length; i++)
7437 cai[7 + i] = bp_parms[3].info[1 + i];
7438 cai[0] = 6 + bp_parms[3].length;
7439 add_p(plci, CAI, cai);
7440 return 0;
7441 }
7442
7443
7444 if ((GET_WORD(bp_parms[0].info) == B1_PIAFS)
7445 && (plci->adapter->man_profile.private_options & (1L << PRIVATE_PIAFS)))
7446 {
7447 plci->B1_resource = add_b1_facilities(plci, 35/* PIAFS HARDWARE FACILITY */, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7448 adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7449 cai[1] = plci->B1_resource;
7450 cai[2] = 0;
7451 cai[3] = 0;
7452 cai[4] = 0;
7453 PUT_WORD(&cai[5], plci->appl->MaxDataLength);
7454 cai[0] = 6;
7455 add_p(plci, CAI, cai);
7456 return 0;
7457 }
7458
7459
7460 if ((GET_WORD(bp_parms[0].info) >= 32)
7461 || (!((1L << GET_WORD(bp_parms[0].info)) & plci->adapter->profile.B1_Protocols)
7462 && ((GET_WORD(bp_parms[0].info) != 3)
7463 || !((1L << B1_HDLC) & plci->adapter->profile.B1_Protocols)
7464 || ((bp_parms[3].length != 0) && (GET_WORD(&bp_parms[3].info[1]) != 0) && (GET_WORD(&bp_parms[3].info[1]) != 56000)))))
7465 {
7466 return _B1_NOT_SUPPORTED;
7467 }
7468 plci->B1_resource = add_b1_facilities(plci, resource[GET_WORD(bp_parms[0].info)],
7469 (word)(b1_facilities & ~B1_FACILITY_VOICE));
7470 adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7471 cai[0] = 6;
7472 cai[1] = plci->B1_resource;
7473 for (i = 2; i < sizeof(cai); i++) cai[i] = 0;
7474
7475 if ((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE)
7476 || (GET_WORD(bp_parms[0].info) == B1_MODEM_ASYNC)
7477 || (GET_WORD(bp_parms[0].info) == B1_MODEM_SYNC_HDLC))
7478 { /* B1 - modem */
7479 for (i = 0; i < 7; i++) mdm_cfg[i].length = 0;
7480
7481 if (bp_parms[3].length)
7482 {
7483 if (api_parse(&bp_parms[3].info[1], (word)bp_parms[3].length, "wwwwww", mdm_cfg))
7484 {
7485 return (_WRONG_MESSAGE_FORMAT);
7486 }
7487
7488 cai[2] = 0; /* Bit rate for adaptation */
7489
7490 dbug(1, dprintf("MDM Max Bit Rate:<%d>", GET_WORD(mdm_cfg[0].info)));
7491
7492 PUT_WORD(&cai[13], 0); /* Min Tx speed */
7493 PUT_WORD(&cai[15], GET_WORD(mdm_cfg[0].info)); /* Max Tx speed */
7494 PUT_WORD(&cai[17], 0); /* Min Rx speed */
7495 PUT_WORD(&cai[19], GET_WORD(mdm_cfg[0].info)); /* Max Rx speed */
7496
7497 cai[3] = 0; /* Async framing parameters */
7498 switch (GET_WORD(mdm_cfg[2].info))
7499 { /* Parity */
7500 case 1: /* odd parity */
7501 cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_ODD);
7502 dbug(1, dprintf("MDM: odd parity"));
7503 break;
7504
7505 case 2: /* even parity */
7506 cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_EVEN);
7507 dbug(1, dprintf("MDM: even parity"));
7508 break;
7509
7510 default:
7511 dbug(1, dprintf("MDM: no parity"));
7512 break;
7513 }
7514
7515 switch (GET_WORD(mdm_cfg[3].info))
7516 { /* stop bits */
7517 case 1: /* 2 stop bits */
7518 cai[3] |= DSP_CAI_ASYNC_TWO_STOP_BITS;
7519 dbug(1, dprintf("MDM: 2 stop bits"));
7520 break;
7521
7522 default:
7523 dbug(1, dprintf("MDM: 1 stop bit"));
7524 break;
7525 }
7526
7527 switch (GET_WORD(mdm_cfg[1].info))
7528 { /* char length */
7529 case 5:
7530 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_5;
7531 dbug(1, dprintf("MDM: 5 bits"));
7532 break;
7533
7534 case 6:
7535 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_6;
7536 dbug(1, dprintf("MDM: 6 bits"));
7537 break;
7538
7539 case 7:
7540 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_7;
7541 dbug(1, dprintf("MDM: 7 bits"));
7542 break;
7543
7544 default:
7545 dbug(1, dprintf("MDM: 8 bits"));
7546 break;
7547 }
7548
7549 cai[7] = 0; /* Line taking options */
7550 cai[8] = 0; /* Modulation negotiation options */
7551 cai[9] = 0; /* Modulation options */
7552
7553 if (((plci->call_dir & CALL_DIR_ORIGINATE) != 0) ^ ((plci->call_dir & CALL_DIR_OUT) != 0))
7554 {
7555 cai[9] |= DSP_CAI_MODEM_REVERSE_DIRECTION;
7556 dbug(1, dprintf("MDM: Reverse direction"));
7557 }
7558
7559 if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_DISABLE_RETRAIN)
7560 {
7561 cai[9] |= DSP_CAI_MODEM_DISABLE_RETRAIN;
7562 dbug(1, dprintf("MDM: Disable retrain"));
7563 }
7564
7565 if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_DISABLE_RING_TONE)
7566 {
7567 cai[7] |= DSP_CAI_MODEM_DISABLE_CALLING_TONE | DSP_CAI_MODEM_DISABLE_ANSWER_TONE;
7568 dbug(1, dprintf("MDM: Disable ring tone"));
7569 }
7570
7571 if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_GUARD_1800)
7572 {
7573 cai[8] |= DSP_CAI_MODEM_GUARD_TONE_1800HZ;
7574 dbug(1, dprintf("MDM: 1800 guard tone"));
7575 }
7576 else if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_GUARD_550)
7577 {
7578 cai[8] |= DSP_CAI_MODEM_GUARD_TONE_550HZ;
7579 dbug(1, dprintf("MDM: 550 guard tone"));
7580 }
7581
7582 if ((GET_WORD(mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_V100)
7583 {
7584 cai[8] |= DSP_CAI_MODEM_NEGOTIATE_V100;
7585 dbug(1, dprintf("MDM: V100"));
7586 }
7587 else if ((GET_WORD(mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_MOD_CLASS)
7588 {
7589 cai[8] |= DSP_CAI_MODEM_NEGOTIATE_IN_CLASS;
7590 dbug(1, dprintf("MDM: IN CLASS"));
7591 }
7592 else if ((GET_WORD(mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_DISABLED)
7593 {
7594 cai[8] |= DSP_CAI_MODEM_NEGOTIATE_DISABLED;
7595 dbug(1, dprintf("MDM: DISABLED"));
7596 }
7597 cai[0] = 20;
7598
7599 if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_V18))
7600 && (GET_WORD(mdm_cfg[5].info) & 0x8000)) /* Private V.18 enable */
7601 {
7602 plci->requested_options |= 1L << PRIVATE_V18;
7603 }
7604 if (GET_WORD(mdm_cfg[5].info) & 0x4000) /* Private VOWN enable */
7605 plci->requested_options |= 1L << PRIVATE_VOWN;
7606
7607 if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
7608 & ((1L << PRIVATE_V18) | (1L << PRIVATE_VOWN)))
7609 {
7610 if (!api_parse(&bp_parms[3].info[1], (word)bp_parms[3].length, "wwwwwws", mdm_cfg))
7611 {
7612 i = 27;
7613 if (mdm_cfg[6].length >= 4)
7614 {
7615 d = GET_DWORD(&mdm_cfg[6].info[1]);
7616 cai[7] |= (byte) d; /* line taking options */
7617 cai[9] |= (byte)(d >> 8); /* modulation options */
7618 cai[++i] = (byte)(d >> 16); /* vown modulation options */
7619 cai[++i] = (byte)(d >> 24);
7620 if (mdm_cfg[6].length >= 8)
7621 {
7622 d = GET_DWORD(&mdm_cfg[6].info[5]);
7623 cai[10] |= (byte) d; /* disabled modulations mask */
7624 cai[11] |= (byte)(d >> 8);
7625 if (mdm_cfg[6].length >= 12)
7626 {
7627 d = GET_DWORD(&mdm_cfg[6].info[9]);
7628 cai[12] = (byte) d; /* enabled modulations mask */
7629 cai[++i] = (byte)(d >> 8); /* vown enabled modulations */
7630 cai[++i] = (byte)(d >> 16);
7631 cai[++i] = (byte)(d >> 24);
7632 cai[++i] = 0;
7633 if (mdm_cfg[6].length >= 14)
7634 {
7635 w = GET_WORD(&mdm_cfg[6].info[13]);
7636 if (w != 0)
7637 PUT_WORD(&cai[13], w); /* min tx speed */
7638 if (mdm_cfg[6].length >= 16)
7639 {
7640 w = GET_WORD(&mdm_cfg[6].info[15]);
7641 if (w != 0)
7642 PUT_WORD(&cai[15], w); /* max tx speed */
7643 if (mdm_cfg[6].length >= 18)
7644 {
7645 w = GET_WORD(&mdm_cfg[6].info[17]);
7646 if (w != 0)
7647 PUT_WORD(&cai[17], w); /* min rx speed */
7648 if (mdm_cfg[6].length >= 20)
7649 {
7650 w = GET_WORD(&mdm_cfg[6].info[19]);
7651 if (w != 0)
7652 PUT_WORD(&cai[19], w); /* max rx speed */
7653 if (mdm_cfg[6].length >= 22)
7654 {
7655 w = GET_WORD(&mdm_cfg[6].info[21]);
7656 cai[23] = (byte)(-((short) w)); /* transmit level */
7657 if (mdm_cfg[6].length >= 24)
7658 {
7659 w = GET_WORD(&mdm_cfg[6].info[23]);
7660 cai[22] |= (byte) w; /* info options mask */
7661 cai[21] |= (byte)(w >> 8); /* disabled symbol rates */
7662 }
7663 }
7664 }
7665 }
7666 }
7667 }
7668 }
7669 }
7670 }
7671 cai[27] = i - 27;
7672 i++;
7673 if (!api_parse(&bp_parms[3].info[1], (word)bp_parms[3].length, "wwwwwwss", mdm_cfg))
7674 {
7675 if (!api_parse(&mdm_cfg[7].info[1], (word)mdm_cfg[7].length, "sss", mdm_cfg_v18))
7676 {
7677 for (n = 0; n < 3; n++)
7678 {
7679 cai[i] = (byte)(mdm_cfg_v18[n].length);
7680 for (j = 1; j < ((word)(cai[i] + 1)); j++)
7681 cai[i + j] = mdm_cfg_v18[n].info[j];
7682 i += cai[i] + 1;
7683 }
7684 }
7685 }
7686 cai[0] = (byte)(i - 1);
7687 }
7688 }
7689
7690 }
7691 }
7692 if (GET_WORD(bp_parms[0].info) == 2 || /* V.110 async */
7693 GET_WORD(bp_parms[0].info) == 3) /* V.110 sync */
7694 {
7695 if (bp_parms[3].length) {
7696 dbug(1, dprintf("V.110,%d", GET_WORD(&bp_parms[3].info[1])));
7697 switch (GET_WORD(&bp_parms[3].info[1])) { /* Rate */
7698 case 0:
7699 case 56000:
7700 if (GET_WORD(bp_parms[0].info) == 3) { /* V.110 sync 56k */
7701 dbug(1, dprintf("56k sync HSCX"));
7702 cai[1] = 8;
7703 cai[2] = 0;
7704 cai[3] = 0;
7705 }
7706 else if (GET_WORD(bp_parms[0].info) == 2) {
7707 dbug(1, dprintf("56k async DSP"));
7708 cai[2] = 9;
7709 }
7710 break;
7711 case 50: cai[2] = 1; break;
7712 case 75: cai[2] = 1; break;
7713 case 110: cai[2] = 1; break;
7714 case 150: cai[2] = 1; break;
7715 case 200: cai[2] = 1; break;
7716 case 300: cai[2] = 1; break;
7717 case 600: cai[2] = 1; break;
7718 case 1200: cai[2] = 2; break;
7719 case 2400: cai[2] = 3; break;
7720 case 4800: cai[2] = 4; break;
7721 case 7200: cai[2] = 10; break;
7722 case 9600: cai[2] = 5; break;
7723 case 12000: cai[2] = 13; break;
7724 case 24000: cai[2] = 0; break;
7725 case 14400: cai[2] = 11; break;
7726 case 19200: cai[2] = 6; break;
7727 case 28800: cai[2] = 12; break;
7728 case 38400: cai[2] = 7; break;
7729 case 48000: cai[2] = 8; break;
7730 case 76: cai[2] = 15; break; /* 75/1200 */
7731 case 1201: cai[2] = 14; break; /* 1200/75 */
7732 case 56001: cai[2] = 9; break; /* V.110 56000 */
7733
7734 default:
7735 return _B1_PARM_NOT_SUPPORTED;
7736 }
7737 cai[3] = 0;
7738 if (cai[1] == 13) /* v.110 async */
7739 {
7740 if (bp_parms[3].length >= 8)
7741 {
7742 switch (GET_WORD(&bp_parms[3].info[3]))
7743 { /* char length */
7744 case 5:
7745 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_5;
7746 break;
7747 case 6:
7748 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_6;
7749 break;
7750 case 7:
7751 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_7;
7752 break;
7753 }
7754 switch (GET_WORD(&bp_parms[3].info[5]))
7755 { /* Parity */
7756 case 1: /* odd parity */
7757 cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_ODD);
7758 break;
7759 case 2: /* even parity */
7760 cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_EVEN);
7761 break;
7762 }
7763 switch (GET_WORD(&bp_parms[3].info[7]))
7764 { /* stop bits */
7765 case 1: /* 2 stop bits */
7766 cai[3] |= DSP_CAI_ASYNC_TWO_STOP_BITS;
7767 break;
7768 }
7769 }
7770 }
7771 }
7772 else if (cai[1] == 8 || GET_WORD(bp_parms[0].info) == 3) {
7773 dbug(1, dprintf("V.110 default 56k sync"));
7774 cai[1] = 8;
7775 cai[2] = 0;
7776 cai[3] = 0;
7777 }
7778 else {
7779 dbug(1, dprintf("V.110 default 9600 async"));
7780 cai[2] = 5;
7781 }
7782 }
7783 PUT_WORD(&cai[5], plci->appl->MaxDataLength);
7784 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]));
7785 /* HexDump ("CAI", sizeof(cai), &cai[0]); */
7786
7787 add_p(plci, CAI, cai);
7788 return 0;
7789 }
7790
7791 /*------------------------------------------------------------------*/
7792 /* put parameter for b2 and B3 protocol in the parameter buffer */
7793 /*------------------------------------------------------------------*/
7794
7795 static word add_b23(PLCI *plci, API_PARSE *bp)
7796 {
7797 word i, fax_control_bits;
7798 byte pos, len;
7799 byte SAPI = 0x40; /* default SAPI 16 for x.31 */
7800 API_PARSE bp_parms[8];
7801 API_PARSE *b1_config;
7802 API_PARSE *b2_config;
7803 API_PARSE b2_config_parms[8];
7804 API_PARSE *b3_config;
7805 API_PARSE b3_config_parms[6];
7806 API_PARSE global_config[2];
7807
7808 static byte llc[3] = {2,0,0};
7809 static byte dlc[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
7810 static byte nlc[256];
7811 static byte lli[12] = {1,1};
7812
7813 const byte llc2_out[] = {1,2,4,6,2,0,0,0, X75_V42BIS,V120_L2,V120_V42BIS,V120_L2,6};
7814 const byte llc2_in[] = {1,3,4,6,3,0,0,0, X75_V42BIS,V120_L2,V120_V42BIS,V120_L2,6};
7815
7816 const byte llc3[] = {4,3,2,2,6,6,0};
7817 const byte header[] = {0,2,3,3,0,0,0};
7818
7819 for (i = 0; i < 8; i++) bp_parms[i].length = 0;
7820 for (i = 0; i < 6; i++) b2_config_parms[i].length = 0;
7821 for (i = 0; i < 5; i++) b3_config_parms[i].length = 0;
7822
7823 lli[0] = 1;
7824 lli[1] = 1;
7825 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL)
7826 lli[1] |= 2;
7827 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL)
7828 lli[1] |= 4;
7829
7830 if ((lli[1] & 0x02) && (diva_xdi_extended_features & DIVA_CAPI_USE_CMA)) {
7831 lli[1] |= 0x10;
7832 if (plci->rx_dma_descriptor <= 0) {
7833 plci->rx_dma_descriptor = diva_get_dma_descriptor(plci, &plci->rx_dma_magic);
7834 if (plci->rx_dma_descriptor >= 0)
7835 plci->rx_dma_descriptor++;
7836 }
7837 if (plci->rx_dma_descriptor > 0) {
7838 lli[0] = 6;
7839 lli[1] |= 0x40;
7840 lli[2] = (byte)(plci->rx_dma_descriptor - 1);
7841 lli[3] = (byte)plci->rx_dma_magic;
7842 lli[4] = (byte)(plci->rx_dma_magic >> 8);
7843 lli[5] = (byte)(plci->rx_dma_magic >> 16);
7844 lli[6] = (byte)(plci->rx_dma_magic >> 24);
7845 }
7846 }
7847
7848 if (DIVA_CAPI_SUPPORTS_NO_CANCEL(plci->adapter)) {
7849 lli[1] |= 0x20;
7850 }
7851
7852 dbug(1, dprintf("add_b23"));
7853 api_save_msg(bp, "s", &plci->B_protocol);
7854
7855 if (!bp->length && plci->tel)
7856 {
7857 plci->adv_nl = true;
7858 dbug(1, dprintf("Default adv.Nl"));
7859 add_p(plci, LLI, lli);
7860 plci->B2_prot = 1 /*XPARENT*/;
7861 plci->B3_prot = 0 /*XPARENT*/;
7862 llc[1] = 2;
7863 llc[2] = 4;
7864 add_p(plci, LLC, llc);
7865 dlc[0] = 2;
7866 PUT_WORD(&dlc[1], plci->appl->MaxDataLength);
7867 add_p(plci, DLC, dlc);
7868 return 0;
7869 }
7870
7871 if (!bp->length) /*default*/
7872 {
7873 dbug(1, dprintf("ret default"));
7874 add_p(plci, LLI, lli);
7875 plci->B2_prot = 0 /*X.75 */;
7876 plci->B3_prot = 0 /*XPARENT*/;
7877 llc[1] = 1;
7878 llc[2] = 4;
7879 add_p(plci, LLC, llc);
7880 dlc[0] = 2;
7881 PUT_WORD(&dlc[1], plci->appl->MaxDataLength);
7882 add_p(plci, DLC, dlc);
7883 return 0;
7884 }
7885 dbug(1, dprintf("b_prot_len=%d", (word)bp->length));
7886 if ((word)bp->length > 256) return _WRONG_MESSAGE_FORMAT;
7887
7888 if (api_parse(&bp->info[1], (word)bp->length, "wwwsssb", bp_parms))
7889 {
7890 bp_parms[6].length = 0;
7891 if (api_parse(&bp->info[1], (word)bp->length, "wwwsss", bp_parms))
7892 {
7893 dbug(1, dprintf("b-form.!"));
7894 return _WRONG_MESSAGE_FORMAT;
7895 }
7896 }
7897 else if (api_parse(&bp->info[1], (word)bp->length, "wwwssss", bp_parms))
7898 {
7899 dbug(1, dprintf("b-form.!"));
7900 return _WRONG_MESSAGE_FORMAT;
7901 }
7902
7903 if (plci->tel == ADV_VOICE) /* transparent B on advanced voice */
7904 {
7905 if (GET_WORD(bp_parms[1].info) != 1
7906 || GET_WORD(bp_parms[2].info) != 0) return _B2_NOT_SUPPORTED;
7907 plci->adv_nl = true;
7908 }
7909 else if (plci->tel) return _B2_NOT_SUPPORTED;
7910
7911
7912 if ((GET_WORD(bp_parms[1].info) == B2_RTP)
7913 && (GET_WORD(bp_parms[2].info) == B3_RTP)
7914 && (plci->adapter->man_profile.private_options & (1L << PRIVATE_RTP)))
7915 {
7916 add_p(plci, LLI, lli);
7917 plci->B2_prot = (byte) GET_WORD(bp_parms[1].info);
7918 plci->B3_prot = (byte) GET_WORD(bp_parms[2].info);
7919 llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ? 14 : 13;
7920 llc[2] = 4;
7921 add_p(plci, LLC, llc);
7922 dlc[0] = 2;
7923 PUT_WORD(&dlc[1], plci->appl->MaxDataLength);
7924 dlc[3] = 3; /* Addr A */
7925 dlc[4] = 1; /* Addr B */
7926 dlc[5] = 7; /* modulo mode */
7927 dlc[6] = 7; /* window size */
7928 dlc[7] = 0; /* XID len Lo */
7929 dlc[8] = 0; /* XID len Hi */
7930 for (i = 0; i < bp_parms[4].length; i++)
7931 dlc[9 + i] = bp_parms[4].info[1 + i];
7932 dlc[0] = (byte)(8 + bp_parms[4].length);
7933 add_p(plci, DLC, dlc);
7934 for (i = 0; i < bp_parms[5].length; i++)
7935 nlc[1 + i] = bp_parms[5].info[1 + i];
7936 nlc[0] = (byte)(bp_parms[5].length);
7937 add_p(plci, NLC, nlc);
7938 return 0;
7939 }
7940
7941
7942
7943 if ((GET_WORD(bp_parms[1].info) >= 32)
7944 || (!((1L << GET_WORD(bp_parms[1].info)) & plci->adapter->profile.B2_Protocols)
7945 && ((GET_WORD(bp_parms[1].info) != B2_PIAFS)
7946 || !(plci->adapter->man_profile.private_options & (1L << PRIVATE_PIAFS)))))
7947
7948 {
7949 return _B2_NOT_SUPPORTED;
7950 }
7951 if ((GET_WORD(bp_parms[2].info) >= 32)
7952 || !((1L << GET_WORD(bp_parms[2].info)) & plci->adapter->profile.B3_Protocols))
7953 {
7954 return _B3_NOT_SUPPORTED;
7955 }
7956 if ((GET_WORD(bp_parms[1].info) != B2_SDLC)
7957 && ((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE)
7958 || (GET_WORD(bp_parms[0].info) == B1_MODEM_ASYNC)
7959 || (GET_WORD(bp_parms[0].info) == B1_MODEM_SYNC_HDLC)))
7960 {
7961 return (add_modem_b23(plci, bp_parms));
7962 }
7963
7964 add_p(plci, LLI, lli);
7965
7966 plci->B2_prot = (byte)GET_WORD(bp_parms[1].info);
7967 plci->B3_prot = (byte)GET_WORD(bp_parms[2].info);
7968 if (plci->B2_prot == 12) SAPI = 0; /* default SAPI D-channel */
7969
7970 if (bp_parms[6].length)
7971 {
7972 if (api_parse(&bp_parms[6].info[1], (word)bp_parms[6].length, "w", global_config))
7973 {
7974 return _WRONG_MESSAGE_FORMAT;
7975 }
7976 switch (GET_WORD(global_config[0].info))
7977 {
7978 case 1:
7979 plci->call_dir = (plci->call_dir & ~CALL_DIR_ANSWER) | CALL_DIR_ORIGINATE;
7980 break;
7981 case 2:
7982 plci->call_dir = (plci->call_dir & ~CALL_DIR_ORIGINATE) | CALL_DIR_ANSWER;
7983 break;
7984 }
7985 }
7986 dbug(1, dprintf("call_dir=%04x", plci->call_dir));
7987
7988
7989 if (plci->B2_prot == B2_PIAFS)
7990 llc[1] = PIAFS_CRC;
7991 else
7992 /* IMPLEMENT_PIAFS */
7993 {
7994 llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ?
7995 llc2_out[GET_WORD(bp_parms[1].info)] : llc2_in[GET_WORD(bp_parms[1].info)];
7996 }
7997 llc[2] = llc3[GET_WORD(bp_parms[2].info)];
7998
7999 add_p(plci, LLC, llc);
8000
8001 dlc[0] = 2;
8002 PUT_WORD(&dlc[1], plci->appl->MaxDataLength +
8003 header[GET_WORD(bp_parms[2].info)]);
8004
8005 b1_config = &bp_parms[3];
8006 nlc[0] = 0;
8007 if (plci->B3_prot == 4
8008 || plci->B3_prot == 5)
8009 {
8010 for (i = 0; i < sizeof(T30_INFO); i++) nlc[i] = 0;
8011 nlc[0] = sizeof(T30_INFO);
8012 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
8013 ((T30_INFO *)&nlc[1])->operating_mode = T30_OPERATING_MODE_CAPI;
8014 ((T30_INFO *)&nlc[1])->rate_div_2400 = 0xff;
8015 if (b1_config->length >= 2)
8016 {
8017 ((T30_INFO *)&nlc[1])->rate_div_2400 = (byte)(GET_WORD(&b1_config->info[1]) / 2400);
8018 }
8019 }
8020 b2_config = &bp_parms[4];
8021
8022
8023 if (llc[1] == PIAFS_CRC)
8024 {
8025 if (plci->B3_prot != B3_TRANSPARENT)
8026 {
8027 return _B_STACK_NOT_SUPPORTED;
8028 }
8029 if (b2_config->length && api_parse(&b2_config->info[1], (word)b2_config->length, "bwww", b2_config_parms)) {
8030 return _WRONG_MESSAGE_FORMAT;
8031 }
8032 PUT_WORD(&dlc[1], plci->appl->MaxDataLength);
8033 dlc[3] = 0; /* Addr A */
8034 dlc[4] = 0; /* Addr B */
8035 dlc[5] = 0; /* modulo mode */
8036 dlc[6] = 0; /* window size */
8037 if (b2_config->length >= 7) {
8038 dlc[7] = 7;
8039 dlc[8] = 0;
8040 dlc[9] = b2_config_parms[0].info[0]; /* PIAFS protocol Speed configuration */
8041 dlc[10] = b2_config_parms[1].info[0]; /* V.42bis P0 */
8042 dlc[11] = b2_config_parms[1].info[1]; /* V.42bis P0 */
8043 dlc[12] = b2_config_parms[2].info[0]; /* V.42bis P1 */
8044 dlc[13] = b2_config_parms[2].info[1]; /* V.42bis P1 */
8045 dlc[14] = b2_config_parms[3].info[0]; /* V.42bis P2 */
8046 dlc[15] = b2_config_parms[3].info[1]; /* V.42bis P2 */
8047 dlc[0] = 15;
8048 if (b2_config->length >= 8) { /* PIAFS control abilities */
8049 dlc[7] = 10;
8050 dlc[16] = 2; /* Length of PIAFS extension */
8051 dlc[17] = PIAFS_UDATA_ABILITIES; /* control (UDATA) ability */
8052 dlc[18] = b2_config_parms[4].info[0]; /* value */
8053 dlc[0] = 18;
8054 }
8055 }
8056 else /* default values, 64K, variable, no compression */
8057 {
8058 dlc[7] = 7;
8059 dlc[8] = 0;
8060 dlc[9] = 0x03; /* PIAFS protocol Speed configuration */
8061 dlc[10] = 0x03; /* V.42bis P0 */
8062 dlc[11] = 0; /* V.42bis P0 */
8063 dlc[12] = 0; /* V.42bis P1 */
8064 dlc[13] = 0; /* V.42bis P1 */
8065 dlc[14] = 0; /* V.42bis P2 */
8066 dlc[15] = 0; /* V.42bis P2 */
8067 dlc[0] = 15;
8068 }
8069 add_p(plci, DLC, dlc);
8070 }
8071 else
8072
8073 if ((llc[1] == V120_L2) || (llc[1] == V120_V42BIS))
8074 {
8075 if (plci->B3_prot != B3_TRANSPARENT)
8076 return _B_STACK_NOT_SUPPORTED;
8077
8078 dlc[0] = 6;
8079 PUT_WORD(&dlc[1], GET_WORD(&dlc[1]) + 2);
8080 dlc[3] = 0x08;
8081 dlc[4] = 0x01;
8082 dlc[5] = 127;
8083 dlc[6] = 7;
8084 if (b2_config->length != 0)
8085 {
8086 if ((llc[1] == V120_V42BIS) && api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbwww", b2_config_parms)) {
8087 return _WRONG_MESSAGE_FORMAT;
8088 }
8089 dlc[3] = (byte)((b2_config->info[2] << 3) | ((b2_config->info[1] >> 5) & 0x04));
8090 dlc[4] = (byte)((b2_config->info[1] << 1) | 0x01);
8091 if (b2_config->info[3] != 128)
8092 {
8093 dbug(1, dprintf("1D-dlc= %x %x %x %x %x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4]));
8094 return _B2_PARM_NOT_SUPPORTED;
8095 }
8096 dlc[5] = (byte)(b2_config->info[3] - 1);
8097 dlc[6] = b2_config->info[4];
8098 if (llc[1] == V120_V42BIS) {
8099 if (b2_config->length >= 10) {
8100 dlc[7] = 6;
8101 dlc[8] = 0;
8102 dlc[9] = b2_config_parms[4].info[0];
8103 dlc[10] = b2_config_parms[4].info[1];
8104 dlc[11] = b2_config_parms[5].info[0];
8105 dlc[12] = b2_config_parms[5].info[1];
8106 dlc[13] = b2_config_parms[6].info[0];
8107 dlc[14] = b2_config_parms[6].info[1];
8108 dlc[0] = 14;
8109 dbug(1, dprintf("b2_config_parms[4].info[0] [1]: %x %x", b2_config_parms[4].info[0], b2_config_parms[4].info[1]));
8110 dbug(1, dprintf("b2_config_parms[5].info[0] [1]: %x %x", b2_config_parms[5].info[0], b2_config_parms[5].info[1]));
8111 dbug(1, dprintf("b2_config_parms[6].info[0] [1]: %x %x", b2_config_parms[6].info[0], b2_config_parms[6].info[1]));
8112 }
8113 else {
8114 dlc[6] = 14;
8115 }
8116 }
8117 }
8118 }
8119 else
8120 {
8121 if (b2_config->length)
8122 {
8123 dbug(1, dprintf("B2-Config"));
8124 if (llc[1] == X75_V42BIS) {
8125 if (api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbwww", b2_config_parms))
8126 {
8127 return _WRONG_MESSAGE_FORMAT;
8128 }
8129 }
8130 else {
8131 if (api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbs", b2_config_parms))
8132 {
8133 return _WRONG_MESSAGE_FORMAT;
8134 }
8135 }
8136 /* if B2 Protocol is LAPD, b2_config structure is different */
8137 if (llc[1] == 6)
8138 {
8139 dlc[0] = 4;
8140 if (b2_config->length >= 1) dlc[2] = b2_config->info[1]; /* TEI */
8141 else dlc[2] = 0x01;
8142 if ((b2_config->length >= 2) && (plci->B2_prot == 12))
8143 {
8144 SAPI = b2_config->info[2]; /* SAPI */
8145 }
8146 dlc[1] = SAPI;
8147 if ((b2_config->length >= 3) && (b2_config->info[3] == 128))
8148 {
8149 dlc[3] = 127; /* Mode */
8150 }
8151 else
8152 {
8153 dlc[3] = 7; /* Mode */
8154 }
8155
8156 if (b2_config->length >= 4) dlc[4] = b2_config->info[4]; /* Window */
8157 else dlc[4] = 1;
8158 dbug(1, dprintf("D-dlc[%d]=%x,%x,%x,%x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4]));
8159 if (b2_config->length > 5) return _B2_PARM_NOT_SUPPORTED;
8160 }
8161 else
8162 {
8163 dlc[0] = (byte)(b2_config_parms[4].length + 6);
8164 dlc[3] = b2_config->info[1];
8165 dlc[4] = b2_config->info[2];
8166 if (b2_config->info[3] != 8 && b2_config->info[3] != 128) {
8167 dbug(1, dprintf("1D-dlc= %x %x %x %x %x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4]));
8168 return _B2_PARM_NOT_SUPPORTED;
8169 }
8170
8171 dlc[5] = (byte)(b2_config->info[3] - 1);
8172 dlc[6] = b2_config->info[4];
8173 if (dlc[6] > dlc[5]) {
8174 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]));
8175 return _B2_PARM_NOT_SUPPORTED;
8176 }
8177
8178 if (llc[1] == X75_V42BIS) {
8179 if (b2_config->length >= 10) {
8180 dlc[7] = 6;
8181 dlc[8] = 0;
8182 dlc[9] = b2_config_parms[4].info[0];
8183 dlc[10] = b2_config_parms[4].info[1];
8184 dlc[11] = b2_config_parms[5].info[0];
8185 dlc[12] = b2_config_parms[5].info[1];
8186 dlc[13] = b2_config_parms[6].info[0];
8187 dlc[14] = b2_config_parms[6].info[1];
8188 dlc[0] = 14;
8189 dbug(1, dprintf("b2_config_parms[4].info[0] [1]: %x %x", b2_config_parms[4].info[0], b2_config_parms[4].info[1]));
8190 dbug(1, dprintf("b2_config_parms[5].info[0] [1]: %x %x", b2_config_parms[5].info[0], b2_config_parms[5].info[1]));
8191 dbug(1, dprintf("b2_config_parms[6].info[0] [1]: %x %x", b2_config_parms[6].info[0], b2_config_parms[6].info[1]));
8192 }
8193 else {
8194 dlc[6] = 14;
8195 }
8196
8197 }
8198 else {
8199 PUT_WORD(&dlc[7], (word)b2_config_parms[4].length);
8200 for (i = 0; i < b2_config_parms[4].length; i++)
8201 dlc[11 + i] = b2_config_parms[4].info[1 + i];
8202 }
8203 }
8204 }
8205 }
8206 add_p(plci, DLC, dlc);
8207
8208 b3_config = &bp_parms[5];
8209 if (b3_config->length)
8210 {
8211 if (plci->B3_prot == 4
8212 || plci->B3_prot == 5)
8213 {
8214 if (api_parse(&b3_config->info[1], (word)b3_config->length, "wwss", b3_config_parms))
8215 {
8216 return _WRONG_MESSAGE_FORMAT;
8217 }
8218 i = GET_WORD((byte *)(b3_config_parms[0].info));
8219 ((T30_INFO *)&nlc[1])->resolution = (byte)(((i & 0x0001) ||
8220 ((plci->B3_prot == 4) && (((byte)(GET_WORD((byte *)b3_config_parms[1].info))) != 5))) ? T30_RESOLUTION_R8_0770_OR_200 : 0);
8221 ((T30_INFO *)&nlc[1])->data_format = (byte)(GET_WORD((byte *)b3_config_parms[1].info));
8222 fax_control_bits = T30_CONTROL_BIT_ALL_FEATURES;
8223 if ((((T30_INFO *)&nlc[1])->rate_div_2400 != 0) && (((T30_INFO *)&nlc[1])->rate_div_2400 <= 6))
8224 fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_V34FAX;
8225 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
8226 {
8227
8228 if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
8229 & (1L << PRIVATE_FAX_PAPER_FORMATS))
8230 {
8231 ((T30_INFO *)&nlc[1])->resolution |= T30_RESOLUTION_R8_1540 |
8232 T30_RESOLUTION_R16_1540_OR_400 | T30_RESOLUTION_300_300 |
8233 T30_RESOLUTION_INCH_BASED | T30_RESOLUTION_METRIC_BASED;
8234 }
8235
8236 ((T30_INFO *)&nlc[1])->recording_properties =
8237 T30_RECORDING_WIDTH_ISO_A3 |
8238 (T30_RECORDING_LENGTH_UNLIMITED << 2) |
8239 (T30_MIN_SCANLINE_TIME_00_00_00 << 4);
8240 }
8241 if (plci->B3_prot == 5)
8242 {
8243 if (i & 0x0002) /* Accept incoming fax-polling requests */
8244 fax_control_bits |= T30_CONTROL_BIT_ACCEPT_POLLING;
8245 if (i & 0x2000) /* Do not use MR compression */
8246 fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_2D_CODING;
8247 if (i & 0x4000) /* Do not use MMR compression */
8248 fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_T6_CODING;
8249 if (i & 0x8000) /* Do not use ECM */
8250 fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_ECM;
8251 if (plci->fax_connect_info_length != 0)
8252 {
8253 ((T30_INFO *)&nlc[1])->resolution = ((T30_INFO *)plci->fax_connect_info_buffer)->resolution;
8254 ((T30_INFO *)&nlc[1])->data_format = ((T30_INFO *)plci->fax_connect_info_buffer)->data_format;
8255 ((T30_INFO *)&nlc[1])->recording_properties = ((T30_INFO *)plci->fax_connect_info_buffer)->recording_properties;
8256 fax_control_bits |= GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low) &
8257 (T30_CONTROL_BIT_REQUEST_POLLING | T30_CONTROL_BIT_MORE_DOCUMENTS);
8258 }
8259 }
8260 /* copy station id to NLC */
8261 for (i = 0; i < T30_MAX_STATION_ID_LENGTH; i++)
8262 {
8263 if (i < b3_config_parms[2].length)
8264 {
8265 ((T30_INFO *)&nlc[1])->station_id[i] = ((byte *)b3_config_parms[2].info)[1 + i];
8266 }
8267 else
8268 {
8269 ((T30_INFO *)&nlc[1])->station_id[i] = ' ';
8270 }
8271 }
8272 ((T30_INFO *)&nlc[1])->station_id_len = T30_MAX_STATION_ID_LENGTH;
8273 /* copy head line to NLC */
8274 if (b3_config_parms[3].length)
8275 {
8276
8277 pos = (byte)(fax_head_line_time(&(((T30_INFO *)&nlc[1])->station_id[T30_MAX_STATION_ID_LENGTH])));
8278 if (pos != 0)
8279 {
8280 if (CAPI_MAX_DATE_TIME_LENGTH + 2 + b3_config_parms[3].length > CAPI_MAX_HEAD_LINE_SPACE)
8281 pos = 0;
8282 else
8283 {
8284 nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
8285 nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
8286 len = (byte)b3_config_parms[2].length;
8287 if (len > 20)
8288 len = 20;
8289 if (CAPI_MAX_DATE_TIME_LENGTH + 2 + len + 2 + b3_config_parms[3].length <= CAPI_MAX_HEAD_LINE_SPACE)
8290 {
8291 for (i = 0; i < len; i++)
8292 nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ((byte *)b3_config_parms[2].info)[1 + i];
8293 nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
8294 nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
8295 }
8296 }
8297 }
8298
8299 len = (byte)b3_config_parms[3].length;
8300 if (len > CAPI_MAX_HEAD_LINE_SPACE - pos)
8301 len = (byte)(CAPI_MAX_HEAD_LINE_SPACE - pos);
8302 ((T30_INFO *)&nlc[1])->head_line_len = (byte)(pos + len);
8303 nlc[0] += (byte)(pos + len);
8304 for (i = 0; i < len; i++)
8305 nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ((byte *)b3_config_parms[3].info)[1 + i];
8306 } else
8307 ((T30_INFO *)&nlc[1])->head_line_len = 0;
8308
8309 plci->nsf_control_bits = 0;
8310 if (plci->B3_prot == 5)
8311 {
8312 if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_FAX_SUB_SEP_PWD))
8313 && (GET_WORD((byte *)b3_config_parms[1].info) & 0x8000)) /* Private SUB/SEP/PWD enable */
8314 {
8315 plci->requested_options |= 1L << PRIVATE_FAX_SUB_SEP_PWD;
8316 }
8317 if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_FAX_NONSTANDARD))
8318 && (GET_WORD((byte *)b3_config_parms[1].info) & 0x4000)) /* Private non-standard facilities enable */
8319 {
8320 plci->requested_options |= 1L << PRIVATE_FAX_NONSTANDARD;
8321 }
8322 if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
8323 & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
8324 {
8325 if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
8326 & (1L << PRIVATE_FAX_SUB_SEP_PWD))
8327 {
8328 fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_PASSWORD;
8329 if (fax_control_bits & T30_CONTROL_BIT_ACCEPT_POLLING)
8330 fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SEL_POLLING;
8331 }
8332 len = nlc[0];
8333 pos = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
8334 if (pos < plci->fax_connect_info_length)
8335 {
8336 for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--)
8337 nlc[++len] = plci->fax_connect_info_buffer[pos++];
8338 }
8339 else
8340 nlc[++len] = 0;
8341 if (pos < plci->fax_connect_info_length)
8342 {
8343 for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--)
8344 nlc[++len] = plci->fax_connect_info_buffer[pos++];
8345 }
8346 else
8347 nlc[++len] = 0;
8348 if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
8349 & (1L << PRIVATE_FAX_NONSTANDARD))
8350 {
8351 if ((pos < plci->fax_connect_info_length) && (plci->fax_connect_info_buffer[pos] != 0))
8352 {
8353 if ((plci->fax_connect_info_buffer[pos] >= 3) && (plci->fax_connect_info_buffer[pos + 1] >= 2))
8354 plci->nsf_control_bits = GET_WORD(&plci->fax_connect_info_buffer[pos + 2]);
8355 for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--)
8356 nlc[++len] = plci->fax_connect_info_buffer[pos++];
8357 }
8358 else
8359 {
8360 if (api_parse(&b3_config->info[1], (word)b3_config->length, "wwsss", b3_config_parms))
8361 {
8362 dbug(1, dprintf("non-standard facilities info missing or wrong format"));
8363 nlc[++len] = 0;
8364 }
8365 else
8366 {
8367 if ((b3_config_parms[4].length >= 3) && (b3_config_parms[4].info[1] >= 2))
8368 plci->nsf_control_bits = GET_WORD(&b3_config_parms[4].info[2]);
8369 nlc[++len] = (byte)(b3_config_parms[4].length);
8370 for (i = 0; i < b3_config_parms[4].length; i++)
8371 nlc[++len] = b3_config_parms[4].info[1 + i];
8372 }
8373 }
8374 }
8375 nlc[0] = len;
8376 if ((plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF)
8377 && (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP))
8378 {
8379 ((T30_INFO *)&nlc[1])->operating_mode = T30_OPERATING_MODE_CAPI_NEG;
8380 }
8381 }
8382 }
8383
8384 PUT_WORD(&(((T30_INFO *)&nlc[1])->control_bits_low), fax_control_bits);
8385 len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
8386 for (i = 0; i < len; i++)
8387 plci->fax_connect_info_buffer[i] = nlc[1 + i];
8388 ((T30_INFO *) plci->fax_connect_info_buffer)->head_line_len = 0;
8389 i += ((T30_INFO *)&nlc[1])->head_line_len;
8390 while (i < nlc[0])
8391 plci->fax_connect_info_buffer[len++] = nlc[++i];
8392 plci->fax_connect_info_length = len;
8393 }
8394 else
8395 {
8396 nlc[0] = 14;
8397 if (b3_config->length != 16)
8398 return _B3_PARM_NOT_SUPPORTED;
8399 for (i = 0; i < 12; i++) nlc[1 + i] = b3_config->info[1 + i];
8400 if (GET_WORD(&b3_config->info[13]) != 8 && GET_WORD(&b3_config->info[13]) != 128)
8401 return _B3_PARM_NOT_SUPPORTED;
8402 nlc[13] = b3_config->info[13];
8403 if (GET_WORD(&b3_config->info[15]) >= nlc[13])
8404 return _B3_PARM_NOT_SUPPORTED;
8405 nlc[14] = b3_config->info[15];
8406 }
8407 }
8408 else
8409 {
8410 if (plci->B3_prot == 4
8411 || plci->B3_prot == 5 /*T.30 - FAX*/) return _B3_PARM_NOT_SUPPORTED;
8412 }
8413 add_p(plci, NLC, nlc);
8414 return 0;
8415 }
8416
8417 /*----------------------------------------------------------------*/
8418 /* make the same as add_b23, but only for the modem related */
8419 /* L2 and L3 B-Chan protocol. */
8420 /* */
8421 /* Enabled L2 and L3 Configurations: */
8422 /* If L1 == Modem all negotiation */
8423 /* only L2 == Modem with full negotiation is allowed */
8424 /* If L1 == Modem async or sync */
8425 /* only L2 == Transparent is allowed */
8426 /* L3 == Modem or L3 == Transparent are allowed */
8427 /* B2 Configuration for modem: */
8428 /* word : enable/disable compression, bitoptions */
8429 /* B3 Configuration for modem: */
8430 /* empty */
8431 /*----------------------------------------------------------------*/
8432 static word add_modem_b23(PLCI *plci, API_PARSE *bp_parms)
8433 {
8434 static byte lli[12] = {1,1};
8435 static byte llc[3] = {2,0,0};
8436 static byte dlc[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
8437 API_PARSE mdm_config[2];
8438 word i;
8439 word b2_config = 0;
8440
8441 for (i = 0; i < 2; i++) mdm_config[i].length = 0;
8442 for (i = 0; i < sizeof(dlc); i++) dlc[i] = 0;
8443
8444 if (((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE)
8445 && (GET_WORD(bp_parms[1].info) != B2_MODEM_EC_COMPRESSION))
8446 || ((GET_WORD(bp_parms[0].info) != B1_MODEM_ALL_NEGOTIATE)
8447 && (GET_WORD(bp_parms[1].info) != B2_TRANSPARENT)))
8448 {
8449 return (_B_STACK_NOT_SUPPORTED);
8450 }
8451 if ((GET_WORD(bp_parms[2].info) != B3_MODEM)
8452 && (GET_WORD(bp_parms[2].info) != B3_TRANSPARENT))
8453 {
8454 return (_B_STACK_NOT_SUPPORTED);
8455 }
8456
8457 plci->B2_prot = (byte) GET_WORD(bp_parms[1].info);
8458 plci->B3_prot = (byte) GET_WORD(bp_parms[2].info);
8459
8460 if ((GET_WORD(bp_parms[1].info) == B2_MODEM_EC_COMPRESSION) && bp_parms[4].length)
8461 {
8462 if (api_parse(&bp_parms[4].info[1],
8463 (word)bp_parms[4].length, "w",
8464 mdm_config))
8465 {
8466 return (_WRONG_MESSAGE_FORMAT);
8467 }
8468 b2_config = GET_WORD(mdm_config[0].info);
8469 }
8470
8471 /* OK, L2 is modem */
8472
8473 lli[0] = 1;
8474 lli[1] = 1;
8475 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL)
8476 lli[1] |= 2;
8477 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL)
8478 lli[1] |= 4;
8479
8480 if ((lli[1] & 0x02) && (diva_xdi_extended_features & DIVA_CAPI_USE_CMA)) {
8481 lli[1] |= 0x10;
8482 if (plci->rx_dma_descriptor <= 0) {
8483 plci->rx_dma_descriptor = diva_get_dma_descriptor(plci, &plci->rx_dma_magic);
8484 if (plci->rx_dma_descriptor >= 0)
8485 plci->rx_dma_descriptor++;
8486 }
8487 if (plci->rx_dma_descriptor > 0) {
8488 lli[1] |= 0x40;
8489 lli[0] = 6;
8490 lli[2] = (byte)(plci->rx_dma_descriptor - 1);
8491 lli[3] = (byte)plci->rx_dma_magic;
8492 lli[4] = (byte)(plci->rx_dma_magic >> 8);
8493 lli[5] = (byte)(plci->rx_dma_magic >> 16);
8494 lli[6] = (byte)(plci->rx_dma_magic >> 24);
8495 }
8496 }
8497
8498 if (DIVA_CAPI_SUPPORTS_NO_CANCEL(plci->adapter)) {
8499 lli[1] |= 0x20;
8500 }
8501
8502 llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ?
8503 /*V42*/ 10 : /*V42_IN*/ 9;
8504 llc[2] = 4; /* pass L3 always transparent */
8505 add_p(plci, LLI, lli);
8506 add_p(plci, LLC, llc);
8507 i = 1;
8508 PUT_WORD(&dlc[i], plci->appl->MaxDataLength);
8509 i += 2;
8510 if (GET_WORD(bp_parms[1].info) == B2_MODEM_EC_COMPRESSION)
8511 {
8512 if (bp_parms[4].length)
8513 {
8514 dbug(1, dprintf("MDM b2_config=%02x", b2_config));
8515 dlc[i++] = 3; /* Addr A */
8516 dlc[i++] = 1; /* Addr B */
8517 dlc[i++] = 7; /* modulo mode */
8518 dlc[i++] = 7; /* window size */
8519 dlc[i++] = 0; /* XID len Lo */
8520 dlc[i++] = 0; /* XID len Hi */
8521
8522 if (b2_config & MDM_B2_DISABLE_V42bis)
8523 {
8524 dlc[i] |= DLC_MODEMPROT_DISABLE_V42_V42BIS;
8525 }
8526 if (b2_config & MDM_B2_DISABLE_MNP)
8527 {
8528 dlc[i] |= DLC_MODEMPROT_DISABLE_MNP_MNP5;
8529 }
8530 if (b2_config & MDM_B2_DISABLE_TRANS)
8531 {
8532 dlc[i] |= DLC_MODEMPROT_REQUIRE_PROTOCOL;
8533 }
8534 if (b2_config & MDM_B2_DISABLE_V42)
8535 {
8536 dlc[i] |= DLC_MODEMPROT_DISABLE_V42_DETECT;
8537 }
8538 if (b2_config & MDM_B2_DISABLE_COMP)
8539 {
8540 dlc[i] |= DLC_MODEMPROT_DISABLE_COMPRESSION;
8541 }
8542 i++;
8543 }
8544 }
8545 else
8546 {
8547 dlc[i++] = 3; /* Addr A */
8548 dlc[i++] = 1; /* Addr B */
8549 dlc[i++] = 7; /* modulo mode */
8550 dlc[i++] = 7; /* window size */
8551 dlc[i++] = 0; /* XID len Lo */
8552 dlc[i++] = 0; /* XID len Hi */
8553 dlc[i++] = DLC_MODEMPROT_DISABLE_V42_V42BIS |
8554 DLC_MODEMPROT_DISABLE_MNP_MNP5 |
8555 DLC_MODEMPROT_DISABLE_V42_DETECT |
8556 DLC_MODEMPROT_DISABLE_COMPRESSION;
8557 }
8558 dlc[0] = (byte)(i - 1);
8559 /* HexDump ("DLC", sizeof(dlc), &dlc[0]); */
8560 add_p(plci, DLC, dlc);
8561 return (0);
8562 }
8563
8564
8565 /*------------------------------------------------------------------*/
8566 /* send a request for the signaling entity */
8567 /*------------------------------------------------------------------*/
8568
8569 static void sig_req(PLCI *plci, byte req, byte Id)
8570 {
8571 if (!plci) return;
8572 if (plci->adapter->adapter_disabled) return;
8573 dbug(1, dprintf("sig_req(%x)", req));
8574 if (req == REMOVE)
8575 plci->sig_remove_id = plci->Sig.Id;
8576 if (plci->req_in == plci->req_in_start) {
8577 plci->req_in += 2;
8578 plci->RBuffer[plci->req_in++] = 0;
8579 }
8580 PUT_WORD(&plci->RBuffer[plci->req_in_start], plci->req_in-plci->req_in_start - 2);
8581 plci->RBuffer[plci->req_in++] = Id; /* sig/nl flag */
8582 plci->RBuffer[plci->req_in++] = req; /* request */
8583 plci->RBuffer[plci->req_in++] = 0; /* channel */
8584 plci->req_in_start = plci->req_in;
8585 }
8586
8587 /*------------------------------------------------------------------*/
8588 /* send a request for the network layer entity */
8589 /*------------------------------------------------------------------*/
8590
8591 static void nl_req_ncci(PLCI *plci, byte req, byte ncci)
8592 {
8593 if (!plci) return;
8594 if (plci->adapter->adapter_disabled) return;
8595 dbug(1, dprintf("nl_req %02x %02x %02x", plci->Id, req, ncci));
8596 if (req == REMOVE)
8597 {
8598 plci->nl_remove_id = plci->NL.Id;
8599 ncci_remove(plci, 0, (byte)(ncci != 0));
8600 ncci = 0;
8601 }
8602 if (plci->req_in == plci->req_in_start) {
8603 plci->req_in += 2;
8604 plci->RBuffer[plci->req_in++] = 0;
8605 }
8606 PUT_WORD(&plci->RBuffer[plci->req_in_start], plci->req_in-plci->req_in_start - 2);
8607 plci->RBuffer[plci->req_in++] = 1; /* sig/nl flag */
8608 plci->RBuffer[plci->req_in++] = req; /* request */
8609 plci->RBuffer[plci->req_in++] = plci->adapter->ncci_ch[ncci]; /* channel */
8610 plci->req_in_start = plci->req_in;
8611 }
8612
8613 static void send_req(PLCI *plci)
8614 {
8615 ENTITY *e;
8616 word l;
8617 /* word i; */
8618
8619 if (!plci) return;
8620 if (plci->adapter->adapter_disabled) return;
8621 channel_xmit_xon(plci);
8622
8623 /* if nothing to do, return */
8624 if (plci->req_in == plci->req_out) return;
8625 dbug(1, dprintf("send_req(in=%d,out=%d)", plci->req_in, plci->req_out));
8626
8627 if (plci->nl_req || plci->sig_req) return;
8628
8629 l = GET_WORD(&plci->RBuffer[plci->req_out]);
8630 plci->req_out += 2;
8631 plci->XData[0].P = &plci->RBuffer[plci->req_out];
8632 plci->req_out += l;
8633 if (plci->RBuffer[plci->req_out] == 1)
8634 {
8635 e = &plci->NL;
8636 plci->req_out++;
8637 e->Req = plci->nl_req = plci->RBuffer[plci->req_out++];
8638 e->ReqCh = plci->RBuffer[plci->req_out++];
8639 if (!(e->Id & 0x1f))
8640 {
8641 e->Id = NL_ID;
8642 plci->RBuffer[plci->req_out - 4] = CAI;
8643 plci->RBuffer[plci->req_out - 3] = 1;
8644 plci->RBuffer[plci->req_out - 2] = (plci->Sig.Id == 0xff) ? 0 : plci->Sig.Id;
8645 plci->RBuffer[plci->req_out - 1] = 0;
8646 l += 3;
8647 plci->nl_global_req = plci->nl_req;
8648 }
8649 dbug(1, dprintf("%x:NLREQ(%x:%x:%x)", plci->adapter->Id, e->Id, e->Req, e->ReqCh));
8650 }
8651 else
8652 {
8653 e = &plci->Sig;
8654 if (plci->RBuffer[plci->req_out])
8655 e->Id = plci->RBuffer[plci->req_out];
8656 plci->req_out++;
8657 e->Req = plci->sig_req = plci->RBuffer[plci->req_out++];
8658 e->ReqCh = plci->RBuffer[plci->req_out++];
8659 if (!(e->Id & 0x1f))
8660 plci->sig_global_req = plci->sig_req;
8661 dbug(1, dprintf("%x:SIGREQ(%x:%x:%x)", plci->adapter->Id, e->Id, e->Req, e->ReqCh));
8662 }
8663 plci->XData[0].PLength = l;
8664 e->X = plci->XData;
8665 plci->adapter->request(e);
8666 dbug(1, dprintf("send_ok"));
8667 }
8668
8669 static void send_data(PLCI *plci)
8670 {
8671 DIVA_CAPI_ADAPTER *a;
8672 DATA_B3_DESC *data;
8673 NCCI *ncci_ptr;
8674 word ncci;
8675
8676 if (!plci->nl_req && plci->ncci_ring_list)
8677 {
8678 a = plci->adapter;
8679 ncci = plci->ncci_ring_list;
8680 do
8681 {
8682 ncci = a->ncci_next[ncci];
8683 ncci_ptr = &(a->ncci[ncci]);
8684 if (!(a->ncci_ch[ncci]
8685 && (a->ch_flow_control[a->ncci_ch[ncci]] & N_OK_FC_PENDING)))
8686 {
8687 if (ncci_ptr->data_pending)
8688 {
8689 if ((a->ncci_state[ncci] == CONNECTED)
8690 || (a->ncci_state[ncci] == INC_ACT_PENDING)
8691 || (plci->send_disc == ncci))
8692 {
8693 data = &(ncci_ptr->DBuffer[ncci_ptr->data_out]);
8694 if ((plci->B2_prot == B2_V120_ASYNC)
8695 || (plci->B2_prot == B2_V120_ASYNC_V42BIS)
8696 || (plci->B2_prot == B2_V120_BIT_TRANSPARENT))
8697 {
8698 plci->NData[1].P = TransmitBufferGet(plci->appl, data->P);
8699 plci->NData[1].PLength = data->Length;
8700 if (data->Flags & 0x10)
8701 plci->NData[0].P = v120_break_header;
8702 else
8703 plci->NData[0].P = v120_default_header;
8704 plci->NData[0].PLength = 1;
8705 plci->NL.XNum = 2;
8706 plci->NL.Req = plci->nl_req = (byte)((data->Flags & 0x07) << 4 | N_DATA);
8707 }
8708 else
8709 {
8710 plci->NData[0].P = TransmitBufferGet(plci->appl, data->P);
8711 plci->NData[0].PLength = data->Length;
8712 if (data->Flags & 0x10)
8713 plci->NL.Req = plci->nl_req = (byte)N_UDATA;
8714
8715 else if ((plci->B3_prot == B3_RTP) && (data->Flags & 0x01))
8716 plci->NL.Req = plci->nl_req = (byte)N_BDATA;
8717
8718 else
8719 plci->NL.Req = plci->nl_req = (byte)((data->Flags & 0x07) << 4 | N_DATA);
8720 }
8721 plci->NL.X = plci->NData;
8722 plci->NL.ReqCh = a->ncci_ch[ncci];
8723 dbug(1, dprintf("%x:DREQ(%x:%x)", a->Id, plci->NL.Id, plci->NL.Req));
8724 plci->data_sent = true;
8725 plci->data_sent_ptr = data->P;
8726 a->request(&plci->NL);
8727 }
8728 else {
8729 cleanup_ncci_data(plci, ncci);
8730 }
8731 }
8732 else if (plci->send_disc == ncci)
8733 {
8734 /* dprintf("N_DISC"); */
8735 plci->NData[0].PLength = 0;
8736 plci->NL.ReqCh = a->ncci_ch[ncci];
8737 plci->NL.Req = plci->nl_req = N_DISC;
8738 a->request(&plci->NL);
8739 plci->command = _DISCONNECT_B3_R;
8740 plci->send_disc = 0;
8741 }
8742 }
8743 } while (!plci->nl_req && (ncci != plci->ncci_ring_list));
8744 plci->ncci_ring_list = ncci;
8745 }
8746 }
8747
8748 static void listen_check(DIVA_CAPI_ADAPTER *a)
8749 {
8750 word i, j;
8751 PLCI *plci;
8752 byte activnotifiedcalls = 0;
8753
8754 dbug(1, dprintf("listen_check(%d,%d)", a->listen_active, a->max_listen));
8755 if (!remove_started && !a->adapter_disabled)
8756 {
8757 for (i = 0; i < a->max_plci; i++)
8758 {
8759 plci = &(a->plci[i]);
8760 if (plci->notifiedcall) activnotifiedcalls++;
8761 }
8762 dbug(1, dprintf("listen_check(%d)", activnotifiedcalls));
8763
8764 for (i = a->listen_active; i < ((word)(a->max_listen + activnotifiedcalls)); i++) {
8765 if ((j = get_plci(a))) {
8766 a->listen_active++;
8767 plci = &a->plci[j - 1];
8768 plci->State = LISTENING;
8769
8770 add_p(plci, OAD, "\x01\xfd");
8771
8772 add_p(plci, KEY, "\x04\x43\x41\x32\x30");
8773
8774 add_p(plci, CAI, "\x01\xc0");
8775 add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
8776 add_p(plci, LLI, "\x01\xc4"); /* support Dummy CR FAC + MWI + SpoofNotify */
8777 add_p(plci, SHIFT | 6, NULL);
8778 add_p(plci, SIN, "\x02\x00\x00");
8779 plci->internal_command = LISTEN_SIG_ASSIGN_PEND; /* do indicate_req if OK */
8780 sig_req(plci, ASSIGN, DSIG_ID);
8781 send_req(plci);
8782 }
8783 }
8784 }
8785 }
8786
8787 /*------------------------------------------------------------------*/
8788 /* functions for all parameters sent in INDs */
8789 /*------------------------------------------------------------------*/
8790
8791 static void IndParse(PLCI *plci, const word *parms_id, byte **parms, byte multiIEsize)
8792 {
8793 word ploc; /* points to current location within packet */
8794 byte w;
8795 byte wlen;
8796 byte codeset, lock;
8797 byte *in;
8798 word i;
8799 word code;
8800 word mIEindex = 0;
8801 ploc = 0;
8802 codeset = 0;
8803 lock = 0;
8804
8805 in = plci->Sig.RBuffer->P;
8806 for (i = 0; i < parms_id[0]; i++) /* multiIE parms_id contains just the 1st */
8807 { /* element but parms array is larger */
8808 parms[i] = (byte *)"";
8809 }
8810 for (i = 0; i < multiIEsize; i++)
8811 {
8812 parms[i] = (byte *)"";
8813 }
8814
8815 while (ploc < plci->Sig.RBuffer->length - 1) {
8816
8817 /* read information element id and length */
8818 w = in[ploc];
8819
8820 if (w & 0x80) {
8821 /* w &=0xf0; removed, cannot detect congestion levels */
8822 /* upper 4 bit masked with w==SHIFT now */
8823 wlen = 0;
8824 }
8825 else {
8826 wlen = (byte)(in[ploc + 1] + 1);
8827 }
8828 /* check if length valid (not exceeding end of packet) */
8829 if ((ploc + wlen) > 270) return;
8830 if (lock & 0x80) lock &= 0x7f;
8831 else codeset = lock;
8832
8833 if ((w & 0xf0) == SHIFT) {
8834 codeset = in[ploc];
8835 if (!(codeset & 0x08)) lock = (byte)(codeset & 7);
8836 codeset &= 7;
8837 lock |= 0x80;
8838 }
8839 else {
8840 if (w == ESC && wlen >= 3) code = in[ploc + 2] | 0x800;
8841 else code = w;
8842 code |= (codeset << 8);
8843
8844 for (i = 1; i < parms_id[0] + 1 && parms_id[i] != code; i++);
8845
8846 if (i < parms_id[0] + 1) {
8847 if (!multiIEsize) { /* with multiIEs use next field index, */
8848 mIEindex = i - 1; /* with normal IEs use same index like parms_id */
8849 }
8850
8851 parms[mIEindex] = &in[ploc + 1];
8852 dbug(1, dprintf("mIE[%d]=0x%x", *parms[mIEindex], in[ploc]));
8853 if (parms_id[i] == OAD
8854 || parms_id[i] == CONN_NR
8855 || parms_id[i] == CAD) {
8856 if (in[ploc + 2] & 0x80) {
8857 in[ploc + 0] = (byte)(in[ploc + 1] + 1);
8858 in[ploc + 1] = (byte)(in[ploc + 2] & 0x7f);
8859 in[ploc + 2] = 0x80;
8860 parms[mIEindex] = &in[ploc];
8861 }
8862 }
8863 mIEindex++; /* effects multiIEs only */
8864 }
8865 }
8866
8867 ploc += (wlen + 1);
8868 }
8869 return;
8870 }
8871
8872 /*------------------------------------------------------------------*/
8873 /* try to match a cip from received BC and HLC */
8874 /*------------------------------------------------------------------*/
8875
8876 static byte ie_compare(byte *ie1, byte *ie2)
8877 {
8878 word i;
8879 if (!ie1 || !ie2) return false;
8880 if (!ie1[0]) return false;
8881 for (i = 0; i < (word)(ie1[0] + 1); i++) if (ie1[i] != ie2[i]) return false;
8882 return true;
8883 }
8884
8885 static word find_cip(DIVA_CAPI_ADAPTER *a, byte *bc, byte *hlc)
8886 {
8887 word i;
8888 word j;
8889
8890 for (i = 9; i && !ie_compare(bc, cip_bc[i][a->u_law]); i--);
8891
8892 for (j = 16; j < 29 &&
8893 (!ie_compare(bc, cip_bc[j][a->u_law]) || !ie_compare(hlc, cip_hlc[j])); j++);
8894 if (j == 29) return i;
8895 return j;
8896 }
8897
8898
8899 static byte AddInfo(byte **add_i,
8900 byte **fty_i,
8901 byte *esc_chi,
8902 byte *facility)
8903 {
8904 byte i;
8905 byte j;
8906 byte k;
8907 byte flen;
8908 byte len = 0;
8909 /* facility is a nested structure */
8910 /* FTY can be more than once */
8911
8912 if (esc_chi[0] && !(esc_chi[esc_chi[0]] & 0x7f))
8913 {
8914 add_i[0] = (byte *)"\x02\x02\x00"; /* use neither b nor d channel */
8915 }
8916
8917 else
8918 {
8919 add_i[0] = (byte *)"";
8920 }
8921 if (!fty_i[0][0])
8922 {
8923 add_i[3] = (byte *)"";
8924 }
8925 else
8926 { /* facility array found */
8927 for (i = 0, j = 1; i < MAX_MULTI_IE && fty_i[i][0]; i++)
8928 {
8929 dbug(1, dprintf("AddIFac[%d]", fty_i[i][0]));
8930 len += fty_i[i][0];
8931 len += 2;
8932 flen = fty_i[i][0];
8933 facility[j++] = 0x1c; /* copy fac IE */
8934 for (k = 0; k <= flen; k++, j++)
8935 {
8936 facility[j] = fty_i[i][k];
8937 /* dbug(1, dprintf("%x ",facility[j])); */
8938 }
8939 }
8940 facility[0] = len;
8941 add_i[3] = facility;
8942 }
8943 /* dbug(1, dprintf("FacArrLen=%d ",len)); */
8944 len = add_i[0][0] + add_i[1][0] + add_i[2][0] + add_i[3][0];
8945 len += 4; /* calculate length of all */
8946 return (len);
8947 }
8948
8949 /*------------------------------------------------------------------*/
8950 /* voice and codec features */
8951 /*------------------------------------------------------------------*/
8952
8953 static void SetVoiceChannel(PLCI *plci, byte *chi, DIVA_CAPI_ADAPTER *a)
8954 {
8955 byte voice_chi[] = "\x02\x18\x01";
8956 byte channel;
8957
8958 channel = chi[chi[0]] & 0x3;
8959 dbug(1, dprintf("ExtDevON(Ch=0x%x)", channel));
8960 voice_chi[2] = (channel) ? channel : 1;
8961 add_p(plci, FTY, "\x02\x01\x07"); /* B On, default on 1 */
8962 add_p(plci, ESC, voice_chi); /* Channel */
8963 sig_req(plci, TEL_CTRL, 0);
8964 send_req(plci);
8965 if (a->AdvSignalPLCI)
8966 {
8967 adv_voice_write_coefs(a->AdvSignalPLCI, ADV_VOICE_WRITE_ACTIVATION);
8968 }
8969 }
8970
8971 static void VoiceChannelOff(PLCI *plci)
8972 {
8973 dbug(1, dprintf("ExtDevOFF"));
8974 add_p(plci, FTY, "\x02\x01\x08"); /* B Off */
8975 sig_req(plci, TEL_CTRL, 0);
8976 send_req(plci);
8977 if (plci->adapter->AdvSignalPLCI)
8978 {
8979 adv_voice_clear_config(plci->adapter->AdvSignalPLCI);
8980 }
8981 }
8982
8983
8984 static word AdvCodecSupport(DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl,
8985 byte hook_listen)
8986 {
8987 word j;
8988 PLCI *splci;
8989
8990 /* check if hardware supports handset with hook states (adv.codec) */
8991 /* or if just a on board codec is supported */
8992 /* the advanced codec plci is just for internal use */
8993
8994 /* diva Pro with on-board codec: */
8995 if (a->profile.Global_Options & HANDSET)
8996 {
8997 /* new call, but hook states are already signalled */
8998 if (a->AdvCodecFLAG)
8999 {
9000 if (a->AdvSignalAppl != appl || a->AdvSignalPLCI)
9001 {
9002 dbug(1, dprintf("AdvSigPlci=0x%x", a->AdvSignalPLCI));
9003 return 0x2001; /* codec in use by another application */
9004 }
9005 if (plci != NULL)
9006 {
9007 a->AdvSignalPLCI = plci;
9008 plci->tel = ADV_VOICE;
9009 }
9010 return 0; /* adv codec still used */
9011 }
9012 if ((j = get_plci(a)))
9013 {
9014 splci = &a->plci[j - 1];
9015 splci->tel = CODEC_PERMANENT;
9016 /* hook_listen indicates if a facility_req with handset/hook support */
9017 /* was sent. Otherwise if just a call on an external device was made */
9018 /* the codec will be used but the hook info will be discarded (just */
9019 /* the external controller is in use */
9020 if (hook_listen) splci->State = ADVANCED_VOICE_SIG;
9021 else
9022 {
9023 splci->State = ADVANCED_VOICE_NOSIG;
9024 if (plci)
9025 {
9026 plci->spoofed_msg = SPOOFING_REQUIRED;
9027 }
9028 /* indicate D-ch connect if */
9029 } /* codec is connected OK */
9030 if (plci != NULL)
9031 {
9032 a->AdvSignalPLCI = plci;
9033 plci->tel = ADV_VOICE;
9034 }
9035 a->AdvSignalAppl = appl;
9036 a->AdvCodecFLAG = true;
9037 a->AdvCodecPLCI = splci;
9038 add_p(splci, CAI, "\x01\x15");
9039 add_p(splci, LLI, "\x01\x00");
9040 add_p(splci, ESC, "\x02\x18\x00");
9041 add_p(splci, UID, "\x06\x43\x61\x70\x69\x32\x30");
9042 splci->internal_command = PERM_COD_ASSIGN;
9043 dbug(1, dprintf("Codec Assign"));
9044 sig_req(splci, ASSIGN, DSIG_ID);
9045 send_req(splci);
9046 }
9047 else
9048 {
9049 return 0x2001; /* wrong state, no more plcis */
9050 }
9051 }
9052 else if (a->profile.Global_Options & ON_BOARD_CODEC)
9053 {
9054 if (hook_listen) return 0x300B; /* Facility not supported */
9055 /* no hook with SCOM */
9056 if (plci != NULL) plci->tel = CODEC;
9057 dbug(1, dprintf("S/SCOM codec"));
9058 /* first time we use the scom-s codec we must shut down the internal */
9059 /* handset application of the card. This can be done by an assign with */
9060 /* a cai with the 0x80 bit set. Assign return code is 'out of resource'*/
9061 if (!a->scom_appl_disable) {
9062 if ((j = get_plci(a))) {
9063 splci = &a->plci[j - 1];
9064 add_p(splci, CAI, "\x01\x80");
9065 add_p(splci, UID, "\x06\x43\x61\x70\x69\x32\x30");
9066 sig_req(splci, ASSIGN, 0xC0); /* 0xc0 is the TEL_ID */
9067 send_req(splci);
9068 a->scom_appl_disable = true;
9069 }
9070 else{
9071 return 0x2001; /* wrong state, no more plcis */
9072 }
9073 }
9074 }
9075 else return 0x300B; /* Facility not supported */
9076
9077 return 0;
9078 }
9079
9080
9081 static void CodecIdCheck(DIVA_CAPI_ADAPTER *a, PLCI *plci)
9082 {
9083
9084 dbug(1, dprintf("CodecIdCheck"));
9085
9086 if (a->AdvSignalPLCI == plci)
9087 {
9088 dbug(1, dprintf("PLCI owns codec"));
9089 VoiceChannelOff(a->AdvCodecPLCI);
9090 if (a->AdvCodecPLCI->State == ADVANCED_VOICE_NOSIG)
9091 {
9092 dbug(1, dprintf("remove temp codec PLCI"));
9093 plci_remove(a->AdvCodecPLCI);
9094 a->AdvCodecFLAG = 0;
9095 a->AdvCodecPLCI = NULL;
9096 a->AdvSignalAppl = NULL;
9097 }
9098 a->AdvSignalPLCI = NULL;
9099 }
9100 }
9101
9102 /* -------------------------------------------------------------------
9103 Ask for physical address of card on PCI bus
9104 ------------------------------------------------------------------- */
9105 static void diva_ask_for_xdi_sdram_bar(DIVA_CAPI_ADAPTER *a,
9106 IDI_SYNC_REQ *preq) {
9107 a->sdram_bar = 0;
9108 if (diva_xdi_extended_features & DIVA_CAPI_XDI_PROVIDES_SDRAM_BAR) {
9109 ENTITY *e = (ENTITY *)preq;
9110
9111 e->user[0] = a->Id - 1;
9112 preq->xdi_sdram_bar.info.bar = 0;
9113 preq->xdi_sdram_bar.Req = 0;
9114 preq->xdi_sdram_bar.Rc = IDI_SYNC_REQ_XDI_GET_ADAPTER_SDRAM_BAR;
9115
9116 (*(a->request))(e);
9117
9118 a->sdram_bar = preq->xdi_sdram_bar.info.bar;
9119 dbug(3, dprintf("A(%d) SDRAM BAR = %08x", a->Id, a->sdram_bar));
9120 }
9121 }
9122
9123 /* -------------------------------------------------------------------
9124 Ask XDI about extended features
9125 ------------------------------------------------------------------- */
9126 static void diva_get_extended_adapter_features(DIVA_CAPI_ADAPTER *a) {
9127 IDI_SYNC_REQ *preq;
9128 char buffer[((sizeof(preq->xdi_extended_features) + 4) > sizeof(ENTITY)) ? (sizeof(preq->xdi_extended_features) + 4) : sizeof(ENTITY)];
9129
9130 char features[4];
9131 preq = (IDI_SYNC_REQ *)&buffer[0];
9132
9133 if (!diva_xdi_extended_features) {
9134 ENTITY *e = (ENTITY *)preq;
9135 diva_xdi_extended_features |= 0x80000000;
9136
9137 e->user[0] = a->Id - 1;
9138 preq->xdi_extended_features.Req = 0;
9139 preq->xdi_extended_features.Rc = IDI_SYNC_REQ_XDI_GET_EXTENDED_FEATURES;
9140 preq->xdi_extended_features.info.buffer_length_in_bytes = sizeof(features);
9141 preq->xdi_extended_features.info.features = &features[0];
9142
9143 (*(a->request))(e);
9144
9145 if (features[0] & DIVA_XDI_EXTENDED_FEATURES_VALID) {
9146 /*
9147 Check features located in the byte '0'
9148 */
9149 if (features[0] & DIVA_XDI_EXTENDED_FEATURE_CMA) {
9150 diva_xdi_extended_features |= DIVA_CAPI_USE_CMA;
9151 }
9152 if (features[0] & DIVA_XDI_EXTENDED_FEATURE_RX_DMA) {
9153 diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_RX_DMA;
9154 dbug(1, dprintf("XDI provides RxDMA"));
9155 }
9156 if (features[0] & DIVA_XDI_EXTENDED_FEATURE_SDRAM_BAR) {
9157 diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_SDRAM_BAR;
9158 }
9159 if (features[0] & DIVA_XDI_EXTENDED_FEATURE_NO_CANCEL_RC) {
9160 diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_NO_CANCEL;
9161 dbug(3, dprintf("XDI provides NO_CANCEL_RC feature"));
9162 }
9163
9164 }
9165 }
9166
9167 diva_ask_for_xdi_sdram_bar(a, preq);
9168 }
9169
9170 /*------------------------------------------------------------------*/
9171 /* automatic law */
9172 /*------------------------------------------------------------------*/
9173 /* called from OS specific part after init time to get the Law */
9174 /* a-law (Euro) and u-law (us,japan) use different BCs in the Setup message */
9175 void AutomaticLaw(DIVA_CAPI_ADAPTER *a)
9176 {
9177 word j;
9178 PLCI *splci;
9179
9180 if (a->automatic_law) {
9181 return;
9182 }
9183 if ((j = get_plci(a))) {
9184 diva_get_extended_adapter_features(a);
9185 splci = &a->plci[j - 1];
9186 a->automatic_lawPLCI = splci;
9187 a->automatic_law = 1;
9188 add_p(splci, CAI, "\x01\x80");
9189 add_p(splci, UID, "\x06\x43\x61\x70\x69\x32\x30");
9190 splci->internal_command = USELAW_REQ;
9191 splci->command = 0;
9192 splci->number = 0;
9193 sig_req(splci, ASSIGN, DSIG_ID);
9194 send_req(splci);
9195 }
9196 }
9197
9198 /* called from OS specific part if an application sends an Capi20Release */
9199 word CapiRelease(word Id)
9200 {
9201 word i, j, appls_found;
9202 PLCI *plci;
9203 APPL *this;
9204 DIVA_CAPI_ADAPTER *a;
9205
9206 if (!Id)
9207 {
9208 dbug(0, dprintf("A: CapiRelease(Id==0)"));
9209 return (_WRONG_APPL_ID);
9210 }
9211
9212 this = &application[Id - 1]; /* get application pointer */
9213
9214 for (i = 0, appls_found = 0; i < max_appl; i++)
9215 {
9216 if (application[i].Id) /* an application has been found */
9217 {
9218 appls_found++;
9219 }
9220 }
9221
9222 for (i = 0; i < max_adapter; i++) /* scan all adapters... */
9223 {
9224 a = &adapter[i];
9225 if (a->request)
9226 {
9227 a->Info_Mask[Id - 1] = 0;
9228 a->CIP_Mask[Id - 1] = 0;
9229 a->Notification_Mask[Id - 1] = 0;
9230 a->codec_listen[Id - 1] = NULL;
9231 a->requested_options_table[Id - 1] = 0;
9232 for (j = 0; j < a->max_plci; j++) /* and all PLCIs connected */
9233 { /* with this application */
9234 plci = &a->plci[j];
9235 if (plci->Id) /* if plci owns no application */
9236 { /* it may be not jet connected */
9237 if (plci->State == INC_CON_PENDING
9238 || plci->State == INC_CON_ALERT)
9239 {
9240 if (test_bit(Id - 1, plci->c_ind_mask_table))
9241 {
9242 __clear_bit(Id - 1, plci->c_ind_mask_table);
9243 if (bitmap_empty(plci->c_ind_mask_table, MAX_APPL))
9244 {
9245 sig_req(plci, HANGUP, 0);
9246 send_req(plci);
9247 plci->State = OUTG_DIS_PENDING;
9248 }
9249 }
9250 }
9251 if (test_bit(Id - 1, plci->c_ind_mask_table))
9252 {
9253 __clear_bit(Id - 1, plci->c_ind_mask_table);
9254 if (bitmap_empty(plci->c_ind_mask_table, MAX_APPL))
9255 {
9256 if (!plci->appl)
9257 {
9258 plci_remove(plci);
9259 plci->State = IDLE;
9260 }
9261 }
9262 }
9263 if (plci->appl == this)
9264 {
9265 plci->appl = NULL;
9266 plci_remove(plci);
9267 plci->State = IDLE;
9268 }
9269 }
9270 }
9271 listen_check(a);
9272
9273 if (a->flag_dynamic_l1_down)
9274 {
9275 if (appls_found == 1) /* last application does a capi release */
9276 {
9277 if ((j = get_plci(a)))
9278 {
9279 plci = &a->plci[j - 1];
9280 plci->command = 0;
9281 add_p(plci, OAD, "\x01\xfd");
9282 add_p(plci, CAI, "\x01\x80");
9283 add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
9284 add_p(plci, SHIFT | 6, NULL);
9285 add_p(plci, SIN, "\x02\x00\x00");
9286 plci->internal_command = REM_L1_SIG_ASSIGN_PEND;
9287 sig_req(plci, ASSIGN, DSIG_ID);
9288 add_p(plci, FTY, "\x02\xff\x06"); /* l1 down */
9289 sig_req(plci, SIG_CTRL, 0);
9290 send_req(plci);
9291 }
9292 }
9293 }
9294 if (a->AdvSignalAppl == this)
9295 {
9296 this->NullCREnable = false;
9297 if (a->AdvCodecPLCI)
9298 {
9299 plci_remove(a->AdvCodecPLCI);
9300 a->AdvCodecPLCI->tel = 0;
9301 a->AdvCodecPLCI->adv_nl = 0;
9302 }
9303 a->AdvSignalAppl = NULL;
9304 a->AdvSignalPLCI = NULL;
9305 a->AdvCodecFLAG = 0;
9306 a->AdvCodecPLCI = NULL;
9307 }
9308 }
9309 }
9310
9311 this->Id = 0;
9312
9313 return GOOD;
9314 }
9315
9316 static word plci_remove_check(PLCI *plci)
9317 {
9318 if (!plci) return true;
9319 if (!plci->NL.Id && bitmap_empty(plci->c_ind_mask_table, MAX_APPL))
9320 {
9321 if (plci->Sig.Id == 0xff)
9322 plci->Sig.Id = 0;
9323 if (!plci->Sig.Id)
9324 {
9325 dbug(1, dprintf("plci_remove_complete(%x)", plci->Id));
9326 dbug(1, dprintf("tel=0x%x,Sig=0x%x", plci->tel, plci->Sig.Id));
9327 if (plci->Id)
9328 {
9329 CodecIdCheck(plci->adapter, plci);
9330 clear_b1_config(plci);
9331 ncci_remove(plci, 0, false);
9332 plci_free_msg_in_queue(plci);
9333 channel_flow_control_remove(plci);
9334 plci->Id = 0;
9335 plci->State = IDLE;
9336 plci->channels = 0;
9337 plci->appl = NULL;
9338 plci->notifiedcall = 0;
9339 }
9340 listen_check(plci->adapter);
9341 return true;
9342 }
9343 }
9344 return false;
9345 }
9346
9347
9348 /*------------------------------------------------------------------*/
9349
9350 static byte plci_nl_busy(PLCI *plci)
9351 {
9352 /* only applicable for non-multiplexed protocols */
9353 return (plci->nl_req
9354 || (plci->ncci_ring_list
9355 && plci->adapter->ncci_ch[plci->ncci_ring_list]
9356 && (plci->adapter->ch_flow_control[plci->adapter->ncci_ch[plci->ncci_ring_list]] & N_OK_FC_PENDING)));
9357 }
9358
9359
9360 /*------------------------------------------------------------------*/
9361 /* DTMF facilities */
9362 /*------------------------------------------------------------------*/
9363
9364
9365 static struct
9366 {
9367 byte send_mask;
9368 byte listen_mask;
9369 byte character;
9370 byte code;
9371 } dtmf_digit_map[] =
9372 {
9373 { 0x01, 0x01, 0x23, DTMF_DIGIT_TONE_CODE_HASHMARK },
9374 { 0x01, 0x01, 0x2a, DTMF_DIGIT_TONE_CODE_STAR },
9375 { 0x01, 0x01, 0x30, DTMF_DIGIT_TONE_CODE_0 },
9376 { 0x01, 0x01, 0x31, DTMF_DIGIT_TONE_CODE_1 },
9377 { 0x01, 0x01, 0x32, DTMF_DIGIT_TONE_CODE_2 },
9378 { 0x01, 0x01, 0x33, DTMF_DIGIT_TONE_CODE_3 },
9379 { 0x01, 0x01, 0x34, DTMF_DIGIT_TONE_CODE_4 },
9380 { 0x01, 0x01, 0x35, DTMF_DIGIT_TONE_CODE_5 },
9381 { 0x01, 0x01, 0x36, DTMF_DIGIT_TONE_CODE_6 },
9382 { 0x01, 0x01, 0x37, DTMF_DIGIT_TONE_CODE_7 },
9383 { 0x01, 0x01, 0x38, DTMF_DIGIT_TONE_CODE_8 },
9384 { 0x01, 0x01, 0x39, DTMF_DIGIT_TONE_CODE_9 },
9385 { 0x01, 0x01, 0x41, DTMF_DIGIT_TONE_CODE_A },
9386 { 0x01, 0x01, 0x42, DTMF_DIGIT_TONE_CODE_B },
9387 { 0x01, 0x01, 0x43, DTMF_DIGIT_TONE_CODE_C },
9388 { 0x01, 0x01, 0x44, DTMF_DIGIT_TONE_CODE_D },
9389 { 0x01, 0x00, 0x61, DTMF_DIGIT_TONE_CODE_A },
9390 { 0x01, 0x00, 0x62, DTMF_DIGIT_TONE_CODE_B },
9391 { 0x01, 0x00, 0x63, DTMF_DIGIT_TONE_CODE_C },
9392 { 0x01, 0x00, 0x64, DTMF_DIGIT_TONE_CODE_D },
9393
9394 { 0x04, 0x04, 0x80, DTMF_SIGNAL_NO_TONE },
9395 { 0x00, 0x04, 0x81, DTMF_SIGNAL_UNIDENTIFIED_TONE },
9396 { 0x04, 0x04, 0x82, DTMF_SIGNAL_DIAL_TONE },
9397 { 0x04, 0x04, 0x83, DTMF_SIGNAL_PABX_INTERNAL_DIAL_TONE },
9398 { 0x04, 0x04, 0x84, DTMF_SIGNAL_SPECIAL_DIAL_TONE },
9399 { 0x04, 0x04, 0x85, DTMF_SIGNAL_SECOND_DIAL_TONE },
9400 { 0x04, 0x04, 0x86, DTMF_SIGNAL_RINGING_TONE },
9401 { 0x04, 0x04, 0x87, DTMF_SIGNAL_SPECIAL_RINGING_TONE },
9402 { 0x04, 0x04, 0x88, DTMF_SIGNAL_BUSY_TONE },
9403 { 0x04, 0x04, 0x89, DTMF_SIGNAL_CONGESTION_TONE },
9404 { 0x04, 0x04, 0x8a, DTMF_SIGNAL_SPECIAL_INFORMATION_TONE },
9405 { 0x04, 0x04, 0x8b, DTMF_SIGNAL_COMFORT_TONE },
9406 { 0x04, 0x04, 0x8c, DTMF_SIGNAL_HOLD_TONE },
9407 { 0x04, 0x04, 0x8d, DTMF_SIGNAL_RECORD_TONE },
9408 { 0x04, 0x04, 0x8e, DTMF_SIGNAL_CALLER_WAITING_TONE },
9409 { 0x04, 0x04, 0x8f, DTMF_SIGNAL_CALL_WAITING_TONE },
9410 { 0x04, 0x04, 0x90, DTMF_SIGNAL_PAY_TONE },
9411 { 0x04, 0x04, 0x91, DTMF_SIGNAL_POSITIVE_INDICATION_TONE },
9412 { 0x04, 0x04, 0x92, DTMF_SIGNAL_NEGATIVE_INDICATION_TONE },
9413 { 0x04, 0x04, 0x93, DTMF_SIGNAL_WARNING_TONE },
9414 { 0x04, 0x04, 0x94, DTMF_SIGNAL_INTRUSION_TONE },
9415 { 0x04, 0x04, 0x95, DTMF_SIGNAL_CALLING_CARD_SERVICE_TONE },
9416 { 0x04, 0x04, 0x96, DTMF_SIGNAL_PAYPHONE_RECOGNITION_TONE },
9417 { 0x04, 0x04, 0x97, DTMF_SIGNAL_CPE_ALERTING_SIGNAL },
9418 { 0x04, 0x04, 0x98, DTMF_SIGNAL_OFF_HOOK_WARNING_TONE },
9419 { 0x04, 0x04, 0xbf, DTMF_SIGNAL_INTERCEPT_TONE },
9420 { 0x04, 0x04, 0xc0, DTMF_SIGNAL_MODEM_CALLING_TONE },
9421 { 0x04, 0x04, 0xc1, DTMF_SIGNAL_FAX_CALLING_TONE },
9422 { 0x04, 0x04, 0xc2, DTMF_SIGNAL_ANSWER_TONE },
9423 { 0x04, 0x04, 0xc3, DTMF_SIGNAL_REVERSED_ANSWER_TONE },
9424 { 0x04, 0x04, 0xc4, DTMF_SIGNAL_ANSAM_TONE },
9425 { 0x04, 0x04, 0xc5, DTMF_SIGNAL_REVERSED_ANSAM_TONE },
9426 { 0x04, 0x04, 0xc6, DTMF_SIGNAL_BELL103_ANSWER_TONE },
9427 { 0x04, 0x04, 0xc7, DTMF_SIGNAL_FAX_FLAGS },
9428 { 0x04, 0x04, 0xc8, DTMF_SIGNAL_G2_FAX_GROUP_ID },
9429 { 0x00, 0x04, 0xc9, DTMF_SIGNAL_HUMAN_SPEECH },
9430 { 0x04, 0x04, 0xca, DTMF_SIGNAL_ANSWERING_MACHINE_390 },
9431 { 0x02, 0x02, 0xf1, DTMF_MF_DIGIT_TONE_CODE_1 },
9432 { 0x02, 0x02, 0xf2, DTMF_MF_DIGIT_TONE_CODE_2 },
9433 { 0x02, 0x02, 0xf3, DTMF_MF_DIGIT_TONE_CODE_3 },
9434 { 0x02, 0x02, 0xf4, DTMF_MF_DIGIT_TONE_CODE_4 },
9435 { 0x02, 0x02, 0xf5, DTMF_MF_DIGIT_TONE_CODE_5 },
9436 { 0x02, 0x02, 0xf6, DTMF_MF_DIGIT_TONE_CODE_6 },
9437 { 0x02, 0x02, 0xf7, DTMF_MF_DIGIT_TONE_CODE_7 },
9438 { 0x02, 0x02, 0xf8, DTMF_MF_DIGIT_TONE_CODE_8 },
9439 { 0x02, 0x02, 0xf9, DTMF_MF_DIGIT_TONE_CODE_9 },
9440 { 0x02, 0x02, 0xfa, DTMF_MF_DIGIT_TONE_CODE_0 },
9441 { 0x02, 0x02, 0xfb, DTMF_MF_DIGIT_TONE_CODE_K1 },
9442 { 0x02, 0x02, 0xfc, DTMF_MF_DIGIT_TONE_CODE_K2 },
9443 { 0x02, 0x02, 0xfd, DTMF_MF_DIGIT_TONE_CODE_KP },
9444 { 0x02, 0x02, 0xfe, DTMF_MF_DIGIT_TONE_CODE_S1 },
9445 { 0x02, 0x02, 0xff, DTMF_MF_DIGIT_TONE_CODE_ST },
9446
9447 };
9448
9449 #define DTMF_DIGIT_MAP_ENTRIES ARRAY_SIZE(dtmf_digit_map)
9450
9451
9452 static void dtmf_enable_receiver(PLCI *plci, byte enable_mask)
9453 {
9454 word min_digit_duration, min_gap_duration;
9455
9456 dbug(1, dprintf("[%06lx] %s,%d: dtmf_enable_receiver %02x",
9457 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
9458 (char *)(FILE_), __LINE__, enable_mask));
9459
9460 if (enable_mask != 0)
9461 {
9462 min_digit_duration = (plci->dtmf_rec_pulse_ms == 0) ? 40 : plci->dtmf_rec_pulse_ms;
9463 min_gap_duration = (plci->dtmf_rec_pause_ms == 0) ? 40 : plci->dtmf_rec_pause_ms;
9464 plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_ENABLE_RECEIVER;
9465 PUT_WORD(&plci->internal_req_buffer[1], min_digit_duration);
9466 PUT_WORD(&plci->internal_req_buffer[3], min_gap_duration);
9467 plci->NData[0].PLength = 5;
9468
9469 PUT_WORD(&plci->internal_req_buffer[5], INTERNAL_IND_BUFFER_SIZE);
9470 plci->NData[0].PLength += 2;
9471 capidtmf_recv_enable(&(plci->capidtmf_state), min_digit_duration, min_gap_duration);
9472
9473 }
9474 else
9475 {
9476 plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_DISABLE_RECEIVER;
9477 plci->NData[0].PLength = 1;
9478
9479 capidtmf_recv_disable(&(plci->capidtmf_state));
9480
9481 }
9482 plci->NData[0].P = plci->internal_req_buffer;
9483 plci->NL.X = plci->NData;
9484 plci->NL.ReqCh = 0;
9485 plci->NL.Req = plci->nl_req = (byte) N_UDATA;
9486 plci->adapter->request(&plci->NL);
9487 }
9488
9489
9490 static void dtmf_send_digits(PLCI *plci, byte *digit_buffer, word digit_count)
9491 {
9492 word w, i;
9493
9494 dbug(1, dprintf("[%06lx] %s,%d: dtmf_send_digits %d",
9495 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
9496 (char *)(FILE_), __LINE__, digit_count));
9497
9498 plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_SEND_DIGITS;
9499 w = (plci->dtmf_send_pulse_ms == 0) ? 40 : plci->dtmf_send_pulse_ms;
9500 PUT_WORD(&plci->internal_req_buffer[1], w);
9501 w = (plci->dtmf_send_pause_ms == 0) ? 40 : plci->dtmf_send_pause_ms;
9502 PUT_WORD(&plci->internal_req_buffer[3], w);
9503 for (i = 0; i < digit_count; i++)
9504 {
9505 w = 0;
9506 while ((w < DTMF_DIGIT_MAP_ENTRIES)
9507 && (digit_buffer[i] != dtmf_digit_map[w].character))
9508 {
9509 w++;
9510 }
9511 plci->internal_req_buffer[5 + i] = (w < DTMF_DIGIT_MAP_ENTRIES) ?
9512 dtmf_digit_map[w].code : DTMF_DIGIT_TONE_CODE_STAR;
9513 }
9514 plci->NData[0].PLength = 5 + digit_count;
9515 plci->NData[0].P = plci->internal_req_buffer;
9516 plci->NL.X = plci->NData;
9517 plci->NL.ReqCh = 0;
9518 plci->NL.Req = plci->nl_req = (byte) N_UDATA;
9519 plci->adapter->request(&plci->NL);
9520 }
9521
9522
9523 static void dtmf_rec_clear_config(PLCI *plci)
9524 {
9525
9526 dbug(1, dprintf("[%06lx] %s,%d: dtmf_rec_clear_config",
9527 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
9528 (char *)(FILE_), __LINE__));
9529
9530 plci->dtmf_rec_active = 0;
9531 plci->dtmf_rec_pulse_ms = 0;
9532 plci->dtmf_rec_pause_ms = 0;
9533
9534 capidtmf_init(&(plci->capidtmf_state), plci->adapter->u_law);
9535
9536 }
9537
9538
9539 static void dtmf_send_clear_config(PLCI *plci)
9540 {
9541
9542 dbug(1, dprintf("[%06lx] %s,%d: dtmf_send_clear_config",
9543 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
9544 (char *)(FILE_), __LINE__));
9545
9546 plci->dtmf_send_requests = 0;
9547 plci->dtmf_send_pulse_ms = 0;
9548 plci->dtmf_send_pause_ms = 0;
9549 }
9550
9551
9552 static void dtmf_prepare_switch(dword Id, PLCI *plci)
9553 {
9554
9555 dbug(1, dprintf("[%06lx] %s,%d: dtmf_prepare_switch",
9556 UnMapId(Id), (char *)(FILE_), __LINE__));
9557
9558 while (plci->dtmf_send_requests != 0)
9559 dtmf_confirmation(Id, plci);
9560 }
9561
9562
9563 static word dtmf_save_config(dword Id, PLCI *plci, byte Rc)
9564 {
9565
9566 dbug(1, dprintf("[%06lx] %s,%d: dtmf_save_config %02x %d",
9567 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
9568
9569 return (GOOD);
9570 }
9571
9572
9573 static word dtmf_restore_config(dword Id, PLCI *plci, byte Rc)
9574 {
9575 word Info;
9576
9577 dbug(1, dprintf("[%06lx] %s,%d: dtmf_restore_config %02x %d",
9578 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
9579
9580 Info = GOOD;
9581 if (plci->B1_facilities & B1_FACILITY_DTMFR)
9582 {
9583 switch (plci->adjust_b_state)
9584 {
9585 case ADJUST_B_RESTORE_DTMF_1:
9586 plci->internal_command = plci->adjust_b_command;
9587 if (plci_nl_busy(plci))
9588 {
9589 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
9590 break;
9591 }
9592 dtmf_enable_receiver(plci, plci->dtmf_rec_active);
9593 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_2;
9594 break;
9595 case ADJUST_B_RESTORE_DTMF_2:
9596 if ((Rc != OK) && (Rc != OK_FC))
9597 {
9598 dbug(1, dprintf("[%06lx] %s,%d: Reenable DTMF receiver failed %02x",
9599 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
9600 Info = _WRONG_STATE;
9601 break;
9602 }
9603 break;
9604 }
9605 }
9606 return (Info);
9607 }
9608
9609
9610 static void dtmf_command(dword Id, PLCI *plci, byte Rc)
9611 {
9612 word internal_command, Info;
9613 byte mask;
9614 byte result[4];
9615
9616 dbug(1, dprintf("[%06lx] %s,%d: dtmf_command %02x %04x %04x %d %d %d %d",
9617 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command,
9618 plci->dtmf_cmd, plci->dtmf_rec_pulse_ms, plci->dtmf_rec_pause_ms,
9619 plci->dtmf_send_pulse_ms, plci->dtmf_send_pause_ms));
9620
9621 Info = GOOD;
9622 result[0] = 2;
9623 PUT_WORD(&result[1], DTMF_SUCCESS);
9624 internal_command = plci->internal_command;
9625 plci->internal_command = 0;
9626 mask = 0x01;
9627 switch (plci->dtmf_cmd)
9628 {
9629
9630 case DTMF_LISTEN_TONE_START:
9631 mask <<= 1; /* fall through */
9632 case DTMF_LISTEN_MF_START:
9633 mask <<= 1; /* fall through */
9634
9635 case DTMF_LISTEN_START:
9636 switch (internal_command)
9637 {
9638 default:
9639 adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities |
9640 B1_FACILITY_DTMFR), DTMF_COMMAND_1);
9641 /* fall through */
9642 case DTMF_COMMAND_1:
9643 if (adjust_b_process(Id, plci, Rc) != GOOD)
9644 {
9645 dbug(1, dprintf("[%06lx] %s,%d: Load DTMF failed",
9646 UnMapId(Id), (char *)(FILE_), __LINE__));
9647 Info = _FACILITY_NOT_SUPPORTED;
9648 break;
9649 }
9650 if (plci->internal_command)
9651 return;
9652 /* fall through */
9653 case DTMF_COMMAND_2:
9654 if (plci_nl_busy(plci))
9655 {
9656 plci->internal_command = DTMF_COMMAND_2;
9657 return;
9658 }
9659 plci->internal_command = DTMF_COMMAND_3;
9660 dtmf_enable_receiver(plci, (byte)(plci->dtmf_rec_active | mask));
9661 return;
9662 case DTMF_COMMAND_3:
9663 if ((Rc != OK) && (Rc != OK_FC))
9664 {
9665 dbug(1, dprintf("[%06lx] %s,%d: Enable DTMF receiver failed %02x",
9666 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
9667 Info = _FACILITY_NOT_SUPPORTED;
9668 break;
9669 }
9670
9671 plci->tone_last_indication_code = DTMF_SIGNAL_NO_TONE;
9672
9673 plci->dtmf_rec_active |= mask;
9674 break;
9675 }
9676 break;
9677
9678
9679 case DTMF_LISTEN_TONE_STOP:
9680 mask <<= 1; /* fall through */
9681 case DTMF_LISTEN_MF_STOP:
9682 mask <<= 1; /* fall through */
9683
9684 case DTMF_LISTEN_STOP:
9685 switch (internal_command)
9686 {
9687 default:
9688 plci->dtmf_rec_active &= ~mask;
9689 if (plci->dtmf_rec_active)
9690 break;
9691 /*
9692 case DTMF_COMMAND_1:
9693 if (plci->dtmf_rec_active)
9694 {
9695 if (plci_nl_busy (plci))
9696 {
9697 plci->internal_command = DTMF_COMMAND_1;
9698 return;
9699 }
9700 plci->dtmf_rec_active &= ~mask;
9701 plci->internal_command = DTMF_COMMAND_2;
9702 dtmf_enable_receiver (plci, false);
9703 return;
9704 }
9705 Rc = OK;
9706 case DTMF_COMMAND_2:
9707 if ((Rc != OK) && (Rc != OK_FC))
9708 {
9709 dbug (1, dprintf("[%06lx] %s,%d: Disable DTMF receiver failed %02x",
9710 UnMapId (Id), (char far *)(FILE_), __LINE__, Rc));
9711 Info = _FACILITY_NOT_SUPPORTED;
9712 break;
9713 }
9714 */
9715 adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities &
9716 ~(B1_FACILITY_DTMFX | B1_FACILITY_DTMFR)), DTMF_COMMAND_3);
9717 /* fall through */
9718 case DTMF_COMMAND_3:
9719 if (adjust_b_process(Id, plci, Rc) != GOOD)
9720 {
9721 dbug(1, dprintf("[%06lx] %s,%d: Unload DTMF failed",
9722 UnMapId(Id), (char *)(FILE_), __LINE__));
9723 Info = _FACILITY_NOT_SUPPORTED;
9724 break;
9725 }
9726 if (plci->internal_command)
9727 return;
9728 break;
9729 }
9730 break;
9731
9732
9733 case DTMF_SEND_TONE:
9734 mask <<= 1; /* fall through */
9735 case DTMF_SEND_MF:
9736 mask <<= 1; /* fall through */
9737
9738 case DTMF_DIGITS_SEND:
9739 switch (internal_command)
9740 {
9741 default:
9742 adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities |
9743 ((plci->dtmf_parameter_length != 0) ? B1_FACILITY_DTMFX | B1_FACILITY_DTMFR : B1_FACILITY_DTMFX)),
9744 DTMF_COMMAND_1);
9745 /* fall through */
9746 case DTMF_COMMAND_1:
9747 if (adjust_b_process(Id, plci, Rc) != GOOD)
9748 {
9749 dbug(1, dprintf("[%06lx] %s,%d: Load DTMF failed",
9750 UnMapId(Id), (char *)(FILE_), __LINE__));
9751 Info = _FACILITY_NOT_SUPPORTED;
9752 break;
9753 }
9754 if (plci->internal_command)
9755 return;
9756 /* fall through */
9757 case DTMF_COMMAND_2:
9758 if (plci_nl_busy(plci))
9759 {
9760 plci->internal_command = DTMF_COMMAND_2;
9761 return;
9762 }
9763 plci->dtmf_msg_number_queue[(plci->dtmf_send_requests)++] = plci->number;
9764 plci->internal_command = DTMF_COMMAND_3;
9765 dtmf_send_digits(plci, &plci->saved_msg.parms[3].info[1], plci->saved_msg.parms[3].length);
9766 return;
9767 case DTMF_COMMAND_3:
9768 if ((Rc != OK) && (Rc != OK_FC))
9769 {
9770 dbug(1, dprintf("[%06lx] %s,%d: Send DTMF digits failed %02x",
9771 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
9772 if (plci->dtmf_send_requests != 0)
9773 (plci->dtmf_send_requests)--;
9774 Info = _FACILITY_NOT_SUPPORTED;
9775 break;
9776 }
9777 return;
9778 }
9779 break;
9780 }
9781 sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->number,
9782 "wws", Info, SELECTOR_DTMF, result);
9783 }
9784
9785
9786 static byte dtmf_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg)
9787 {
9788 word Info;
9789 word i, j;
9790 byte mask;
9791 API_PARSE dtmf_parms[5];
9792 byte result[40];
9793
9794 dbug(1, dprintf("[%06lx] %s,%d: dtmf_request",
9795 UnMapId(Id), (char *)(FILE_), __LINE__));
9796
9797 Info = GOOD;
9798 result[0] = 2;
9799 PUT_WORD(&result[1], DTMF_SUCCESS);
9800 if (!(a->profile.Global_Options & GL_DTMF_SUPPORTED))
9801 {
9802 dbug(1, dprintf("[%06lx] %s,%d: Facility not supported",
9803 UnMapId(Id), (char *)(FILE_), __LINE__));
9804 Info = _FACILITY_NOT_SUPPORTED;
9805 }
9806 else if (api_parse(&msg[1].info[1], msg[1].length, "w", dtmf_parms))
9807 {
9808 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
9809 UnMapId(Id), (char *)(FILE_), __LINE__));
9810 Info = _WRONG_MESSAGE_FORMAT;
9811 }
9812
9813 else if ((GET_WORD(dtmf_parms[0].info) == DTMF_GET_SUPPORTED_DETECT_CODES)
9814 || (GET_WORD(dtmf_parms[0].info) == DTMF_GET_SUPPORTED_SEND_CODES))
9815 {
9816 if (!((a->requested_options_table[appl->Id - 1])
9817 & (1L << PRIVATE_DTMF_TONE)))
9818 {
9819 dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x",
9820 UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(dtmf_parms[0].info)));
9821 PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST);
9822 }
9823 else
9824 {
9825 for (i = 0; i < 32; i++)
9826 result[4 + i] = 0;
9827 if (GET_WORD(dtmf_parms[0].info) == DTMF_GET_SUPPORTED_DETECT_CODES)
9828 {
9829 for (i = 0; i < DTMF_DIGIT_MAP_ENTRIES; i++)
9830 {
9831 if (dtmf_digit_map[i].listen_mask != 0)
9832 result[4 + (dtmf_digit_map[i].character >> 3)] |= (1 << (dtmf_digit_map[i].character & 0x7));
9833 }
9834 }
9835 else
9836 {
9837 for (i = 0; i < DTMF_DIGIT_MAP_ENTRIES; i++)
9838 {
9839 if (dtmf_digit_map[i].send_mask != 0)
9840 result[4 + (dtmf_digit_map[i].character >> 3)] |= (1 << (dtmf_digit_map[i].character & 0x7));
9841 }
9842 }
9843 result[0] = 3 + 32;
9844 result[3] = 32;
9845 }
9846 }
9847
9848 else if (plci == NULL)
9849 {
9850 dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI",
9851 UnMapId(Id), (char *)(FILE_), __LINE__));
9852 Info = _WRONG_IDENTIFIER;
9853 }
9854 else
9855 {
9856 if (!plci->State
9857 || !plci->NL.Id || plci->nl_remove_id)
9858 {
9859 dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
9860 UnMapId(Id), (char *)(FILE_), __LINE__));
9861 Info = _WRONG_STATE;
9862 }
9863 else
9864 {
9865 plci->command = 0;
9866 plci->dtmf_cmd = GET_WORD(dtmf_parms[0].info);
9867 mask = 0x01;
9868 switch (plci->dtmf_cmd)
9869 {
9870
9871 case DTMF_LISTEN_TONE_START:
9872 case DTMF_LISTEN_TONE_STOP:
9873 mask <<= 1; /* fall through */
9874 case DTMF_LISTEN_MF_START:
9875 case DTMF_LISTEN_MF_STOP:
9876 mask <<= 1;
9877 if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[appl->Id - 1])
9878 & (1L << PRIVATE_DTMF_TONE)))
9879 {
9880 dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x",
9881 UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(dtmf_parms[0].info)));
9882 PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST);
9883 break;
9884 }
9885 /* fall through */
9886
9887 case DTMF_LISTEN_START:
9888 case DTMF_LISTEN_STOP:
9889 if (!(a->manufacturer_features & MANUFACTURER_FEATURE_HARDDTMF)
9890 && !(a->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE))
9891 {
9892 dbug(1, dprintf("[%06lx] %s,%d: Facility not supported",
9893 UnMapId(Id), (char *)(FILE_), __LINE__));
9894 Info = _FACILITY_NOT_SUPPORTED;
9895 break;
9896 }
9897 if (mask & DTMF_LISTEN_ACTIVE_FLAG)
9898 {
9899 if (api_parse(&msg[1].info[1], msg[1].length, "wwws", dtmf_parms))
9900 {
9901 plci->dtmf_rec_pulse_ms = 0;
9902 plci->dtmf_rec_pause_ms = 0;
9903 }
9904 else
9905 {
9906 plci->dtmf_rec_pulse_ms = GET_WORD(dtmf_parms[1].info);
9907 plci->dtmf_rec_pause_ms = GET_WORD(dtmf_parms[2].info);
9908 }
9909 }
9910 start_internal_command(Id, plci, dtmf_command);
9911 return (false);
9912
9913
9914 case DTMF_SEND_TONE:
9915 mask <<= 1; /* fall through */
9916 case DTMF_SEND_MF:
9917 mask <<= 1;
9918 if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[appl->Id - 1])
9919 & (1L << PRIVATE_DTMF_TONE)))
9920 {
9921 dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x",
9922 UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(dtmf_parms[0].info)));
9923 PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST);
9924 break;
9925 }
9926 /* fall through */
9927
9928 case DTMF_DIGITS_SEND:
9929 if (api_parse(&msg[1].info[1], msg[1].length, "wwws", dtmf_parms))
9930 {
9931 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
9932 UnMapId(Id), (char *)(FILE_), __LINE__));
9933 Info = _WRONG_MESSAGE_FORMAT;
9934 break;
9935 }
9936 if (mask & DTMF_LISTEN_ACTIVE_FLAG)
9937 {
9938 plci->dtmf_send_pulse_ms = GET_WORD(dtmf_parms[1].info);
9939 plci->dtmf_send_pause_ms = GET_WORD(dtmf_parms[2].info);
9940 }
9941 i = 0;
9942 j = 0;
9943 while ((i < dtmf_parms[3].length) && (j < DTMF_DIGIT_MAP_ENTRIES))
9944 {
9945 j = 0;
9946 while ((j < DTMF_DIGIT_MAP_ENTRIES)
9947 && ((dtmf_parms[3].info[i + 1] != dtmf_digit_map[j].character)
9948 || ((dtmf_digit_map[j].send_mask & mask) == 0)))
9949 {
9950 j++;
9951 }
9952 i++;
9953 }
9954 if (j == DTMF_DIGIT_MAP_ENTRIES)
9955 {
9956 dbug(1, dprintf("[%06lx] %s,%d: Incorrect DTMF digit %02x",
9957 UnMapId(Id), (char *)(FILE_), __LINE__, dtmf_parms[3].info[i]));
9958 PUT_WORD(&result[1], DTMF_INCORRECT_DIGIT);
9959 break;
9960 }
9961 if (plci->dtmf_send_requests >= ARRAY_SIZE(plci->dtmf_msg_number_queue))
9962 {
9963 dbug(1, dprintf("[%06lx] %s,%d: DTMF request overrun",
9964 UnMapId(Id), (char *)(FILE_), __LINE__));
9965 Info = _WRONG_STATE;
9966 break;
9967 }
9968 api_save_msg(dtmf_parms, "wwws", &plci->saved_msg);
9969 start_internal_command(Id, plci, dtmf_command);
9970 return (false);
9971
9972 default:
9973 dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x",
9974 UnMapId(Id), (char *)(FILE_), __LINE__, plci->dtmf_cmd));
9975 PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST);
9976 }
9977 }
9978 }
9979 sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
9980 "wws", Info, SELECTOR_DTMF, result);
9981 return (false);
9982 }
9983
9984
9985 static void dtmf_confirmation(dword Id, PLCI *plci)
9986 {
9987 word i;
9988 byte result[4];
9989
9990 dbug(1, dprintf("[%06lx] %s,%d: dtmf_confirmation",
9991 UnMapId(Id), (char *)(FILE_), __LINE__));
9992
9993 result[0] = 2;
9994 PUT_WORD(&result[1], DTMF_SUCCESS);
9995 if (plci->dtmf_send_requests != 0)
9996 {
9997 sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->dtmf_msg_number_queue[0],
9998 "wws", GOOD, SELECTOR_DTMF, result);
9999 (plci->dtmf_send_requests)--;
10000 for (i = 0; i < plci->dtmf_send_requests; i++)
10001 plci->dtmf_msg_number_queue[i] = plci->dtmf_msg_number_queue[i + 1];
10002 }
10003 }
10004
10005
10006 static void dtmf_indication(dword Id, PLCI *plci, byte *msg, word length)
10007 {
10008 word i, j, n;
10009
10010 dbug(1, dprintf("[%06lx] %s,%d: dtmf_indication",
10011 UnMapId(Id), (char *)(FILE_), __LINE__));
10012
10013 n = 0;
10014 for (i = 1; i < length; i++)
10015 {
10016 j = 0;
10017 while ((j < DTMF_DIGIT_MAP_ENTRIES)
10018 && ((msg[i] != dtmf_digit_map[j].code)
10019 || ((dtmf_digit_map[j].listen_mask & plci->dtmf_rec_active) == 0)))
10020 {
10021 j++;
10022 }
10023 if (j < DTMF_DIGIT_MAP_ENTRIES)
10024 {
10025
10026 if ((dtmf_digit_map[j].listen_mask & DTMF_TONE_LISTEN_ACTIVE_FLAG)
10027 && (plci->tone_last_indication_code == DTMF_SIGNAL_NO_TONE)
10028 && (dtmf_digit_map[j].character != DTMF_SIGNAL_UNIDENTIFIED_TONE))
10029 {
10030 if (n + 1 == i)
10031 {
10032 for (i = length; i > n + 1; i--)
10033 msg[i] = msg[i - 1];
10034 length++;
10035 i++;
10036 }
10037 msg[++n] = DTMF_SIGNAL_UNIDENTIFIED_TONE;
10038 }
10039 plci->tone_last_indication_code = dtmf_digit_map[j].character;
10040
10041 msg[++n] = dtmf_digit_map[j].character;
10042 }
10043 }
10044 if (n != 0)
10045 {
10046 msg[0] = (byte) n;
10047 sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "wS", SELECTOR_DTMF, msg);
10048 }
10049 }
10050
10051
10052 /*------------------------------------------------------------------*/
10053 /* DTMF parameters */
10054 /*------------------------------------------------------------------*/
10055
10056 static void dtmf_parameter_write(PLCI *plci)
10057 {
10058 word i;
10059 byte parameter_buffer[DTMF_PARAMETER_BUFFER_SIZE + 2];
10060
10061 dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_write",
10062 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10063 (char *)(FILE_), __LINE__));
10064
10065 parameter_buffer[0] = plci->dtmf_parameter_length + 1;
10066 parameter_buffer[1] = DSP_CTRL_SET_DTMF_PARAMETERS;
10067 for (i = 0; i < plci->dtmf_parameter_length; i++)
10068 parameter_buffer[2 + i] = plci->dtmf_parameter_buffer[i];
10069 add_p(plci, FTY, parameter_buffer);
10070 sig_req(plci, TEL_CTRL, 0);
10071 send_req(plci);
10072 }
10073
10074
10075 static void dtmf_parameter_clear_config(PLCI *plci)
10076 {
10077
10078 dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_clear_config",
10079 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10080 (char *)(FILE_), __LINE__));
10081
10082 plci->dtmf_parameter_length = 0;
10083 }
10084
10085
10086 static void dtmf_parameter_prepare_switch(dword Id, PLCI *plci)
10087 {
10088
10089 dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_prepare_switch",
10090 UnMapId(Id), (char *)(FILE_), __LINE__));
10091
10092 }
10093
10094
10095 static word dtmf_parameter_save_config(dword Id, PLCI *plci, byte Rc)
10096 {
10097
10098 dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_save_config %02x %d",
10099 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
10100
10101 return (GOOD);
10102 }
10103
10104
10105 static word dtmf_parameter_restore_config(dword Id, PLCI *plci, byte Rc)
10106 {
10107 word Info;
10108
10109 dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_restore_config %02x %d",
10110 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
10111
10112 Info = GOOD;
10113 if ((plci->B1_facilities & B1_FACILITY_DTMFR)
10114 && (plci->dtmf_parameter_length != 0))
10115 {
10116 switch (plci->adjust_b_state)
10117 {
10118 case ADJUST_B_RESTORE_DTMF_PARAMETER_1:
10119 plci->internal_command = plci->adjust_b_command;
10120 if (plci->sig_req)
10121 {
10122 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_1;
10123 break;
10124 }
10125 dtmf_parameter_write(plci);
10126 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_2;
10127 break;
10128 case ADJUST_B_RESTORE_DTMF_PARAMETER_2:
10129 if ((Rc != OK) && (Rc != OK_FC))
10130 {
10131 dbug(1, dprintf("[%06lx] %s,%d: Restore DTMF parameters failed %02x",
10132 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
10133 Info = _WRONG_STATE;
10134 break;
10135 }
10136 break;
10137 }
10138 }
10139 return (Info);
10140 }
10141
10142
10143 /*------------------------------------------------------------------*/
10144 /* Line interconnect facilities */
10145 /*------------------------------------------------------------------*/
10146
10147
10148 LI_CONFIG *li_config_table;
10149 word li_total_channels;
10150
10151
10152 /*------------------------------------------------------------------*/
10153 /* translate a CHI information element to a channel number */
10154 /* returns 0xff - any channel */
10155 /* 0xfe - chi wrong coding */
10156 /* 0xfd - D-channel */
10157 /* 0x00 - no channel */
10158 /* else channel number / PRI: timeslot */
10159 /* if channels is provided we accept more than one channel. */
10160 /*------------------------------------------------------------------*/
10161
10162 static byte chi_to_channel(byte *chi, dword *pchannelmap)
10163 {
10164 int p;
10165 int i;
10166 dword map;
10167 byte excl;
10168 byte ofs;
10169 byte ch;
10170
10171 if (pchannelmap) *pchannelmap = 0;
10172 if (!chi[0]) return 0xff;
10173 excl = 0;
10174
10175 if (chi[1] & 0x20) {
10176 if (chi[0] == 1 && chi[1] == 0xac) return 0xfd; /* exclusive d-channel */
10177 for (i = 1; i < chi[0] && !(chi[i] & 0x80); i++);
10178 if (i == chi[0] || !(chi[i] & 0x80)) return 0xfe;
10179 if ((chi[1] | 0xc8) != 0xe9) return 0xfe;
10180 if (chi[1] & 0x08) excl = 0x40;
10181
10182 /* int. id present */
10183 if (chi[1] & 0x40) {
10184 p = i + 1;
10185 for (i = p; i < chi[0] && !(chi[i] & 0x80); i++);
10186 if (i == chi[0] || !(chi[i] & 0x80)) return 0xfe;
10187 }
10188
10189 /* coding standard, Number/Map, Channel Type */
10190 p = i + 1;
10191 for (i = p; i < chi[0] && !(chi[i] & 0x80); i++);
10192 if (i == chi[0] || !(chi[i] & 0x80)) return 0xfe;
10193 if ((chi[p] | 0xd0) != 0xd3) return 0xfe;
10194
10195 /* Number/Map */
10196 if (chi[p] & 0x10) {
10197
10198 /* map */
10199 if ((chi[0] - p) == 4) ofs = 0;
10200 else if ((chi[0] - p) == 3) ofs = 1;
10201 else return 0xfe;
10202 ch = 0;
10203 map = 0;
10204 for (i = 0; i < 4 && p < chi[0]; i++) {
10205 p++;
10206 ch += 8;
10207 map <<= 8;
10208 if (chi[p]) {
10209 for (ch = 0; !(chi[p] & (1 << ch)); ch++);
10210 map |= chi[p];
10211 }
10212 }
10213 ch += ofs;
10214 map <<= ofs;
10215 }
10216 else {
10217
10218 /* number */
10219 p = i + 1;
10220 ch = chi[p] & 0x3f;
10221 if (pchannelmap) {
10222 if ((byte)(chi[0] - p) > 30) return 0xfe;
10223 map = 0;
10224 for (i = p; i <= chi[0]; i++) {
10225 if ((chi[i] & 0x7f) > 31) return 0xfe;
10226 map |= (1L << (chi[i] & 0x7f));
10227 }
10228 }
10229 else {
10230 if (p != chi[0]) return 0xfe;
10231 if (ch > 31) return 0xfe;
10232 map = (1L << ch);
10233 }
10234 if (chi[p] & 0x40) return 0xfe;
10235 }
10236 if (pchannelmap) *pchannelmap = map;
10237 else if (map != ((dword)(1L << ch))) return 0xfe;
10238 return (byte)(excl | ch);
10239 }
10240 else { /* not PRI */
10241 for (i = 1; i < chi[0] && !(chi[i] & 0x80); i++);
10242 if (i != chi[0] || !(chi[i] & 0x80)) return 0xfe;
10243 if (chi[1] & 0x08) excl = 0x40;
10244
10245 switch (chi[1] | 0x98) {
10246 case 0x98: return 0;
10247 case 0x99:
10248 if (pchannelmap) *pchannelmap = 2;
10249 return excl | 1;
10250 case 0x9a:
10251 if (pchannelmap) *pchannelmap = 4;
10252 return excl | 2;
10253 case 0x9b: return 0xff;
10254 case 0x9c: return 0xfd; /* d-ch */
10255 default: return 0xfe;
10256 }
10257 }
10258 }
10259
10260
10261 static void mixer_set_bchannel_id_esc(PLCI *plci, byte bchannel_id)
10262 {
10263 DIVA_CAPI_ADAPTER *a;
10264 PLCI *splci;
10265 byte old_id;
10266
10267 a = plci->adapter;
10268 old_id = plci->li_bchannel_id;
10269 if (a->li_pri)
10270 {
10271 if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10272 li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10273 plci->li_bchannel_id = (bchannel_id & 0x1f) + 1;
10274 if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10275 li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10276 }
10277 else
10278 {
10279 if (((bchannel_id & 0x03) == 1) || ((bchannel_id & 0x03) == 2))
10280 {
10281 if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10282 li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10283 plci->li_bchannel_id = bchannel_id & 0x03;
10284 if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI != plci) && (a->AdvSignalPLCI->tel == ADV_VOICE))
10285 {
10286 splci = a->AdvSignalPLCI;
10287 if (li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci == NULL)
10288 {
10289 if ((splci->li_bchannel_id != 0)
10290 && (li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci == splci))
10291 {
10292 li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci = NULL;
10293 }
10294 splci->li_bchannel_id = 3 - plci->li_bchannel_id;
10295 li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci = splci;
10296 dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id_esc %d",
10297 (dword)((splci->Id << 8) | UnMapController(splci->adapter->Id)),
10298 (char *)(FILE_), __LINE__, splci->li_bchannel_id));
10299 }
10300 }
10301 if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10302 li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10303 }
10304 }
10305 if ((old_id == 0) && (plci->li_bchannel_id != 0)
10306 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
10307 {
10308 mixer_clear_config(plci);
10309 }
10310 dbug(1, dprintf("[%06lx] %s,%d: mixer_set_bchannel_id_esc %d %d",
10311 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10312 (char *)(FILE_), __LINE__, bchannel_id, plci->li_bchannel_id));
10313 }
10314
10315
10316 static void mixer_set_bchannel_id(PLCI *plci, byte *chi)
10317 {
10318 DIVA_CAPI_ADAPTER *a;
10319 PLCI *splci;
10320 byte ch, old_id;
10321
10322 a = plci->adapter;
10323 old_id = plci->li_bchannel_id;
10324 ch = chi_to_channel(chi, NULL);
10325 if (!(ch & 0x80))
10326 {
10327 if (a->li_pri)
10328 {
10329 if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10330 li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10331 plci->li_bchannel_id = (ch & 0x1f) + 1;
10332 if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10333 li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10334 }
10335 else
10336 {
10337 if (((ch & 0x1f) == 1) || ((ch & 0x1f) == 2))
10338 {
10339 if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10340 li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10341 plci->li_bchannel_id = ch & 0x1f;
10342 if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI != plci) && (a->AdvSignalPLCI->tel == ADV_VOICE))
10343 {
10344 splci = a->AdvSignalPLCI;
10345 if (li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci == NULL)
10346 {
10347 if ((splci->li_bchannel_id != 0)
10348 && (li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci == splci))
10349 {
10350 li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci = NULL;
10351 }
10352 splci->li_bchannel_id = 3 - plci->li_bchannel_id;
10353 li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci = splci;
10354 dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id %d",
10355 (dword)((splci->Id << 8) | UnMapController(splci->adapter->Id)),
10356 (char *)(FILE_), __LINE__, splci->li_bchannel_id));
10357 }
10358 }
10359 if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10360 li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10361 }
10362 }
10363 }
10364 if ((old_id == 0) && (plci->li_bchannel_id != 0)
10365 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
10366 {
10367 mixer_clear_config(plci);
10368 }
10369 dbug(1, dprintf("[%06lx] %s,%d: mixer_set_bchannel_id %02x %d",
10370 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10371 (char *)(FILE_), __LINE__, ch, plci->li_bchannel_id));
10372 }
10373
10374
10375 #define MIXER_MAX_DUMP_CHANNELS 34
10376
10377 static void mixer_calculate_coefs(DIVA_CAPI_ADAPTER *a)
10378 {
10379 word n, i, j;
10380 char *p;
10381 char hex_line[2 * MIXER_MAX_DUMP_CHANNELS + MIXER_MAX_DUMP_CHANNELS / 8 + 4];
10382
10383 dbug(1, dprintf("[%06lx] %s,%d: mixer_calculate_coefs",
10384 (dword)(UnMapController(a->Id)), (char *)(FILE_), __LINE__));
10385
10386 for (i = 0; i < li_total_channels; i++)
10387 {
10388 li_config_table[i].channel &= LI_CHANNEL_ADDRESSES_SET;
10389 if (li_config_table[i].chflags != 0)
10390 li_config_table[i].channel |= LI_CHANNEL_INVOLVED;
10391 else
10392 {
10393 for (j = 0; j < li_total_channels; j++)
10394 {
10395 if (((li_config_table[i].flag_table[j]) != 0)
10396 || ((li_config_table[j].flag_table[i]) != 0))
10397 {
10398 li_config_table[i].channel |= LI_CHANNEL_INVOLVED;
10399 }
10400 if (((li_config_table[i].flag_table[j] & LI_FLAG_CONFERENCE) != 0)
10401 || ((li_config_table[j].flag_table[i] & LI_FLAG_CONFERENCE) != 0))
10402 {
10403 li_config_table[i].channel |= LI_CHANNEL_CONFERENCE;
10404 }
10405 }
10406 }
10407 }
10408 for (i = 0; i < li_total_channels; i++)
10409 {
10410 for (j = 0; j < li_total_channels; j++)
10411 {
10412 li_config_table[i].coef_table[j] &= ~(LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC);
10413 if (li_config_table[i].flag_table[j] & LI_FLAG_CONFERENCE)
10414 li_config_table[i].coef_table[j] |= LI_COEF_CH_CH;
10415 }
10416 }
10417 for (n = 0; n < li_total_channels; n++)
10418 {
10419 if (li_config_table[n].channel & LI_CHANNEL_CONFERENCE)
10420 {
10421 for (i = 0; i < li_total_channels; i++)
10422 {
10423 if (li_config_table[i].channel & LI_CHANNEL_CONFERENCE)
10424 {
10425 for (j = 0; j < li_total_channels; j++)
10426 {
10427 li_config_table[i].coef_table[j] |=
10428 li_config_table[i].coef_table[n] & li_config_table[n].coef_table[j];
10429 }
10430 }
10431 }
10432 }
10433 }
10434 for (i = 0; i < li_total_channels; i++)
10435 {
10436 if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10437 {
10438 li_config_table[i].coef_table[i] &= ~LI_COEF_CH_CH;
10439 for (j = 0; j < li_total_channels; j++)
10440 {
10441 if (li_config_table[i].coef_table[j] & LI_COEF_CH_CH)
10442 li_config_table[i].flag_table[j] |= LI_FLAG_CONFERENCE;
10443 }
10444 if (li_config_table[i].flag_table[i] & LI_FLAG_CONFERENCE)
10445 li_config_table[i].coef_table[i] |= LI_COEF_CH_CH;
10446 }
10447 }
10448 for (i = 0; i < li_total_channels; i++)
10449 {
10450 if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10451 {
10452 for (j = 0; j < li_total_channels; j++)
10453 {
10454 if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
10455 li_config_table[i].coef_table[j] |= LI_COEF_CH_CH;
10456 if (li_config_table[i].flag_table[j] & LI_FLAG_MONITOR)
10457 li_config_table[i].coef_table[j] |= LI_COEF_CH_PC;
10458 if (li_config_table[i].flag_table[j] & LI_FLAG_MIX)
10459 li_config_table[i].coef_table[j] |= LI_COEF_PC_CH;
10460 if (li_config_table[i].flag_table[j] & LI_FLAG_PCCONNECT)
10461 li_config_table[i].coef_table[j] |= LI_COEF_PC_PC;
10462 }
10463 if (li_config_table[i].chflags & LI_CHFLAG_MONITOR)
10464 {
10465 for (j = 0; j < li_total_channels; j++)
10466 {
10467 if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
10468 {
10469 li_config_table[i].coef_table[j] |= LI_COEF_CH_PC;
10470 if (li_config_table[j].chflags & LI_CHFLAG_MIX)
10471 li_config_table[i].coef_table[j] |= LI_COEF_PC_CH | LI_COEF_PC_PC;
10472 }
10473 }
10474 }
10475 if (li_config_table[i].chflags & LI_CHFLAG_MIX)
10476 {
10477 for (j = 0; j < li_total_channels; j++)
10478 {
10479 if (li_config_table[j].flag_table[i] & LI_FLAG_INTERCONNECT)
10480 li_config_table[j].coef_table[i] |= LI_COEF_PC_CH;
10481 }
10482 }
10483 if (li_config_table[i].chflags & LI_CHFLAG_LOOP)
10484 {
10485 for (j = 0; j < li_total_channels; j++)
10486 {
10487 if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
10488 {
10489 for (n = 0; n < li_total_channels; n++)
10490 {
10491 if (li_config_table[n].flag_table[i] & LI_FLAG_INTERCONNECT)
10492 {
10493 li_config_table[n].coef_table[j] |= LI_COEF_CH_CH;
10494 if (li_config_table[j].chflags & LI_CHFLAG_MIX)
10495 {
10496 li_config_table[n].coef_table[j] |= LI_COEF_PC_CH;
10497 if (li_config_table[n].chflags & LI_CHFLAG_MONITOR)
10498 li_config_table[n].coef_table[j] |= LI_COEF_CH_PC | LI_COEF_PC_PC;
10499 }
10500 else if (li_config_table[n].chflags & LI_CHFLAG_MONITOR)
10501 li_config_table[n].coef_table[j] |= LI_COEF_CH_PC;
10502 }
10503 }
10504 }
10505 }
10506 }
10507 }
10508 }
10509 for (i = 0; i < li_total_channels; i++)
10510 {
10511 if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10512 {
10513 if (li_config_table[i].chflags & (LI_CHFLAG_MONITOR | LI_CHFLAG_MIX | LI_CHFLAG_LOOP))
10514 li_config_table[i].channel |= LI_CHANNEL_ACTIVE;
10515 if (li_config_table[i].chflags & LI_CHFLAG_MONITOR)
10516 li_config_table[i].channel |= LI_CHANNEL_RX_DATA;
10517 if (li_config_table[i].chflags & LI_CHFLAG_MIX)
10518 li_config_table[i].channel |= LI_CHANNEL_TX_DATA;
10519 for (j = 0; j < li_total_channels; j++)
10520 {
10521 if ((li_config_table[i].flag_table[j] &
10522 (LI_FLAG_INTERCONNECT | LI_FLAG_PCCONNECT | LI_FLAG_CONFERENCE | LI_FLAG_MONITOR))
10523 || (li_config_table[j].flag_table[i] &
10524 (LI_FLAG_INTERCONNECT | LI_FLAG_PCCONNECT | LI_FLAG_CONFERENCE | LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX)))
10525 {
10526 li_config_table[i].channel |= LI_CHANNEL_ACTIVE;
10527 }
10528 if (li_config_table[i].flag_table[j] & (LI_FLAG_PCCONNECT | LI_FLAG_MONITOR))
10529 li_config_table[i].channel |= LI_CHANNEL_RX_DATA;
10530 if (li_config_table[j].flag_table[i] & (LI_FLAG_PCCONNECT | LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX))
10531 li_config_table[i].channel |= LI_CHANNEL_TX_DATA;
10532 }
10533 if (!(li_config_table[i].channel & LI_CHANNEL_ACTIVE))
10534 {
10535 li_config_table[i].coef_table[i] |= LI_COEF_PC_CH | LI_COEF_CH_PC;
10536 li_config_table[i].channel |= LI_CHANNEL_TX_DATA | LI_CHANNEL_RX_DATA;
10537 }
10538 }
10539 }
10540 for (i = 0; i < li_total_channels; i++)
10541 {
10542 if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10543 {
10544 j = 0;
10545 while ((j < li_total_channels) && !(li_config_table[i].flag_table[j] & LI_FLAG_ANNOUNCEMENT))
10546 j++;
10547 if (j < li_total_channels)
10548 {
10549 for (j = 0; j < li_total_channels; j++)
10550 {
10551 li_config_table[i].coef_table[j] &= ~(LI_COEF_CH_CH | LI_COEF_PC_CH);
10552 if (li_config_table[i].flag_table[j] & LI_FLAG_ANNOUNCEMENT)
10553 li_config_table[i].coef_table[j] |= LI_COEF_PC_CH;
10554 }
10555 }
10556 }
10557 }
10558 n = li_total_channels;
10559 if (n > MIXER_MAX_DUMP_CHANNELS)
10560 n = MIXER_MAX_DUMP_CHANNELS;
10561
10562 p = hex_line;
10563 for (j = 0; j < n; j++)
10564 {
10565 if ((j & 0x7) == 0)
10566 *(p++) = ' ';
10567 p = hex_byte_pack(p, li_config_table[j].curchnl);
10568 }
10569 *p = '\0';
10570 dbug(1, dprintf("[%06lx] CURRENT %s",
10571 (dword)(UnMapController(a->Id)), (char *)hex_line));
10572 p = hex_line;
10573 for (j = 0; j < n; j++)
10574 {
10575 if ((j & 0x7) == 0)
10576 *(p++) = ' ';
10577 p = hex_byte_pack(p, li_config_table[j].channel);
10578 }
10579 *p = '\0';
10580 dbug(1, dprintf("[%06lx] CHANNEL %s",
10581 (dword)(UnMapController(a->Id)), (char *)hex_line));
10582 p = hex_line;
10583 for (j = 0; j < n; j++)
10584 {
10585 if ((j & 0x7) == 0)
10586 *(p++) = ' ';
10587 p = hex_byte_pack(p, li_config_table[j].chflags);
10588 }
10589 *p = '\0';
10590 dbug(1, dprintf("[%06lx] CHFLAG %s",
10591 (dword)(UnMapController(a->Id)), (char *)hex_line));
10592 for (i = 0; i < n; i++)
10593 {
10594 p = hex_line;
10595 for (j = 0; j < n; j++)
10596 {
10597 if ((j & 0x7) == 0)
10598 *(p++) = ' ';
10599 p = hex_byte_pack(p, li_config_table[i].flag_table[j]);
10600 }
10601 *p = '\0';
10602 dbug(1, dprintf("[%06lx] FLAG[%02x]%s",
10603 (dword)(UnMapController(a->Id)), i, (char *)hex_line));
10604 }
10605 for (i = 0; i < n; i++)
10606 {
10607 p = hex_line;
10608 for (j = 0; j < n; j++)
10609 {
10610 if ((j & 0x7) == 0)
10611 *(p++) = ' ';
10612 p = hex_byte_pack(p, li_config_table[i].coef_table[j]);
10613 }
10614 *p = '\0';
10615 dbug(1, dprintf("[%06lx] COEF[%02x]%s",
10616 (dword)(UnMapController(a->Id)), i, (char *)hex_line));
10617 }
10618 }
10619
10620
10621 static struct
10622 {
10623 byte mask;
10624 byte line_flags;
10625 } mixer_write_prog_pri[] =
10626 {
10627 { LI_COEF_CH_CH, 0 },
10628 { LI_COEF_CH_PC, MIXER_COEF_LINE_TO_PC_FLAG },
10629 { LI_COEF_PC_CH, MIXER_COEF_LINE_FROM_PC_FLAG },
10630 { LI_COEF_PC_PC, MIXER_COEF_LINE_TO_PC_FLAG | MIXER_COEF_LINE_FROM_PC_FLAG }
10631 };
10632
10633 static struct
10634 {
10635 byte from_ch;
10636 byte to_ch;
10637 byte mask;
10638 byte xconnect_override;
10639 } mixer_write_prog_bri[] =
10640 {
10641 { 0, 0, LI_COEF_CH_CH, 0x01 }, /* B to B */
10642 { 1, 0, LI_COEF_CH_CH, 0x01 }, /* Alt B to B */
10643 { 0, 0, LI_COEF_PC_CH, 0x80 }, /* PC to B */
10644 { 1, 0, LI_COEF_PC_CH, 0x01 }, /* Alt PC to B */
10645 { 2, 0, LI_COEF_CH_CH, 0x00 }, /* IC to B */
10646 { 3, 0, LI_COEF_CH_CH, 0x00 }, /* Alt IC to B */
10647 { 0, 0, LI_COEF_CH_PC, 0x80 }, /* B to PC */
10648 { 1, 0, LI_COEF_CH_PC, 0x01 }, /* Alt B to PC */
10649 { 0, 0, LI_COEF_PC_PC, 0x01 }, /* PC to PC */
10650 { 1, 0, LI_COEF_PC_PC, 0x01 }, /* Alt PC to PC */
10651 { 2, 0, LI_COEF_CH_PC, 0x00 }, /* IC to PC */
10652 { 3, 0, LI_COEF_CH_PC, 0x00 }, /* Alt IC to PC */
10653 { 0, 2, LI_COEF_CH_CH, 0x00 }, /* B to IC */
10654 { 1, 2, LI_COEF_CH_CH, 0x00 }, /* Alt B to IC */
10655 { 0, 2, LI_COEF_PC_CH, 0x00 }, /* PC to IC */
10656 { 1, 2, LI_COEF_PC_CH, 0x00 }, /* Alt PC to IC */
10657 { 2, 2, LI_COEF_CH_CH, 0x00 }, /* IC to IC */
10658 { 3, 2, LI_COEF_CH_CH, 0x00 }, /* Alt IC to IC */
10659 { 1, 1, LI_COEF_CH_CH, 0x01 }, /* Alt B to Alt B */
10660 { 0, 1, LI_COEF_CH_CH, 0x01 }, /* B to Alt B */
10661 { 1, 1, LI_COEF_PC_CH, 0x80 }, /* Alt PC to Alt B */
10662 { 0, 1, LI_COEF_PC_CH, 0x01 }, /* PC to Alt B */
10663 { 3, 1, LI_COEF_CH_CH, 0x00 }, /* Alt IC to Alt B */
10664 { 2, 1, LI_COEF_CH_CH, 0x00 }, /* IC to Alt B */
10665 { 1, 1, LI_COEF_CH_PC, 0x80 }, /* Alt B to Alt PC */
10666 { 0, 1, LI_COEF_CH_PC, 0x01 }, /* B to Alt PC */
10667 { 1, 1, LI_COEF_PC_PC, 0x01 }, /* Alt PC to Alt PC */
10668 { 0, 1, LI_COEF_PC_PC, 0x01 }, /* PC to Alt PC */
10669 { 3, 1, LI_COEF_CH_PC, 0x00 }, /* Alt IC to Alt PC */
10670 { 2, 1, LI_COEF_CH_PC, 0x00 }, /* IC to Alt PC */
10671 { 1, 3, LI_COEF_CH_CH, 0x00 }, /* Alt B to Alt IC */
10672 { 0, 3, LI_COEF_CH_CH, 0x00 }, /* B to Alt IC */
10673 { 1, 3, LI_COEF_PC_CH, 0x00 }, /* Alt PC to Alt IC */
10674 { 0, 3, LI_COEF_PC_CH, 0x00 }, /* PC to Alt IC */
10675 { 3, 3, LI_COEF_CH_CH, 0x00 }, /* Alt IC to Alt IC */
10676 { 2, 3, LI_COEF_CH_CH, 0x00 } /* IC to Alt IC */
10677 };
10678
10679 static byte mixer_swapped_index_bri[] =
10680 {
10681 18, /* B to B */
10682 19, /* Alt B to B */
10683 20, /* PC to B */
10684 21, /* Alt PC to B */
10685 22, /* IC to B */
10686 23, /* Alt IC to B */
10687 24, /* B to PC */
10688 25, /* Alt B to PC */
10689 26, /* PC to PC */
10690 27, /* Alt PC to PC */
10691 28, /* IC to PC */
10692 29, /* Alt IC to PC */
10693 30, /* B to IC */
10694 31, /* Alt B to IC */
10695 32, /* PC to IC */
10696 33, /* Alt PC to IC */
10697 34, /* IC to IC */
10698 35, /* Alt IC to IC */
10699 0, /* Alt B to Alt B */
10700 1, /* B to Alt B */
10701 2, /* Alt PC to Alt B */
10702 3, /* PC to Alt B */
10703 4, /* Alt IC to Alt B */
10704 5, /* IC to Alt B */
10705 6, /* Alt B to Alt PC */
10706 7, /* B to Alt PC */
10707 8, /* Alt PC to Alt PC */
10708 9, /* PC to Alt PC */
10709 10, /* Alt IC to Alt PC */
10710 11, /* IC to Alt PC */
10711 12, /* Alt B to Alt IC */
10712 13, /* B to Alt IC */
10713 14, /* Alt PC to Alt IC */
10714 15, /* PC to Alt IC */
10715 16, /* Alt IC to Alt IC */
10716 17 /* IC to Alt IC */
10717 };
10718
10719 static struct
10720 {
10721 byte mask;
10722 byte from_pc;
10723 byte to_pc;
10724 } xconnect_write_prog[] =
10725 {
10726 { LI_COEF_CH_CH, false, false },
10727 { LI_COEF_CH_PC, false, true },
10728 { LI_COEF_PC_CH, true, false },
10729 { LI_COEF_PC_PC, true, true }
10730 };
10731
10732
10733 static void xconnect_query_addresses(PLCI *plci)
10734 {
10735 DIVA_CAPI_ADAPTER *a;
10736 word w, ch;
10737 byte *p;
10738
10739 dbug(1, dprintf("[%06lx] %s,%d: xconnect_query_addresses",
10740 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10741 (char *)(FILE_), __LINE__));
10742
10743 a = plci->adapter;
10744 if (a->li_pri && ((plci->li_bchannel_id == 0)
10745 || (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci)))
10746 {
10747 dbug(1, dprintf("[%06x] %s,%d: Channel id wiped out",
10748 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10749 (char *)(FILE_), __LINE__));
10750 return;
10751 }
10752 p = plci->internal_req_buffer;
10753 ch = (a->li_pri) ? plci->li_bchannel_id - 1 : 0;
10754 *(p++) = UDATA_REQUEST_XCONNECT_FROM;
10755 w = ch;
10756 *(p++) = (byte) w;
10757 *(p++) = (byte)(w >> 8);
10758 w = ch | XCONNECT_CHANNEL_PORT_PC;
10759 *(p++) = (byte) w;
10760 *(p++) = (byte)(w >> 8);
10761 plci->NData[0].P = plci->internal_req_buffer;
10762 plci->NData[0].PLength = p - plci->internal_req_buffer;
10763 plci->NL.X = plci->NData;
10764 plci->NL.ReqCh = 0;
10765 plci->NL.Req = plci->nl_req = (byte) N_UDATA;
10766 plci->adapter->request(&plci->NL);
10767 }
10768
10769
10770 static void xconnect_write_coefs(PLCI *plci, word internal_command)
10771 {
10772
10773 dbug(1, dprintf("[%06lx] %s,%d: xconnect_write_coefs %04x",
10774 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10775 (char *)(FILE_), __LINE__, internal_command));
10776
10777 plci->li_write_command = internal_command;
10778 plci->li_write_channel = 0;
10779 }
10780
10781
10782 static byte xconnect_write_coefs_process(dword Id, PLCI *plci, byte Rc)
10783 {
10784 DIVA_CAPI_ADAPTER *a;
10785 word w, n, i, j, r, s, to_ch;
10786 dword d;
10787 byte *p;
10788 struct xconnect_transfer_address_s *transfer_address;
10789 byte ch_map[MIXER_CHANNELS_BRI];
10790
10791 dbug(1, dprintf("[%06x] %s,%d: xconnect_write_coefs_process %02x %d",
10792 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->li_write_channel));
10793
10794 a = plci->adapter;
10795 if ((plci->li_bchannel_id == 0)
10796 || (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci))
10797 {
10798 dbug(1, dprintf("[%06x] %s,%d: Channel id wiped out",
10799 UnMapId(Id), (char *)(FILE_), __LINE__));
10800 return (true);
10801 }
10802 i = a->li_base + (plci->li_bchannel_id - 1);
10803 j = plci->li_write_channel;
10804 p = plci->internal_req_buffer;
10805 if (j != 0)
10806 {
10807 if ((Rc != OK) && (Rc != OK_FC))
10808 {
10809 dbug(1, dprintf("[%06lx] %s,%d: LI write coefs failed %02x",
10810 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
10811 return (false);
10812 }
10813 }
10814 if (li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
10815 {
10816 r = 0;
10817 s = 0;
10818 if (j < li_total_channels)
10819 {
10820 if (li_config_table[i].channel & LI_CHANNEL_ADDRESSES_SET)
10821 {
10822 s = ((li_config_table[i].send_b.card_address.low | li_config_table[i].send_b.card_address.high) ?
10823 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_PC | LI_COEF_PC_PC)) &
10824 ((li_config_table[i].send_pc.card_address.low | li_config_table[i].send_pc.card_address.high) ?
10825 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_PC_CH));
10826 }
10827 r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
10828 while ((j < li_total_channels)
10829 && ((r == 0)
10830 || (!(li_config_table[j].channel & LI_CHANNEL_ADDRESSES_SET))
10831 || (!li_config_table[j].adapter->li_pri
10832 && (j >= li_config_table[j].adapter->li_base + MIXER_BCHANNELS_BRI))
10833 || (((li_config_table[j].send_b.card_address.low != li_config_table[i].send_b.card_address.low)
10834 || (li_config_table[j].send_b.card_address.high != li_config_table[i].send_b.card_address.high))
10835 && (!(a->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)
10836 || !(li_config_table[j].adapter->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)))
10837 || ((li_config_table[j].adapter->li_base != a->li_base)
10838 && !(r & s &
10839 ((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ?
10840 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) &
10841 ((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ?
10842 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC))))))
10843 {
10844 j++;
10845 if (j < li_total_channels)
10846 r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
10847 }
10848 }
10849 if (j < li_total_channels)
10850 {
10851 plci->internal_command = plci->li_write_command;
10852 if (plci_nl_busy(plci))
10853 return (true);
10854 to_ch = (a->li_pri) ? plci->li_bchannel_id - 1 : 0;
10855 *(p++) = UDATA_REQUEST_XCONNECT_TO;
10856 do
10857 {
10858 if (li_config_table[j].adapter->li_base != a->li_base)
10859 {
10860 r &= s &
10861 ((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ?
10862 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) &
10863 ((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ?
10864 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC));
10865 }
10866 n = 0;
10867 do
10868 {
10869 if (r & xconnect_write_prog[n].mask)
10870 {
10871 if (xconnect_write_prog[n].from_pc)
10872 transfer_address = &(li_config_table[j].send_pc);
10873 else
10874 transfer_address = &(li_config_table[j].send_b);
10875 d = transfer_address->card_address.low;
10876 *(p++) = (byte) d;
10877 *(p++) = (byte)(d >> 8);
10878 *(p++) = (byte)(d >> 16);
10879 *(p++) = (byte)(d >> 24);
10880 d = transfer_address->card_address.high;
10881 *(p++) = (byte) d;
10882 *(p++) = (byte)(d >> 8);
10883 *(p++) = (byte)(d >> 16);
10884 *(p++) = (byte)(d >> 24);
10885 d = transfer_address->offset;
10886 *(p++) = (byte) d;
10887 *(p++) = (byte)(d >> 8);
10888 *(p++) = (byte)(d >> 16);
10889 *(p++) = (byte)(d >> 24);
10890 w = xconnect_write_prog[n].to_pc ? to_ch | XCONNECT_CHANNEL_PORT_PC : to_ch;
10891 *(p++) = (byte) w;
10892 *(p++) = (byte)(w >> 8);
10893 w = ((li_config_table[i].coef_table[j] & xconnect_write_prog[n].mask) == 0) ? 0x01 :
10894 (li_config_table[i].adapter->u_law ?
10895 (li_config_table[j].adapter->u_law ? 0x80 : 0x86) :
10896 (li_config_table[j].adapter->u_law ? 0x7a : 0x80));
10897 *(p++) = (byte) w;
10898 *(p++) = (byte) 0;
10899 li_config_table[i].coef_table[j] ^= xconnect_write_prog[n].mask << 4;
10900 }
10901 n++;
10902 } while ((n < ARRAY_SIZE(xconnect_write_prog))
10903 && ((p - plci->internal_req_buffer) + 16 < INTERNAL_REQ_BUFFER_SIZE));
10904 if (n == ARRAY_SIZE(xconnect_write_prog))
10905 {
10906 do
10907 {
10908 j++;
10909 if (j < li_total_channels)
10910 r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
10911 } while ((j < li_total_channels)
10912 && ((r == 0)
10913 || (!(li_config_table[j].channel & LI_CHANNEL_ADDRESSES_SET))
10914 || (!li_config_table[j].adapter->li_pri
10915 && (j >= li_config_table[j].adapter->li_base + MIXER_BCHANNELS_BRI))
10916 || (((li_config_table[j].send_b.card_address.low != li_config_table[i].send_b.card_address.low)
10917 || (li_config_table[j].send_b.card_address.high != li_config_table[i].send_b.card_address.high))
10918 && (!(a->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)
10919 || !(li_config_table[j].adapter->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)))
10920 || ((li_config_table[j].adapter->li_base != a->li_base)
10921 && !(r & s &
10922 ((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ?
10923 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) &
10924 ((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ?
10925 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC))))));
10926 }
10927 } while ((j < li_total_channels)
10928 && ((p - plci->internal_req_buffer) + 16 < INTERNAL_REQ_BUFFER_SIZE));
10929 }
10930 else if (j == li_total_channels)
10931 {
10932 plci->internal_command = plci->li_write_command;
10933 if (plci_nl_busy(plci))
10934 return (true);
10935 if (a->li_pri)
10936 {
10937 *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_PRI_SYNC;
10938 w = 0;
10939 if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
10940 w |= MIXER_FEATURE_ENABLE_TX_DATA;
10941 if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
10942 w |= MIXER_FEATURE_ENABLE_RX_DATA;
10943 *(p++) = (byte) w;
10944 *(p++) = (byte)(w >> 8);
10945 }
10946 else
10947 {
10948 *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_BRI;
10949 w = 0;
10950 if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI)
10951 && (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length))
10952 {
10953 w = GET_WORD(a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE);
10954 }
10955 if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
10956 w |= MIXER_FEATURE_ENABLE_TX_DATA;
10957 if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
10958 w |= MIXER_FEATURE_ENABLE_RX_DATA;
10959 *(p++) = (byte) w;
10960 *(p++) = (byte)(w >> 8);
10961 for (j = 0; j < sizeof(ch_map); j += 2)
10962 {
10963 if (plci->li_bchannel_id == 2)
10964 {
10965 ch_map[j] = (byte)(j + 1);
10966 ch_map[j + 1] = (byte) j;
10967 }
10968 else
10969 {
10970 ch_map[j] = (byte) j;
10971 ch_map[j + 1] = (byte)(j + 1);
10972 }
10973 }
10974 for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++)
10975 {
10976 i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch];
10977 j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch];
10978 if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED)
10979 {
10980 *p = (mixer_write_prog_bri[n].xconnect_override != 0) ?
10981 mixer_write_prog_bri[n].xconnect_override :
10982 ((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01);
10983 if ((i >= a->li_base + MIXER_BCHANNELS_BRI) || (j >= a->li_base + MIXER_BCHANNELS_BRI))
10984 {
10985 w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
10986 li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4;
10987 }
10988 }
10989 else
10990 {
10991 *p = 0x00;
10992 if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI->tel == ADV_VOICE))
10993 {
10994 w = (plci == a->AdvSignalPLCI) ? n : mixer_swapped_index_bri[n];
10995 if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w < a->adv_voice_coef_length)
10996 *p = a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w];
10997 }
10998 }
10999 p++;
11000 }
11001 }
11002 j = li_total_channels + 1;
11003 }
11004 }
11005 else
11006 {
11007 if (j <= li_total_channels)
11008 {
11009 plci->internal_command = plci->li_write_command;
11010 if (plci_nl_busy(plci))
11011 return (true);
11012 if (j < a->li_base)
11013 j = a->li_base;
11014 if (a->li_pri)
11015 {
11016 *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_PRI_SYNC;
11017 w = 0;
11018 if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
11019 w |= MIXER_FEATURE_ENABLE_TX_DATA;
11020 if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
11021 w |= MIXER_FEATURE_ENABLE_RX_DATA;
11022 *(p++) = (byte) w;
11023 *(p++) = (byte)(w >> 8);
11024 for (n = 0; n < ARRAY_SIZE(mixer_write_prog_pri); n++)
11025 {
11026 *(p++) = (byte)((plci->li_bchannel_id - 1) | mixer_write_prog_pri[n].line_flags);
11027 for (j = a->li_base; j < a->li_base + MIXER_CHANNELS_PRI; j++)
11028 {
11029 w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
11030 if (w & mixer_write_prog_pri[n].mask)
11031 {
11032 *(p++) = (li_config_table[i].coef_table[j] & mixer_write_prog_pri[n].mask) ? 0x80 : 0x01;
11033 li_config_table[i].coef_table[j] ^= mixer_write_prog_pri[n].mask << 4;
11034 }
11035 else
11036 *(p++) = 0x00;
11037 }
11038 *(p++) = (byte)((plci->li_bchannel_id - 1) | MIXER_COEF_LINE_ROW_FLAG | mixer_write_prog_pri[n].line_flags);
11039 for (j = a->li_base; j < a->li_base + MIXER_CHANNELS_PRI; j++)
11040 {
11041 w = ((li_config_table[j].coef_table[i] & 0xf) ^ (li_config_table[j].coef_table[i] >> 4));
11042 if (w & mixer_write_prog_pri[n].mask)
11043 {
11044 *(p++) = (li_config_table[j].coef_table[i] & mixer_write_prog_pri[n].mask) ? 0x80 : 0x01;
11045 li_config_table[j].coef_table[i] ^= mixer_write_prog_pri[n].mask << 4;
11046 }
11047 else
11048 *(p++) = 0x00;
11049 }
11050 }
11051 }
11052 else
11053 {
11054 *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_BRI;
11055 w = 0;
11056 if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI)
11057 && (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length))
11058 {
11059 w = GET_WORD(a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE);
11060 }
11061 if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
11062 w |= MIXER_FEATURE_ENABLE_TX_DATA;
11063 if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
11064 w |= MIXER_FEATURE_ENABLE_RX_DATA;
11065 *(p++) = (byte) w;
11066 *(p++) = (byte)(w >> 8);
11067 for (j = 0; j < sizeof(ch_map); j += 2)
11068 {
11069 if (plci->li_bchannel_id == 2)
11070 {
11071 ch_map[j] = (byte)(j + 1);
11072 ch_map[j + 1] = (byte) j;
11073 }
11074 else
11075 {
11076 ch_map[j] = (byte) j;
11077 ch_map[j + 1] = (byte)(j + 1);
11078 }
11079 }
11080 for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++)
11081 {
11082 i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch];
11083 j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch];
11084 if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED)
11085 {
11086 *p = ((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01);
11087 w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
11088 li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4;
11089 }
11090 else
11091 {
11092 *p = 0x00;
11093 if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI->tel == ADV_VOICE))
11094 {
11095 w = (plci == a->AdvSignalPLCI) ? n : mixer_swapped_index_bri[n];
11096 if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w < a->adv_voice_coef_length)
11097 *p = a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w];
11098 }
11099 }
11100 p++;
11101 }
11102 }
11103 j = li_total_channels + 1;
11104 }
11105 }
11106 plci->li_write_channel = j;
11107 if (p != plci->internal_req_buffer)
11108 {
11109 plci->NData[0].P = plci->internal_req_buffer;
11110 plci->NData[0].PLength = p - plci->internal_req_buffer;
11111 plci->NL.X = plci->NData;
11112 plci->NL.ReqCh = 0;
11113 plci->NL.Req = plci->nl_req = (byte) N_UDATA;
11114 plci->adapter->request(&plci->NL);
11115 }
11116 return (true);
11117 }
11118
11119
11120 static void mixer_notify_update(PLCI *plci, byte others)
11121 {
11122 DIVA_CAPI_ADAPTER *a;
11123 word i, w;
11124 PLCI *notify_plci;
11125 byte msg[sizeof(CAPI_MSG_HEADER) + 6];
11126
11127 dbug(1, dprintf("[%06lx] %s,%d: mixer_notify_update %d",
11128 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
11129 (char *)(FILE_), __LINE__, others));
11130
11131 a = plci->adapter;
11132 if (a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED)
11133 {
11134 if (others)
11135 plci->li_notify_update = true;
11136 i = 0;
11137 do
11138 {
11139 notify_plci = NULL;
11140 if (others)
11141 {
11142 while ((i < li_total_channels) && (li_config_table[i].plci == NULL))
11143 i++;
11144 if (i < li_total_channels)
11145 notify_plci = li_config_table[i++].plci;
11146 }
11147 else
11148 {
11149 if ((plci->li_bchannel_id != 0)
11150 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11151 {
11152 notify_plci = plci;
11153 }
11154 }
11155 if ((notify_plci != NULL)
11156 && !notify_plci->li_notify_update
11157 && (notify_plci->appl != NULL)
11158 && (notify_plci->State)
11159 && notify_plci->NL.Id && !notify_plci->nl_remove_id)
11160 {
11161 notify_plci->li_notify_update = true;
11162 ((CAPI_MSG *) msg)->header.length = 18;
11163 ((CAPI_MSG *) msg)->header.appl_id = notify_plci->appl->Id;
11164 ((CAPI_MSG *) msg)->header.command = _FACILITY_R;
11165 ((CAPI_MSG *) msg)->header.number = 0;
11166 ((CAPI_MSG *) msg)->header.controller = notify_plci->adapter->Id;
11167 ((CAPI_MSG *) msg)->header.plci = notify_plci->Id;
11168 ((CAPI_MSG *) msg)->header.ncci = 0;
11169 ((CAPI_MSG *) msg)->info.facility_req.Selector = SELECTOR_LINE_INTERCONNECT;
11170 ((CAPI_MSG *) msg)->info.facility_req.structs[0] = 3;
11171 ((CAPI_MSG *) msg)->info.facility_req.structs[1] = LI_REQ_SILENT_UPDATE & 0xff;
11172 ((CAPI_MSG *) msg)->info.facility_req.structs[2] = LI_REQ_SILENT_UPDATE >> 8;
11173 ((CAPI_MSG *) msg)->info.facility_req.structs[3] = 0;
11174 w = api_put(notify_plci->appl, (CAPI_MSG *) msg);
11175 if (w != _QUEUE_FULL)
11176 {
11177 if (w != 0)
11178 {
11179 dbug(1, dprintf("[%06lx] %s,%d: Interconnect notify failed %06x %d",
11180 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
11181 (char *)(FILE_), __LINE__,
11182 (dword)((notify_plci->Id << 8) | UnMapController(notify_plci->adapter->Id)), w));
11183 }
11184 notify_plci->li_notify_update = false;
11185 }
11186 }
11187 } while (others && (notify_plci != NULL));
11188 if (others)
11189 plci->li_notify_update = false;
11190 }
11191 }
11192
11193
11194 static void mixer_clear_config(PLCI *plci)
11195 {
11196 DIVA_CAPI_ADAPTER *a;
11197 word i, j;
11198
11199 dbug(1, dprintf("[%06lx] %s,%d: mixer_clear_config",
11200 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
11201 (char *)(FILE_), __LINE__));
11202
11203 plci->li_notify_update = false;
11204 plci->li_plci_b_write_pos = 0;
11205 plci->li_plci_b_read_pos = 0;
11206 plci->li_plci_b_req_pos = 0;
11207 a = plci->adapter;
11208 if ((plci->li_bchannel_id != 0)
11209 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11210 {
11211 i = a->li_base + (plci->li_bchannel_id - 1);
11212 li_config_table[i].curchnl = 0;
11213 li_config_table[i].channel = 0;
11214 li_config_table[i].chflags = 0;
11215 for (j = 0; j < li_total_channels; j++)
11216 {
11217 li_config_table[j].flag_table[i] = 0;
11218 li_config_table[i].flag_table[j] = 0;
11219 li_config_table[i].coef_table[j] = 0;
11220 li_config_table[j].coef_table[i] = 0;
11221 }
11222 if (!a->li_pri)
11223 {
11224 li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET;
11225 if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
11226 {
11227 i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
11228 li_config_table[i].curchnl = 0;
11229 li_config_table[i].channel = 0;
11230 li_config_table[i].chflags = 0;
11231 for (j = 0; j < li_total_channels; j++)
11232 {
11233 li_config_table[i].flag_table[j] = 0;
11234 li_config_table[j].flag_table[i] = 0;
11235 li_config_table[i].coef_table[j] = 0;
11236 li_config_table[j].coef_table[i] = 0;
11237 }
11238 if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
11239 {
11240 i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
11241 li_config_table[i].curchnl = 0;
11242 li_config_table[i].channel = 0;
11243 li_config_table[i].chflags = 0;
11244 for (j = 0; j < li_total_channels; j++)
11245 {
11246 li_config_table[i].flag_table[j] = 0;
11247 li_config_table[j].flag_table[i] = 0;
11248 li_config_table[i].coef_table[j] = 0;
11249 li_config_table[j].coef_table[i] = 0;
11250 }
11251 }
11252 }
11253 }
11254 }
11255 }
11256
11257
11258 static void mixer_prepare_switch(dword Id, PLCI *plci)
11259 {
11260
11261 dbug(1, dprintf("[%06lx] %s,%d: mixer_prepare_switch",
11262 UnMapId(Id), (char *)(FILE_), __LINE__));
11263
11264 do
11265 {
11266 mixer_indication_coefs_set(Id, plci);
11267 } while (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos);
11268 }
11269
11270
11271 static word mixer_save_config(dword Id, PLCI *plci, byte Rc)
11272 {
11273 DIVA_CAPI_ADAPTER *a;
11274 word i, j;
11275
11276 dbug(1, dprintf("[%06lx] %s,%d: mixer_save_config %02x %d",
11277 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
11278
11279 a = plci->adapter;
11280 if ((plci->li_bchannel_id != 0)
11281 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11282 {
11283 i = a->li_base + (plci->li_bchannel_id - 1);
11284 for (j = 0; j < li_total_channels; j++)
11285 {
11286 li_config_table[i].coef_table[j] &= 0xf;
11287 li_config_table[j].coef_table[i] &= 0xf;
11288 }
11289 if (!a->li_pri)
11290 li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET;
11291 }
11292 return (GOOD);
11293 }
11294
11295
11296 static word mixer_restore_config(dword Id, PLCI *plci, byte Rc)
11297 {
11298 DIVA_CAPI_ADAPTER *a;
11299 word Info;
11300
11301 dbug(1, dprintf("[%06lx] %s,%d: mixer_restore_config %02x %d",
11302 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
11303
11304 Info = GOOD;
11305 a = plci->adapter;
11306 if ((plci->B1_facilities & B1_FACILITY_MIXER)
11307 && (plci->li_bchannel_id != 0)
11308 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11309 {
11310 switch (plci->adjust_b_state)
11311 {
11312 case ADJUST_B_RESTORE_MIXER_1:
11313 if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
11314 {
11315 plci->internal_command = plci->adjust_b_command;
11316 if (plci_nl_busy(plci))
11317 {
11318 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_1;
11319 break;
11320 }
11321 xconnect_query_addresses(plci);
11322 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_2;
11323 break;
11324 }
11325 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5;
11326 Rc = OK;
11327 /* fall through */
11328 case ADJUST_B_RESTORE_MIXER_2:
11329 case ADJUST_B_RESTORE_MIXER_3:
11330 case ADJUST_B_RESTORE_MIXER_4:
11331 if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0))
11332 {
11333 dbug(1, dprintf("[%06lx] %s,%d: Adjust B query addresses failed %02x",
11334 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
11335 Info = _WRONG_STATE;
11336 break;
11337 }
11338 if (Rc == OK)
11339 {
11340 if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2)
11341 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_3;
11342 else if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_4)
11343 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5;
11344 }
11345 else if (Rc == 0)
11346 {
11347 if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2)
11348 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_4;
11349 else if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_3)
11350 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5;
11351 }
11352 if (plci->adjust_b_state != ADJUST_B_RESTORE_MIXER_5)
11353 {
11354 plci->internal_command = plci->adjust_b_command;
11355 break;
11356 }
11357 /* fall through */
11358 case ADJUST_B_RESTORE_MIXER_5:
11359 xconnect_write_coefs(plci, plci->adjust_b_command);
11360 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_6;
11361 Rc = OK;
11362 /* fall through */
11363 case ADJUST_B_RESTORE_MIXER_6:
11364 if (!xconnect_write_coefs_process(Id, plci, Rc))
11365 {
11366 dbug(1, dprintf("[%06lx] %s,%d: Write mixer coefs failed",
11367 UnMapId(Id), (char *)(FILE_), __LINE__));
11368 Info = _FACILITY_NOT_SUPPORTED;
11369 break;
11370 }
11371 if (plci->internal_command)
11372 break;
11373 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_7;
11374 case ADJUST_B_RESTORE_MIXER_7:
11375 break;
11376 }
11377 }
11378 return (Info);
11379 }
11380
11381
11382 static void mixer_command(dword Id, PLCI *plci, byte Rc)
11383 {
11384 DIVA_CAPI_ADAPTER *a;
11385 word i, internal_command;
11386
11387 dbug(1, dprintf("[%06lx] %s,%d: mixer_command %02x %04x %04x",
11388 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command,
11389 plci->li_cmd));
11390
11391 a = plci->adapter;
11392 internal_command = plci->internal_command;
11393 plci->internal_command = 0;
11394 switch (plci->li_cmd)
11395 {
11396 case LI_REQ_CONNECT:
11397 case LI_REQ_DISCONNECT:
11398 case LI_REQ_SILENT_UPDATE:
11399 switch (internal_command)
11400 {
11401 default:
11402 if (plci->li_channel_bits & LI_CHANNEL_INVOLVED)
11403 {
11404 adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities |
11405 B1_FACILITY_MIXER), MIXER_COMMAND_1);
11406 }
11407 /* fall through */
11408 case MIXER_COMMAND_1:
11409 if (plci->li_channel_bits & LI_CHANNEL_INVOLVED)
11410 {
11411 if (adjust_b_process(Id, plci, Rc) != GOOD)
11412 {
11413 dbug(1, dprintf("[%06lx] %s,%d: Load mixer failed",
11414 UnMapId(Id), (char *)(FILE_), __LINE__));
11415 break;
11416 }
11417 if (plci->internal_command)
11418 return;
11419 }
11420 plci->li_plci_b_req_pos = plci->li_plci_b_write_pos;
11421 if ((plci->li_channel_bits & LI_CHANNEL_INVOLVED)
11422 || ((get_b1_facilities(plci, plci->B1_resource) & B1_FACILITY_MIXER)
11423 && (add_b1_facilities(plci, plci->B1_resource, (word)(plci->B1_facilities &
11424 ~B1_FACILITY_MIXER)) == plci->B1_resource)))
11425 {
11426 xconnect_write_coefs(plci, MIXER_COMMAND_2);
11427 }
11428 else
11429 {
11430 do
11431 {
11432 mixer_indication_coefs_set(Id, plci);
11433 } while (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos);
11434 }
11435 /* fall through */
11436 case MIXER_COMMAND_2:
11437 if ((plci->li_channel_bits & LI_CHANNEL_INVOLVED)
11438 || ((get_b1_facilities(plci, plci->B1_resource) & B1_FACILITY_MIXER)
11439 && (add_b1_facilities(plci, plci->B1_resource, (word)(plci->B1_facilities &
11440 ~B1_FACILITY_MIXER)) == plci->B1_resource)))
11441 {
11442 if (!xconnect_write_coefs_process(Id, plci, Rc))
11443 {
11444 dbug(1, dprintf("[%06lx] %s,%d: Write mixer coefs failed",
11445 UnMapId(Id), (char *)(FILE_), __LINE__));
11446 if (plci->li_plci_b_write_pos != plci->li_plci_b_req_pos)
11447 {
11448 do
11449 {
11450 plci->li_plci_b_write_pos = (plci->li_plci_b_write_pos == 0) ?
11451 LI_PLCI_B_QUEUE_ENTRIES - 1 : plci->li_plci_b_write_pos - 1;
11452 i = (plci->li_plci_b_write_pos == 0) ?
11453 LI_PLCI_B_QUEUE_ENTRIES - 1 : plci->li_plci_b_write_pos - 1;
11454 } while ((plci->li_plci_b_write_pos != plci->li_plci_b_req_pos)
11455 && !(plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG));
11456 }
11457 break;
11458 }
11459 if (plci->internal_command)
11460 return;
11461 }
11462 if (!(plci->li_channel_bits & LI_CHANNEL_INVOLVED))
11463 {
11464 adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities &
11465 ~B1_FACILITY_MIXER), MIXER_COMMAND_3);
11466 }
11467 /* fall through */
11468 case MIXER_COMMAND_3:
11469 if (!(plci->li_channel_bits & LI_CHANNEL_INVOLVED))
11470 {
11471 if (adjust_b_process(Id, plci, Rc) != GOOD)
11472 {
11473 dbug(1, dprintf("[%06lx] %s,%d: Unload mixer failed",
11474 UnMapId(Id), (char *)(FILE_), __LINE__));
11475 break;
11476 }
11477 if (plci->internal_command)
11478 return;
11479 }
11480 break;
11481 }
11482 break;
11483 }
11484 if ((plci->li_bchannel_id == 0)
11485 || (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci))
11486 {
11487 dbug(1, dprintf("[%06x] %s,%d: Channel id wiped out %d",
11488 UnMapId(Id), (char *)(FILE_), __LINE__, (int)(plci->li_bchannel_id)));
11489 }
11490 else
11491 {
11492 i = a->li_base + (plci->li_bchannel_id - 1);
11493 li_config_table[i].curchnl = plci->li_channel_bits;
11494 if (!a->li_pri && (plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
11495 {
11496 i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
11497 li_config_table[i].curchnl = plci->li_channel_bits;
11498 if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
11499 {
11500 i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
11501 li_config_table[i].curchnl = plci->li_channel_bits;
11502 }
11503 }
11504 }
11505 }
11506
11507
11508 static void li_update_connect(dword Id, DIVA_CAPI_ADAPTER *a, PLCI *plci,
11509 dword plci_b_id, byte connect, dword li_flags)
11510 {
11511 word i, ch_a, ch_a_v, ch_a_s, ch_b, ch_b_v, ch_b_s;
11512 PLCI *plci_b;
11513 DIVA_CAPI_ADAPTER *a_b;
11514
11515 a_b = &(adapter[MapController((byte)(plci_b_id & 0x7f)) - 1]);
11516 plci_b = &(a_b->plci[((plci_b_id >> 8) & 0xff) - 1]);
11517 ch_a = a->li_base + (plci->li_bchannel_id - 1);
11518 if (!a->li_pri && (plci->tel == ADV_VOICE)
11519 && (plci == a->AdvSignalPLCI) && (Id & EXT_CONTROLLER))
11520 {
11521 ch_a_v = ch_a + MIXER_IC_CHANNEL_BASE;
11522 ch_a_s = (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11523 a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id) : ch_a_v;
11524 }
11525 else
11526 {
11527 ch_a_v = ch_a;
11528 ch_a_s = ch_a;
11529 }
11530 ch_b = a_b->li_base + (plci_b->li_bchannel_id - 1);
11531 if (!a_b->li_pri && (plci_b->tel == ADV_VOICE)
11532 && (plci_b == a_b->AdvSignalPLCI) && (plci_b_id & EXT_CONTROLLER))
11533 {
11534 ch_b_v = ch_b + MIXER_IC_CHANNEL_BASE;
11535 ch_b_s = (a_b->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11536 a_b->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci_b->li_bchannel_id) : ch_b_v;
11537 }
11538 else
11539 {
11540 ch_b_v = ch_b;
11541 ch_b_s = ch_b;
11542 }
11543 if (connect)
11544 {
11545 li_config_table[ch_a].flag_table[ch_a_v] &= ~LI_FLAG_MONITOR;
11546 li_config_table[ch_a].flag_table[ch_a_s] &= ~LI_FLAG_MONITOR;
11547 li_config_table[ch_a_v].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11548 li_config_table[ch_a_s].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11549 }
11550 li_config_table[ch_a].flag_table[ch_b_v] &= ~LI_FLAG_MONITOR;
11551 li_config_table[ch_a].flag_table[ch_b_s] &= ~LI_FLAG_MONITOR;
11552 li_config_table[ch_b_v].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11553 li_config_table[ch_b_s].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11554 if (ch_a_v == ch_b_v)
11555 {
11556 li_config_table[ch_a_v].flag_table[ch_b_v] &= ~LI_FLAG_CONFERENCE;
11557 li_config_table[ch_a_s].flag_table[ch_b_s] &= ~LI_FLAG_CONFERENCE;
11558 }
11559 else
11560 {
11561 if (li_config_table[ch_a_v].flag_table[ch_b_v] & LI_FLAG_CONFERENCE)
11562 {
11563 for (i = 0; i < li_total_channels; i++)
11564 {
11565 if (i != ch_a_v)
11566 li_config_table[ch_a_v].flag_table[i] &= ~LI_FLAG_CONFERENCE;
11567 }
11568 }
11569 if (li_config_table[ch_a_s].flag_table[ch_b_v] & LI_FLAG_CONFERENCE)
11570 {
11571 for (i = 0; i < li_total_channels; i++)
11572 {
11573 if (i != ch_a_s)
11574 li_config_table[ch_a_s].flag_table[i] &= ~LI_FLAG_CONFERENCE;
11575 }
11576 }
11577 if (li_config_table[ch_b_v].flag_table[ch_a_v] & LI_FLAG_CONFERENCE)
11578 {
11579 for (i = 0; i < li_total_channels; i++)
11580 {
11581 if (i != ch_a_v)
11582 li_config_table[i].flag_table[ch_a_v] &= ~LI_FLAG_CONFERENCE;
11583 }
11584 }
11585 if (li_config_table[ch_b_v].flag_table[ch_a_s] & LI_FLAG_CONFERENCE)
11586 {
11587 for (i = 0; i < li_total_channels; i++)
11588 {
11589 if (i != ch_a_s)
11590 li_config_table[i].flag_table[ch_a_s] &= ~LI_FLAG_CONFERENCE;
11591 }
11592 }
11593 }
11594 if (li_flags & LI_FLAG_CONFERENCE_A_B)
11595 {
11596 li_config_table[ch_b_v].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11597 li_config_table[ch_b_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11598 li_config_table[ch_b_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11599 li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11600 }
11601 if (li_flags & LI_FLAG_CONFERENCE_B_A)
11602 {
11603 li_config_table[ch_a_v].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11604 li_config_table[ch_a_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11605 li_config_table[ch_a_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11606 li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11607 }
11608 if (li_flags & LI_FLAG_MONITOR_A)
11609 {
11610 li_config_table[ch_a].flag_table[ch_a_v] |= LI_FLAG_MONITOR;
11611 li_config_table[ch_a].flag_table[ch_a_s] |= LI_FLAG_MONITOR;
11612 }
11613 if (li_flags & LI_FLAG_MONITOR_B)
11614 {
11615 li_config_table[ch_a].flag_table[ch_b_v] |= LI_FLAG_MONITOR;
11616 li_config_table[ch_a].flag_table[ch_b_s] |= LI_FLAG_MONITOR;
11617 }
11618 if (li_flags & LI_FLAG_ANNOUNCEMENT_A)
11619 {
11620 li_config_table[ch_a_v].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11621 li_config_table[ch_a_s].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11622 }
11623 if (li_flags & LI_FLAG_ANNOUNCEMENT_B)
11624 {
11625 li_config_table[ch_b_v].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11626 li_config_table[ch_b_s].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11627 }
11628 if (li_flags & LI_FLAG_MIX_A)
11629 {
11630 li_config_table[ch_a_v].flag_table[ch_a] |= LI_FLAG_MIX;
11631 li_config_table[ch_a_s].flag_table[ch_a] |= LI_FLAG_MIX;
11632 }
11633 if (li_flags & LI_FLAG_MIX_B)
11634 {
11635 li_config_table[ch_b_v].flag_table[ch_a] |= LI_FLAG_MIX;
11636 li_config_table[ch_b_s].flag_table[ch_a] |= LI_FLAG_MIX;
11637 }
11638 if (ch_a_v != ch_a_s)
11639 {
11640 li_config_table[ch_a_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11641 li_config_table[ch_a_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11642 }
11643 if (ch_b_v != ch_b_s)
11644 {
11645 li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11646 li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11647 }
11648 }
11649
11650
11651 static void li2_update_connect(dword Id, DIVA_CAPI_ADAPTER *a, PLCI *plci,
11652 dword plci_b_id, byte connect, dword li_flags)
11653 {
11654 word ch_a, ch_a_v, ch_a_s, ch_b, ch_b_v, ch_b_s;
11655 PLCI *plci_b;
11656 DIVA_CAPI_ADAPTER *a_b;
11657
11658 a_b = &(adapter[MapController((byte)(plci_b_id & 0x7f)) - 1]);
11659 plci_b = &(a_b->plci[((plci_b_id >> 8) & 0xff) - 1]);
11660 ch_a = a->li_base + (plci->li_bchannel_id - 1);
11661 if (!a->li_pri && (plci->tel == ADV_VOICE)
11662 && (plci == a->AdvSignalPLCI) && (Id & EXT_CONTROLLER))
11663 {
11664 ch_a_v = ch_a + MIXER_IC_CHANNEL_BASE;
11665 ch_a_s = (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11666 a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id) : ch_a_v;
11667 }
11668 else
11669 {
11670 ch_a_v = ch_a;
11671 ch_a_s = ch_a;
11672 }
11673 ch_b = a_b->li_base + (plci_b->li_bchannel_id - 1);
11674 if (!a_b->li_pri && (plci_b->tel == ADV_VOICE)
11675 && (plci_b == a_b->AdvSignalPLCI) && (plci_b_id & EXT_CONTROLLER))
11676 {
11677 ch_b_v = ch_b + MIXER_IC_CHANNEL_BASE;
11678 ch_b_s = (a_b->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11679 a_b->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci_b->li_bchannel_id) : ch_b_v;
11680 }
11681 else
11682 {
11683 ch_b_v = ch_b;
11684 ch_b_s = ch_b;
11685 }
11686 if (connect)
11687 {
11688 li_config_table[ch_b].flag_table[ch_b_v] &= ~LI_FLAG_MONITOR;
11689 li_config_table[ch_b].flag_table[ch_b_s] &= ~LI_FLAG_MONITOR;
11690 li_config_table[ch_b_v].flag_table[ch_b] &= ~LI_FLAG_MIX;
11691 li_config_table[ch_b_s].flag_table[ch_b] &= ~LI_FLAG_MIX;
11692 li_config_table[ch_b].flag_table[ch_b] &= ~LI_FLAG_PCCONNECT;
11693 li_config_table[ch_b].chflags &= ~(LI_CHFLAG_MONITOR | LI_CHFLAG_MIX | LI_CHFLAG_LOOP);
11694 }
11695 li_config_table[ch_b_v].flag_table[ch_a_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11696 li_config_table[ch_b_s].flag_table[ch_a_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11697 li_config_table[ch_b_v].flag_table[ch_a_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11698 li_config_table[ch_b_s].flag_table[ch_a_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11699 li_config_table[ch_a_v].flag_table[ch_b_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11700 li_config_table[ch_a_v].flag_table[ch_b_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11701 li_config_table[ch_a_s].flag_table[ch_b_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11702 li_config_table[ch_a_s].flag_table[ch_b_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11703 if (li_flags & LI2_FLAG_INTERCONNECT_A_B)
11704 {
11705 li_config_table[ch_b_v].flag_table[ch_a_v] |= LI_FLAG_INTERCONNECT;
11706 li_config_table[ch_b_s].flag_table[ch_a_v] |= LI_FLAG_INTERCONNECT;
11707 li_config_table[ch_b_v].flag_table[ch_a_s] |= LI_FLAG_INTERCONNECT;
11708 li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_INTERCONNECT;
11709 }
11710 if (li_flags & LI2_FLAG_INTERCONNECT_B_A)
11711 {
11712 li_config_table[ch_a_v].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11713 li_config_table[ch_a_v].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11714 li_config_table[ch_a_s].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11715 li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11716 }
11717 if (li_flags & LI2_FLAG_MONITOR_B)
11718 {
11719 li_config_table[ch_b].flag_table[ch_b_v] |= LI_FLAG_MONITOR;
11720 li_config_table[ch_b].flag_table[ch_b_s] |= LI_FLAG_MONITOR;
11721 }
11722 if (li_flags & LI2_FLAG_MIX_B)
11723 {
11724 li_config_table[ch_b_v].flag_table[ch_b] |= LI_FLAG_MIX;
11725 li_config_table[ch_b_s].flag_table[ch_b] |= LI_FLAG_MIX;
11726 }
11727 if (li_flags & LI2_FLAG_MONITOR_X)
11728 li_config_table[ch_b].chflags |= LI_CHFLAG_MONITOR;
11729 if (li_flags & LI2_FLAG_MIX_X)
11730 li_config_table[ch_b].chflags |= LI_CHFLAG_MIX;
11731 if (li_flags & LI2_FLAG_LOOP_B)
11732 {
11733 li_config_table[ch_b_v].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11734 li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11735 li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11736 li_config_table[ch_b_s].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11737 }
11738 if (li_flags & LI2_FLAG_LOOP_PC)
11739 li_config_table[ch_b].flag_table[ch_b] |= LI_FLAG_PCCONNECT;
11740 if (li_flags & LI2_FLAG_LOOP_X)
11741 li_config_table[ch_b].chflags |= LI_CHFLAG_LOOP;
11742 if (li_flags & LI2_FLAG_PCCONNECT_A_B)
11743 li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_PCCONNECT;
11744 if (li_flags & LI2_FLAG_PCCONNECT_B_A)
11745 li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_PCCONNECT;
11746 if (ch_a_v != ch_a_s)
11747 {
11748 li_config_table[ch_a_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11749 li_config_table[ch_a_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11750 }
11751 if (ch_b_v != ch_b_s)
11752 {
11753 li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11754 li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11755 }
11756 }
11757
11758
11759 static word li_check_main_plci(dword Id, PLCI *plci)
11760 {
11761 if (plci == NULL)
11762 {
11763 dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI",
11764 UnMapId(Id), (char *)(FILE_), __LINE__));
11765 return (_WRONG_IDENTIFIER);
11766 }
11767 if (!plci->State
11768 || !plci->NL.Id || plci->nl_remove_id
11769 || (plci->li_bchannel_id == 0))
11770 {
11771 dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
11772 UnMapId(Id), (char *)(FILE_), __LINE__));
11773 return (_WRONG_STATE);
11774 }
11775 li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci = plci;
11776 return (GOOD);
11777 }
11778
11779
11780 static PLCI *li_check_plci_b(dword Id, PLCI *plci,
11781 dword plci_b_id, word plci_b_write_pos, byte *p_result)
11782 {
11783 byte ctlr_b;
11784 PLCI *plci_b;
11785
11786 if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
11787 LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2)
11788 {
11789 dbug(1, dprintf("[%06lx] %s,%d: LI request overrun",
11790 UnMapId(Id), (char *)(FILE_), __LINE__));
11791 PUT_WORD(p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE);
11792 return (NULL);
11793 }
11794 ctlr_b = 0;
11795 if ((plci_b_id & 0x7f) != 0)
11796 {
11797 ctlr_b = MapController((byte)(plci_b_id & 0x7f));
11798 if ((ctlr_b > max_adapter) || ((ctlr_b != 0) && (adapter[ctlr_b - 1].request == NULL)))
11799 ctlr_b = 0;
11800 }
11801 if ((ctlr_b == 0)
11802 || (((plci_b_id >> 8) & 0xff) == 0)
11803 || (((plci_b_id >> 8) & 0xff) > adapter[ctlr_b - 1].max_plci))
11804 {
11805 dbug(1, dprintf("[%06lx] %s,%d: LI invalid second PLCI %08lx",
11806 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
11807 PUT_WORD(p_result, _WRONG_IDENTIFIER);
11808 return (NULL);
11809 }
11810 plci_b = &(adapter[ctlr_b - 1].plci[((plci_b_id >> 8) & 0xff) - 1]);
11811 if (!plci_b->State
11812 || !plci_b->NL.Id || plci_b->nl_remove_id
11813 || (plci_b->li_bchannel_id == 0))
11814 {
11815 dbug(1, dprintf("[%06lx] %s,%d: LI peer in wrong state %08lx",
11816 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
11817 PUT_WORD(p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE);
11818 return (NULL);
11819 }
11820 li_config_table[plci_b->adapter->li_base + (plci_b->li_bchannel_id - 1)].plci = plci_b;
11821 if (((byte)(plci_b_id & ~EXT_CONTROLLER)) !=
11822 ((byte)(UnMapController(plci->adapter->Id) & ~EXT_CONTROLLER))
11823 && (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
11824 || !(plci_b->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)))
11825 {
11826 dbug(1, dprintf("[%06lx] %s,%d: LI not on same ctrl %08lx",
11827 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
11828 PUT_WORD(p_result, _WRONG_IDENTIFIER);
11829 return (NULL);
11830 }
11831 if (!(get_b1_facilities(plci_b, add_b1_facilities(plci_b, plci_b->B1_resource,
11832 (word)(plci_b->B1_facilities | B1_FACILITY_MIXER))) & B1_FACILITY_MIXER))
11833 {
11834 dbug(1, dprintf("[%06lx] %s,%d: Interconnect peer cannot mix %d",
11835 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b->B1_resource));
11836 PUT_WORD(p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE);
11837 return (NULL);
11838 }
11839 return (plci_b);
11840 }
11841
11842
11843 static PLCI *li2_check_plci_b(dword Id, PLCI *plci,
11844 dword plci_b_id, word plci_b_write_pos, byte *p_result)
11845 {
11846 byte ctlr_b;
11847 PLCI *plci_b;
11848
11849 if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
11850 LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2)
11851 {
11852 dbug(1, dprintf("[%06lx] %s,%d: LI request overrun",
11853 UnMapId(Id), (char *)(FILE_), __LINE__));
11854 PUT_WORD(p_result, _WRONG_STATE);
11855 return (NULL);
11856 }
11857 ctlr_b = 0;
11858 if ((plci_b_id & 0x7f) != 0)
11859 {
11860 ctlr_b = MapController((byte)(plci_b_id & 0x7f));
11861 if ((ctlr_b > max_adapter) || ((ctlr_b != 0) && (adapter[ctlr_b - 1].request == NULL)))
11862 ctlr_b = 0;
11863 }
11864 if ((ctlr_b == 0)
11865 || (((plci_b_id >> 8) & 0xff) == 0)
11866 || (((plci_b_id >> 8) & 0xff) > adapter[ctlr_b - 1].max_plci))
11867 {
11868 dbug(1, dprintf("[%06lx] %s,%d: LI invalid second PLCI %08lx",
11869 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
11870 PUT_WORD(p_result, _WRONG_IDENTIFIER);
11871 return (NULL);
11872 }
11873 plci_b = &(adapter[ctlr_b - 1].plci[((plci_b_id >> 8) & 0xff) - 1]);
11874 if (!plci_b->State
11875 || !plci_b->NL.Id || plci_b->nl_remove_id
11876 || (plci_b->li_bchannel_id == 0)
11877 || (li_config_table[plci_b->adapter->li_base + (plci_b->li_bchannel_id - 1)].plci != plci_b))
11878 {
11879 dbug(1, dprintf("[%06lx] %s,%d: LI peer in wrong state %08lx",
11880 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
11881 PUT_WORD(p_result, _WRONG_STATE);
11882 return (NULL);
11883 }
11884 if (((byte)(plci_b_id & ~EXT_CONTROLLER)) !=
11885 ((byte)(UnMapController(plci->adapter->Id) & ~EXT_CONTROLLER))
11886 && (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
11887 || !(plci_b->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)))
11888 {
11889 dbug(1, dprintf("[%06lx] %s,%d: LI not on same ctrl %08lx",
11890 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
11891 PUT_WORD(p_result, _WRONG_IDENTIFIER);
11892 return (NULL);
11893 }
11894 if (!(get_b1_facilities(plci_b, add_b1_facilities(plci_b, plci_b->B1_resource,
11895 (word)(plci_b->B1_facilities | B1_FACILITY_MIXER))) & B1_FACILITY_MIXER))
11896 {
11897 dbug(1, dprintf("[%06lx] %s,%d: Interconnect peer cannot mix %d",
11898 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b->B1_resource));
11899 PUT_WORD(p_result, _WRONG_STATE);
11900 return (NULL);
11901 }
11902 return (plci_b);
11903 }
11904
11905
11906 static byte mixer_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg)
11907 {
11908 word Info;
11909 word i;
11910 dword d, li_flags, plci_b_id;
11911 PLCI *plci_b;
11912 API_PARSE li_parms[3];
11913 API_PARSE li_req_parms[3];
11914 API_PARSE li_participant_struct[2];
11915 API_PARSE li_participant_parms[3];
11916 word participant_parms_pos;
11917 byte result_buffer[32];
11918 byte *result;
11919 word result_pos;
11920 word plci_b_write_pos;
11921
11922 dbug(1, dprintf("[%06lx] %s,%d: mixer_request",
11923 UnMapId(Id), (char *)(FILE_), __LINE__));
11924
11925 Info = GOOD;
11926 result = result_buffer;
11927 result_buffer[0] = 0;
11928 if (!(a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED))
11929 {
11930 dbug(1, dprintf("[%06lx] %s,%d: Facility not supported",
11931 UnMapId(Id), (char *)(FILE_), __LINE__));
11932 Info = _FACILITY_NOT_SUPPORTED;
11933 }
11934 else if (api_parse(&msg[1].info[1], msg[1].length, "ws", li_parms))
11935 {
11936 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
11937 UnMapId(Id), (char *)(FILE_), __LINE__));
11938 Info = _WRONG_MESSAGE_FORMAT;
11939 }
11940 else
11941 {
11942 result_buffer[0] = 3;
11943 PUT_WORD(&result_buffer[1], GET_WORD(li_parms[0].info));
11944 result_buffer[3] = 0;
11945 switch (GET_WORD(li_parms[0].info))
11946 {
11947 case LI_GET_SUPPORTED_SERVICES:
11948 if (appl->appl_flags & APPL_FLAG_OLD_LI_SPEC)
11949 {
11950 result_buffer[0] = 17;
11951 result_buffer[3] = 14;
11952 PUT_WORD(&result_buffer[4], GOOD);
11953 d = 0;
11954 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_CH)
11955 d |= LI_CONFERENCING_SUPPORTED;
11956 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_PC)
11957 d |= LI_MONITORING_SUPPORTED;
11958 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_CH)
11959 d |= LI_ANNOUNCEMENTS_SUPPORTED | LI_MIXING_SUPPORTED;
11960 if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
11961 d |= LI_CROSS_CONTROLLER_SUPPORTED;
11962 PUT_DWORD(&result_buffer[6], d);
11963 if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
11964 {
11965 d = 0;
11966 for (i = 0; i < li_total_channels; i++)
11967 {
11968 if ((li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
11969 && (li_config_table[i].adapter->li_pri
11970 || (i < li_config_table[i].adapter->li_base + MIXER_BCHANNELS_BRI)))
11971 {
11972 d++;
11973 }
11974 }
11975 }
11976 else
11977 {
11978 d = a->li_pri ? a->li_channels : MIXER_BCHANNELS_BRI;
11979 }
11980 PUT_DWORD(&result_buffer[10], d / 2);
11981 PUT_DWORD(&result_buffer[14], d);
11982 }
11983 else
11984 {
11985 result_buffer[0] = 25;
11986 result_buffer[3] = 22;
11987 PUT_WORD(&result_buffer[4], GOOD);
11988 d = LI2_ASYMMETRIC_SUPPORTED | LI2_B_LOOPING_SUPPORTED | LI2_X_LOOPING_SUPPORTED;
11989 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_PC)
11990 d |= LI2_MONITORING_SUPPORTED | LI2_REMOTE_MONITORING_SUPPORTED;
11991 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_CH)
11992 d |= LI2_MIXING_SUPPORTED | LI2_REMOTE_MIXING_SUPPORTED;
11993 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_PC)
11994 d |= LI2_PC_LOOPING_SUPPORTED;
11995 if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
11996 d |= LI2_CROSS_CONTROLLER_SUPPORTED;
11997 PUT_DWORD(&result_buffer[6], d);
11998 d = a->li_pri ? a->li_channels : MIXER_BCHANNELS_BRI;
11999 PUT_DWORD(&result_buffer[10], d / 2);
12000 PUT_DWORD(&result_buffer[14], d - 1);
12001 if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12002 {
12003 d = 0;
12004 for (i = 0; i < li_total_channels; i++)
12005 {
12006 if ((li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12007 && (li_config_table[i].adapter->li_pri
12008 || (i < li_config_table[i].adapter->li_base + MIXER_BCHANNELS_BRI)))
12009 {
12010 d++;
12011 }
12012 }
12013 }
12014 PUT_DWORD(&result_buffer[18], d / 2);
12015 PUT_DWORD(&result_buffer[22], d - 1);
12016 }
12017 break;
12018
12019 case LI_REQ_CONNECT:
12020 if (li_parms[1].length == 8)
12021 {
12022 appl->appl_flags |= APPL_FLAG_OLD_LI_SPEC;
12023 if (api_parse(&li_parms[1].info[1], li_parms[1].length, "dd", li_req_parms))
12024 {
12025 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12026 UnMapId(Id), (char *)(FILE_), __LINE__));
12027 Info = _WRONG_MESSAGE_FORMAT;
12028 break;
12029 }
12030 plci_b_id = GET_DWORD(li_req_parms[0].info) & 0xffff;
12031 li_flags = GET_DWORD(li_req_parms[1].info);
12032 Info = li_check_main_plci(Id, plci);
12033 result_buffer[0] = 9;
12034 result_buffer[3] = 6;
12035 PUT_DWORD(&result_buffer[4], plci_b_id);
12036 PUT_WORD(&result_buffer[8], GOOD);
12037 if (Info != GOOD)
12038 break;
12039 result = plci->saved_msg.info;
12040 for (i = 0; i <= result_buffer[0]; i++)
12041 result[i] = result_buffer[i];
12042 plci_b_write_pos = plci->li_plci_b_write_pos;
12043 plci_b = li_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[8]);
12044 if (plci_b == NULL)
12045 break;
12046 li_update_connect(Id, a, plci, plci_b_id, true, li_flags);
12047 plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_LAST_FLAG;
12048 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12049 plci->li_plci_b_write_pos = plci_b_write_pos;
12050 }
12051 else
12052 {
12053 appl->appl_flags &= ~APPL_FLAG_OLD_LI_SPEC;
12054 if (api_parse(&li_parms[1].info[1], li_parms[1].length, "ds", li_req_parms))
12055 {
12056 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12057 UnMapId(Id), (char *)(FILE_), __LINE__));
12058 Info = _WRONG_MESSAGE_FORMAT;
12059 break;
12060 }
12061 li_flags = GET_DWORD(li_req_parms[0].info) & ~(LI2_FLAG_INTERCONNECT_A_B | LI2_FLAG_INTERCONNECT_B_A);
12062 Info = li_check_main_plci(Id, plci);
12063 result_buffer[0] = 7;
12064 result_buffer[3] = 4;
12065 PUT_WORD(&result_buffer[4], Info);
12066 result_buffer[6] = 0;
12067 if (Info != GOOD)
12068 break;
12069 result = plci->saved_msg.info;
12070 for (i = 0; i <= result_buffer[0]; i++)
12071 result[i] = result_buffer[i];
12072 plci_b_write_pos = plci->li_plci_b_write_pos;
12073 participant_parms_pos = 0;
12074 result_pos = 7;
12075 li2_update_connect(Id, a, plci, UnMapId(Id), true, li_flags);
12076 while (participant_parms_pos < li_req_parms[1].length)
12077 {
12078 result[result_pos] = 6;
12079 result_pos += 7;
12080 PUT_DWORD(&result[result_pos - 6], 0);
12081 PUT_WORD(&result[result_pos - 2], GOOD);
12082 if (api_parse(&li_req_parms[1].info[1 + participant_parms_pos],
12083 (word)(li_parms[1].length - participant_parms_pos), "s", li_participant_struct))
12084 {
12085 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12086 UnMapId(Id), (char *)(FILE_), __LINE__));
12087 PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12088 break;
12089 }
12090 if (api_parse(&li_participant_struct[0].info[1],
12091 li_participant_struct[0].length, "dd", li_participant_parms))
12092 {
12093 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12094 UnMapId(Id), (char *)(FILE_), __LINE__));
12095 PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12096 break;
12097 }
12098 plci_b_id = GET_DWORD(li_participant_parms[0].info) & 0xffff;
12099 li_flags = GET_DWORD(li_participant_parms[1].info);
12100 PUT_DWORD(&result[result_pos - 6], plci_b_id);
12101 if (sizeof(result) - result_pos < 7)
12102 {
12103 dbug(1, dprintf("[%06lx] %s,%d: LI result overrun",
12104 UnMapId(Id), (char *)(FILE_), __LINE__));
12105 PUT_WORD(&result[result_pos - 2], _WRONG_STATE);
12106 break;
12107 }
12108 plci_b = li2_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[result_pos - 2]);
12109 if (plci_b != NULL)
12110 {
12111 li2_update_connect(Id, a, plci, plci_b_id, true, li_flags);
12112 plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id |
12113 ((li_flags & (LI2_FLAG_INTERCONNECT_A_B | LI2_FLAG_INTERCONNECT_B_A |
12114 LI2_FLAG_PCCONNECT_A_B | LI2_FLAG_PCCONNECT_B_A)) ? 0 : LI_PLCI_B_DISC_FLAG);
12115 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12116 }
12117 participant_parms_pos = (word)((&li_participant_struct[0].info[1 + li_participant_struct[0].length]) -
12118 (&li_req_parms[1].info[1]));
12119 }
12120 result[0] = (byte)(result_pos - 1);
12121 result[3] = (byte)(result_pos - 4);
12122 result[6] = (byte)(result_pos - 7);
12123 i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES - 1 : plci_b_write_pos - 1;
12124 if ((plci_b_write_pos == plci->li_plci_b_read_pos)
12125 || (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG))
12126 {
12127 plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_FLAG | LI_PLCI_B_LAST_FLAG;
12128 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12129 }
12130 else
12131 plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG;
12132 plci->li_plci_b_write_pos = plci_b_write_pos;
12133 }
12134 mixer_calculate_coefs(a);
12135 plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel;
12136 mixer_notify_update(plci, true);
12137 sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
12138 "wwS", Info, SELECTOR_LINE_INTERCONNECT, result);
12139 plci->command = 0;
12140 plci->li_cmd = GET_WORD(li_parms[0].info);
12141 start_internal_command(Id, plci, mixer_command);
12142 return (false);
12143
12144 case LI_REQ_DISCONNECT:
12145 if (li_parms[1].length == 4)
12146 {
12147 appl->appl_flags |= APPL_FLAG_OLD_LI_SPEC;
12148 if (api_parse(&li_parms[1].info[1], li_parms[1].length, "d", li_req_parms))
12149 {
12150 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12151 UnMapId(Id), (char *)(FILE_), __LINE__));
12152 Info = _WRONG_MESSAGE_FORMAT;
12153 break;
12154 }
12155 plci_b_id = GET_DWORD(li_req_parms[0].info) & 0xffff;
12156 Info = li_check_main_plci(Id, plci);
12157 result_buffer[0] = 9;
12158 result_buffer[3] = 6;
12159 PUT_DWORD(&result_buffer[4], GET_DWORD(li_req_parms[0].info));
12160 PUT_WORD(&result_buffer[8], GOOD);
12161 if (Info != GOOD)
12162 break;
12163 result = plci->saved_msg.info;
12164 for (i = 0; i <= result_buffer[0]; i++)
12165 result[i] = result_buffer[i];
12166 plci_b_write_pos = plci->li_plci_b_write_pos;
12167 plci_b = li_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[8]);
12168 if (plci_b == NULL)
12169 break;
12170 li_update_connect(Id, a, plci, plci_b_id, false, 0);
12171 plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG | LI_PLCI_B_LAST_FLAG;
12172 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12173 plci->li_plci_b_write_pos = plci_b_write_pos;
12174 }
12175 else
12176 {
12177 appl->appl_flags &= ~APPL_FLAG_OLD_LI_SPEC;
12178 if (api_parse(&li_parms[1].info[1], li_parms[1].length, "s", li_req_parms))
12179 {
12180 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12181 UnMapId(Id), (char *)(FILE_), __LINE__));
12182 Info = _WRONG_MESSAGE_FORMAT;
12183 break;
12184 }
12185 Info = li_check_main_plci(Id, plci);
12186 result_buffer[0] = 7;
12187 result_buffer[3] = 4;
12188 PUT_WORD(&result_buffer[4], Info);
12189 result_buffer[6] = 0;
12190 if (Info != GOOD)
12191 break;
12192 result = plci->saved_msg.info;
12193 for (i = 0; i <= result_buffer[0]; i++)
12194 result[i] = result_buffer[i];
12195 plci_b_write_pos = plci->li_plci_b_write_pos;
12196 participant_parms_pos = 0;
12197 result_pos = 7;
12198 while (participant_parms_pos < li_req_parms[0].length)
12199 {
12200 result[result_pos] = 6;
12201 result_pos += 7;
12202 PUT_DWORD(&result[result_pos - 6], 0);
12203 PUT_WORD(&result[result_pos - 2], GOOD);
12204 if (api_parse(&li_req_parms[0].info[1 + participant_parms_pos],
12205 (word)(li_parms[1].length - participant_parms_pos), "s", li_participant_struct))
12206 {
12207 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12208 UnMapId(Id), (char *)(FILE_), __LINE__));
12209 PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12210 break;
12211 }
12212 if (api_parse(&li_participant_struct[0].info[1],
12213 li_participant_struct[0].length, "d", li_participant_parms))
12214 {
12215 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12216 UnMapId(Id), (char *)(FILE_), __LINE__));
12217 PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12218 break;
12219 }
12220 plci_b_id = GET_DWORD(li_participant_parms[0].info) & 0xffff;
12221 PUT_DWORD(&result[result_pos - 6], plci_b_id);
12222 if (sizeof(result) - result_pos < 7)
12223 {
12224 dbug(1, dprintf("[%06lx] %s,%d: LI result overrun",
12225 UnMapId(Id), (char *)(FILE_), __LINE__));
12226 PUT_WORD(&result[result_pos - 2], _WRONG_STATE);
12227 break;
12228 }
12229 plci_b = li2_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[result_pos - 2]);
12230 if (plci_b != NULL)
12231 {
12232 li2_update_connect(Id, a, plci, plci_b_id, false, 0);
12233 plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG;
12234 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12235 }
12236 participant_parms_pos = (word)((&li_participant_struct[0].info[1 + li_participant_struct[0].length]) -
12237 (&li_req_parms[0].info[1]));
12238 }
12239 result[0] = (byte)(result_pos - 1);
12240 result[3] = (byte)(result_pos - 4);
12241 result[6] = (byte)(result_pos - 7);
12242 i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES - 1 : plci_b_write_pos - 1;
12243 if ((plci_b_write_pos == plci->li_plci_b_read_pos)
12244 || (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG))
12245 {
12246 plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_FLAG | LI_PLCI_B_LAST_FLAG;
12247 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12248 }
12249 else
12250 plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG;
12251 plci->li_plci_b_write_pos = plci_b_write_pos;
12252 }
12253 mixer_calculate_coefs(a);
12254 plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel;
12255 mixer_notify_update(plci, true);
12256 sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
12257 "wwS", Info, SELECTOR_LINE_INTERCONNECT, result);
12258 plci->command = 0;
12259 plci->li_cmd = GET_WORD(li_parms[0].info);
12260 start_internal_command(Id, plci, mixer_command);
12261 return (false);
12262
12263 case LI_REQ_SILENT_UPDATE:
12264 if (!plci || !plci->State
12265 || !plci->NL.Id || plci->nl_remove_id
12266 || (plci->li_bchannel_id == 0)
12267 || (li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci != plci))
12268 {
12269 dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
12270 UnMapId(Id), (char *)(FILE_), __LINE__));
12271 return (false);
12272 }
12273 plci_b_write_pos = plci->li_plci_b_write_pos;
12274 if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
12275 LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2)
12276 {
12277 dbug(1, dprintf("[%06lx] %s,%d: LI request overrun",
12278 UnMapId(Id), (char *)(FILE_), __LINE__));
12279 return (false);
12280 }
12281 i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES - 1 : plci_b_write_pos - 1;
12282 if ((plci_b_write_pos == plci->li_plci_b_read_pos)
12283 || (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG))
12284 {
12285 plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_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 }
12288 else
12289 plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG;
12290 plci->li_plci_b_write_pos = plci_b_write_pos;
12291 plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel;
12292 plci->command = 0;
12293 plci->li_cmd = GET_WORD(li_parms[0].info);
12294 start_internal_command(Id, plci, mixer_command);
12295 return (false);
12296
12297 default:
12298 dbug(1, dprintf("[%06lx] %s,%d: LI unknown request %04x",
12299 UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(li_parms[0].info)));
12300 Info = _FACILITY_NOT_SUPPORTED;
12301 }
12302 }
12303 sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
12304 "wwS", Info, SELECTOR_LINE_INTERCONNECT, result);
12305 return (false);
12306 }
12307
12308
12309 static void mixer_indication_coefs_set(dword Id, PLCI *plci)
12310 {
12311 dword d;
12312 byte result[12];
12313
12314 dbug(1, dprintf("[%06lx] %s,%d: mixer_indication_coefs_set",
12315 UnMapId(Id), (char *)(FILE_), __LINE__));
12316
12317 if (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos)
12318 {
12319 do
12320 {
12321 d = plci->li_plci_b_queue[plci->li_plci_b_read_pos];
12322 if (!(d & LI_PLCI_B_SKIP_FLAG))
12323 {
12324 if (plci->appl->appl_flags & APPL_FLAG_OLD_LI_SPEC)
12325 {
12326 if (d & LI_PLCI_B_DISC_FLAG)
12327 {
12328 result[0] = 5;
12329 PUT_WORD(&result[1], LI_IND_DISCONNECT);
12330 result[3] = 2;
12331 PUT_WORD(&result[4], _LI_USER_INITIATED);
12332 }
12333 else
12334 {
12335 result[0] = 7;
12336 PUT_WORD(&result[1], LI_IND_CONNECT_ACTIVE);
12337 result[3] = 4;
12338 PUT_DWORD(&result[4], d & ~LI_PLCI_B_FLAG_MASK);
12339 }
12340 }
12341 else
12342 {
12343 if (d & LI_PLCI_B_DISC_FLAG)
12344 {
12345 result[0] = 9;
12346 PUT_WORD(&result[1], LI_IND_DISCONNECT);
12347 result[3] = 6;
12348 PUT_DWORD(&result[4], d & ~LI_PLCI_B_FLAG_MASK);
12349 PUT_WORD(&result[8], _LI_USER_INITIATED);
12350 }
12351 else
12352 {
12353 result[0] = 7;
12354 PUT_WORD(&result[1], LI_IND_CONNECT_ACTIVE);
12355 result[3] = 4;
12356 PUT_DWORD(&result[4], d & ~LI_PLCI_B_FLAG_MASK);
12357 }
12358 }
12359 sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0,
12360 "ws", SELECTOR_LINE_INTERCONNECT, result);
12361 }
12362 plci->li_plci_b_read_pos = (plci->li_plci_b_read_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ?
12363 0 : plci->li_plci_b_read_pos + 1;
12364 } while (!(d & LI_PLCI_B_LAST_FLAG) && (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos));
12365 }
12366 }
12367
12368
12369 static void mixer_indication_xconnect_from(dword Id, PLCI *plci, byte *msg, word length)
12370 {
12371 word i, j, ch;
12372 struct xconnect_transfer_address_s s, *p;
12373 DIVA_CAPI_ADAPTER *a;
12374
12375 dbug(1, dprintf("[%06lx] %s,%d: mixer_indication_xconnect_from %d",
12376 UnMapId(Id), (char *)(FILE_), __LINE__, (int)length));
12377
12378 a = plci->adapter;
12379 i = 1;
12380 for (i = 1; i < length; i += 16)
12381 {
12382 s.card_address.low = msg[i] | (msg[i + 1] << 8) | (((dword)(msg[i + 2])) << 16) | (((dword)(msg[i + 3])) << 24);
12383 s.card_address.high = msg[i + 4] | (msg[i + 5] << 8) | (((dword)(msg[i + 6])) << 16) | (((dword)(msg[i + 7])) << 24);
12384 s.offset = msg[i + 8] | (msg[i + 9] << 8) | (((dword)(msg[i + 10])) << 16) | (((dword)(msg[i + 11])) << 24);
12385 ch = msg[i + 12] | (msg[i + 13] << 8);
12386 j = ch & XCONNECT_CHANNEL_NUMBER_MASK;
12387 if (!a->li_pri && (plci->li_bchannel_id == 2))
12388 j = 1 - j;
12389 j += a->li_base;
12390 if (ch & XCONNECT_CHANNEL_PORT_PC)
12391 p = &(li_config_table[j].send_pc);
12392 else
12393 p = &(li_config_table[j].send_b);
12394 p->card_address.low = s.card_address.low;
12395 p->card_address.high = s.card_address.high;
12396 p->offset = s.offset;
12397 li_config_table[j].channel |= LI_CHANNEL_ADDRESSES_SET;
12398 }
12399 if (plci->internal_command_queue[0]
12400 && ((plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2)
12401 || (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_3)
12402 || (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_4)))
12403 {
12404 (*(plci->internal_command_queue[0]))(Id, plci, 0);
12405 if (!plci->internal_command)
12406 next_internal_command(Id, plci);
12407 }
12408 mixer_notify_update(plci, true);
12409 }
12410
12411
12412 static void mixer_indication_xconnect_to(dword Id, PLCI *plci, byte *msg, word length)
12413 {
12414
12415 dbug(1, dprintf("[%06lx] %s,%d: mixer_indication_xconnect_to %d",
12416 UnMapId(Id), (char *)(FILE_), __LINE__, (int) length));
12417
12418 }
12419
12420
12421 static byte mixer_notify_source_removed(PLCI *plci, dword plci_b_id)
12422 {
12423 word plci_b_write_pos;
12424
12425 plci_b_write_pos = plci->li_plci_b_write_pos;
12426 if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
12427 LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 1)
12428 {
12429 dbug(1, dprintf("[%06lx] %s,%d: LI request overrun",
12430 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
12431 (char *)(FILE_), __LINE__));
12432 return (false);
12433 }
12434 plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG;
12435 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12436 plci->li_plci_b_write_pos = plci_b_write_pos;
12437 return (true);
12438 }
12439
12440
12441 static void mixer_remove(PLCI *plci)
12442 {
12443 DIVA_CAPI_ADAPTER *a;
12444 PLCI *notify_plci;
12445 dword plci_b_id;
12446 word i, j;
12447
12448 dbug(1, dprintf("[%06lx] %s,%d: mixer_remove",
12449 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
12450 (char *)(FILE_), __LINE__));
12451
12452 a = plci->adapter;
12453 plci_b_id = (plci->Id << 8) | UnMapController(plci->adapter->Id);
12454 if (a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED)
12455 {
12456 if ((plci->li_bchannel_id != 0)
12457 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
12458 {
12459 i = a->li_base + (plci->li_bchannel_id - 1);
12460 if ((li_config_table[i].curchnl | li_config_table[i].channel) & LI_CHANNEL_INVOLVED)
12461 {
12462 for (j = 0; j < li_total_channels; j++)
12463 {
12464 if ((li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
12465 || (li_config_table[j].flag_table[i] & LI_FLAG_INTERCONNECT))
12466 {
12467 notify_plci = li_config_table[j].plci;
12468 if ((notify_plci != NULL)
12469 && (notify_plci != plci)
12470 && (notify_plci->appl != NULL)
12471 && !(notify_plci->appl->appl_flags & APPL_FLAG_OLD_LI_SPEC)
12472 && (notify_plci->State)
12473 && notify_plci->NL.Id && !notify_plci->nl_remove_id)
12474 {
12475 mixer_notify_source_removed(notify_plci, plci_b_id);
12476 }
12477 }
12478 }
12479 mixer_clear_config(plci);
12480 mixer_calculate_coefs(a);
12481 mixer_notify_update(plci, true);
12482 }
12483 li_config_table[i].plci = NULL;
12484 plci->li_bchannel_id = 0;
12485 }
12486 }
12487 }
12488
12489
12490 /*------------------------------------------------------------------*/
12491 /* Echo canceller facilities */
12492 /*------------------------------------------------------------------*/
12493
12494
12495 static void ec_write_parameters(PLCI *plci)
12496 {
12497 word w;
12498 byte parameter_buffer[6];
12499
12500 dbug(1, dprintf("[%06lx] %s,%d: ec_write_parameters",
12501 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
12502 (char *)(FILE_), __LINE__));
12503
12504 parameter_buffer[0] = 5;
12505 parameter_buffer[1] = DSP_CTRL_SET_LEC_PARAMETERS;
12506 PUT_WORD(&parameter_buffer[2], plci->ec_idi_options);
12507 plci->ec_idi_options &= ~LEC_RESET_COEFFICIENTS;
12508 w = (plci->ec_tail_length == 0) ? 128 : plci->ec_tail_length;
12509 PUT_WORD(&parameter_buffer[4], w);
12510 add_p(plci, FTY, parameter_buffer);
12511 sig_req(plci, TEL_CTRL, 0);
12512 send_req(plci);
12513 }
12514
12515
12516 static void ec_clear_config(PLCI *plci)
12517 {
12518
12519 dbug(1, dprintf("[%06lx] %s,%d: ec_clear_config",
12520 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
12521 (char *)(FILE_), __LINE__));
12522
12523 plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER |
12524 LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING;
12525 plci->ec_tail_length = 0;
12526 }
12527
12528
12529 static void ec_prepare_switch(dword Id, PLCI *plci)
12530 {
12531
12532 dbug(1, dprintf("[%06lx] %s,%d: ec_prepare_switch",
12533 UnMapId(Id), (char *)(FILE_), __LINE__));
12534
12535 }
12536
12537
12538 static word ec_save_config(dword Id, PLCI *plci, byte Rc)
12539 {
12540
12541 dbug(1, dprintf("[%06lx] %s,%d: ec_save_config %02x %d",
12542 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
12543
12544 return (GOOD);
12545 }
12546
12547
12548 static word ec_restore_config(dword Id, PLCI *plci, byte Rc)
12549 {
12550 word Info;
12551
12552 dbug(1, dprintf("[%06lx] %s,%d: ec_restore_config %02x %d",
12553 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
12554
12555 Info = GOOD;
12556 if (plci->B1_facilities & B1_FACILITY_EC)
12557 {
12558 switch (plci->adjust_b_state)
12559 {
12560 case ADJUST_B_RESTORE_EC_1:
12561 plci->internal_command = plci->adjust_b_command;
12562 if (plci->sig_req)
12563 {
12564 plci->adjust_b_state = ADJUST_B_RESTORE_EC_1;
12565 break;
12566 }
12567 ec_write_parameters(plci);
12568 plci->adjust_b_state = ADJUST_B_RESTORE_EC_2;
12569 break;
12570 case ADJUST_B_RESTORE_EC_2:
12571 if ((Rc != OK) && (Rc != OK_FC))
12572 {
12573 dbug(1, dprintf("[%06lx] %s,%d: Restore EC failed %02x",
12574 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
12575 Info = _WRONG_STATE;
12576 break;
12577 }
12578 break;
12579 }
12580 }
12581 return (Info);
12582 }
12583
12584
12585 static void ec_command(dword Id, PLCI *plci, byte Rc)
12586 {
12587 word internal_command, Info;
12588 byte result[8];
12589
12590 dbug(1, dprintf("[%06lx] %s,%d: ec_command %02x %04x %04x %04x %d",
12591 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command,
12592 plci->ec_cmd, plci->ec_idi_options, plci->ec_tail_length));
12593
12594 Info = GOOD;
12595 if (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC)
12596 {
12597 result[0] = 2;
12598 PUT_WORD(&result[1], EC_SUCCESS);
12599 }
12600 else
12601 {
12602 result[0] = 5;
12603 PUT_WORD(&result[1], plci->ec_cmd);
12604 result[3] = 2;
12605 PUT_WORD(&result[4], GOOD);
12606 }
12607 internal_command = plci->internal_command;
12608 plci->internal_command = 0;
12609 switch (plci->ec_cmd)
12610 {
12611 case EC_ENABLE_OPERATION:
12612 case EC_FREEZE_COEFFICIENTS:
12613 case EC_RESUME_COEFFICIENT_UPDATE:
12614 case EC_RESET_COEFFICIENTS:
12615 switch (internal_command)
12616 {
12617 default:
12618 adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities |
12619 B1_FACILITY_EC), EC_COMMAND_1);
12620 /* fall through */
12621 case EC_COMMAND_1:
12622 if (adjust_b_process(Id, plci, Rc) != GOOD)
12623 {
12624 dbug(1, dprintf("[%06lx] %s,%d: Load EC failed",
12625 UnMapId(Id), (char *)(FILE_), __LINE__));
12626 Info = _FACILITY_NOT_SUPPORTED;
12627 break;
12628 }
12629 if (plci->internal_command)
12630 return;
12631 /* fall through */
12632 case EC_COMMAND_2:
12633 if (plci->sig_req)
12634 {
12635 plci->internal_command = EC_COMMAND_2;
12636 return;
12637 }
12638 plci->internal_command = EC_COMMAND_3;
12639 ec_write_parameters(plci);
12640 return;
12641 case EC_COMMAND_3:
12642 if ((Rc != OK) && (Rc != OK_FC))
12643 {
12644 dbug(1, dprintf("[%06lx] %s,%d: Enable EC failed %02x",
12645 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
12646 Info = _FACILITY_NOT_SUPPORTED;
12647 break;
12648 }
12649 break;
12650 }
12651 break;
12652
12653 case EC_DISABLE_OPERATION:
12654 switch (internal_command)
12655 {
12656 default:
12657 case EC_COMMAND_1:
12658 if (plci->B1_facilities & B1_FACILITY_EC)
12659 {
12660 if (plci->sig_req)
12661 {
12662 plci->internal_command = EC_COMMAND_1;
12663 return;
12664 }
12665 plci->internal_command = EC_COMMAND_2;
12666 ec_write_parameters(plci);
12667 return;
12668 }
12669 Rc = OK;
12670 /* fall through */
12671 case EC_COMMAND_2:
12672 if ((Rc != OK) && (Rc != OK_FC))
12673 {
12674 dbug(1, dprintf("[%06lx] %s,%d: Disable EC failed %02x",
12675 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
12676 Info = _FACILITY_NOT_SUPPORTED;
12677 break;
12678 }
12679 adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities &
12680 ~B1_FACILITY_EC), EC_COMMAND_3);
12681 /* fall through */
12682 case EC_COMMAND_3:
12683 if (adjust_b_process(Id, plci, Rc) != GOOD)
12684 {
12685 dbug(1, dprintf("[%06lx] %s,%d: Unload EC failed",
12686 UnMapId(Id), (char *)(FILE_), __LINE__));
12687 Info = _FACILITY_NOT_SUPPORTED;
12688 break;
12689 }
12690 if (plci->internal_command)
12691 return;
12692 break;
12693 }
12694 break;
12695 }
12696 sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->number,
12697 "wws", Info, (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ?
12698 PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result);
12699 }
12700
12701
12702 static byte ec_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg)
12703 {
12704 word Info;
12705 word opt;
12706 API_PARSE ec_parms[3];
12707 byte result[16];
12708
12709 dbug(1, dprintf("[%06lx] %s,%d: ec_request",
12710 UnMapId(Id), (char *)(FILE_), __LINE__));
12711
12712 Info = GOOD;
12713 result[0] = 0;
12714 if (!(a->man_profile.private_options & (1L << PRIVATE_ECHO_CANCELLER)))
12715 {
12716 dbug(1, dprintf("[%06lx] %s,%d: Facility not supported",
12717 UnMapId(Id), (char *)(FILE_), __LINE__));
12718 Info = _FACILITY_NOT_SUPPORTED;
12719 }
12720 else
12721 {
12722 if (appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC)
12723 {
12724 if (api_parse(&msg[1].info[1], msg[1].length, "w", ec_parms))
12725 {
12726 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12727 UnMapId(Id), (char *)(FILE_), __LINE__));
12728 Info = _WRONG_MESSAGE_FORMAT;
12729 }
12730 else
12731 {
12732 if (plci == NULL)
12733 {
12734 dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI",
12735 UnMapId(Id), (char *)(FILE_), __LINE__));
12736 Info = _WRONG_IDENTIFIER;
12737 }
12738 else if (!plci->State || !plci->NL.Id || plci->nl_remove_id)
12739 {
12740 dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
12741 UnMapId(Id), (char *)(FILE_), __LINE__));
12742 Info = _WRONG_STATE;
12743 }
12744 else
12745 {
12746 plci->command = 0;
12747 plci->ec_cmd = GET_WORD(ec_parms[0].info);
12748 plci->ec_idi_options &= ~(LEC_MANUAL_DISABLE | LEC_RESET_COEFFICIENTS);
12749 result[0] = 2;
12750 PUT_WORD(&result[1], EC_SUCCESS);
12751 if (msg[1].length >= 4)
12752 {
12753 opt = GET_WORD(&ec_parms[0].info[2]);
12754 plci->ec_idi_options &= ~(LEC_ENABLE_NONLINEAR_PROCESSING |
12755 LEC_ENABLE_2100HZ_DETECTOR | LEC_REQUIRE_2100HZ_REVERSALS);
12756 if (!(opt & EC_DISABLE_NON_LINEAR_PROCESSING))
12757 plci->ec_idi_options |= LEC_ENABLE_NONLINEAR_PROCESSING;
12758 if (opt & EC_DETECT_DISABLE_TONE)
12759 plci->ec_idi_options |= LEC_ENABLE_2100HZ_DETECTOR;
12760 if (!(opt & EC_DO_NOT_REQUIRE_REVERSALS))
12761 plci->ec_idi_options |= LEC_REQUIRE_2100HZ_REVERSALS;
12762 if (msg[1].length >= 6)
12763 {
12764 plci->ec_tail_length = GET_WORD(&ec_parms[0].info[4]);
12765 }
12766 }
12767 switch (plci->ec_cmd)
12768 {
12769 case EC_ENABLE_OPERATION:
12770 plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS;
12771 start_internal_command(Id, plci, ec_command);
12772 return (false);
12773
12774 case EC_DISABLE_OPERATION:
12775 plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER |
12776 LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING |
12777 LEC_RESET_COEFFICIENTS;
12778 start_internal_command(Id, plci, ec_command);
12779 return (false);
12780
12781 case EC_FREEZE_COEFFICIENTS:
12782 plci->ec_idi_options |= LEC_FREEZE_COEFFICIENTS;
12783 start_internal_command(Id, plci, ec_command);
12784 return (false);
12785
12786 case EC_RESUME_COEFFICIENT_UPDATE:
12787 plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS;
12788 start_internal_command(Id, plci, ec_command);
12789 return (false);
12790
12791 case EC_RESET_COEFFICIENTS:
12792 plci->ec_idi_options |= LEC_RESET_COEFFICIENTS;
12793 start_internal_command(Id, plci, ec_command);
12794 return (false);
12795
12796 default:
12797 dbug(1, dprintf("[%06lx] %s,%d: EC unknown request %04x",
12798 UnMapId(Id), (char *)(FILE_), __LINE__, plci->ec_cmd));
12799 PUT_WORD(&result[1], EC_UNSUPPORTED_OPERATION);
12800 }
12801 }
12802 }
12803 }
12804 else
12805 {
12806 if (api_parse(&msg[1].info[1], msg[1].length, "ws", ec_parms))
12807 {
12808 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12809 UnMapId(Id), (char *)(FILE_), __LINE__));
12810 Info = _WRONG_MESSAGE_FORMAT;
12811 }
12812 else
12813 {
12814 if (GET_WORD(ec_parms[0].info) == EC_GET_SUPPORTED_SERVICES)
12815 {
12816 result[0] = 11;
12817 PUT_WORD(&result[1], EC_GET_SUPPORTED_SERVICES);
12818 result[3] = 8;
12819 PUT_WORD(&result[4], GOOD);
12820 PUT_WORD(&result[6], 0x0007);
12821 PUT_WORD(&result[8], LEC_MAX_SUPPORTED_TAIL_LENGTH);
12822 PUT_WORD(&result[10], 0);
12823 }
12824 else if (plci == NULL)
12825 {
12826 dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI",
12827 UnMapId(Id), (char *)(FILE_), __LINE__));
12828 Info = _WRONG_IDENTIFIER;
12829 }
12830 else if (!plci->State || !plci->NL.Id || plci->nl_remove_id)
12831 {
12832 dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
12833 UnMapId(Id), (char *)(FILE_), __LINE__));
12834 Info = _WRONG_STATE;
12835 }
12836 else
12837 {
12838 plci->command = 0;
12839 plci->ec_cmd = GET_WORD(ec_parms[0].info);
12840 plci->ec_idi_options &= ~(LEC_MANUAL_DISABLE | LEC_RESET_COEFFICIENTS);
12841 result[0] = 5;
12842 PUT_WORD(&result[1], plci->ec_cmd);
12843 result[3] = 2;
12844 PUT_WORD(&result[4], GOOD);
12845 plci->ec_idi_options &= ~(LEC_ENABLE_NONLINEAR_PROCESSING |
12846 LEC_ENABLE_2100HZ_DETECTOR | LEC_REQUIRE_2100HZ_REVERSALS);
12847 plci->ec_tail_length = 0;
12848 if (ec_parms[1].length >= 2)
12849 {
12850 opt = GET_WORD(&ec_parms[1].info[1]);
12851 if (opt & EC_ENABLE_NON_LINEAR_PROCESSING)
12852 plci->ec_idi_options |= LEC_ENABLE_NONLINEAR_PROCESSING;
12853 if (opt & EC_DETECT_DISABLE_TONE)
12854 plci->ec_idi_options |= LEC_ENABLE_2100HZ_DETECTOR;
12855 if (!(opt & EC_DO_NOT_REQUIRE_REVERSALS))
12856 plci->ec_idi_options |= LEC_REQUIRE_2100HZ_REVERSALS;
12857 if (ec_parms[1].length >= 4)
12858 {
12859 plci->ec_tail_length = GET_WORD(&ec_parms[1].info[3]);
12860 }
12861 }
12862 switch (plci->ec_cmd)
12863 {
12864 case EC_ENABLE_OPERATION:
12865 plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS;
12866 start_internal_command(Id, plci, ec_command);
12867 return (false);
12868
12869 case EC_DISABLE_OPERATION:
12870 plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER |
12871 LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING |
12872 LEC_RESET_COEFFICIENTS;
12873 start_internal_command(Id, plci, ec_command);
12874 return (false);
12875
12876 default:
12877 dbug(1, dprintf("[%06lx] %s,%d: EC unknown request %04x",
12878 UnMapId(Id), (char *)(FILE_), __LINE__, plci->ec_cmd));
12879 PUT_WORD(&result[4], _FACILITY_SPECIFIC_FUNCTION_NOT_SUPP);
12880 }
12881 }
12882 }
12883 }
12884 }
12885 sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
12886 "wws", Info, (appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ?
12887 PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result);
12888 return (false);
12889 }
12890
12891
12892 static void ec_indication(dword Id, PLCI *plci, byte *msg, word length)
12893 {
12894 byte result[8];
12895
12896 dbug(1, dprintf("[%06lx] %s,%d: ec_indication",
12897 UnMapId(Id), (char *)(FILE_), __LINE__));
12898
12899 if (!(plci->ec_idi_options & LEC_MANUAL_DISABLE))
12900 {
12901 if (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC)
12902 {
12903 result[0] = 2;
12904 PUT_WORD(&result[1], 0);
12905 switch (msg[1])
12906 {
12907 case LEC_DISABLE_TYPE_CONTIGNUOUS_2100HZ:
12908 PUT_WORD(&result[1], EC_BYPASS_DUE_TO_CONTINUOUS_2100HZ);
12909 break;
12910 case LEC_DISABLE_TYPE_REVERSED_2100HZ:
12911 PUT_WORD(&result[1], EC_BYPASS_DUE_TO_REVERSED_2100HZ);
12912 break;
12913 case LEC_DISABLE_RELEASED:
12914 PUT_WORD(&result[1], EC_BYPASS_RELEASED);
12915 break;
12916 }
12917 }
12918 else
12919 {
12920 result[0] = 5;
12921 PUT_WORD(&result[1], EC_BYPASS_INDICATION);
12922 result[3] = 2;
12923 PUT_WORD(&result[4], 0);
12924 switch (msg[1])
12925 {
12926 case LEC_DISABLE_TYPE_CONTIGNUOUS_2100HZ:
12927 PUT_WORD(&result[4], EC_BYPASS_DUE_TO_CONTINUOUS_2100HZ);
12928 break;
12929 case LEC_DISABLE_TYPE_REVERSED_2100HZ:
12930 PUT_WORD(&result[4], EC_BYPASS_DUE_TO_REVERSED_2100HZ);
12931 break;
12932 case LEC_DISABLE_RELEASED:
12933 PUT_WORD(&result[4], EC_BYPASS_RELEASED);
12934 break;
12935 }
12936 }
12937 sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ?
12938 PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result);
12939 }
12940 }
12941
12942
12943
12944 /*------------------------------------------------------------------*/
12945 /* Advanced voice */
12946 /*------------------------------------------------------------------*/
12947
12948 static void adv_voice_write_coefs(PLCI *plci, word write_command)
12949 {
12950 DIVA_CAPI_ADAPTER *a;
12951 word i;
12952 byte *p;
12953
12954 word w, n, j, k;
12955 byte ch_map[MIXER_CHANNELS_BRI];
12956
12957 byte coef_buffer[ADV_VOICE_COEF_BUFFER_SIZE + 2];
12958
12959 dbug(1, dprintf("[%06lx] %s,%d: adv_voice_write_coefs %d",
12960 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
12961 (char *)(FILE_), __LINE__, write_command));
12962
12963 a = plci->adapter;
12964 p = coef_buffer + 1;
12965 *(p++) = DSP_CTRL_OLD_SET_MIXER_COEFFICIENTS;
12966 i = 0;
12967 while (i + sizeof(word) <= a->adv_voice_coef_length)
12968 {
12969 PUT_WORD(p, GET_WORD(a->adv_voice_coef_buffer + i));
12970 p += 2;
12971 i += 2;
12972 }
12973 while (i < ADV_VOICE_OLD_COEF_COUNT * sizeof(word))
12974 {
12975 PUT_WORD(p, 0x8000);
12976 p += 2;
12977 i += 2;
12978 }
12979
12980 if (!a->li_pri && (plci->li_bchannel_id == 0))
12981 {
12982 if ((li_config_table[a->li_base].plci == NULL) && (li_config_table[a->li_base + 1].plci != NULL))
12983 {
12984 plci->li_bchannel_id = 1;
12985 li_config_table[a->li_base].plci = plci;
12986 dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id %d",
12987 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
12988 (char *)(FILE_), __LINE__, plci->li_bchannel_id));
12989 }
12990 else if ((li_config_table[a->li_base].plci != NULL) && (li_config_table[a->li_base + 1].plci == NULL))
12991 {
12992 plci->li_bchannel_id = 2;
12993 li_config_table[a->li_base + 1].plci = plci;
12994 dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id %d",
12995 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
12996 (char *)(FILE_), __LINE__, plci->li_bchannel_id));
12997 }
12998 }
12999 if (!a->li_pri && (plci->li_bchannel_id != 0)
13000 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
13001 {
13002 i = a->li_base + (plci->li_bchannel_id - 1);
13003 switch (write_command)
13004 {
13005 case ADV_VOICE_WRITE_ACTIVATION:
13006 j = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
13007 k = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
13008 if (!(plci->B1_facilities & B1_FACILITY_MIXER))
13009 {
13010 li_config_table[j].flag_table[i] |= LI_FLAG_CONFERENCE | LI_FLAG_MIX;
13011 li_config_table[i].flag_table[j] |= LI_FLAG_CONFERENCE | LI_FLAG_MONITOR;
13012 }
13013 if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13014 {
13015 li_config_table[k].flag_table[i] |= LI_FLAG_CONFERENCE | LI_FLAG_MIX;
13016 li_config_table[i].flag_table[k] |= LI_FLAG_CONFERENCE | LI_FLAG_MONITOR;
13017 li_config_table[k].flag_table[j] |= LI_FLAG_CONFERENCE;
13018 li_config_table[j].flag_table[k] |= LI_FLAG_CONFERENCE;
13019 }
13020 mixer_calculate_coefs(a);
13021 li_config_table[i].curchnl = li_config_table[i].channel;
13022 li_config_table[j].curchnl = li_config_table[j].channel;
13023 if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13024 li_config_table[k].curchnl = li_config_table[k].channel;
13025 break;
13026
13027 case ADV_VOICE_WRITE_DEACTIVATION:
13028 for (j = 0; j < li_total_channels; j++)
13029 {
13030 li_config_table[i].flag_table[j] = 0;
13031 li_config_table[j].flag_table[i] = 0;
13032 }
13033 k = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
13034 for (j = 0; j < li_total_channels; j++)
13035 {
13036 li_config_table[k].flag_table[j] = 0;
13037 li_config_table[j].flag_table[k] = 0;
13038 }
13039 if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13040 {
13041 k = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
13042 for (j = 0; j < li_total_channels; j++)
13043 {
13044 li_config_table[k].flag_table[j] = 0;
13045 li_config_table[j].flag_table[k] = 0;
13046 }
13047 }
13048 mixer_calculate_coefs(a);
13049 break;
13050 }
13051 if (plci->B1_facilities & B1_FACILITY_MIXER)
13052 {
13053 w = 0;
13054 if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length)
13055 w = GET_WORD(a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE);
13056 if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
13057 w |= MIXER_FEATURE_ENABLE_TX_DATA;
13058 if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
13059 w |= MIXER_FEATURE_ENABLE_RX_DATA;
13060 *(p++) = (byte) w;
13061 *(p++) = (byte)(w >> 8);
13062 for (j = 0; j < sizeof(ch_map); j += 2)
13063 {
13064 ch_map[j] = (byte)(j + (plci->li_bchannel_id - 1));
13065 ch_map[j + 1] = (byte)(j + (2 - plci->li_bchannel_id));
13066 }
13067 for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++)
13068 {
13069 i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch];
13070 j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch];
13071 if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED)
13072 {
13073 *(p++) = ((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01);
13074 w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
13075 li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4;
13076 }
13077 else
13078 {
13079 *(p++) = (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + n < a->adv_voice_coef_length) ?
13080 a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + n] : 0x00;
13081 }
13082 }
13083 }
13084 else
13085 {
13086 for (i = ADV_VOICE_NEW_COEF_BASE; i < a->adv_voice_coef_length; i++)
13087 *(p++) = a->adv_voice_coef_buffer[i];
13088 }
13089 }
13090 else
13091
13092 {
13093 for (i = ADV_VOICE_NEW_COEF_BASE; i < a->adv_voice_coef_length; i++)
13094 *(p++) = a->adv_voice_coef_buffer[i];
13095 }
13096 coef_buffer[0] = (p - coef_buffer) - 1;
13097 add_p(plci, FTY, coef_buffer);
13098 sig_req(plci, TEL_CTRL, 0);
13099 send_req(plci);
13100 }
13101
13102
13103 static void adv_voice_clear_config(PLCI *plci)
13104 {
13105 DIVA_CAPI_ADAPTER *a;
13106
13107 word i, j;
13108
13109
13110 dbug(1, dprintf("[%06lx] %s,%d: adv_voice_clear_config",
13111 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13112 (char *)(FILE_), __LINE__));
13113
13114 a = plci->adapter;
13115 if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
13116 {
13117 a->adv_voice_coef_length = 0;
13118
13119 if (!a->li_pri && (plci->li_bchannel_id != 0)
13120 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
13121 {
13122 i = a->li_base + (plci->li_bchannel_id - 1);
13123 li_config_table[i].curchnl = 0;
13124 li_config_table[i].channel = 0;
13125 li_config_table[i].chflags = 0;
13126 for (j = 0; j < li_total_channels; j++)
13127 {
13128 li_config_table[i].flag_table[j] = 0;
13129 li_config_table[j].flag_table[i] = 0;
13130 li_config_table[i].coef_table[j] = 0;
13131 li_config_table[j].coef_table[i] = 0;
13132 }
13133 li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET;
13134 i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
13135 li_config_table[i].curchnl = 0;
13136 li_config_table[i].channel = 0;
13137 li_config_table[i].chflags = 0;
13138 for (j = 0; j < li_total_channels; j++)
13139 {
13140 li_config_table[i].flag_table[j] = 0;
13141 li_config_table[j].flag_table[i] = 0;
13142 li_config_table[i].coef_table[j] = 0;
13143 li_config_table[j].coef_table[i] = 0;
13144 }
13145 if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13146 {
13147 i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
13148 li_config_table[i].curchnl = 0;
13149 li_config_table[i].channel = 0;
13150 li_config_table[i].chflags = 0;
13151 for (j = 0; j < li_total_channels; j++)
13152 {
13153 li_config_table[i].flag_table[j] = 0;
13154 li_config_table[j].flag_table[i] = 0;
13155 li_config_table[i].coef_table[j] = 0;
13156 li_config_table[j].coef_table[i] = 0;
13157 }
13158 }
13159 }
13160
13161 }
13162 }
13163
13164
13165 static void adv_voice_prepare_switch(dword Id, PLCI *plci)
13166 {
13167
13168 dbug(1, dprintf("[%06lx] %s,%d: adv_voice_prepare_switch",
13169 UnMapId(Id), (char *)(FILE_), __LINE__));
13170
13171 }
13172
13173
13174 static word adv_voice_save_config(dword Id, PLCI *plci, byte Rc)
13175 {
13176
13177 dbug(1, dprintf("[%06lx] %s,%d: adv_voice_save_config %02x %d",
13178 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
13179
13180 return (GOOD);
13181 }
13182
13183
13184 static word adv_voice_restore_config(dword Id, PLCI *plci, byte Rc)
13185 {
13186 DIVA_CAPI_ADAPTER *a;
13187 word Info;
13188
13189 dbug(1, dprintf("[%06lx] %s,%d: adv_voice_restore_config %02x %d",
13190 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
13191
13192 Info = GOOD;
13193 a = plci->adapter;
13194 if ((plci->B1_facilities & B1_FACILITY_VOICE)
13195 && (plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
13196 {
13197 switch (plci->adjust_b_state)
13198 {
13199 case ADJUST_B_RESTORE_VOICE_1:
13200 plci->internal_command = plci->adjust_b_command;
13201 if (plci->sig_req)
13202 {
13203 plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_1;
13204 break;
13205 }
13206 adv_voice_write_coefs(plci, ADV_VOICE_WRITE_UPDATE);
13207 plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_2;
13208 break;
13209 case ADJUST_B_RESTORE_VOICE_2:
13210 if ((Rc != OK) && (Rc != OK_FC))
13211 {
13212 dbug(1, dprintf("[%06lx] %s,%d: Restore voice config failed %02x",
13213 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
13214 Info = _WRONG_STATE;
13215 break;
13216 }
13217 break;
13218 }
13219 }
13220 return (Info);
13221 }
13222
13223
13224
13225
13226 /*------------------------------------------------------------------*/
13227 /* B1 resource switching */
13228 /*------------------------------------------------------------------*/
13229
13230 static byte b1_facilities_table[] =
13231 {
13232 0x00, /* 0 No bchannel resources */
13233 0x00, /* 1 Codec (automatic law) */
13234 0x00, /* 2 Codec (A-law) */
13235 0x00, /* 3 Codec (y-law) */
13236 0x00, /* 4 HDLC for X.21 */
13237 0x00, /* 5 HDLC */
13238 0x00, /* 6 External Device 0 */
13239 0x00, /* 7 External Device 1 */
13240 0x00, /* 8 HDLC 56k */
13241 0x00, /* 9 Transparent */
13242 0x00, /* 10 Loopback to network */
13243 0x00, /* 11 Test pattern to net */
13244 0x00, /* 12 Rate adaptation sync */
13245 0x00, /* 13 Rate adaptation async */
13246 0x00, /* 14 R-Interface */
13247 0x00, /* 15 HDLC 128k leased line */
13248 0x00, /* 16 FAX */
13249 0x00, /* 17 Modem async */
13250 0x00, /* 18 Modem sync HDLC */
13251 0x00, /* 19 V.110 async HDLC */
13252 0x12, /* 20 Adv voice (Trans,mixer) */
13253 0x00, /* 21 Codec connected to IC */
13254 0x0c, /* 22 Trans,DTMF */
13255 0x1e, /* 23 Trans,DTMF+mixer */
13256 0x1f, /* 24 Trans,DTMF+mixer+local */
13257 0x13, /* 25 Trans,mixer+local */
13258 0x12, /* 26 HDLC,mixer */
13259 0x12, /* 27 HDLC 56k,mixer */
13260 0x2c, /* 28 Trans,LEC+DTMF */
13261 0x3e, /* 29 Trans,LEC+DTMF+mixer */
13262 0x3f, /* 30 Trans,LEC+DTMF+mixer+local */
13263 0x2c, /* 31 RTP,LEC+DTMF */
13264 0x3e, /* 32 RTP,LEC+DTMF+mixer */
13265 0x3f, /* 33 RTP,LEC+DTMF+mixer+local */
13266 0x00, /* 34 Signaling task */
13267 0x00, /* 35 PIAFS */
13268 0x0c, /* 36 Trans,DTMF+TONE */
13269 0x1e, /* 37 Trans,DTMF+TONE+mixer */
13270 0x1f /* 38 Trans,DTMF+TONE+mixer+local*/
13271 };
13272
13273
13274 static word get_b1_facilities(PLCI *plci, byte b1_resource)
13275 {
13276 word b1_facilities;
13277
13278 b1_facilities = b1_facilities_table[b1_resource];
13279 if ((b1_resource == 9) || (b1_resource == 20) || (b1_resource == 25))
13280 {
13281
13282 if (!(((plci->requested_options_conn | plci->requested_options) & (1L << PRIVATE_DTMF_TONE))
13283 || (plci->appl && (plci->adapter->requested_options_table[plci->appl->Id - 1] & (1L << PRIVATE_DTMF_TONE)))))
13284
13285 {
13286 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_SEND)
13287 b1_facilities |= B1_FACILITY_DTMFX;
13288 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE)
13289 b1_facilities |= B1_FACILITY_DTMFR;
13290 }
13291 }
13292 if ((b1_resource == 17) || (b1_resource == 18))
13293 {
13294 if (plci->adapter->manufacturer_features & (MANUFACTURER_FEATURE_V18 | MANUFACTURER_FEATURE_VOWN))
13295 b1_facilities |= B1_FACILITY_DTMFX | B1_FACILITY_DTMFR;
13296 }
13297 /*
13298 dbug (1, dprintf("[%06lx] %s,%d: get_b1_facilities %d %04x",
13299 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13300 (char far *)(FILE_), __LINE__, b1_resource, b1_facilites));
13301 */
13302 return (b1_facilities);
13303 }
13304
13305
13306 static byte add_b1_facilities(PLCI *plci, byte b1_resource, word b1_facilities)
13307 {
13308 byte b;
13309
13310 switch (b1_resource)
13311 {
13312 case 5:
13313 case 26:
13314 if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13315 b = 26;
13316 else
13317 b = 5;
13318 break;
13319
13320 case 8:
13321 case 27:
13322 if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13323 b = 27;
13324 else
13325 b = 8;
13326 break;
13327
13328 case 9:
13329 case 20:
13330 case 22:
13331 case 23:
13332 case 24:
13333 case 25:
13334 case 28:
13335 case 29:
13336 case 30:
13337 case 36:
13338 case 37:
13339 case 38:
13340 if (b1_facilities & B1_FACILITY_EC)
13341 {
13342 if (b1_facilities & B1_FACILITY_LOCAL)
13343 b = 30;
13344 else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13345 b = 29;
13346 else
13347 b = 28;
13348 }
13349
13350 else if ((b1_facilities & (B1_FACILITY_DTMFX | B1_FACILITY_DTMFR | B1_FACILITY_MIXER))
13351 && (((plci->requested_options_conn | plci->requested_options) & (1L << PRIVATE_DTMF_TONE))
13352 || (plci->appl && (plci->adapter->requested_options_table[plci->appl->Id - 1] & (1L << PRIVATE_DTMF_TONE)))))
13353 {
13354 if (b1_facilities & B1_FACILITY_LOCAL)
13355 b = 38;
13356 else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13357 b = 37;
13358 else
13359 b = 36;
13360 }
13361
13362 else if (((plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_HARDDTMF)
13363 && !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE))
13364 || ((b1_facilities & B1_FACILITY_DTMFR)
13365 && ((b1_facilities & B1_FACILITY_MIXER)
13366 || !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE)))
13367 || ((b1_facilities & B1_FACILITY_DTMFX)
13368 && ((b1_facilities & B1_FACILITY_MIXER)
13369 || !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_SEND))))
13370 {
13371 if (b1_facilities & B1_FACILITY_LOCAL)
13372 b = 24;
13373 else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13374 b = 23;
13375 else
13376 b = 22;
13377 }
13378 else
13379 {
13380 if (b1_facilities & B1_FACILITY_LOCAL)
13381 b = 25;
13382 else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13383 b = 20;
13384 else
13385 b = 9;
13386 }
13387 break;
13388
13389 case 31:
13390 case 32:
13391 case 33:
13392 if (b1_facilities & B1_FACILITY_LOCAL)
13393 b = 33;
13394 else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13395 b = 32;
13396 else
13397 b = 31;
13398 break;
13399
13400 default:
13401 b = b1_resource;
13402 }
13403 dbug(1, dprintf("[%06lx] %s,%d: add_b1_facilities %d %04x %d %04x",
13404 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13405 (char *)(FILE_), __LINE__,
13406 b1_resource, b1_facilities, b, get_b1_facilities(plci, b)));
13407 return (b);
13408 }
13409
13410
13411 static void adjust_b1_facilities(PLCI *plci, byte new_b1_resource, word new_b1_facilities)
13412 {
13413 word removed_facilities;
13414
13415 dbug(1, dprintf("[%06lx] %s,%d: adjust_b1_facilities %d %04x %04x",
13416 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13417 (char *)(FILE_), __LINE__, new_b1_resource, new_b1_facilities,
13418 new_b1_facilities & get_b1_facilities(plci, new_b1_resource)));
13419
13420 new_b1_facilities &= get_b1_facilities(plci, new_b1_resource);
13421 removed_facilities = plci->B1_facilities & ~new_b1_facilities;
13422
13423 if (removed_facilities & B1_FACILITY_EC)
13424 ec_clear_config(plci);
13425
13426
13427 if (removed_facilities & B1_FACILITY_DTMFR)
13428 {
13429 dtmf_rec_clear_config(plci);
13430 dtmf_parameter_clear_config(plci);
13431 }
13432 if (removed_facilities & B1_FACILITY_DTMFX)
13433 dtmf_send_clear_config(plci);
13434
13435
13436 if (removed_facilities & B1_FACILITY_MIXER)
13437 mixer_clear_config(plci);
13438
13439 if (removed_facilities & B1_FACILITY_VOICE)
13440 adv_voice_clear_config(plci);
13441 plci->B1_facilities = new_b1_facilities;
13442 }
13443
13444
13445 static void adjust_b_clear(PLCI *plci)
13446 {
13447
13448 dbug(1, dprintf("[%06lx] %s,%d: adjust_b_clear",
13449 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13450 (char *)(FILE_), __LINE__));
13451
13452 plci->adjust_b_restore = false;
13453 }
13454
13455
13456 static word adjust_b_process(dword Id, PLCI *plci, byte Rc)
13457 {
13458 word Info;
13459 byte b1_resource;
13460 NCCI *ncci_ptr;
13461 API_PARSE bp[2];
13462
13463 dbug(1, dprintf("[%06lx] %s,%d: adjust_b_process %02x %d",
13464 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
13465
13466 Info = GOOD;
13467 switch (plci->adjust_b_state)
13468 {
13469 case ADJUST_B_START:
13470 if ((plci->adjust_b_parms_msg == NULL)
13471 && (plci->adjust_b_mode & ADJUST_B_MODE_SWITCH_L1)
13472 && ((plci->adjust_b_mode & ~(ADJUST_B_MODE_SAVE | ADJUST_B_MODE_SWITCH_L1 |
13473 ADJUST_B_MODE_NO_RESOURCE | ADJUST_B_MODE_RESTORE)) == 0))
13474 {
13475 b1_resource = (plci->adjust_b_mode == ADJUST_B_MODE_NO_RESOURCE) ?
13476 0 : add_b1_facilities(plci, plci->B1_resource, plci->adjust_b_facilities);
13477 if (b1_resource == plci->B1_resource)
13478 {
13479 adjust_b1_facilities(plci, b1_resource, plci->adjust_b_facilities);
13480 break;
13481 }
13482 if (plci->adjust_b_facilities & ~get_b1_facilities(plci, b1_resource))
13483 {
13484 dbug(1, dprintf("[%06lx] %s,%d: Adjust B nonsupported facilities %d %d %04x",
13485 UnMapId(Id), (char *)(FILE_), __LINE__,
13486 plci->B1_resource, b1_resource, plci->adjust_b_facilities));
13487 Info = _WRONG_STATE;
13488 break;
13489 }
13490 }
13491 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13492 {
13493
13494 mixer_prepare_switch(Id, plci);
13495
13496
13497 dtmf_prepare_switch(Id, plci);
13498 dtmf_parameter_prepare_switch(Id, plci);
13499
13500
13501 ec_prepare_switch(Id, plci);
13502
13503 adv_voice_prepare_switch(Id, plci);
13504 }
13505 plci->adjust_b_state = ADJUST_B_SAVE_MIXER_1;
13506 Rc = OK;
13507 /* fall through */
13508 case ADJUST_B_SAVE_MIXER_1:
13509 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13510 {
13511
13512 Info = mixer_save_config(Id, plci, Rc);
13513 if ((Info != GOOD) || plci->internal_command)
13514 break;
13515
13516 }
13517 plci->adjust_b_state = ADJUST_B_SAVE_DTMF_1;
13518 Rc = OK;
13519 /* fall through */
13520 case ADJUST_B_SAVE_DTMF_1:
13521 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13522 {
13523
13524 Info = dtmf_save_config(Id, plci, Rc);
13525 if ((Info != GOOD) || plci->internal_command)
13526 break;
13527
13528 }
13529 plci->adjust_b_state = ADJUST_B_REMOVE_L23_1;
13530 /* fall through */
13531 case ADJUST_B_REMOVE_L23_1:
13532 if ((plci->adjust_b_mode & ADJUST_B_MODE_REMOVE_L23)
13533 && plci->NL.Id && !plci->nl_remove_id)
13534 {
13535 plci->internal_command = plci->adjust_b_command;
13536 if (plci->adjust_b_ncci != 0)
13537 {
13538 ncci_ptr = &(plci->adapter->ncci[plci->adjust_b_ncci]);
13539 while (ncci_ptr->data_pending)
13540 {
13541 plci->data_sent_ptr = ncci_ptr->DBuffer[ncci_ptr->data_out].P;
13542 data_rc(plci, plci->adapter->ncci_ch[plci->adjust_b_ncci]);
13543 }
13544 while (ncci_ptr->data_ack_pending)
13545 data_ack(plci, plci->adapter->ncci_ch[plci->adjust_b_ncci]);
13546 }
13547 nl_req_ncci(plci, REMOVE,
13548 (byte)((plci->adjust_b_mode & ADJUST_B_MODE_CONNECT) ? plci->adjust_b_ncci : 0));
13549 send_req(plci);
13550 plci->adjust_b_state = ADJUST_B_REMOVE_L23_2;
13551 break;
13552 }
13553 plci->adjust_b_state = ADJUST_B_REMOVE_L23_2;
13554 Rc = OK;
13555 /* fall through */
13556 case ADJUST_B_REMOVE_L23_2:
13557 if ((Rc != OK) && (Rc != OK_FC))
13558 {
13559 dbug(1, dprintf("[%06lx] %s,%d: Adjust B remove failed %02x",
13560 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
13561 Info = _WRONG_STATE;
13562 break;
13563 }
13564 if (plci->adjust_b_mode & ADJUST_B_MODE_REMOVE_L23)
13565 {
13566 if (plci_nl_busy(plci))
13567 {
13568 plci->internal_command = plci->adjust_b_command;
13569 break;
13570 }
13571 }
13572 plci->adjust_b_state = ADJUST_B_SAVE_EC_1;
13573 Rc = OK;
13574 /* fall through */
13575 case ADJUST_B_SAVE_EC_1:
13576 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13577 {
13578
13579 Info = ec_save_config(Id, plci, Rc);
13580 if ((Info != GOOD) || plci->internal_command)
13581 break;
13582
13583 }
13584 plci->adjust_b_state = ADJUST_B_SAVE_DTMF_PARAMETER_1;
13585 Rc = OK;
13586 /* fall through */
13587 case ADJUST_B_SAVE_DTMF_PARAMETER_1:
13588 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13589 {
13590
13591 Info = dtmf_parameter_save_config(Id, plci, Rc);
13592 if ((Info != GOOD) || plci->internal_command)
13593 break;
13594
13595 }
13596 plci->adjust_b_state = ADJUST_B_SAVE_VOICE_1;
13597 Rc = OK;
13598 /* fall through */
13599 case ADJUST_B_SAVE_VOICE_1:
13600 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13601 {
13602 Info = adv_voice_save_config(Id, plci, Rc);
13603 if ((Info != GOOD) || plci->internal_command)
13604 break;
13605 }
13606 plci->adjust_b_state = ADJUST_B_SWITCH_L1_1;
13607 /* fall through */
13608 case ADJUST_B_SWITCH_L1_1:
13609 if (plci->adjust_b_mode & ADJUST_B_MODE_SWITCH_L1)
13610 {
13611 if (plci->sig_req)
13612 {
13613 plci->internal_command = plci->adjust_b_command;
13614 break;
13615 }
13616 if (plci->adjust_b_parms_msg != NULL)
13617 api_load_msg(plci->adjust_b_parms_msg, bp);
13618 else
13619 api_load_msg(&plci->B_protocol, bp);
13620 Info = add_b1(plci, bp,
13621 (word)((plci->adjust_b_mode & ADJUST_B_MODE_NO_RESOURCE) ? 2 : 0),
13622 plci->adjust_b_facilities);
13623 if (Info != GOOD)
13624 {
13625 dbug(1, dprintf("[%06lx] %s,%d: Adjust B invalid L1 parameters %d %04x",
13626 UnMapId(Id), (char *)(FILE_), __LINE__,
13627 plci->B1_resource, plci->adjust_b_facilities));
13628 break;
13629 }
13630 plci->internal_command = plci->adjust_b_command;
13631 sig_req(plci, RESOURCES, 0);
13632 send_req(plci);
13633 plci->adjust_b_state = ADJUST_B_SWITCH_L1_2;
13634 break;
13635 }
13636 plci->adjust_b_state = ADJUST_B_SWITCH_L1_2;
13637 Rc = OK;
13638 /* fall through */
13639 case ADJUST_B_SWITCH_L1_2:
13640 if ((Rc != OK) && (Rc != OK_FC))
13641 {
13642 dbug(1, dprintf("[%06lx] %s,%d: Adjust B switch failed %02x %d %04x",
13643 UnMapId(Id), (char *)(FILE_), __LINE__,
13644 Rc, plci->B1_resource, plci->adjust_b_facilities));
13645 Info = _WRONG_STATE;
13646 break;
13647 }
13648 plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_1;
13649 Rc = OK;
13650 /* fall through */
13651 case ADJUST_B_RESTORE_VOICE_1:
13652 case ADJUST_B_RESTORE_VOICE_2:
13653 if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13654 {
13655 Info = adv_voice_restore_config(Id, plci, Rc);
13656 if ((Info != GOOD) || plci->internal_command)
13657 break;
13658 }
13659 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_1;
13660 Rc = OK;
13661 /* fall through */
13662 case ADJUST_B_RESTORE_DTMF_PARAMETER_1:
13663 case ADJUST_B_RESTORE_DTMF_PARAMETER_2:
13664 if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13665 {
13666
13667 Info = dtmf_parameter_restore_config(Id, plci, Rc);
13668 if ((Info != GOOD) || plci->internal_command)
13669 break;
13670
13671 }
13672 plci->adjust_b_state = ADJUST_B_RESTORE_EC_1;
13673 Rc = OK;
13674 /* fall through */
13675 case ADJUST_B_RESTORE_EC_1:
13676 case ADJUST_B_RESTORE_EC_2:
13677 if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13678 {
13679
13680 Info = ec_restore_config(Id, plci, Rc);
13681 if ((Info != GOOD) || plci->internal_command)
13682 break;
13683
13684 }
13685 plci->adjust_b_state = ADJUST_B_ASSIGN_L23_1;
13686 /* fall through */
13687 case ADJUST_B_ASSIGN_L23_1:
13688 if (plci->adjust_b_mode & ADJUST_B_MODE_ASSIGN_L23)
13689 {
13690 if (plci_nl_busy(plci))
13691 {
13692 plci->internal_command = plci->adjust_b_command;
13693 break;
13694 }
13695 if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT)
13696 plci->call_dir |= CALL_DIR_FORCE_OUTG_NL;
13697 if (plci->adjust_b_parms_msg != NULL)
13698 api_load_msg(plci->adjust_b_parms_msg, bp);
13699 else
13700 api_load_msg(&plci->B_protocol, bp);
13701 Info = add_b23(plci, bp);
13702 if (Info != GOOD)
13703 {
13704 dbug(1, dprintf("[%06lx] %s,%d: Adjust B invalid L23 parameters %04x",
13705 UnMapId(Id), (char *)(FILE_), __LINE__, Info));
13706 break;
13707 }
13708 plci->internal_command = plci->adjust_b_command;
13709 nl_req_ncci(plci, ASSIGN, 0);
13710 send_req(plci);
13711 plci->adjust_b_state = ADJUST_B_ASSIGN_L23_2;
13712 break;
13713 }
13714 plci->adjust_b_state = ADJUST_B_ASSIGN_L23_2;
13715 Rc = ASSIGN_OK;
13716 /* fall through */
13717 case ADJUST_B_ASSIGN_L23_2:
13718 if ((Rc != OK) && (Rc != OK_FC) && (Rc != ASSIGN_OK))
13719 {
13720 dbug(1, dprintf("[%06lx] %s,%d: Adjust B assign failed %02x",
13721 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
13722 Info = _WRONG_STATE;
13723 break;
13724 }
13725 if (plci->adjust_b_mode & ADJUST_B_MODE_ASSIGN_L23)
13726 {
13727 if (Rc != ASSIGN_OK)
13728 {
13729 plci->internal_command = plci->adjust_b_command;
13730 break;
13731 }
13732 }
13733 if (plci->adjust_b_mode & ADJUST_B_MODE_USER_CONNECT)
13734 {
13735 plci->adjust_b_restore = true;
13736 break;
13737 }
13738 plci->adjust_b_state = ADJUST_B_CONNECT_1;
13739 /* fall through */
13740 case ADJUST_B_CONNECT_1:
13741 if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT)
13742 {
13743 plci->internal_command = plci->adjust_b_command;
13744 if (plci_nl_busy(plci))
13745 break;
13746 nl_req_ncci(plci, N_CONNECT, 0);
13747 send_req(plci);
13748 plci->adjust_b_state = ADJUST_B_CONNECT_2;
13749 break;
13750 }
13751 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
13752 Rc = OK;
13753 /* fall through */
13754 case ADJUST_B_CONNECT_2:
13755 case ADJUST_B_CONNECT_3:
13756 case ADJUST_B_CONNECT_4:
13757 if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0))
13758 {
13759 dbug(1, dprintf("[%06lx] %s,%d: Adjust B connect failed %02x",
13760 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
13761 Info = _WRONG_STATE;
13762 break;
13763 }
13764 if (Rc == OK)
13765 {
13766 if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT)
13767 {
13768 get_ncci(plci, (byte)(Id >> 16), plci->adjust_b_ncci);
13769 Id = (Id & 0xffff) | (((dword)(plci->adjust_b_ncci)) << 16);
13770 }
13771 if (plci->adjust_b_state == ADJUST_B_CONNECT_2)
13772 plci->adjust_b_state = ADJUST_B_CONNECT_3;
13773 else if (plci->adjust_b_state == ADJUST_B_CONNECT_4)
13774 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
13775 }
13776 else if (Rc == 0)
13777 {
13778 if (plci->adjust_b_state == ADJUST_B_CONNECT_2)
13779 plci->adjust_b_state = ADJUST_B_CONNECT_4;
13780 else if (plci->adjust_b_state == ADJUST_B_CONNECT_3)
13781 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
13782 }
13783 if (plci->adjust_b_state != ADJUST_B_RESTORE_DTMF_1)
13784 {
13785 plci->internal_command = plci->adjust_b_command;
13786 break;
13787 }
13788 Rc = OK;
13789 /* fall through */
13790 case ADJUST_B_RESTORE_DTMF_1:
13791 case ADJUST_B_RESTORE_DTMF_2:
13792 if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13793 {
13794
13795 Info = dtmf_restore_config(Id, plci, Rc);
13796 if ((Info != GOOD) || plci->internal_command)
13797 break;
13798
13799 }
13800 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_1;
13801 Rc = OK;
13802 /* fall through */
13803 case ADJUST_B_RESTORE_MIXER_1:
13804 case ADJUST_B_RESTORE_MIXER_2:
13805 case ADJUST_B_RESTORE_MIXER_3:
13806 case ADJUST_B_RESTORE_MIXER_4:
13807 case ADJUST_B_RESTORE_MIXER_5:
13808 case ADJUST_B_RESTORE_MIXER_6:
13809 case ADJUST_B_RESTORE_MIXER_7:
13810 if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13811 {
13812
13813 Info = mixer_restore_config(Id, plci, Rc);
13814 if ((Info != GOOD) || plci->internal_command)
13815 break;
13816
13817 }
13818 plci->adjust_b_state = ADJUST_B_END;
13819 case ADJUST_B_END:
13820 break;
13821 }
13822 return (Info);
13823 }
13824
13825
13826 static void adjust_b1_resource(dword Id, PLCI *plci, API_SAVE *bp_msg, word b1_facilities, word internal_command)
13827 {
13828
13829 dbug(1, dprintf("[%06lx] %s,%d: adjust_b1_resource %d %04x",
13830 UnMapId(Id), (char *)(FILE_), __LINE__,
13831 plci->B1_resource, b1_facilities));
13832
13833 plci->adjust_b_parms_msg = bp_msg;
13834 plci->adjust_b_facilities = b1_facilities;
13835 plci->adjust_b_command = internal_command;
13836 plci->adjust_b_ncci = (word)(Id >> 16);
13837 if ((bp_msg == NULL) && (plci->B1_resource == 0))
13838 plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_NO_RESOURCE | ADJUST_B_MODE_SWITCH_L1;
13839 else
13840 plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_SWITCH_L1 | ADJUST_B_MODE_RESTORE;
13841 plci->adjust_b_state = ADJUST_B_START;
13842 dbug(1, dprintf("[%06lx] %s,%d: Adjust B1 resource %d %04x...",
13843 UnMapId(Id), (char *)(FILE_), __LINE__,
13844 plci->B1_resource, b1_facilities));
13845 }
13846
13847
13848 static void adjust_b_restore(dword Id, PLCI *plci, byte Rc)
13849 {
13850 word internal_command;
13851
13852 dbug(1, dprintf("[%06lx] %s,%d: adjust_b_restore %02x %04x",
13853 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
13854
13855 internal_command = plci->internal_command;
13856 plci->internal_command = 0;
13857 switch (internal_command)
13858 {
13859 default:
13860 plci->command = 0;
13861 if (plci->req_in != 0)
13862 {
13863 plci->internal_command = ADJUST_B_RESTORE_1;
13864 break;
13865 }
13866 Rc = OK;
13867 /* fall through */
13868 case ADJUST_B_RESTORE_1:
13869 if ((Rc != OK) && (Rc != OK_FC))
13870 {
13871 dbug(1, dprintf("[%06lx] %s,%d: Adjust B enqueued failed %02x",
13872 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
13873 }
13874 plci->adjust_b_parms_msg = NULL;
13875 plci->adjust_b_facilities = plci->B1_facilities;
13876 plci->adjust_b_command = ADJUST_B_RESTORE_2;
13877 plci->adjust_b_ncci = (word)(Id >> 16);
13878 plci->adjust_b_mode = ADJUST_B_MODE_RESTORE;
13879 plci->adjust_b_state = ADJUST_B_START;
13880 dbug(1, dprintf("[%06lx] %s,%d: Adjust B restore...",
13881 UnMapId(Id), (char *)(FILE_), __LINE__));
13882 /* fall through */
13883 case ADJUST_B_RESTORE_2:
13884 if (adjust_b_process(Id, plci, Rc) != GOOD)
13885 {
13886 dbug(1, dprintf("[%06lx] %s,%d: Adjust B restore failed",
13887 UnMapId(Id), (char *)(FILE_), __LINE__));
13888 }
13889 if (plci->internal_command)
13890 break;
13891 break;
13892 }
13893 }
13894
13895
13896 static void reset_b3_command(dword Id, PLCI *plci, byte Rc)
13897 {
13898 word Info;
13899 word internal_command;
13900
13901 dbug(1, dprintf("[%06lx] %s,%d: reset_b3_command %02x %04x",
13902 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
13903
13904 Info = GOOD;
13905 internal_command = plci->internal_command;
13906 plci->internal_command = 0;
13907 switch (internal_command)
13908 {
13909 default:
13910 plci->command = 0;
13911 plci->adjust_b_parms_msg = NULL;
13912 plci->adjust_b_facilities = plci->B1_facilities;
13913 plci->adjust_b_command = RESET_B3_COMMAND_1;
13914 plci->adjust_b_ncci = (word)(Id >> 16);
13915 plci->adjust_b_mode = ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_CONNECT;
13916 plci->adjust_b_state = ADJUST_B_START;
13917 dbug(1, dprintf("[%06lx] %s,%d: Reset B3...",
13918 UnMapId(Id), (char *)(FILE_), __LINE__));
13919 /* fall through */
13920 case RESET_B3_COMMAND_1:
13921 Info = adjust_b_process(Id, plci, Rc);
13922 if (Info != GOOD)
13923 {
13924 dbug(1, dprintf("[%06lx] %s,%d: Reset failed",
13925 UnMapId(Id), (char *)(FILE_), __LINE__));
13926 break;
13927 }
13928 if (plci->internal_command)
13929 return;
13930 break;
13931 }
13932 /* sendf (plci->appl, _RESET_B3_R | CONFIRM, Id, plci->number, "w", Info);*/
13933 sendf(plci->appl, _RESET_B3_I, Id, 0, "s", "");
13934 }
13935
13936
13937 static void select_b_command(dword Id, PLCI *plci, byte Rc)
13938 {
13939 word Info;
13940 word internal_command;
13941 byte esc_chi[3];
13942
13943 dbug(1, dprintf("[%06lx] %s,%d: select_b_command %02x %04x",
13944 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
13945
13946 Info = GOOD;
13947 internal_command = plci->internal_command;
13948 plci->internal_command = 0;
13949 switch (internal_command)
13950 {
13951 default:
13952 plci->command = 0;
13953 plci->adjust_b_parms_msg = &plci->saved_msg;
13954 if ((plci->tel == ADV_VOICE) && (plci == plci->adapter->AdvSignalPLCI))
13955 plci->adjust_b_facilities = plci->B1_facilities | B1_FACILITY_VOICE;
13956 else
13957 plci->adjust_b_facilities = plci->B1_facilities & ~B1_FACILITY_VOICE;
13958 plci->adjust_b_command = SELECT_B_COMMAND_1;
13959 plci->adjust_b_ncci = (word)(Id >> 16);
13960 if (plci->saved_msg.parms[0].length == 0)
13961 {
13962 plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_SWITCH_L1 |
13963 ADJUST_B_MODE_NO_RESOURCE;
13964 }
13965 else
13966 {
13967 plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_SWITCH_L1 |
13968 ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_USER_CONNECT | ADJUST_B_MODE_RESTORE;
13969 }
13970 plci->adjust_b_state = ADJUST_B_START;
13971 dbug(1, dprintf("[%06lx] %s,%d: Select B protocol...",
13972 UnMapId(Id), (char *)(FILE_), __LINE__));
13973 /* fall through */
13974 case SELECT_B_COMMAND_1:
13975 Info = adjust_b_process(Id, plci, Rc);
13976 if (Info != GOOD)
13977 {
13978 dbug(1, dprintf("[%06lx] %s,%d: Select B protocol failed",
13979 UnMapId(Id), (char *)(FILE_), __LINE__));
13980 break;
13981 }
13982 if (plci->internal_command)
13983 return;
13984 if (plci->tel == ADV_VOICE)
13985 {
13986 esc_chi[0] = 0x02;
13987 esc_chi[1] = 0x18;
13988 esc_chi[2] = plci->b_channel;
13989 SetVoiceChannel(plci->adapter->AdvCodecPLCI, esc_chi, plci->adapter);
13990 }
13991 break;
13992 }
13993 sendf(plci->appl, _SELECT_B_REQ | CONFIRM, Id, plci->number, "w", Info);
13994 }
13995
13996
13997 static void fax_connect_ack_command(dword Id, PLCI *plci, byte Rc)
13998 {
13999 word internal_command;
14000
14001 dbug(1, dprintf("[%06lx] %s,%d: fax_connect_ack_command %02x %04x",
14002 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14003
14004 internal_command = plci->internal_command;
14005 plci->internal_command = 0;
14006 switch (internal_command)
14007 {
14008 default:
14009 plci->command = 0; /* fall through */
14010 case FAX_CONNECT_ACK_COMMAND_1:
14011 if (plci_nl_busy(plci))
14012 {
14013 plci->internal_command = FAX_CONNECT_ACK_COMMAND_1;
14014 return;
14015 }
14016 plci->internal_command = FAX_CONNECT_ACK_COMMAND_2;
14017 plci->NData[0].P = plci->fax_connect_info_buffer;
14018 plci->NData[0].PLength = plci->fax_connect_info_length;
14019 plci->NL.X = plci->NData;
14020 plci->NL.ReqCh = 0;
14021 plci->NL.Req = plci->nl_req = (byte) N_CONNECT_ACK;
14022 plci->adapter->request(&plci->NL);
14023 return;
14024 case FAX_CONNECT_ACK_COMMAND_2:
14025 if ((Rc != OK) && (Rc != OK_FC))
14026 {
14027 dbug(1, dprintf("[%06lx] %s,%d: FAX issue CONNECT ACK failed %02x",
14028 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14029 break;
14030 }
14031 }
14032 if ((plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
14033 && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
14034 {
14035 if (plci->B3_prot == 4)
14036 sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
14037 else
14038 sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
14039 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
14040 }
14041 }
14042
14043
14044 static void fax_edata_ack_command(dword Id, PLCI *plci, byte Rc)
14045 {
14046 word internal_command;
14047
14048 dbug(1, dprintf("[%06lx] %s,%d: fax_edata_ack_command %02x %04x",
14049 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14050
14051 internal_command = plci->internal_command;
14052 plci->internal_command = 0;
14053 switch (internal_command)
14054 {
14055 default:
14056 plci->command = 0;
14057 /* fall through */
14058 case FAX_EDATA_ACK_COMMAND_1:
14059 if (plci_nl_busy(plci))
14060 {
14061 plci->internal_command = FAX_EDATA_ACK_COMMAND_1;
14062 return;
14063 }
14064 plci->internal_command = FAX_EDATA_ACK_COMMAND_2;
14065 plci->NData[0].P = plci->fax_connect_info_buffer;
14066 plci->NData[0].PLength = plci->fax_edata_ack_length;
14067 plci->NL.X = plci->NData;
14068 plci->NL.ReqCh = 0;
14069 plci->NL.Req = plci->nl_req = (byte) N_EDATA;
14070 plci->adapter->request(&plci->NL);
14071 return;
14072 case FAX_EDATA_ACK_COMMAND_2:
14073 if ((Rc != OK) && (Rc != OK_FC))
14074 {
14075 dbug(1, dprintf("[%06lx] %s,%d: FAX issue EDATA ACK failed %02x",
14076 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14077 break;
14078 }
14079 }
14080 }
14081
14082
14083 static void fax_connect_info_command(dword Id, PLCI *plci, byte Rc)
14084 {
14085 word Info;
14086 word internal_command;
14087
14088 dbug(1, dprintf("[%06lx] %s,%d: fax_connect_info_command %02x %04x",
14089 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14090
14091 Info = GOOD;
14092 internal_command = plci->internal_command;
14093 plci->internal_command = 0;
14094 switch (internal_command)
14095 {
14096 default:
14097 plci->command = 0; /* fall through */
14098 case FAX_CONNECT_INFO_COMMAND_1:
14099 if (plci_nl_busy(plci))
14100 {
14101 plci->internal_command = FAX_CONNECT_INFO_COMMAND_1;
14102 return;
14103 }
14104 plci->internal_command = FAX_CONNECT_INFO_COMMAND_2;
14105 plci->NData[0].P = plci->fax_connect_info_buffer;
14106 plci->NData[0].PLength = plci->fax_connect_info_length;
14107 plci->NL.X = plci->NData;
14108 plci->NL.ReqCh = 0;
14109 plci->NL.Req = plci->nl_req = (byte) N_EDATA;
14110 plci->adapter->request(&plci->NL);
14111 return;
14112 case FAX_CONNECT_INFO_COMMAND_2:
14113 if ((Rc != OK) && (Rc != OK_FC))
14114 {
14115 dbug(1, dprintf("[%06lx] %s,%d: FAX setting connect info failed %02x",
14116 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14117 Info = _WRONG_STATE;
14118 break;
14119 }
14120 if (plci_nl_busy(plci))
14121 {
14122 plci->internal_command = FAX_CONNECT_INFO_COMMAND_2;
14123 return;
14124 }
14125 plci->command = _CONNECT_B3_R;
14126 nl_req_ncci(plci, N_CONNECT, 0);
14127 send_req(plci);
14128 return;
14129 }
14130 sendf(plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info);
14131 }
14132
14133
14134 static void fax_adjust_b23_command(dword Id, PLCI *plci, byte Rc)
14135 {
14136 word Info;
14137 word internal_command;
14138
14139 dbug(1, dprintf("[%06lx] %s,%d: fax_adjust_b23_command %02x %04x",
14140 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14141
14142 Info = GOOD;
14143 internal_command = plci->internal_command;
14144 plci->internal_command = 0;
14145 switch (internal_command)
14146 {
14147 default:
14148 plci->command = 0;
14149 plci->adjust_b_parms_msg = NULL;
14150 plci->adjust_b_facilities = plci->B1_facilities;
14151 plci->adjust_b_command = FAX_ADJUST_B23_COMMAND_1;
14152 plci->adjust_b_ncci = (word)(Id >> 16);
14153 plci->adjust_b_mode = ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_ASSIGN_L23;
14154 plci->adjust_b_state = ADJUST_B_START;
14155 dbug(1, dprintf("[%06lx] %s,%d: FAX adjust B23...",
14156 UnMapId(Id), (char *)(FILE_), __LINE__));
14157 /* fall through */
14158 case FAX_ADJUST_B23_COMMAND_1:
14159 Info = adjust_b_process(Id, plci, Rc);
14160 if (Info != GOOD)
14161 {
14162 dbug(1, dprintf("[%06lx] %s,%d: FAX adjust failed",
14163 UnMapId(Id), (char *)(FILE_), __LINE__));
14164 break;
14165 }
14166 if (plci->internal_command)
14167 return;
14168 /* fall through */
14169 case FAX_ADJUST_B23_COMMAND_2:
14170 if (plci_nl_busy(plci))
14171 {
14172 plci->internal_command = FAX_ADJUST_B23_COMMAND_2;
14173 return;
14174 }
14175 plci->command = _CONNECT_B3_R;
14176 nl_req_ncci(plci, N_CONNECT, 0);
14177 send_req(plci);
14178 return;
14179 }
14180 sendf(plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info);
14181 }
14182
14183
14184 static void fax_disconnect_command(dword Id, PLCI *plci, byte Rc)
14185 {
14186 word internal_command;
14187
14188 dbug(1, dprintf("[%06lx] %s,%d: fax_disconnect_command %02x %04x",
14189 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14190
14191 internal_command = plci->internal_command;
14192 plci->internal_command = 0;
14193 switch (internal_command)
14194 {
14195 default:
14196 plci->command = 0;
14197 plci->internal_command = FAX_DISCONNECT_COMMAND_1;
14198 return;
14199 case FAX_DISCONNECT_COMMAND_1:
14200 case FAX_DISCONNECT_COMMAND_2:
14201 case FAX_DISCONNECT_COMMAND_3:
14202 if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0))
14203 {
14204 dbug(1, dprintf("[%06lx] %s,%d: FAX disconnect EDATA failed %02x",
14205 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14206 break;
14207 }
14208 if (Rc == OK)
14209 {
14210 if ((internal_command == FAX_DISCONNECT_COMMAND_1)
14211 || (internal_command == FAX_DISCONNECT_COMMAND_2))
14212 {
14213 plci->internal_command = FAX_DISCONNECT_COMMAND_2;
14214 }
14215 }
14216 else if (Rc == 0)
14217 {
14218 if (internal_command == FAX_DISCONNECT_COMMAND_1)
14219 plci->internal_command = FAX_DISCONNECT_COMMAND_3;
14220 }
14221 return;
14222 }
14223 }
14224
14225
14226
14227 static void rtp_connect_b3_req_command(dword Id, PLCI *plci, byte Rc)
14228 {
14229 word Info;
14230 word internal_command;
14231
14232 dbug(1, dprintf("[%06lx] %s,%d: rtp_connect_b3_req_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; /* fall through */
14242 case RTP_CONNECT_B3_REQ_COMMAND_1:
14243 if (plci_nl_busy(plci))
14244 {
14245 plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_1;
14246 return;
14247 }
14248 plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_2;
14249 nl_req_ncci(plci, N_CONNECT, 0);
14250 send_req(plci);
14251 return;
14252 case RTP_CONNECT_B3_REQ_COMMAND_2:
14253 if ((Rc != OK) && (Rc != OK_FC))
14254 {
14255 dbug(1, dprintf("[%06lx] %s,%d: RTP setting connect info failed %02x",
14256 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14257 Info = _WRONG_STATE;
14258 break;
14259 }
14260 if (plci_nl_busy(plci))
14261 {
14262 plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_2;
14263 return;
14264 }
14265 plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_3;
14266 plci->NData[0].PLength = plci->internal_req_buffer[0];
14267 plci->NData[0].P = plci->internal_req_buffer + 1;
14268 plci->NL.X = plci->NData;
14269 plci->NL.ReqCh = 0;
14270 plci->NL.Req = plci->nl_req = (byte) N_UDATA;
14271 plci->adapter->request(&plci->NL);
14272 break;
14273 case RTP_CONNECT_B3_REQ_COMMAND_3:
14274 return;
14275 }
14276 sendf(plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info);
14277 }
14278
14279
14280 static void rtp_connect_b3_res_command(dword Id, PLCI *plci, byte Rc)
14281 {
14282 word internal_command;
14283
14284 dbug(1, dprintf("[%06lx] %s,%d: rtp_connect_b3_res_command %02x %04x",
14285 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14286
14287 internal_command = plci->internal_command;
14288 plci->internal_command = 0;
14289 switch (internal_command)
14290 {
14291 default:
14292 plci->command = 0; /* fall through */
14293 case RTP_CONNECT_B3_RES_COMMAND_1:
14294 if (plci_nl_busy(plci))
14295 {
14296 plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_1;
14297 return;
14298 }
14299 plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_2;
14300 nl_req_ncci(plci, N_CONNECT_ACK, (byte)(Id >> 16));
14301 send_req(plci);
14302 return;
14303 case RTP_CONNECT_B3_RES_COMMAND_2:
14304 if ((Rc != OK) && (Rc != OK_FC))
14305 {
14306 dbug(1, dprintf("[%06lx] %s,%d: RTP setting connect resp info failed %02x",
14307 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14308 break;
14309 }
14310 if (plci_nl_busy(plci))
14311 {
14312 plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_2;
14313 return;
14314 }
14315 sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
14316 plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_3;
14317 plci->NData[0].PLength = plci->internal_req_buffer[0];
14318 plci->NData[0].P = plci->internal_req_buffer + 1;
14319 plci->NL.X = plci->NData;
14320 plci->NL.ReqCh = 0;
14321 plci->NL.Req = plci->nl_req = (byte) N_UDATA;
14322 plci->adapter->request(&plci->NL);
14323 return;
14324 case RTP_CONNECT_B3_RES_COMMAND_3:
14325 return;
14326 }
14327 }
14328
14329
14330
14331 static void hold_save_command(dword Id, PLCI *plci, byte Rc)
14332 {
14333 byte SS_Ind[] = "\x05\x02\x00\x02\x00\x00"; /* Hold_Ind struct*/
14334 word Info;
14335 word internal_command;
14336
14337 dbug(1, dprintf("[%06lx] %s,%d: hold_save_command %02x %04x",
14338 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14339
14340 Info = GOOD;
14341 internal_command = plci->internal_command;
14342 plci->internal_command = 0;
14343 switch (internal_command)
14344 {
14345 default:
14346 if (!plci->NL.Id)
14347 break;
14348 plci->command = 0;
14349 plci->adjust_b_parms_msg = NULL;
14350 plci->adjust_b_facilities = plci->B1_facilities;
14351 plci->adjust_b_command = HOLD_SAVE_COMMAND_1;
14352 plci->adjust_b_ncci = (word)(Id >> 16);
14353 plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23;
14354 plci->adjust_b_state = ADJUST_B_START;
14355 dbug(1, dprintf("[%06lx] %s,%d: HOLD save...",
14356 UnMapId(Id), (char *)(FILE_), __LINE__));
14357 /* fall through */
14358 case HOLD_SAVE_COMMAND_1:
14359 Info = adjust_b_process(Id, plci, Rc);
14360 if (Info != GOOD)
14361 {
14362 dbug(1, dprintf("[%06lx] %s,%d: HOLD save failed",
14363 UnMapId(Id), (char *)(FILE_), __LINE__));
14364 break;
14365 }
14366 if (plci->internal_command)
14367 return;
14368 }
14369 sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", 3, SS_Ind);
14370 }
14371
14372
14373 static void retrieve_restore_command(dword Id, PLCI *plci, byte Rc)
14374 {
14375 byte SS_Ind[] = "\x05\x03\x00\x02\x00\x00"; /* Retrieve_Ind struct*/
14376 word Info;
14377 word internal_command;
14378
14379 dbug(1, dprintf("[%06lx] %s,%d: retrieve_restore_command %02x %04x",
14380 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14381
14382 Info = GOOD;
14383 internal_command = plci->internal_command;
14384 plci->internal_command = 0;
14385 switch (internal_command)
14386 {
14387 default:
14388 plci->command = 0;
14389 plci->adjust_b_parms_msg = NULL;
14390 plci->adjust_b_facilities = plci->B1_facilities;
14391 plci->adjust_b_command = RETRIEVE_RESTORE_COMMAND_1;
14392 plci->adjust_b_ncci = (word)(Id >> 16);
14393 plci->adjust_b_mode = ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_USER_CONNECT | ADJUST_B_MODE_RESTORE;
14394 plci->adjust_b_state = ADJUST_B_START;
14395 dbug(1, dprintf("[%06lx] %s,%d: RETRIEVE restore...",
14396 UnMapId(Id), (char *)(FILE_), __LINE__));
14397 /* fall through */
14398 case RETRIEVE_RESTORE_COMMAND_1:
14399 Info = adjust_b_process(Id, plci, Rc);
14400 if (Info != GOOD)
14401 {
14402 dbug(1, dprintf("[%06lx] %s,%d: RETRIEVE restore failed",
14403 UnMapId(Id), (char *)(FILE_), __LINE__));
14404 break;
14405 }
14406 if (plci->internal_command)
14407 return;
14408 }
14409 sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", 3, SS_Ind);
14410 }
14411
14412
14413 static void init_b1_config(PLCI *plci)
14414 {
14415
14416 dbug(1, dprintf("[%06lx] %s,%d: init_b1_config",
14417 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
14418 (char *)(FILE_), __LINE__));
14419
14420 plci->B1_resource = 0;
14421 plci->B1_facilities = 0;
14422
14423 plci->li_bchannel_id = 0;
14424 mixer_clear_config(plci);
14425
14426
14427 ec_clear_config(plci);
14428
14429
14430 dtmf_rec_clear_config(plci);
14431 dtmf_send_clear_config(plci);
14432 dtmf_parameter_clear_config(plci);
14433
14434 adv_voice_clear_config(plci);
14435 adjust_b_clear(plci);
14436 }
14437
14438
14439 static void clear_b1_config(PLCI *plci)
14440 {
14441
14442 dbug(1, dprintf("[%06lx] %s,%d: clear_b1_config",
14443 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
14444 (char *)(FILE_), __LINE__));
14445
14446 adv_voice_clear_config(plci);
14447 adjust_b_clear(plci);
14448
14449 ec_clear_config(plci);
14450
14451
14452 dtmf_rec_clear_config(plci);
14453 dtmf_send_clear_config(plci);
14454 dtmf_parameter_clear_config(plci);
14455
14456
14457 if ((plci->li_bchannel_id != 0)
14458 && (li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci == plci))
14459 {
14460 mixer_clear_config(plci);
14461 li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci = NULL;
14462 plci->li_bchannel_id = 0;
14463 }
14464
14465 plci->B1_resource = 0;
14466 plci->B1_facilities = 0;
14467 }
14468
14469
14470 /* -----------------------------------------------------------------
14471 XON protocol local helpers
14472 ----------------------------------------------------------------- */
14473 static void channel_flow_control_remove(PLCI *plci) {
14474 DIVA_CAPI_ADAPTER *a = plci->adapter;
14475 word i;
14476 for (i = 1; i < MAX_NL_CHANNEL + 1; i++) {
14477 if (a->ch_flow_plci[i] == plci->Id) {
14478 a->ch_flow_plci[i] = 0;
14479 a->ch_flow_control[i] = 0;
14480 }
14481 }
14482 }
14483
14484 static void channel_x_on(PLCI *plci, byte ch) {
14485 DIVA_CAPI_ADAPTER *a = plci->adapter;
14486 if (a->ch_flow_control[ch] & N_XON_SENT) {
14487 a->ch_flow_control[ch] &= ~N_XON_SENT;
14488 }
14489 }
14490
14491 static void channel_x_off(PLCI *plci, byte ch, byte flag) {
14492 DIVA_CAPI_ADAPTER *a = plci->adapter;
14493 if ((a->ch_flow_control[ch] & N_RX_FLOW_CONTROL_MASK) == 0) {
14494 a->ch_flow_control[ch] |= (N_CH_XOFF | flag);
14495 a->ch_flow_plci[ch] = plci->Id;
14496 a->ch_flow_control_pending++;
14497 }
14498 }
14499
14500 static void channel_request_xon(PLCI *plci, byte ch) {
14501 DIVA_CAPI_ADAPTER *a = plci->adapter;
14502
14503 if (a->ch_flow_control[ch] & N_CH_XOFF) {
14504 a->ch_flow_control[ch] |= N_XON_REQ;
14505 a->ch_flow_control[ch] &= ~N_CH_XOFF;
14506 a->ch_flow_control[ch] &= ~N_XON_CONNECT_IND;
14507 }
14508 }
14509
14510 static void channel_xmit_extended_xon(PLCI *plci) {
14511 DIVA_CAPI_ADAPTER *a;
14512 int max_ch = ARRAY_SIZE(a->ch_flow_control);
14513 int i, one_requested = 0;
14514
14515 if ((!plci) || (!plci->Id) || ((a = plci->adapter) == NULL)) {
14516 return;
14517 }
14518
14519 for (i = 0; i < max_ch; i++) {
14520 if ((a->ch_flow_control[i] & N_CH_XOFF) &&
14521 (a->ch_flow_control[i] & N_XON_CONNECT_IND) &&
14522 (plci->Id == a->ch_flow_plci[i])) {
14523 channel_request_xon(plci, (byte)i);
14524 one_requested = 1;
14525 }
14526 }
14527
14528 if (one_requested) {
14529 channel_xmit_xon(plci);
14530 }
14531 }
14532
14533 /*
14534 Try to xmit next X_ON
14535 */
14536 static int find_channel_with_pending_x_on(DIVA_CAPI_ADAPTER *a, PLCI *plci) {
14537 int max_ch = ARRAY_SIZE(a->ch_flow_control);
14538 int i;
14539
14540 if (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL)) {
14541 return (0);
14542 }
14543
14544 if (a->last_flow_control_ch >= max_ch) {
14545 a->last_flow_control_ch = 1;
14546 }
14547 for (i = a->last_flow_control_ch; i < max_ch; i++) {
14548 if ((a->ch_flow_control[i] & N_XON_REQ) &&
14549 (plci->Id == a->ch_flow_plci[i])) {
14550 a->last_flow_control_ch = i + 1;
14551 return (i);
14552 }
14553 }
14554
14555 for (i = 1; i < a->last_flow_control_ch; i++) {
14556 if ((a->ch_flow_control[i] & N_XON_REQ) &&
14557 (plci->Id == a->ch_flow_plci[i])) {
14558 a->last_flow_control_ch = i + 1;
14559 return (i);
14560 }
14561 }
14562
14563 return (0);
14564 }
14565
14566 static void channel_xmit_xon(PLCI *plci) {
14567 DIVA_CAPI_ADAPTER *a = plci->adapter;
14568 byte ch;
14569
14570 if (plci->nl_req || !plci->NL.Id || plci->nl_remove_id) {
14571 return;
14572 }
14573 if ((ch = (byte)find_channel_with_pending_x_on(a, plci)) == 0) {
14574 return;
14575 }
14576 a->ch_flow_control[ch] &= ~N_XON_REQ;
14577 a->ch_flow_control[ch] |= N_XON_SENT;
14578
14579 plci->NL.Req = plci->nl_req = (byte)N_XON;
14580 plci->NL.ReqCh = ch;
14581 plci->NL.X = plci->NData;
14582 plci->NL.XNum = 1;
14583 plci->NData[0].P = &plci->RBuffer[0];
14584 plci->NData[0].PLength = 0;
14585
14586 plci->adapter->request(&plci->NL);
14587 }
14588
14589 static int channel_can_xon(PLCI *plci, byte ch) {
14590 APPL *APPLptr;
14591 DIVA_CAPI_ADAPTER *a;
14592 word NCCIcode;
14593 dword count;
14594 word Num;
14595 word i;
14596
14597 APPLptr = plci->appl;
14598 a = plci->adapter;
14599
14600 if (!APPLptr)
14601 return (0);
14602
14603 NCCIcode = a->ch_ncci[ch] | (((word) a->Id) << 8);
14604
14605 /* count all buffers within the Application pool */
14606 /* belonging to the same NCCI. XON if a first is */
14607 /* used. */
14608 count = 0;
14609 Num = 0xffff;
14610 for (i = 0; i < APPLptr->MaxBuffer; i++) {
14611 if (NCCIcode == APPLptr->DataNCCI[i]) count++;
14612 if (!APPLptr->DataNCCI[i] && Num == 0xffff) Num = i;
14613 }
14614 if ((count > 2) || (Num == 0xffff)) {
14615 return (0);
14616 }
14617 return (1);
14618 }
14619
14620
14621 /*------------------------------------------------------------------*/
14622
14623 static word CPN_filter_ok(byte *cpn, DIVA_CAPI_ADAPTER *a, word offset)
14624 {
14625 return 1;
14626 }
14627
14628
14629
14630 /**********************************************************************************/
14631 /* function groups the listening applications according to the CIP mask and the */
14632 /* Info_Mask. Each group gets just one Connect_Ind. Some application manufacturer */
14633 /* are not multi-instance capable, so they start e.g. 30 applications what causes */
14634 /* big problems on application level (one call, 30 Connect_Ind, ect). The */
14635 /* function must be enabled by setting "a->group_optimization_enabled" from the */
14636 /* OS specific part (per adapter). */
14637 /**********************************************************************************/
14638 static void group_optimization(DIVA_CAPI_ADAPTER *a, PLCI *plci)
14639 {
14640 word i, j, k, busy, group_found;
14641 dword info_mask_group[MAX_CIP_TYPES];
14642 dword cip_mask_group[MAX_CIP_TYPES];
14643 word appl_number_group_type[MAX_APPL];
14644 PLCI *auxplci;
14645
14646 /* all APPLs within this inc. call are allowed to dial in */
14647 bitmap_fill(plci->group_optimization_mask_table, MAX_APPL);
14648
14649 if (!a->group_optimization_enabled)
14650 {
14651 dbug(1, dprintf("No group optimization"));
14652 return;
14653 }
14654
14655 dbug(1, dprintf("Group optimization = 0x%x...", a->group_optimization_enabled));
14656
14657 for (i = 0; i < MAX_CIP_TYPES; i++)
14658 {
14659 info_mask_group[i] = 0;
14660 cip_mask_group[i] = 0;
14661 }
14662 for (i = 0; i < MAX_APPL; i++)
14663 {
14664 appl_number_group_type[i] = 0;
14665 }
14666 for (i = 0; i < max_appl; i++) /* check if any multi instance capable application is present */
14667 { /* group_optimization set to 1 means not to optimize multi-instance capable applications (default) */
14668 if (application[i].Id && (application[i].MaxNCCI) > 1 && (a->CIP_Mask[i]) && (a->group_optimization_enabled == 1))
14669 {
14670 dbug(1, dprintf("Multi-Instance capable, no optimization required"));
14671 return; /* allow good application unfiltered access */
14672 }
14673 }
14674 for (i = 0; i < max_appl; i++) /* Build CIP Groups */
14675 {
14676 if (application[i].Id && a->CIP_Mask[i])
14677 {
14678 for (k = 0, busy = false; k < a->max_plci; k++)
14679 {
14680 if (a->plci[k].Id)
14681 {
14682 auxplci = &a->plci[k];
14683 if (auxplci->appl == &application[i]) {
14684 /* application has a busy PLCI */
14685 busy = true;
14686 dbug(1, dprintf("Appl 0x%x is busy", i + 1));
14687 } else if (test_bit(i, plci->c_ind_mask_table)) {
14688 /* application has an incoming call pending */
14689 busy = true;
14690 dbug(1, dprintf("Appl 0x%x has inc. call pending", i + 1));
14691 }
14692 }
14693 }
14694
14695 for (j = 0, group_found = 0; j <= (MAX_CIP_TYPES) && !busy && !group_found; j++) /* build groups with free applications only */
14696 {
14697 if (j == MAX_CIP_TYPES) /* all groups are in use but group still not found */
14698 { /* the MAX_CIP_TYPES group enables all calls because of field overflow */
14699 appl_number_group_type[i] = MAX_CIP_TYPES;
14700 group_found = true;
14701 dbug(1, dprintf("Field overflow appl 0x%x", i + 1));
14702 }
14703 else if ((info_mask_group[j] == a->CIP_Mask[i]) && (cip_mask_group[j] == a->Info_Mask[i]))
14704 { /* is group already present ? */
14705 appl_number_group_type[i] = j | 0x80; /* store the group number for each application */
14706 group_found = true;
14707 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]));
14708 }
14709 else if (!info_mask_group[j])
14710 { /* establish a new group */
14711 appl_number_group_type[i] = j | 0x80; /* store the group number for each application */
14712 info_mask_group[j] = a->CIP_Mask[i]; /* store the new CIP mask for the new group */
14713 cip_mask_group[j] = a->Info_Mask[i]; /* store the new Info_Mask for this new group */
14714 group_found = true;
14715 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]));
14716 }
14717 }
14718 }
14719 }
14720
14721 for (i = 0; i < max_appl; i++) /* Build group_optimization_mask_table */
14722 {
14723 if (appl_number_group_type[i]) /* application is free, has listens and is member of a group */
14724 {
14725 if (appl_number_group_type[i] == MAX_CIP_TYPES)
14726 {
14727 dbug(1, dprintf("OverflowGroup 0x%x, valid appl = 0x%x, call enabled", appl_number_group_type[i], i + 1));
14728 }
14729 else
14730 {
14731 dbug(1, dprintf("Group 0x%x, valid appl = 0x%x", appl_number_group_type[i], i + 1));
14732 for (j = i + 1; j < max_appl; j++) /* search other group members and mark them as busy */
14733 {
14734 if (appl_number_group_type[i] == appl_number_group_type[j])
14735 {
14736 dbug(1, dprintf("Appl 0x%x is member of group 0x%x, no call", j + 1, appl_number_group_type[j]));
14737 /* disable call on other group members */
14738 __clear_bit(j, plci->group_optimization_mask_table);
14739 appl_number_group_type[j] = 0; /* remove disabled group member from group list */
14740 }
14741 }
14742 }
14743 }
14744 else /* application should not get a call */
14745 {
14746 __clear_bit(i, plci->group_optimization_mask_table);
14747 }
14748 }
14749
14750 }
14751
14752
14753
14754 /* OS notifies the driver about a application Capi_Register */
14755 word CapiRegister(word id)
14756 {
14757 word i, j, appls_found;
14758
14759 PLCI *plci;
14760 DIVA_CAPI_ADAPTER *a;
14761
14762 for (i = 0, appls_found = 0; i < max_appl; i++)
14763 {
14764 if (application[i].Id && (application[i].Id != id))
14765 {
14766 appls_found++; /* an application has been found */
14767 }
14768 }
14769
14770 if (appls_found) return true;
14771 for (i = 0; i < max_adapter; i++) /* scan all adapters... */
14772 {
14773 a = &adapter[i];
14774 if (a->request)
14775 {
14776 if (a->flag_dynamic_l1_down) /* remove adapter from L1 tristate (Huntgroup) */
14777 {
14778 if (!appls_found) /* first application does a capi register */
14779 {
14780 if ((j = get_plci(a))) /* activate L1 of all adapters */
14781 {
14782 plci = &a->plci[j - 1];
14783 plci->command = 0;
14784 add_p(plci, OAD, "\x01\xfd");
14785 add_p(plci, CAI, "\x01\x80");
14786 add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
14787 add_p(plci, SHIFT | 6, NULL);
14788 add_p(plci, SIN, "\x02\x00\x00");
14789 plci->internal_command = START_L1_SIG_ASSIGN_PEND;
14790 sig_req(plci, ASSIGN, DSIG_ID);
14791 add_p(plci, FTY, "\x02\xff\x07"); /* l1 start */
14792 sig_req(plci, SIG_CTRL, 0);
14793 send_req(plci);
14794 }
14795 }
14796 }
14797 }
14798 }
14799 return false;
14800 }
14801
14802 /*------------------------------------------------------------------*/
14803
14804 /* Functions for virtual Switching e.g. Transfer by join, Conference */
14805
14806 static void VSwitchReqInd(PLCI *plci, dword Id, byte **parms)
14807 {
14808 word i;
14809 /* Format of vswitch_t:
14810 0 byte length
14811 1 byte VSWITCHIE
14812 2 byte VSWITCH_REQ/VSWITCH_IND
14813 3 byte reserved
14814 4 word VSwitchcommand
14815 6 word returnerror
14816 8... Params
14817 */
14818 if (!plci ||
14819 !plci->appl ||
14820 !plci->State ||
14821 plci->Sig.Ind == NCR_FACILITY
14822 )
14823 return;
14824
14825 for (i = 0; i < MAX_MULTI_IE; i++)
14826 {
14827 if (!parms[i][0]) continue;
14828 if (parms[i][0] < 7)
14829 {
14830 parms[i][0] = 0; /* kill it */
14831 continue;
14832 }
14833 dbug(1, dprintf("VSwitchReqInd(%d)", parms[i][4]));
14834 switch (parms[i][4])
14835 {
14836 case VSJOIN:
14837 if (!plci->relatedPTYPLCI ||
14838 (plci->ptyState != S_ECT && plci->relatedPTYPLCI->ptyState != S_ECT))
14839 { /* Error */
14840 break;
14841 }
14842 /* remember all necessary informations */
14843 if (parms[i][0] != 11 || parms[i][8] != 3) /* Length Test */
14844 {
14845 break;
14846 }
14847 if (parms[i][2] == VSWITCH_IND && parms[i][9] == 1)
14848 { /* first indication after ECT-Request on Consultation Call */
14849 plci->vswitchstate = parms[i][9];
14850 parms[i][9] = 2; /* State */
14851 /* now ask first Call to join */
14852 }
14853 else if (parms[i][2] == VSWITCH_REQ && parms[i][9] == 3)
14854 { /* Answer of VSWITCH_REQ from first Call */
14855 plci->vswitchstate = parms[i][9];
14856 /* tell consultation call to join
14857 and the protocol capabilities of the first call */
14858 }
14859 else
14860 { /* Error */
14861 break;
14862 }
14863 plci->vsprot = parms[i][10]; /* protocol */
14864 plci->vsprotdialect = parms[i][11]; /* protocoldialect */
14865 /* send join request to related PLCI */
14866 parms[i][1] = VSWITCHIE;
14867 parms[i][2] = VSWITCH_REQ;
14868
14869 plci->relatedPTYPLCI->command = 0;
14870 plci->relatedPTYPLCI->internal_command = VSWITCH_REQ_PEND;
14871 add_p(plci->relatedPTYPLCI, ESC, &parms[i][0]);
14872 sig_req(plci->relatedPTYPLCI, VSWITCH_REQ, 0);
14873 send_req(plci->relatedPTYPLCI);
14874 break;
14875 case VSTRANSPORT:
14876 default:
14877 if (plci->relatedPTYPLCI &&
14878 plci->vswitchstate == 3 &&
14879 plci->relatedPTYPLCI->vswitchstate == 3)
14880 {
14881 add_p(plci->relatedPTYPLCI, ESC, &parms[i][0]);
14882 sig_req(plci->relatedPTYPLCI, VSWITCH_REQ, 0);
14883 send_req(plci->relatedPTYPLCI);
14884 }
14885 break;
14886 }
14887 parms[i][0] = 0; /* kill it */
14888 }
14889 }
14890
14891
14892 /*------------------------------------------------------------------*/
14893
14894 static int diva_get_dma_descriptor(PLCI *plci, dword *dma_magic) {
14895 ENTITY e;
14896 IDI_SYNC_REQ *pReq = (IDI_SYNC_REQ *)&e;
14897
14898 if (!(diva_xdi_extended_features & DIVA_CAPI_XDI_PROVIDES_RX_DMA)) {
14899 return (-1);
14900 }
14901
14902 pReq->xdi_dma_descriptor_operation.Req = 0;
14903 pReq->xdi_dma_descriptor_operation.Rc = IDI_SYNC_REQ_DMA_DESCRIPTOR_OPERATION;
14904
14905 pReq->xdi_dma_descriptor_operation.info.operation = IDI_SYNC_REQ_DMA_DESCRIPTOR_ALLOC;
14906 pReq->xdi_dma_descriptor_operation.info.descriptor_number = -1;
14907 pReq->xdi_dma_descriptor_operation.info.descriptor_address = NULL;
14908 pReq->xdi_dma_descriptor_operation.info.descriptor_magic = 0;
14909
14910 e.user[0] = plci->adapter->Id - 1;
14911 plci->adapter->request((ENTITY *)pReq);
14912
14913 if (!pReq->xdi_dma_descriptor_operation.info.operation &&
14914 (pReq->xdi_dma_descriptor_operation.info.descriptor_number >= 0) &&
14915 pReq->xdi_dma_descriptor_operation.info.descriptor_magic) {
14916 *dma_magic = pReq->xdi_dma_descriptor_operation.info.descriptor_magic;
14917 dbug(3, dprintf("dma_alloc, a:%d (%d-%08x)",
14918 plci->adapter->Id,
14919 pReq->xdi_dma_descriptor_operation.info.descriptor_number,
14920 *dma_magic));
14921 return (pReq->xdi_dma_descriptor_operation.info.descriptor_number);
14922 } else {
14923 dbug(1, dprintf("dma_alloc failed"));
14924 return (-1);
14925 }
14926 }
14927
14928 static void diva_free_dma_descriptor(PLCI *plci, int nr) {
14929 ENTITY e;
14930 IDI_SYNC_REQ *pReq = (IDI_SYNC_REQ *)&e;
14931
14932 if (nr < 0) {
14933 return;
14934 }
14935
14936 pReq->xdi_dma_descriptor_operation.Req = 0;
14937 pReq->xdi_dma_descriptor_operation.Rc = IDI_SYNC_REQ_DMA_DESCRIPTOR_OPERATION;
14938
14939 pReq->xdi_dma_descriptor_operation.info.operation = IDI_SYNC_REQ_DMA_DESCRIPTOR_FREE;
14940 pReq->xdi_dma_descriptor_operation.info.descriptor_number = nr;
14941 pReq->xdi_dma_descriptor_operation.info.descriptor_address = NULL;
14942 pReq->xdi_dma_descriptor_operation.info.descriptor_magic = 0;
14943
14944 e.user[0] = plci->adapter->Id - 1;
14945 plci->adapter->request((ENTITY *)pReq);
14946
14947 if (!pReq->xdi_dma_descriptor_operation.info.operation) {
14948 dbug(1, dprintf("dma_free(%d)", nr));
14949 } else {
14950 dbug(1, dprintf("dma_free failed (%d)", nr));
14951 }
14952 }
14953
14954 /*------------------------------------------------------------------*/
CRIS linux kernel tree