?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jmorris...
[linux/fpc-iii.git] / drivers / isdn / hardware / eicon / message.c
bloba82e542ffc21dd4dccf9d1b810ab9373984c1d0d
1 /*
2 *
3 Copyright (c) Eicon Networks, 2002.
4 *
5 This source file is supplied for the use with
6 Eicon Networks range of DIVA Server Adapters.
7 *
8 Eicon File Revision : 2.1
9 *
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2, or (at your option)
13 any later version.
14 *
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY OF ANY KIND WHATSOEVER INCLUDING ANY
17 implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
18 See the GNU General Public License for more details.
19 *
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 *
24 */
25
26
27
28
29
30 #include "platform.h"
31 #include "di_defs.h"
32 #include "pc.h"
33 #include "capi20.h"
34 #include "divacapi.h"
35 #include "mdm_msg.h"
36 #include "divasync.h"
37
38
39
40 #define FILE_ "MESSAGE.C"
41 #define dprintf
42
43
44
45
46
47
48
49
50
51 /*------------------------------------------------------------------*/
52 /* This is options supported for all adapters that are server by */
53 /* XDI driver. Allo it is not necessary to ask it from every adapter*/
54 /* and it is not necessary to save it separate for every adapter */
55 /* Macrose defined here have only local meaning */
56 /*------------------------------------------------------------------*/
57 static dword diva_xdi_extended_features = 0;
58
59 #define DIVA_CAPI_USE_CMA 0x00000001
60 #define DIVA_CAPI_XDI_PROVIDES_SDRAM_BAR 0x00000002
61 #define DIVA_CAPI_XDI_PROVIDES_NO_CANCEL 0x00000004
62 #define DIVA_CAPI_XDI_PROVIDES_RX_DMA 0x00000008
63
64 /*
65 CAPI can request to process all return codes self only if:
66 protocol code supports this && xdi supports this
67 */
68 #define DIVA_CAPI_SUPPORTS_NO_CANCEL(__a__) (((__a__)->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL) && ((__a__)->manufacturer_features & MANUFACTURER_FEATURE_OK_FC_LABEL) && (diva_xdi_extended_features & DIVA_CAPI_XDI_PROVIDES_NO_CANCEL))
69
70 /*------------------------------------------------------------------*/
71 /* local function prototypes */
72 /*------------------------------------------------------------------*/
73
74 static void group_optimization(DIVA_CAPI_ADAPTER *a, PLCI *plci);
75 static void set_group_ind_mask(PLCI *plci);
76 static void clear_group_ind_mask_bit(PLCI *plci, word b);
77 static byte test_group_ind_mask_bit(PLCI *plci, word b);
78 void AutomaticLaw(DIVA_CAPI_ADAPTER *);
79 word CapiRelease(word);
80 word CapiRegister(word);
81 word api_put(APPL *, CAPI_MSG *);
82 static word api_parse(byte *, word, byte *, API_PARSE *);
83 static void api_save_msg(API_PARSE *in, byte *format, API_SAVE *out);
84 static void api_load_msg(API_SAVE *in, API_PARSE *out);
85
86 word api_remove_start(void);
87 void api_remove_complete(void);
88
89 static void plci_remove(PLCI *);
90 static void diva_get_extended_adapter_features(DIVA_CAPI_ADAPTER *a);
91 static void diva_ask_for_xdi_sdram_bar(DIVA_CAPI_ADAPTER *, IDI_SYNC_REQ *);
92
93 void callback(ENTITY *);
94
95 static void control_rc(PLCI *, byte, byte, byte, byte, byte);
96 static void data_rc(PLCI *, byte);
97 static void data_ack(PLCI *, byte);
98 static void sig_ind(PLCI *);
99 static void SendInfo(PLCI *, dword, byte **, byte);
100 static void SendSetupInfo(APPL *, PLCI *, dword, byte **, byte);
101 static void SendSSExtInd(APPL *, PLCI *plci, dword Id, byte **parms);
102
103 static void VSwitchReqInd(PLCI *plci, dword Id, byte **parms);
104
105 static void nl_ind(PLCI *);
106
107 static byte connect_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
108 static byte connect_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
109 static byte connect_a_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
110 static byte disconnect_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
111 static byte disconnect_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
112 static byte listen_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
113 static byte info_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
114 static byte info_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
115 static byte alert_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
116 static byte facility_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
117 static byte facility_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
118 static byte connect_b3_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
119 static byte connect_b3_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
120 static byte connect_b3_a_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
121 static byte disconnect_b3_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
122 static byte disconnect_b3_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
123 static byte data_b3_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
124 static byte data_b3_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
125 static byte reset_b3_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
126 static byte reset_b3_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
127 static byte connect_b3_t90_a_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
128 static byte select_b_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
129 static byte manufacturer_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
130 static byte manufacturer_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
131
132 static word get_plci(DIVA_CAPI_ADAPTER *);
133 static void add_p(PLCI *, byte, byte *);
134 static void add_s(PLCI *plci, byte code, API_PARSE *p);
135 static void add_ss(PLCI *plci, byte code, API_PARSE *p);
136 static void add_ie(PLCI *plci, byte code, byte *p, word p_length);
137 static void add_d(PLCI *, word, byte *);
138 static void add_ai(PLCI *, API_PARSE *);
139 static word add_b1(PLCI *, API_PARSE *, word, word);
140 static word add_b23(PLCI *, API_PARSE *);
141 static word add_modem_b23(PLCI *plci, API_PARSE *bp_parms);
142 static void sig_req(PLCI *, byte, byte);
143 static void nl_req_ncci(PLCI *, byte, byte);
144 static void send_req(PLCI *);
145 static void send_data(PLCI *);
146 static word plci_remove_check(PLCI *);
147 static void listen_check(DIVA_CAPI_ADAPTER *);
148 static byte AddInfo(byte **, byte **, byte *, byte *);
149 static byte getChannel(API_PARSE *);
150 static void IndParse(PLCI *, word *, byte **, byte);
151 static byte ie_compare(byte *, byte *);
152 static word find_cip(DIVA_CAPI_ADAPTER *, byte *, byte *);
153 static word CPN_filter_ok(byte *cpn, DIVA_CAPI_ADAPTER *, word);
154
155 /*
156 XON protocol helpers
157 */
158 static void channel_flow_control_remove(PLCI *plci);
159 static void channel_x_off(PLCI *plci, byte ch, byte flag);
160 static void channel_x_on(PLCI *plci, byte ch);
161 static void channel_request_xon(PLCI *plci, byte ch);
162 static void channel_xmit_xon(PLCI *plci);
163 static int channel_can_xon(PLCI *plci, byte ch);
164 static void channel_xmit_extended_xon(PLCI *plci);
165
166 static byte SendMultiIE(PLCI *plci, dword Id, byte **parms, byte ie_type, dword info_mask, byte setupParse);
167 static word AdvCodecSupport(DIVA_CAPI_ADAPTER *, PLCI *, APPL *, byte);
168 static void CodecIdCheck(DIVA_CAPI_ADAPTER *, PLCI *);
169 static void SetVoiceChannel(PLCI *, byte *, DIVA_CAPI_ADAPTER *);
170 static void VoiceChannelOff(PLCI *plci);
171 static void adv_voice_write_coefs(PLCI *plci, word write_command);
172 static void adv_voice_clear_config(PLCI *plci);
173
174 static word get_b1_facilities(PLCI *plci, byte b1_resource);
175 static byte add_b1_facilities(PLCI *plci, byte b1_resource, word b1_facilities);
176 static void adjust_b1_facilities(PLCI *plci, byte new_b1_resource, word new_b1_facilities);
177 static word adjust_b_process(dword Id, PLCI *plci, byte Rc);
178 static void adjust_b1_resource(dword Id, PLCI *plci, API_SAVE *bp_msg, word b1_facilities, word internal_command);
179 static void adjust_b_restore(dword Id, PLCI *plci, byte Rc);
180 static void reset_b3_command(dword Id, PLCI *plci, byte Rc);
181 static void select_b_command(dword Id, PLCI *plci, byte Rc);
182 static void fax_connect_ack_command(dword Id, PLCI *plci, byte Rc);
183 static void fax_edata_ack_command(dword Id, PLCI *plci, byte Rc);
184 static void fax_connect_info_command(dword Id, PLCI *plci, byte Rc);
185 static void fax_adjust_b23_command(dword Id, PLCI *plci, byte Rc);
186 static void fax_disconnect_command(dword Id, PLCI *plci, byte Rc);
187 static void hold_save_command(dword Id, PLCI *plci, byte Rc);
188 static void retrieve_restore_command(dword Id, PLCI *plci, byte Rc);
189 static void init_b1_config(PLCI *plci);
190 static void clear_b1_config(PLCI *plci);
191
192 static void dtmf_command(dword Id, PLCI *plci, byte Rc);
193 static byte dtmf_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg);
194 static void dtmf_confirmation(dword Id, PLCI *plci);
195 static void dtmf_indication(dword Id, PLCI *plci, byte *msg, word length);
196 static void dtmf_parameter_write(PLCI *plci);
197
198
199 static void mixer_set_bchannel_id_esc(PLCI *plci, byte bchannel_id);
200 static void mixer_set_bchannel_id(PLCI *plci, byte *chi);
201 static void mixer_clear_config(PLCI *plci);
202 static void mixer_notify_update(PLCI *plci, byte others);
203 static void mixer_command(dword Id, PLCI *plci, byte Rc);
204 static byte mixer_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg);
205 static void mixer_indication_coefs_set(dword Id, PLCI *plci);
206 static void mixer_indication_xconnect_from(dword Id, PLCI *plci, byte *msg, word length);
207 static void mixer_indication_xconnect_to(dword Id, PLCI *plci, byte *msg, word length);
208 static void mixer_remove(PLCI *plci);
209
210
211 static void ec_command(dword Id, PLCI *plci, byte Rc);
212 static byte ec_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg);
213 static void ec_indication(dword Id, PLCI *plci, byte *msg, word length);
214
215
216 static void rtp_connect_b3_req_command(dword Id, PLCI *plci, byte Rc);
217 static void rtp_connect_b3_res_command(dword Id, PLCI *plci, byte Rc);
218
219
220 static int diva_get_dma_descriptor(PLCI *plci, dword *dma_magic);
221 static void diva_free_dma_descriptor(PLCI *plci, int nr);
222
223 /*------------------------------------------------------------------*/
224 /* external function prototypes */
225 /*------------------------------------------------------------------*/
226
227 extern byte MapController(byte);
228 extern byte UnMapController(byte);
229 #define MapId(Id)(((Id) & 0xffffff00L) | MapController((byte)(Id)))
230 #define UnMapId(Id)(((Id) & 0xffffff00L) | UnMapController((byte)(Id)))
231
232 void sendf(APPL *, word, dword, word, byte *, ...);
233 void *TransmitBufferSet(APPL *appl, dword ref);
234 void *TransmitBufferGet(APPL *appl, void *p);
235 void TransmitBufferFree(APPL *appl, void *p);
236 void *ReceiveBufferGet(APPL *appl, int Num);
237
238 int fax_head_line_time(char *buffer);
239
240
241 /*------------------------------------------------------------------*/
242 /* Global data definitions */
243 /*------------------------------------------------------------------*/
244 extern byte max_adapter;
245 extern byte max_appl;
246 extern DIVA_CAPI_ADAPTER *adapter;
247 extern APPL *application;
248
249
250
251
252
253
254
255 static byte remove_started = false;
256 static PLCI dummy_plci;
257
258
259 static struct _ftable {
260 word command;
261 byte *format;
262 byte (*function)(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
263 } ftable[] = {
264 {_DATA_B3_R, "dwww", data_b3_req},
265 {_DATA_B3_I | RESPONSE, "w", data_b3_res},
266 {_INFO_R, "ss", info_req},
267 {_INFO_I | RESPONSE, "", info_res},
268 {_CONNECT_R, "wsssssssss", connect_req},
269 {_CONNECT_I | RESPONSE, "wsssss", connect_res},
270 {_CONNECT_ACTIVE_I | RESPONSE, "", connect_a_res},
271 {_DISCONNECT_R, "s", disconnect_req},
272 {_DISCONNECT_I | RESPONSE, "", disconnect_res},
273 {_LISTEN_R, "dddss", listen_req},
274 {_ALERT_R, "s", alert_req},
275 {_FACILITY_R, "ws", facility_req},
276 {_FACILITY_I | RESPONSE, "ws", facility_res},
277 {_CONNECT_B3_R, "s", connect_b3_req},
278 {_CONNECT_B3_I | RESPONSE, "ws", connect_b3_res},
279 {_CONNECT_B3_ACTIVE_I | RESPONSE, "", connect_b3_a_res},
280 {_DISCONNECT_B3_R, "s", disconnect_b3_req},
281 {_DISCONNECT_B3_I | RESPONSE, "", disconnect_b3_res},
282 {_RESET_B3_R, "s", reset_b3_req},
283 {_RESET_B3_I | RESPONSE, "", reset_b3_res},
284 {_CONNECT_B3_T90_ACTIVE_I | RESPONSE, "ws", connect_b3_t90_a_res},
285 {_CONNECT_B3_T90_ACTIVE_I | RESPONSE, "", connect_b3_t90_a_res},
286 {_SELECT_B_REQ, "s", select_b_req},
287 {_MANUFACTURER_R, "dws", manufacturer_req},
288 {_MANUFACTURER_I | RESPONSE, "dws", manufacturer_res},
289 {_MANUFACTURER_I | RESPONSE, "", manufacturer_res}
290 };
291
292 static byte *cip_bc[29][2] = {
293 { "", "" }, /* 0 */
294 { "\x03\x80\x90\xa3", "\x03\x80\x90\xa2" }, /* 1 */
295 { "\x02\x88\x90", "\x02\x88\x90" }, /* 2 */
296 { "\x02\x89\x90", "\x02\x89\x90" }, /* 3 */
297 { "\x03\x90\x90\xa3", "\x03\x90\x90\xa2" }, /* 4 */
298 { "\x03\x91\x90\xa5", "\x03\x91\x90\xa5" }, /* 5 */
299 { "\x02\x98\x90", "\x02\x98\x90" }, /* 6 */
300 { "\x04\x88\xc0\xc6\xe6", "\x04\x88\xc0\xc6\xe6" }, /* 7 */
301 { "\x04\x88\x90\x21\x8f", "\x04\x88\x90\x21\x8f" }, /* 8 */
302 { "\x03\x91\x90\xa5", "\x03\x91\x90\xa5" }, /* 9 */
303 { "", "" }, /* 10 */
304 { "", "" }, /* 11 */
305 { "", "" }, /* 12 */
306 { "", "" }, /* 13 */
307 { "", "" }, /* 14 */
308 { "", "" }, /* 15 */
309
310 { "\x03\x80\x90\xa3", "\x03\x80\x90\xa2" }, /* 16 */
311 { "\x03\x90\x90\xa3", "\x03\x90\x90\xa2" }, /* 17 */
312 { "\x02\x88\x90", "\x02\x88\x90" }, /* 18 */
313 { "\x02\x88\x90", "\x02\x88\x90" }, /* 19 */
314 { "\x02\x88\x90", "\x02\x88\x90" }, /* 20 */
315 { "\x02\x88\x90", "\x02\x88\x90" }, /* 21 */
316 { "\x02\x88\x90", "\x02\x88\x90" }, /* 22 */
317 { "\x02\x88\x90", "\x02\x88\x90" }, /* 23 */
318 { "\x02\x88\x90", "\x02\x88\x90" }, /* 24 */
319 { "\x02\x88\x90", "\x02\x88\x90" }, /* 25 */
320 { "\x03\x91\x90\xa5", "\x03\x91\x90\xa5" }, /* 26 */
321 { "\x03\x91\x90\xa5", "\x03\x91\x90\xa5" }, /* 27 */
322 { "\x02\x88\x90", "\x02\x88\x90" } /* 28 */
323 };
324
325 static byte *cip_hlc[29] = {
326 "", /* 0 */
327 "", /* 1 */
328 "", /* 2 */
329 "", /* 3 */
330 "", /* 4 */
331 "", /* 5 */
332 "", /* 6 */
333 "", /* 7 */
334 "", /* 8 */
335 "", /* 9 */
336 "", /* 10 */
337 "", /* 11 */
338 "", /* 12 */
339 "", /* 13 */
340 "", /* 14 */
341 "", /* 15 */
342
343 "\x02\x91\x81", /* 16 */
344 "\x02\x91\x84", /* 17 */
345 "\x02\x91\xa1", /* 18 */
346 "\x02\x91\xa4", /* 19 */
347 "\x02\x91\xa8", /* 20 */
348 "\x02\x91\xb1", /* 21 */
349 "\x02\x91\xb2", /* 22 */
350 "\x02\x91\xb5", /* 23 */
351 "\x02\x91\xb8", /* 24 */
352 "\x02\x91\xc1", /* 25 */
353 "\x02\x91\x81", /* 26 */
354 "\x03\x91\xe0\x01", /* 27 */
355 "\x03\x91\xe0\x02" /* 28 */
356 };
357
358 /*------------------------------------------------------------------*/
359
360 #define V120_HEADER_LENGTH 1
361 #define V120_HEADER_EXTEND_BIT 0x80
362 #define V120_HEADER_BREAK_BIT 0x40
363 #define V120_HEADER_C1_BIT 0x04
364 #define V120_HEADER_C2_BIT 0x08
365 #define V120_HEADER_FLUSH_COND (V120_HEADER_BREAK_BIT | V120_HEADER_C1_BIT | V120_HEADER_C2_BIT)
366
367 static byte v120_default_header[] =
368 {
369
370 0x83 /* Ext, BR , res, res, C2 , C1 , B , F */
371
372 };
373
374 static byte v120_break_header[] =
375 {
376
377 0xc3 | V120_HEADER_BREAK_BIT /* Ext, BR , res, res, C2 , C1 , B , F */
378
379 };
380
381
382 /*------------------------------------------------------------------*/
383 /* API_PUT function */
384 /*------------------------------------------------------------------*/
385
386 word api_put(APPL *appl, CAPI_MSG *msg)
387 {
388 word i, j, k, l, n;
389 word ret;
390 byte c;
391 byte controller;
392 DIVA_CAPI_ADAPTER *a;
393 PLCI *plci;
394 NCCI *ncci_ptr;
395 word ncci;
396 CAPI_MSG *m;
397 API_PARSE msg_parms[MAX_MSG_PARMS + 1];
398
399 if (msg->header.length < sizeof(msg->header) ||
400 msg->header.length > MAX_MSG_SIZE) {
401 dbug(1, dprintf("bad len"));
402 return _BAD_MSG;
403 }
404
405 controller = (byte)((msg->header.controller & 0x7f) - 1);
406
407 /* controller starts with 0 up to (max_adapter - 1) */
408 if (controller >= max_adapter)
409 {
410 dbug(1, dprintf("invalid ctrl"));
411 return _BAD_MSG;
412 }
413
414 a = &adapter[controller];
415 plci = NULL;
416 if ((msg->header.plci != 0) && (msg->header.plci <= a->max_plci) && !a->adapter_disabled)
417 {
418 dbug(1, dprintf("plci=%x", msg->header.plci));
419 plci = &a->plci[msg->header.plci - 1];
420 ncci = GET_WORD(&msg->header.ncci);
421 if (plci->Id
422 && (plci->appl
423 || (plci->State == INC_CON_PENDING)
424 || (plci->State == INC_CON_ALERT)
425 || (msg->header.command == (_DISCONNECT_I | RESPONSE)))
426 && ((ncci == 0)
427 || (msg->header.command == (_DISCONNECT_B3_I | RESPONSE))
428 || ((ncci < MAX_NCCI + 1) && (a->ncci_plci[ncci] == plci->Id))))
429 {
430 i = plci->msg_in_read_pos;
431 j = plci->msg_in_write_pos;
432 if (j >= i)
433 {
434 if (j + msg->header.length + MSG_IN_OVERHEAD <= MSG_IN_QUEUE_SIZE)
435 i += MSG_IN_QUEUE_SIZE - j;
436 else
437 j = 0;
438 }
439 else
440 {
441
442 n = (((CAPI_MSG *)(plci->msg_in_queue))->header.length + MSG_IN_OVERHEAD + 3) & 0xfffc;
443
444 if (i > MSG_IN_QUEUE_SIZE - n)
445 i = MSG_IN_QUEUE_SIZE - n + 1;
446 i -= j;
447 }
448
449 if (i <= ((msg->header.length + MSG_IN_OVERHEAD + 3) & 0xfffc))
450
451 {
452 dbug(0, dprintf("Q-FULL1(msg) - len=%d write=%d read=%d wrap=%d free=%d",
453 msg->header.length, plci->msg_in_write_pos,
454 plci->msg_in_read_pos, plci->msg_in_wrap_pos, i));
455
456 return _QUEUE_FULL;
457 }
458 c = false;
459 if ((((byte *) msg) < ((byte *)(plci->msg_in_queue)))
460 || (((byte *) msg) >= ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
461 {
462 if (plci->msg_in_write_pos != plci->msg_in_read_pos)
463 c = true;
464 }
465 if (msg->header.command == _DATA_B3_R)
466 {
467 if (msg->header.length < 20)
468 {
469 dbug(1, dprintf("DATA_B3 REQ wrong length %d", msg->header.length));
470 return _BAD_MSG;
471 }
472 ncci_ptr = &(a->ncci[ncci]);
473 n = ncci_ptr->data_pending;
474 l = ncci_ptr->data_ack_pending;
475 k = plci->msg_in_read_pos;
476 while (k != plci->msg_in_write_pos)
477 {
478 if (k == plci->msg_in_wrap_pos)
479 k = 0;
480 if ((((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[k]))->header.command == _DATA_B3_R)
481 && (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[k]))->header.ncci == ncci))
482 {
483 n++;
484 if (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[k]))->info.data_b3_req.Flags & 0x0004)
485 l++;
486 }
487
488 k += (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[k]))->header.length +
489 MSG_IN_OVERHEAD + 3) & 0xfffc;
490
491 }
492 if ((n >= MAX_DATA_B3) || (l >= MAX_DATA_ACK))
493 {
494 dbug(0, dprintf("Q-FULL2(data) - pending=%d/%d ack_pending=%d/%d",
495 ncci_ptr->data_pending, n, ncci_ptr->data_ack_pending, l));
496
497 return _QUEUE_FULL;
498 }
499 if (plci->req_in || plci->internal_command)
500 {
501 if ((((byte *) msg) >= ((byte *)(plci->msg_in_queue)))
502 && (((byte *) msg) < ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
503 {
504 dbug(0, dprintf("Q-FULL3(requeue)"));
505
506 return _QUEUE_FULL;
507 }
508 c = true;
509 }
510 }
511 else
512 {
513 if (plci->req_in || plci->internal_command)
514 c = true;
515 else
516 {
517 plci->command = msg->header.command;
518 plci->number = msg->header.number;
519 }
520 }
521 if (c)
522 {
523 dbug(1, dprintf("enqueue msg(0x%04x,0x%x,0x%x) - len=%d write=%d read=%d wrap=%d free=%d",
524 msg->header.command, plci->req_in, plci->internal_command,
525 msg->header.length, plci->msg_in_write_pos,
526 plci->msg_in_read_pos, plci->msg_in_wrap_pos, i));
527 if (j == 0)
528 plci->msg_in_wrap_pos = plci->msg_in_write_pos;
529 m = (CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[j]);
530 for (i = 0; i < msg->header.length; i++)
531 ((byte *)(plci->msg_in_queue))[j++] = ((byte *) msg)[i];
532 if (m->header.command == _DATA_B3_R)
533 {
534
535 m->info.data_b3_req.Data = (dword)(long)(TransmitBufferSet(appl, m->info.data_b3_req.Data));
536
537 }
538
539 j = (j + 3) & 0xfffc;
540
541 *((APPL **)(&((byte *)(plci->msg_in_queue))[j])) = appl;
542 plci->msg_in_write_pos = j + MSG_IN_OVERHEAD;
543 return 0;
544 }
545 }
546 else
547 {
548 plci = NULL;
549 }
550 }
551 dbug(1, dprintf("com=%x", msg->header.command));
552
553 for (j = 0; j < MAX_MSG_PARMS + 1; j++) msg_parms[j].length = 0;
554 for (i = 0, ret = _BAD_MSG; i < ARRAY_SIZE(ftable); i++) {
555
556 if (ftable[i].command == msg->header.command) {
557 /* break loop if the message is correct, otherwise continue scan */
558 /* (for example: CONNECT_B3_T90_ACT_RES has two specifications) */
559 if (!api_parse(msg->info.b, (word)(msg->header.length - 12), ftable[i].format, msg_parms)) {
560 ret = 0;
561 break;
562 }
563 for (j = 0; j < MAX_MSG_PARMS + 1; j++) msg_parms[j].length = 0;
564 }
565 }
566 if (ret) {
567 dbug(1, dprintf("BAD_MSG"));
568 if (plci) plci->command = 0;
569 return ret;
570 }
571
572
573 c = ftable[i].function(GET_DWORD(&msg->header.controller),
574 msg->header.number,
575 a,
576 plci,
577 appl,
578 msg_parms);
579
580 channel_xmit_extended_xon(plci);
581
582 if (c == 1) send_req(plci);
583 if (c == 2 && plci) plci->req_in = plci->req_in_start = plci->req_out = 0;
584 if (plci && !plci->req_in) plci->command = 0;
585 return 0;
586 }
587
588
589 /*------------------------------------------------------------------*/
590 /* api_parse function, check the format of api messages */
591 /*------------------------------------------------------------------*/
592
593 static word api_parse(byte *msg, word length, byte *format, API_PARSE *parms)
594 {
595 word i;
596 word p;
597
598 for (i = 0, p = 0; format[i]; i++) {
599 if (parms)
600 {
601 parms[i].info = &msg[p];
602 }
603 switch (format[i]) {
604 case 'b':
605 p += 1;
606 break;
607 case 'w':
608 p += 2;
609 break;
610 case 'd':
611 p += 4;
612 break;
613 case 's':
614 if (msg[p] == 0xff) {
615 parms[i].info += 2;
616 parms[i].length = msg[p + 1] + (msg[p + 2] << 8);
617 p += (parms[i].length + 3);
618 }
619 else {
620 parms[i].length = msg[p];
621 p += (parms[i].length + 1);
622 }
623 break;
624 }
625
626 if (p > length) return true;
627 }
628 if (parms) parms[i].info = NULL;
629 return false;
630 }
631
632 static void api_save_msg(API_PARSE *in, byte *format, API_SAVE *out)
633 {
634 word i, j, n = 0;
635 byte *p;
636
637 p = out->info;
638 for (i = 0; format[i] != '\0'; i++)
639 {
640 out->parms[i].info = p;
641 out->parms[i].length = in[i].length;
642 switch (format[i])
643 {
644 case 'b':
645 n = 1;
646 break;
647 case 'w':
648 n = 2;
649 break;
650 case 'd':
651 n = 4;
652 break;
653 case 's':
654 n = in[i].length + 1;
655 break;
656 }
657 for (j = 0; j < n; j++)
658 *(p++) = in[i].info[j];
659 }
660 out->parms[i].info = NULL;
661 out->parms[i].length = 0;
662 }
663
664 static void api_load_msg(API_SAVE *in, API_PARSE *out)
665 {
666 word i;
667
668 i = 0;
669 do
670 {
671 out[i].info = in->parms[i].info;
672 out[i].length = in->parms[i].length;
673 } while (in->parms[i++].info);
674 }
675
676
677 /*------------------------------------------------------------------*/
678 /* CAPI remove function */
679 /*------------------------------------------------------------------*/
680
681 word api_remove_start(void)
682 {
683 word i;
684 word j;
685
686 if (!remove_started) {
687 remove_started = true;
688 for (i = 0; i < max_adapter; i++) {
689 if (adapter[i].request) {
690 for (j = 0; j < adapter[i].max_plci; j++) {
691 if (adapter[i].plci[j].Sig.Id) plci_remove(&adapter[i].plci[j]);
692 }
693 }
694 }
695 return 1;
696 }
697 else {
698 for (i = 0; i < max_adapter; i++) {
699 if (adapter[i].request) {
700 for (j = 0; j < adapter[i].max_plci; j++) {
701 if (adapter[i].plci[j].Sig.Id) return 1;
702 }
703 }
704 }
705 }
706 api_remove_complete();
707 return 0;
708 }
709
710
711 /*------------------------------------------------------------------*/
712 /* internal command queue */
713 /*------------------------------------------------------------------*/
714
715 static void init_internal_command_queue(PLCI *plci)
716 {
717 word i;
718
719 dbug(1, dprintf("%s,%d: init_internal_command_queue",
720 (char *)(FILE_), __LINE__));
721
722 plci->internal_command = 0;
723 for (i = 0; i < MAX_INTERNAL_COMMAND_LEVELS; i++)
724 plci->internal_command_queue[i] = NULL;
725 }
726
727
728 static void start_internal_command(dword Id, PLCI *plci, t_std_internal_command command_function)
729 {
730 word i;
731
732 dbug(1, dprintf("[%06lx] %s,%d: start_internal_command",
733 UnMapId(Id), (char *)(FILE_), __LINE__));
734
735 if (plci->internal_command == 0)
736 {
737 plci->internal_command_queue[0] = command_function;
738 (*command_function)(Id, plci, OK);
739 }
740 else
741 {
742 i = 1;
743 while (plci->internal_command_queue[i] != NULL)
744 i++;
745 plci->internal_command_queue[i] = command_function;
746 }
747 }
748
749
750 static void next_internal_command(dword Id, PLCI *plci)
751 {
752 word i;
753
754 dbug(1, dprintf("[%06lx] %s,%d: next_internal_command",
755 UnMapId(Id), (char *)(FILE_), __LINE__));
756
757 plci->internal_command = 0;
758 plci->internal_command_queue[0] = NULL;
759 while (plci->internal_command_queue[1] != NULL)
760 {
761 for (i = 0; i < MAX_INTERNAL_COMMAND_LEVELS - 1; i++)
762 plci->internal_command_queue[i] = plci->internal_command_queue[i + 1];
763 plci->internal_command_queue[MAX_INTERNAL_COMMAND_LEVELS - 1] = NULL;
764 (*(plci->internal_command_queue[0]))(Id, plci, OK);
765 if (plci->internal_command != 0)
766 return;
767 plci->internal_command_queue[0] = NULL;
768 }
769 }
770
771
772 /*------------------------------------------------------------------*/
773 /* NCCI allocate/remove function */
774 /*------------------------------------------------------------------*/
775
776 static dword ncci_mapping_bug = 0;
777
778 static word get_ncci(PLCI *plci, byte ch, word force_ncci)
779 {
780 DIVA_CAPI_ADAPTER *a;
781 word ncci, i, j, k;
782
783 a = plci->adapter;
784 if (!ch || a->ch_ncci[ch])
785 {
786 ncci_mapping_bug++;
787 dbug(1, dprintf("NCCI mapping exists %ld %02x %02x %02x-%02x",
788 ncci_mapping_bug, ch, force_ncci, a->ncci_ch[a->ch_ncci[ch]], a->ch_ncci[ch]));
789 ncci = ch;
790 }
791 else
792 {
793 if (force_ncci)
794 ncci = force_ncci;
795 else
796 {
797 if ((ch < MAX_NCCI + 1) && !a->ncci_ch[ch])
798 ncci = ch;
799 else
800 {
801 ncci = 1;
802 while ((ncci < MAX_NCCI + 1) && a->ncci_ch[ncci])
803 ncci++;
804 if (ncci == MAX_NCCI + 1)
805 {
806 ncci_mapping_bug++;
807 i = 1;
808 do
809 {
810 j = 1;
811 while ((j < MAX_NCCI + 1) && (a->ncci_ch[j] != i))
812 j++;
813 k = j;
814 if (j < MAX_NCCI + 1)
815 {
816 do
817 {
818 j++;
819 } while ((j < MAX_NCCI + 1) && (a->ncci_ch[j] != i));
820 }
821 } while ((i < MAX_NL_CHANNEL + 1) && (j < MAX_NCCI + 1));
822 if (i < MAX_NL_CHANNEL + 1)
823 {
824 dbug(1, dprintf("NCCI mapping overflow %ld %02x %02x %02x-%02x-%02x",
825 ncci_mapping_bug, ch, force_ncci, i, k, j));
826 }
827 else
828 {
829 dbug(1, dprintf("NCCI mapping overflow %ld %02x %02x",
830 ncci_mapping_bug, ch, force_ncci));
831 }
832 ncci = ch;
833 }
834 }
835 a->ncci_plci[ncci] = plci->Id;
836 a->ncci_state[ncci] = IDLE;
837 if (!plci->ncci_ring_list)
838 plci->ncci_ring_list = ncci;
839 else
840 a->ncci_next[ncci] = a->ncci_next[plci->ncci_ring_list];
841 a->ncci_next[plci->ncci_ring_list] = (byte) ncci;
842 }
843 a->ncci_ch[ncci] = ch;
844 a->ch_ncci[ch] = (byte) ncci;
845 dbug(1, dprintf("NCCI mapping established %ld %02x %02x %02x-%02x",
846 ncci_mapping_bug, ch, force_ncci, ch, ncci));
847 }
848 return (ncci);
849 }
850
851
852 static void ncci_free_receive_buffers(PLCI *plci, word ncci)
853 {
854 DIVA_CAPI_ADAPTER *a;
855 APPL *appl;
856 word i, ncci_code;
857 dword Id;
858
859 a = plci->adapter;
860 Id = (((dword) ncci) << 16) | (((word)(plci->Id)) << 8) | a->Id;
861 if (ncci)
862 {
863 if (a->ncci_plci[ncci] == plci->Id)
864 {
865 if (!plci->appl)
866 {
867 ncci_mapping_bug++;
868 dbug(1, dprintf("NCCI mapping appl expected %ld %08lx",
869 ncci_mapping_bug, Id));
870 }
871 else
872 {
873 appl = plci->appl;
874 ncci_code = ncci | (((word) a->Id) << 8);
875 for (i = 0; i < appl->MaxBuffer; i++)
876 {
877 if ((appl->DataNCCI[i] == ncci_code)
878 && (((byte)(appl->DataFlags[i] >> 8)) == plci->Id))
879 {
880 appl->DataNCCI[i] = 0;
881 }
882 }
883 }
884 }
885 }
886 else
887 {
888 for (ncci = 1; ncci < MAX_NCCI + 1; ncci++)
889 {
890 if (a->ncci_plci[ncci] == plci->Id)
891 {
892 if (!plci->appl)
893 {
894 ncci_mapping_bug++;
895 dbug(1, dprintf("NCCI mapping no appl %ld %08lx",
896 ncci_mapping_bug, Id));
897 }
898 else
899 {
900 appl = plci->appl;
901 ncci_code = ncci | (((word) a->Id) << 8);
902 for (i = 0; i < appl->MaxBuffer; i++)
903 {
904 if ((appl->DataNCCI[i] == ncci_code)
905 && (((byte)(appl->DataFlags[i] >> 8)) == plci->Id))
906 {
907 appl->DataNCCI[i] = 0;
908 }
909 }
910 }
911 }
912 }
913 }
914 }
915
916
917 static void cleanup_ncci_data(PLCI *plci, word ncci)
918 {
919 NCCI *ncci_ptr;
920
921 if (ncci && (plci->adapter->ncci_plci[ncci] == plci->Id))
922 {
923 ncci_ptr = &(plci->adapter->ncci[ncci]);
924 if (plci->appl)
925 {
926 while (ncci_ptr->data_pending != 0)
927 {
928 if (!plci->data_sent || (ncci_ptr->DBuffer[ncci_ptr->data_out].P != plci->data_sent_ptr))
929 TransmitBufferFree(plci->appl, ncci_ptr->DBuffer[ncci_ptr->data_out].P);
930 (ncci_ptr->data_out)++;
931 if (ncci_ptr->data_out == MAX_DATA_B3)
932 ncci_ptr->data_out = 0;
933 (ncci_ptr->data_pending)--;
934 }
935 }
936 ncci_ptr->data_out = 0;
937 ncci_ptr->data_pending = 0;
938 ncci_ptr->data_ack_out = 0;
939 ncci_ptr->data_ack_pending = 0;
940 }
941 }
942
943
944 static void ncci_remove(PLCI *plci, word ncci, byte preserve_ncci)
945 {
946 DIVA_CAPI_ADAPTER *a;
947 dword Id;
948 word i;
949
950 a = plci->adapter;
951 Id = (((dword) ncci) << 16) | (((word)(plci->Id)) << 8) | a->Id;
952 if (!preserve_ncci)
953 ncci_free_receive_buffers(plci, ncci);
954 if (ncci)
955 {
956 if (a->ncci_plci[ncci] != plci->Id)
957 {
958 ncci_mapping_bug++;
959 dbug(1, dprintf("NCCI mapping doesn't exist %ld %08lx %02x",
960 ncci_mapping_bug, Id, preserve_ncci));
961 }
962 else
963 {
964 cleanup_ncci_data(plci, ncci);
965 dbug(1, dprintf("NCCI mapping released %ld %08lx %02x %02x-%02x",
966 ncci_mapping_bug, Id, preserve_ncci, a->ncci_ch[ncci], ncci));
967 a->ch_ncci[a->ncci_ch[ncci]] = 0;
968 if (!preserve_ncci)
969 {
970 a->ncci_ch[ncci] = 0;
971 a->ncci_plci[ncci] = 0;
972 a->ncci_state[ncci] = IDLE;
973 i = plci->ncci_ring_list;
974 while ((i != 0) && (a->ncci_next[i] != plci->ncci_ring_list) && (a->ncci_next[i] != ncci))
975 i = a->ncci_next[i];
976 if ((i != 0) && (a->ncci_next[i] == ncci))
977 {
978 if (i == ncci)
979 plci->ncci_ring_list = 0;
980 else if (plci->ncci_ring_list == ncci)
981 plci->ncci_ring_list = i;
982 a->ncci_next[i] = a->ncci_next[ncci];
983 }
984 a->ncci_next[ncci] = 0;
985 }
986 }
987 }
988 else
989 {
990 for (ncci = 1; ncci < MAX_NCCI + 1; ncci++)
991 {
992 if (a->ncci_plci[ncci] == plci->Id)
993 {
994 cleanup_ncci_data(plci, ncci);
995 dbug(1, dprintf("NCCI mapping released %ld %08lx %02x %02x-%02x",
996 ncci_mapping_bug, Id, preserve_ncci, a->ncci_ch[ncci], ncci));
997 a->ch_ncci[a->ncci_ch[ncci]] = 0;
998 if (!preserve_ncci)
999 {
1000 a->ncci_ch[ncci] = 0;
1001 a->ncci_plci[ncci] = 0;
1002 a->ncci_state[ncci] = IDLE;
1003 a->ncci_next[ncci] = 0;
1004 }
1005 }
1006 }
1007 if (!preserve_ncci)
1008 plci->ncci_ring_list = 0;
1009 }
1010 }
1011
1012
1013 /*------------------------------------------------------------------*/
1014 /* PLCI remove function */
1015 /*------------------------------------------------------------------*/
1016
1017 static void plci_free_msg_in_queue(PLCI *plci)
1018 {
1019 word i;
1020
1021 if (plci->appl)
1022 {
1023 i = plci->msg_in_read_pos;
1024 while (i != plci->msg_in_write_pos)
1025 {
1026 if (i == plci->msg_in_wrap_pos)
1027 i = 0;
1028 if (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[i]))->header.command == _DATA_B3_R)
1029 {
1030
1031 TransmitBufferFree(plci->appl,
1032 (byte *)(long)(((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[i]))->info.data_b3_req.Data));
1033
1034 }
1035
1036 i += (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[i]))->header.length +
1037 MSG_IN_OVERHEAD + 3) & 0xfffc;
1038
1039 }
1040 }
1041 plci->msg_in_write_pos = MSG_IN_QUEUE_SIZE;
1042 plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
1043 plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
1044 }
1045
1046
1047 static void plci_remove(PLCI *plci)
1048 {
1049
1050 if (!plci) {
1051 dbug(1, dprintf("plci_remove(no plci)"));
1052 return;
1053 }
1054 init_internal_command_queue(plci);
1055 dbug(1, dprintf("plci_remove(%x,tel=%x)", plci->Id, plci->tel));
1056 if (plci_remove_check(plci))
1057 {
1058 return;
1059 }
1060 if (plci->Sig.Id == 0xff)
1061 {
1062 dbug(1, dprintf("D-channel X.25 plci->NL.Id:%0x", plci->NL.Id));
1063 if (plci->NL.Id && !plci->nl_remove_id)
1064 {
1065 nl_req_ncci(plci, REMOVE, 0);
1066 send_req(plci);
1067 }
1068 }
1069 else
1070 {
1071 if (!plci->sig_remove_id
1072 && (plci->Sig.Id
1073 || (plci->req_in != plci->req_out)
1074 || (plci->nl_req || plci->sig_req)))
1075 {
1076 sig_req(plci, HANGUP, 0);
1077 send_req(plci);
1078 }
1079 }
1080 ncci_remove(plci, 0, false);
1081 plci_free_msg_in_queue(plci);
1082
1083 plci->channels = 0;
1084 plci->appl = NULL;
1085 if ((plci->State == INC_CON_PENDING) || (plci->State == INC_CON_ALERT))
1086 plci->State = OUTG_DIS_PENDING;
1087 }
1088
1089 /*------------------------------------------------------------------*/
1090 /* Application Group function helpers */
1091 /*------------------------------------------------------------------*/
1092
1093 static void set_group_ind_mask(PLCI *plci)
1094 {
1095 word i;
1096
1097 for (i = 0; i < C_IND_MASK_DWORDS; i++)
1098 plci->group_optimization_mask_table[i] = 0xffffffffL;
1099 }
1100
1101 static void clear_group_ind_mask_bit(PLCI *plci, word b)
1102 {
1103 plci->group_optimization_mask_table[b >> 5] &= ~(1L << (b & 0x1f));
1104 }
1105
1106 static byte test_group_ind_mask_bit(PLCI *plci, word b)
1107 {
1108 return ((plci->group_optimization_mask_table[b >> 5] & (1L << (b & 0x1f))) != 0);
1109 }
1110
1111 /*------------------------------------------------------------------*/
1112 /* c_ind_mask operations for arbitrary MAX_APPL */
1113 /*------------------------------------------------------------------*/
1114
1115 static void clear_c_ind_mask(PLCI *plci)
1116 {
1117 word i;
1118
1119 for (i = 0; i < C_IND_MASK_DWORDS; i++)
1120 plci->c_ind_mask_table[i] = 0;
1121 }
1122
1123 static byte c_ind_mask_empty(PLCI *plci)
1124 {
1125 word i;
1126
1127 i = 0;
1128 while ((i < C_IND_MASK_DWORDS) && (plci->c_ind_mask_table[i] == 0))
1129 i++;
1130 return (i == C_IND_MASK_DWORDS);
1131 }
1132
1133 static void set_c_ind_mask_bit(PLCI *plci, word b)
1134 {
1135 plci->c_ind_mask_table[b >> 5] |= (1L << (b & 0x1f));
1136 }
1137
1138 static void clear_c_ind_mask_bit(PLCI *plci, word b)
1139 {
1140 plci->c_ind_mask_table[b >> 5] &= ~(1L << (b & 0x1f));
1141 }
1142
1143 static byte test_c_ind_mask_bit(PLCI *plci, word b)
1144 {
1145 return ((plci->c_ind_mask_table[b >> 5] & (1L << (b & 0x1f))) != 0);
1146 }
1147
1148 static void dump_c_ind_mask(PLCI *plci)
1149 {
1150 static char hex_digit_table[0x10] =
1151 {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
1152 word i, j, k;
1153 dword d;
1154 char *p;
1155 char buf[40];
1156
1157 for (i = 0; i < C_IND_MASK_DWORDS; i += 4)
1158 {
1159 p = buf + 36;
1160 *p = '\0';
1161 for (j = 0; j < 4; j++)
1162 {
1163 if (i + j < C_IND_MASK_DWORDS)
1164 {
1165 d = plci->c_ind_mask_table[i + j];
1166 for (k = 0; k < 8; k++)
1167 {
1168 *(--p) = hex_digit_table[d & 0xf];
1169 d >>= 4;
1170 }
1171 }
1172 else if (i != 0)
1173 {
1174 for (k = 0; k < 8; k++)
1175 *(--p) = ' ';
1176 }
1177 *(--p) = ' ';
1178 }
1179 dbug(1, dprintf("c_ind_mask =%s", (char *) p));
1180 }
1181 }
1182
1183
1184
1185
1186
1187 #define dump_plcis(a)
1188
1189
1190
1191 /*------------------------------------------------------------------*/
1192 /* translation function for each message */
1193 /*------------------------------------------------------------------*/
1194
1195 static byte connect_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1196 PLCI *plci, APPL *appl, API_PARSE *parms)
1197 {
1198 word ch;
1199 word i;
1200 word Info;
1201 byte LinkLayer;
1202 API_PARSE *ai;
1203 API_PARSE *bp;
1204 API_PARSE ai_parms[5];
1205 word channel = 0;
1206 dword ch_mask;
1207 byte m;
1208 static byte esc_chi[35] = {0x02, 0x18, 0x01};
1209 static byte lli[2] = {0x01, 0x00};
1210 byte noCh = 0;
1211 word dir = 0;
1212 byte *p_chi = "";
1213
1214 for (i = 0; i < 5; i++) ai_parms[i].length = 0;
1215
1216 dbug(1, dprintf("connect_req(%d)", parms->length));
1217 Info = _WRONG_IDENTIFIER;
1218 if (a)
1219 {
1220 if (a->adapter_disabled)
1221 {
1222 dbug(1, dprintf("adapter disabled"));
1223 Id = ((word)1 << 8) | a->Id;
1224 sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", 0);
1225 sendf(appl, _DISCONNECT_I, Id, 0, "w", _L1_ERROR);
1226 return false;
1227 }
1228 Info = _OUT_OF_PLCI;
1229 if ((i = get_plci(a)))
1230 {
1231 Info = 0;
1232 plci = &a->plci[i - 1];
1233 plci->appl = appl;
1234 plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
1235 /* check 'external controller' bit for codec support */
1236 if (Id & EXT_CONTROLLER)
1237 {
1238 if (AdvCodecSupport(a, plci, appl, 0))
1239 {
1240 plci->Id = 0;
1241 sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", _WRONG_IDENTIFIER);
1242 return 2;
1243 }
1244 }
1245 ai = &parms[9];
1246 bp = &parms[5];
1247 ch = 0;
1248 if (bp->length)LinkLayer = bp->info[3];
1249 else LinkLayer = 0;
1250 if (ai->length)
1251 {
1252 ch = 0xffff;
1253 if (!api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms))
1254 {
1255 ch = 0;
1256 if (ai_parms[0].length)
1257 {
1258 ch = GET_WORD(ai_parms[0].info + 1);
1259 if (ch > 4) ch = 0; /* safety -> ignore ChannelID */
1260 if (ch == 4) /* explizit CHI in message */
1261 {
1262 /* check length of B-CH struct */
1263 if ((ai_parms[0].info)[3] >= 1)
1264 {
1265 if ((ai_parms[0].info)[4] == CHI)
1266 {
1267 p_chi = &((ai_parms[0].info)[5]);
1268 }
1269 else
1270 {
1271 p_chi = &((ai_parms[0].info)[3]);
1272 }
1273 if (p_chi[0] > 35) /* check length of channel ID */
1274 {
1275 Info = _WRONG_MESSAGE_FORMAT;
1276 }
1277 }
1278 else Info = _WRONG_MESSAGE_FORMAT;
1279 }
1280
1281 if (ch == 3 && ai_parms[0].length >= 7 && ai_parms[0].length <= 36)
1282 {
1283 dir = GET_WORD(ai_parms[0].info + 3);
1284 ch_mask = 0;
1285 m = 0x3f;
1286 for (i = 0; i + 5 <= ai_parms[0].length; i++)
1287 {
1288 if (ai_parms[0].info[i + 5] != 0)
1289 {
1290 if ((ai_parms[0].info[i + 5] | m) != 0xff)
1291 Info = _WRONG_MESSAGE_FORMAT;
1292 else
1293 {
1294 if (ch_mask == 0)
1295 channel = i;
1296 ch_mask |= 1L << i;
1297 }
1298 }
1299 m = 0;
1300 }
1301 if (ch_mask == 0)
1302 Info = _WRONG_MESSAGE_FORMAT;
1303 if (!Info)
1304 {
1305 if ((ai_parms[0].length == 36) || (ch_mask != ((dword)(1L << channel))))
1306 {
1307 esc_chi[0] = (byte)(ai_parms[0].length - 2);
1308 for (i = 0; i + 5 <= ai_parms[0].length; i++)
1309 esc_chi[i + 3] = ai_parms[0].info[i + 5];
1310 }
1311 else
1312 esc_chi[0] = 2;
1313 esc_chi[2] = (byte)channel;
1314 plci->b_channel = (byte)channel; /* not correct for ETSI ch 17..31 */
1315 add_p(plci, LLI, lli);
1316 add_p(plci, ESC, esc_chi);
1317 plci->State = LOCAL_CONNECT;
1318 if (!dir) plci->call_dir |= CALL_DIR_FORCE_OUTG_NL; /* dir 0=DTE, 1=DCE */
1319 }
1320 }
1321 }
1322 }
1323 else Info = _WRONG_MESSAGE_FORMAT;
1324 }
1325
1326 dbug(1, dprintf("ch=%x,dir=%x,p_ch=%d", ch, dir, channel));
1327 plci->command = _CONNECT_R;
1328 plci->number = Number;
1329 /* x.31 or D-ch free SAPI in LinkLayer? */
1330 if (ch == 1 && LinkLayer != 3 && LinkLayer != 12) noCh = true;
1331 if ((ch == 0 || ch == 2 || noCh || ch == 3 || ch == 4) && !Info)
1332 {
1333 /* B-channel used for B3 connections (ch==0), or no B channel */
1334 /* is used (ch==2) or perm. connection (3) is used do a CALL */
1335 if (noCh) Info = add_b1(plci, &parms[5], 2, 0); /* no resource */
1336 else Info = add_b1(plci, &parms[5], ch, 0);
1337 add_s(plci, OAD, &parms[2]);
1338 add_s(plci, OSA, &parms[4]);
1339 add_s(plci, BC, &parms[6]);
1340 add_s(plci, LLC, &parms[7]);
1341 add_s(plci, HLC, &parms[8]);
1342 if (a->Info_Mask[appl->Id - 1] & 0x200)
1343 {
1344 /* early B3 connect (CIP mask bit 9) no release after a disc */
1345 add_p(plci, LLI, "\x01\x01");
1346 }
1347 if (GET_WORD(parms[0].info) < 29) {
1348 add_p(plci, BC, cip_bc[GET_WORD(parms[0].info)][a->u_law]);
1349 add_p(plci, HLC, cip_hlc[GET_WORD(parms[0].info)]);
1350 }
1351 add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
1352 sig_req(plci, ASSIGN, DSIG_ID);
1353 }
1354 else if (ch == 1) {
1355
1356 /* D-Channel used for B3 connections */
1357 plci->Sig.Id = 0xff;
1358 Info = 0;
1359 }
1360
1361 if (!Info && ch != 2 && !noCh) {
1362 Info = add_b23(plci, &parms[5]);
1363 if (!Info) {
1364 if (!(plci->tel && !plci->adv_nl))nl_req_ncci(plci, ASSIGN, 0);
1365 }
1366 }
1367
1368 if (!Info)
1369 {
1370 if (ch == 0 || ch == 2 || ch == 3 || noCh || ch == 4)
1371 {
1372 if (plci->spoofed_msg == SPOOFING_REQUIRED)
1373 {
1374 api_save_msg(parms, "wsssssssss", &plci->saved_msg);
1375 plci->spoofed_msg = CALL_REQ;
1376 plci->internal_command = BLOCK_PLCI;
1377 plci->command = 0;
1378 dbug(1, dprintf("Spoof"));
1379 send_req(plci);
1380 return false;
1381 }
1382 if (ch == 4)add_p(plci, CHI, p_chi);
1383 add_s(plci, CPN, &parms[1]);
1384 add_s(plci, DSA, &parms[3]);
1385 if (noCh) add_p(plci, ESC, "\x02\x18\xfd"); /* D-channel, no B-L3 */
1386 add_ai(plci, &parms[9]);
1387 if (!dir)sig_req(plci, CALL_REQ, 0);
1388 else
1389 {
1390 plci->command = PERM_LIST_REQ;
1391 plci->appl = appl;
1392 sig_req(plci, LISTEN_REQ, 0);
1393 send_req(plci);
1394 return false;
1395 }
1396 }
1397 send_req(plci);
1398 return false;
1399 }
1400 plci->Id = 0;
1401 }
1402 }
1403 sendf(appl,
1404 _CONNECT_R | CONFIRM,
1405 Id,
1406 Number,
1407 "w", Info);
1408 return 2;
1409 }
1410
1411 static byte connect_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1412 PLCI *plci, APPL *appl, API_PARSE *parms)
1413 {
1414 word i, Info;
1415 word Reject;
1416 static byte cau_t[] = {0, 0, 0x90, 0x91, 0xac, 0x9d, 0x86, 0xd8, 0x9b};
1417 static byte esc_t[] = {0x03, 0x08, 0x00, 0x00};
1418 API_PARSE *ai;
1419 API_PARSE ai_parms[5];
1420 word ch = 0;
1421
1422 if (!plci) {
1423 dbug(1, dprintf("connect_res(no plci)"));
1424 return 0; /* no plci, no send */
1425 }
1426
1427 dbug(1, dprintf("connect_res(State=0x%x)", plci->State));
1428 for (i = 0; i < 5; i++) ai_parms[i].length = 0;
1429 ai = &parms[5];
1430 dbug(1, dprintf("ai->length=%d", ai->length));
1431
1432 if (ai->length)
1433 {
1434 if (!api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms))
1435 {
1436 dbug(1, dprintf("ai_parms[0].length=%d/0x%x", ai_parms[0].length, GET_WORD(ai_parms[0].info + 1)));
1437 ch = 0;
1438 if (ai_parms[0].length)
1439 {
1440 ch = GET_WORD(ai_parms[0].info + 1);
1441 dbug(1, dprintf("BCH-I=0x%x", ch));
1442 }
1443 }
1444 }
1445
1446 if (plci->State == INC_CON_CONNECTED_ALERT)
1447 {
1448 dbug(1, dprintf("Connected Alert Call_Res"));
1449 if (a->Info_Mask[appl->Id - 1] & 0x200)
1450 {
1451 /* early B3 connect (CIP mask bit 9) no release after a disc */
1452 add_p(plci, LLI, "\x01\x01");
1453 }
1454 add_s(plci, CONN_NR, &parms[2]);
1455 add_s(plci, LLC, &parms[4]);
1456 add_ai(plci, &parms[5]);
1457 plci->State = INC_CON_ACCEPT;
1458 sig_req(plci, CALL_RES, 0);
1459 return 1;
1460 }
1461 else if (plci->State == INC_CON_PENDING || plci->State == INC_CON_ALERT) {
1462 clear_c_ind_mask_bit(plci, (word)(appl->Id - 1));
1463 dump_c_ind_mask(plci);
1464 Reject = GET_WORD(parms[0].info);
1465 dbug(1, dprintf("Reject=0x%x", Reject));
1466 if (Reject)
1467 {
1468 if (c_ind_mask_empty(plci))
1469 {
1470 if ((Reject & 0xff00) == 0x3400)
1471 {
1472 esc_t[2] = ((byte)(Reject & 0x00ff)) | 0x80;
1473 add_p(plci, ESC, esc_t);
1474 add_ai(plci, &parms[5]);
1475 sig_req(plci, REJECT, 0);
1476 }
1477 else if (Reject == 1 || Reject > 9)
1478 {
1479 add_ai(plci, &parms[5]);
1480 sig_req(plci, HANGUP, 0);
1481 }
1482 else
1483 {
1484 esc_t[2] = cau_t[(Reject&0x000f)];
1485 add_p(plci, ESC, esc_t);
1486 add_ai(plci, &parms[5]);
1487 sig_req(plci, REJECT, 0);
1488 }
1489 plci->appl = appl;
1490 }
1491 else
1492 {
1493 sendf(appl, _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED);
1494 }
1495 }
1496 else {
1497 plci->appl = appl;
1498 if (Id & EXT_CONTROLLER) {
1499 if (AdvCodecSupport(a, plci, appl, 0)) {
1500 dbug(1, dprintf("connect_res(error from AdvCodecSupport)"));
1501 sig_req(plci, HANGUP, 0);
1502 return 1;
1503 }
1504 if (plci->tel == ADV_VOICE && a->AdvCodecPLCI)
1505 {
1506 Info = add_b23(plci, &parms[1]);
1507 if (Info)
1508 {
1509 dbug(1, dprintf("connect_res(error from add_b23)"));
1510 sig_req(plci, HANGUP, 0);
1511 return 1;
1512 }
1513 if (plci->adv_nl)
1514 {
1515 nl_req_ncci(plci, ASSIGN, 0);
1516 }
1517 }
1518 }
1519 else
1520 {
1521 plci->tel = 0;
1522 if (ch != 2)
1523 {
1524 Info = add_b23(plci, &parms[1]);
1525 if (Info)
1526 {
1527 dbug(1, dprintf("connect_res(error from add_b23 2)"));
1528 sig_req(plci, HANGUP, 0);
1529 return 1;
1530 }
1531 }
1532 nl_req_ncci(plci, ASSIGN, 0);
1533 }
1534
1535 if (plci->spoofed_msg == SPOOFING_REQUIRED)
1536 {
1537 api_save_msg(parms, "wsssss", &plci->saved_msg);
1538 plci->spoofed_msg = CALL_RES;
1539 plci->internal_command = BLOCK_PLCI;
1540 plci->command = 0;
1541 dbug(1, dprintf("Spoof"));
1542 }
1543 else
1544 {
1545 add_b1(plci, &parms[1], ch, plci->B1_facilities);
1546 if (a->Info_Mask[appl->Id - 1] & 0x200)
1547 {
1548 /* early B3 connect (CIP mask bit 9) no release after a disc */
1549 add_p(plci, LLI, "\x01\x01");
1550 }
1551 add_s(plci, CONN_NR, &parms[2]);
1552 add_s(plci, LLC, &parms[4]);
1553 add_ai(plci, &parms[5]);
1554 plci->State = INC_CON_ACCEPT;
1555 sig_req(plci, CALL_RES, 0);
1556 }
1557
1558 for (i = 0; i < max_appl; i++) {
1559 if (test_c_ind_mask_bit(plci, i)) {
1560 sendf(&application[i], _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED);
1561 }
1562 }
1563 }
1564 }
1565 return 1;
1566 }
1567
1568 static byte connect_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1569 PLCI *plci, APPL *appl, API_PARSE *msg)
1570 {
1571 dbug(1, dprintf("connect_a_res"));
1572 return false;
1573 }
1574
1575 static byte disconnect_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1576 PLCI *plci, APPL *appl, API_PARSE *msg)
1577 {
1578 word Info;
1579 word i;
1580
1581 dbug(1, dprintf("disconnect_req"));
1582
1583 Info = _WRONG_IDENTIFIER;
1584
1585 if (plci)
1586 {
1587 if (plci->State == INC_CON_PENDING || plci->State == INC_CON_ALERT)
1588 {
1589 clear_c_ind_mask_bit(plci, (word)(appl->Id - 1));
1590 plci->appl = appl;
1591 for (i = 0; i < max_appl; i++)
1592 {
1593 if (test_c_ind_mask_bit(plci, i))
1594 sendf(&application[i], _DISCONNECT_I, Id, 0, "w", 0);
1595 }
1596 plci->State = OUTG_DIS_PENDING;
1597 }
1598 if (plci->Sig.Id && plci->appl)
1599 {
1600 Info = 0;
1601 if (plci->Sig.Id != 0xff)
1602 {
1603 if (plci->State != INC_DIS_PENDING)
1604 {
1605 add_ai(plci, &msg[0]);
1606 sig_req(plci, HANGUP, 0);
1607 plci->State = OUTG_DIS_PENDING;
1608 return 1;
1609 }
1610 }
1611 else
1612 {
1613 if (plci->NL.Id && !plci->nl_remove_id)
1614 {
1615 mixer_remove(plci);
1616 nl_req_ncci(plci, REMOVE, 0);
1617 sendf(appl, _DISCONNECT_R | CONFIRM, Id, Number, "w", 0);
1618 sendf(appl, _DISCONNECT_I, Id, 0, "w", 0);
1619 plci->State = INC_DIS_PENDING;
1620 }
1621 return 1;
1622 }
1623 }
1624 }
1625
1626 if (!appl) return false;
1627 sendf(appl, _DISCONNECT_R | CONFIRM, Id, Number, "w", Info);
1628 return false;
1629 }
1630
1631 static byte disconnect_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1632 PLCI *plci, APPL *appl, API_PARSE *msg)
1633 {
1634 dbug(1, dprintf("disconnect_res"));
1635 if (plci)
1636 {
1637 /* clear ind mask bit, just in case of collsion of */
1638 /* DISCONNECT_IND and CONNECT_RES */
1639 clear_c_ind_mask_bit(plci, (word)(appl->Id - 1));
1640 ncci_free_receive_buffers(plci, 0);
1641 if (plci_remove_check(plci))
1642 {
1643 return 0;
1644 }
1645 if (plci->State == INC_DIS_PENDING
1646 || plci->State == SUSPENDING) {
1647 if (c_ind_mask_empty(plci)) {
1648 if (plci->State != SUSPENDING) plci->State = IDLE;
1649 dbug(1, dprintf("chs=%d", plci->channels));
1650 if (!plci->channels) {
1651 plci_remove(plci);
1652 }
1653 }
1654 }
1655 }
1656 return 0;
1657 }
1658
1659 static byte listen_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1660 PLCI *plci, APPL *appl, API_PARSE *parms)
1661 {
1662 word Info;
1663 byte i;
1664
1665 dbug(1, dprintf("listen_req(Appl=0x%x)", appl->Id));
1666
1667 Info = _WRONG_IDENTIFIER;
1668 if (a) {
1669 Info = 0;
1670 a->Info_Mask[appl->Id - 1] = GET_DWORD(parms[0].info);
1671 a->CIP_Mask[appl->Id - 1] = GET_DWORD(parms[1].info);
1672 dbug(1, dprintf("CIP_MASK=0x%lx", GET_DWORD(parms[1].info)));
1673 if (a->Info_Mask[appl->Id - 1] & 0x200) { /* early B3 connect provides */
1674 a->Info_Mask[appl->Id - 1] |= 0x10; /* call progression infos */
1675 }
1676
1677 /* check if external controller listen and switch listen on or off*/
1678 if (Id&EXT_CONTROLLER && GET_DWORD(parms[1].info)) {
1679 if (a->profile.Global_Options & ON_BOARD_CODEC) {
1680 dummy_plci.State = IDLE;
1681 a->codec_listen[appl->Id - 1] = &dummy_plci;
1682 a->TelOAD[0] = (byte)(parms[3].length);
1683 for (i = 1; parms[3].length >= i && i < 22; i++) {
1684 a->TelOAD[i] = parms[3].info[i];
1685 }
1686 a->TelOAD[i] = 0;
1687 a->TelOSA[0] = (byte)(parms[4].length);
1688 for (i = 1; parms[4].length >= i && i < 22; i++) {
1689 a->TelOSA[i] = parms[4].info[i];
1690 }
1691 a->TelOSA[i] = 0;
1692 }
1693 else Info = 0x2002; /* wrong controller, codec not supported */
1694 }
1695 else{ /* clear listen */
1696 a->codec_listen[appl->Id - 1] = (PLCI *)0;
1697 }
1698 }
1699 sendf(appl,
1700 _LISTEN_R | CONFIRM,
1701 Id,
1702 Number,
1703 "w", Info);
1704
1705 if (a) listen_check(a);
1706 return false;
1707 }
1708
1709 static byte info_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1710 PLCI *plci, APPL *appl, API_PARSE *msg)
1711 {
1712 word i;
1713 API_PARSE *ai;
1714 PLCI *rc_plci = NULL;
1715 API_PARSE ai_parms[5];
1716 word Info = 0;
1717
1718 dbug(1, dprintf("info_req"));
1719 for (i = 0; i < 5; i++) ai_parms[i].length = 0;
1720
1721 ai = &msg[1];
1722
1723 if (ai->length)
1724 {
1725 if (api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms))
1726 {
1727 dbug(1, dprintf("AddInfo wrong"));
1728 Info = _WRONG_MESSAGE_FORMAT;
1729 }
1730 }
1731 if (!a) Info = _WRONG_STATE;
1732
1733 if (!Info && plci)
1734 { /* no fac, with CPN, or KEY */
1735 rc_plci = plci;
1736 if (!ai_parms[3].length && plci->State && (msg[0].length || ai_parms[1].length))
1737 {
1738 /* overlap sending option */
1739 dbug(1, dprintf("OvlSnd"));
1740 add_s(plci, CPN, &msg[0]);
1741 add_s(plci, KEY, &ai_parms[1]);
1742 sig_req(plci, INFO_REQ, 0);
1743 send_req(plci);
1744 return false;
1745 }
1746
1747 if (plci->State && ai_parms[2].length)
1748 {
1749 /* User_Info option */
1750 dbug(1, dprintf("UUI"));
1751 add_s(plci, UUI, &ai_parms[2]);
1752 sig_req(plci, USER_DATA, 0);
1753 }
1754 else if (plci->State && ai_parms[3].length)
1755 {
1756 /* Facility option */
1757 dbug(1, dprintf("FAC"));
1758 add_s(plci, CPN, &msg[0]);
1759 add_ai(plci, &msg[1]);
1760 sig_req(plci, FACILITY_REQ, 0);
1761 }
1762 else
1763 {
1764 Info = _WRONG_STATE;
1765 }
1766 }
1767 else if ((ai_parms[1].length || ai_parms[2].length || ai_parms[3].length) && !Info)
1768 {
1769 /* NCR_Facility option -> send UUI and Keypad too */
1770 dbug(1, dprintf("NCR_FAC"));
1771 if ((i = get_plci(a)))
1772 {
1773 rc_plci = &a->plci[i - 1];
1774 appl->NullCREnable = true;
1775 rc_plci->internal_command = C_NCR_FAC_REQ;
1776 rc_plci->appl = appl;
1777 add_p(rc_plci, CAI, "\x01\x80");
1778 add_p(rc_plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
1779 sig_req(rc_plci, ASSIGN, DSIG_ID);
1780 send_req(rc_plci);
1781 }
1782 else
1783 {
1784 Info = _OUT_OF_PLCI;
1785 }
1786
1787 if (!Info)
1788 {
1789 add_s(rc_plci, CPN, &msg[0]);
1790 add_ai(rc_plci, &msg[1]);
1791 sig_req(rc_plci, NCR_FACILITY, 0);
1792 send_req(rc_plci);
1793 return false;
1794 /* for application controlled supplementary services */
1795 }
1796 }
1797
1798 if (!rc_plci)
1799 {
1800 Info = _WRONG_MESSAGE_FORMAT;
1801 }
1802
1803 if (!Info)
1804 {
1805 send_req(rc_plci);
1806 }
1807 else
1808 { /* appl is not assigned to a PLCI or error condition */
1809 dbug(1, dprintf("localInfoCon"));
1810 sendf(appl,
1811 _INFO_R | CONFIRM,
1812 Id,
1813 Number,
1814 "w", Info);
1815 }
1816 return false;
1817 }
1818
1819 static byte info_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1820 PLCI *plci, APPL *appl, API_PARSE *msg)
1821 {
1822 dbug(1, dprintf("info_res"));
1823 return false;
1824 }
1825
1826 static byte alert_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1827 PLCI *plci, APPL *appl, API_PARSE *msg)
1828 {
1829 word Info;
1830 byte ret;
1831
1832 dbug(1, dprintf("alert_req"));
1833
1834 Info = _WRONG_IDENTIFIER;
1835 ret = false;
1836 if (plci) {
1837 Info = _ALERT_IGNORED;
1838 if (plci->State != INC_CON_ALERT) {
1839 Info = _WRONG_STATE;
1840 if (plci->State == INC_CON_PENDING) {
1841 Info = 0;
1842 plci->State = INC_CON_ALERT;
1843 add_ai(plci, &msg[0]);
1844 sig_req(plci, CALL_ALERT, 0);
1845 ret = 1;
1846 }
1847 }
1848 }
1849 sendf(appl,
1850 _ALERT_R | CONFIRM,
1851 Id,
1852 Number,
1853 "w", Info);
1854 return ret;
1855 }
1856
1857 static byte facility_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
1858 PLCI *plci, APPL *appl, API_PARSE *msg)
1859 {
1860 word Info = 0;
1861 word i = 0;
1862
1863 word selector;
1864 word SSreq;
1865 long relatedPLCIvalue;
1866 DIVA_CAPI_ADAPTER *relatedadapter;
1867 byte *SSparms = "";
1868 byte RCparms[] = "\x05\x00\x00\x02\x00\x00";
1869 byte SSstruct[] = "\x09\x00\x00\x06\x00\x00\x00\x00\x00\x00";
1870 API_PARSE *parms;
1871 API_PARSE ss_parms[11];
1872 PLCI *rplci;
1873 byte cai[15];
1874 dword d;
1875 API_PARSE dummy;
1876
1877 dbug(1, dprintf("facility_req"));
1878 for (i = 0; i < 9; i++) ss_parms[i].length = 0;
1879
1880 parms = &msg[1];
1881
1882 if (!a)
1883 {
1884 dbug(1, dprintf("wrong Ctrl"));
1885 Info = _WRONG_IDENTIFIER;
1886 }
1887
1888 selector = GET_WORD(msg[0].info);
1889
1890 if (!Info)
1891 {
1892 switch (selector)
1893 {
1894 case SELECTOR_HANDSET:
1895 Info = AdvCodecSupport(a, plci, appl, HOOK_SUPPORT);
1896 break;
1897
1898 case SELECTOR_SU_SERV:
1899 if (!msg[1].length)
1900 {
1901 Info = _WRONG_MESSAGE_FORMAT;
1902 break;
1903 }
1904 SSreq = GET_WORD(&(msg[1].info[1]));
1905 PUT_WORD(&RCparms[1], SSreq);
1906 SSparms = RCparms;
1907 switch (SSreq)
1908 {
1909 case S_GET_SUPPORTED_SERVICES:
1910 if ((i = get_plci(a)))
1911 {
1912 rplci = &a->plci[i - 1];
1913 rplci->appl = appl;
1914 add_p(rplci, CAI, "\x01\x80");
1915 add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
1916 sig_req(rplci, ASSIGN, DSIG_ID);
1917 send_req(rplci);
1918 }
1919 else
1920 {
1921 PUT_DWORD(&SSstruct[6], MASK_TERMINAL_PORTABILITY);
1922 SSparms = (byte *)SSstruct;
1923 break;
1924 }
1925 rplci->internal_command = GETSERV_REQ_PEND;
1926 rplci->number = Number;
1927 rplci->appl = appl;
1928 sig_req(rplci, S_SUPPORTED, 0);
1929 send_req(rplci);
1930 return false;
1931 break;
1932
1933 case S_LISTEN:
1934 if (parms->length == 7)
1935 {
1936 if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms))
1937 {
1938 dbug(1, dprintf("format wrong"));
1939 Info = _WRONG_MESSAGE_FORMAT;
1940 break;
1941 }
1942 }
1943 else
1944 {
1945 Info = _WRONG_MESSAGE_FORMAT;
1946 break;
1947 }
1948 a->Notification_Mask[appl->Id - 1] = GET_DWORD(ss_parms[2].info);
1949 if (a->Notification_Mask[appl->Id - 1] & SMASK_MWI) /* MWI active? */
1950 {
1951 if ((i = get_plci(a)))
1952 {
1953 rplci = &a->plci[i - 1];
1954 rplci->appl = appl;
1955 add_p(rplci, CAI, "\x01\x80");
1956 add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
1957 sig_req(rplci, ASSIGN, DSIG_ID);
1958 send_req(rplci);
1959 }
1960 else
1961 {
1962 break;
1963 }
1964 rplci->internal_command = GET_MWI_STATE;
1965 rplci->number = Number;
1966 sig_req(rplci, MWI_POLL, 0);
1967 send_req(rplci);
1968 }
1969 break;
1970
1971 case S_HOLD:
1972 api_parse(&parms->info[1], (word)parms->length, "ws", ss_parms);
1973 if (plci && plci->State && plci->SuppState == IDLE)
1974 {
1975 plci->SuppState = HOLD_REQUEST;
1976 plci->command = C_HOLD_REQ;
1977 add_s(plci, CAI, &ss_parms[1]);
1978 sig_req(plci, CALL_HOLD, 0);
1979 send_req(plci);
1980 return false;
1981 }
1982 else Info = 0x3010; /* wrong state */
1983 break;
1984 case S_RETRIEVE:
1985 if (plci && plci->State && plci->SuppState == CALL_HELD)
1986 {
1987 if (Id & EXT_CONTROLLER)
1988 {
1989 if (AdvCodecSupport(a, plci, appl, 0))
1990 {
1991 Info = 0x3010; /* wrong state */
1992 break;
1993 }
1994 }
1995 else plci->tel = 0;
1996
1997 plci->SuppState = RETRIEVE_REQUEST;
1998 plci->command = C_RETRIEVE_REQ;
1999 if (plci->spoofed_msg == SPOOFING_REQUIRED)
2000 {
2001 plci->spoofed_msg = CALL_RETRIEVE;
2002 plci->internal_command = BLOCK_PLCI;
2003 plci->command = 0;
2004 dbug(1, dprintf("Spoof"));
2005 return false;
2006 }
2007 else
2008 {
2009 sig_req(plci, CALL_RETRIEVE, 0);
2010 send_req(plci);
2011 return false;
2012 }
2013 }
2014 else Info = 0x3010; /* wrong state */
2015 break;
2016 case S_SUSPEND:
2017 if (parms->length)
2018 {
2019 if (api_parse(&parms->info[1], (word)parms->length, "wbs", ss_parms))
2020 {
2021 dbug(1, dprintf("format wrong"));
2022 Info = _WRONG_MESSAGE_FORMAT;
2023 break;
2024 }
2025 }
2026 if (plci && plci->State)
2027 {
2028 add_s(plci, CAI, &ss_parms[2]);
2029 plci->command = SUSPEND_REQ;
2030 sig_req(plci, SUSPEND, 0);
2031 plci->State = SUSPENDING;
2032 send_req(plci);
2033 }
2034 else Info = 0x3010; /* wrong state */
2035 break;
2036
2037 case S_RESUME:
2038 if (!(i = get_plci(a)))
2039 {
2040 Info = _OUT_OF_PLCI;
2041 break;
2042 }
2043 rplci = &a->plci[i - 1];
2044 rplci->appl = appl;
2045 rplci->number = Number;
2046 rplci->tel = 0;
2047 rplci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
2048 /* check 'external controller' bit for codec support */
2049 if (Id & EXT_CONTROLLER)
2050 {
2051 if (AdvCodecSupport(a, rplci, appl, 0))
2052 {
2053 rplci->Id = 0;
2054 Info = 0x300A;
2055 break;
2056 }
2057 }
2058 if (parms->length)
2059 {
2060 if (api_parse(&parms->info[1], (word)parms->length, "wbs", ss_parms))
2061 {
2062 dbug(1, dprintf("format wrong"));
2063 rplci->Id = 0;
2064 Info = _WRONG_MESSAGE_FORMAT;
2065 break;
2066 }
2067 }
2068 dummy.length = 0;
2069 dummy.info = "\x00";
2070 add_b1(rplci, &dummy, 0, 0);
2071 if (a->Info_Mask[appl->Id - 1] & 0x200)
2072 {
2073 /* early B3 connect (CIP mask bit 9) no release after a disc */
2074 add_p(rplci, LLI, "\x01\x01");
2075 }
2076 add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
2077 sig_req(rplci, ASSIGN, DSIG_ID);
2078 send_req(rplci);
2079 add_s(rplci, CAI, &ss_parms[2]);
2080 rplci->command = RESUME_REQ;
2081 sig_req(rplci, RESUME, 0);
2082 rplci->State = RESUMING;
2083 send_req(rplci);
2084 break;
2085
2086 case S_CONF_BEGIN: /* Request */
2087 case S_CONF_DROP:
2088 case S_CONF_ISOLATE:
2089 case S_CONF_REATTACH:
2090 if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms))
2091 {
2092 dbug(1, dprintf("format wrong"));
2093 Info = _WRONG_MESSAGE_FORMAT;
2094 break;
2095 }
2096 if (plci && plci->State && ((plci->SuppState == IDLE) || (plci->SuppState == CALL_HELD)))
2097 {
2098 d = GET_DWORD(ss_parms[2].info);
2099 if (d >= 0x80)
2100 {
2101 dbug(1, dprintf("format wrong"));
2102 Info = _WRONG_MESSAGE_FORMAT;
2103 break;
2104 }
2105 plci->ptyState = (byte)SSreq;
2106 plci->command = 0;
2107 cai[0] = 2;
2108 switch (SSreq)
2109 {
2110 case S_CONF_BEGIN:
2111 cai[1] = CONF_BEGIN;
2112 plci->internal_command = CONF_BEGIN_REQ_PEND;
2113 break;
2114 case S_CONF_DROP:
2115 cai[1] = CONF_DROP;
2116 plci->internal_command = CONF_DROP_REQ_PEND;
2117 break;
2118 case S_CONF_ISOLATE:
2119 cai[1] = CONF_ISOLATE;
2120 plci->internal_command = CONF_ISOLATE_REQ_PEND;
2121 break;
2122 case S_CONF_REATTACH:
2123 cai[1] = CONF_REATTACH;
2124 plci->internal_command = CONF_REATTACH_REQ_PEND;
2125 break;
2126 }
2127 cai[2] = (byte)d; /* Conference Size resp. PartyId */
2128 add_p(plci, CAI, cai);
2129 sig_req(plci, S_SERVICE, 0);
2130 send_req(plci);
2131 return false;
2132 }
2133 else Info = 0x3010; /* wrong state */
2134 break;
2135
2136 case S_ECT:
2137 case S_3PTY_BEGIN:
2138 case S_3PTY_END:
2139 case S_CONF_ADD:
2140 if (parms->length == 7)
2141 {
2142 if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms))
2143 {
2144 dbug(1, dprintf("format wrong"));
2145 Info = _WRONG_MESSAGE_FORMAT;
2146 break;
2147 }
2148 }
2149 else if (parms->length == 8) /* workaround for the T-View-S */
2150 {
2151 if (api_parse(&parms->info[1], (word)parms->length, "wbdb", ss_parms))
2152 {
2153 dbug(1, dprintf("format wrong"));
2154 Info = _WRONG_MESSAGE_FORMAT;
2155 break;
2156 }
2157 }
2158 else
2159 {
2160 Info = _WRONG_MESSAGE_FORMAT;
2161 break;
2162 }
2163 if (!msg[1].length)
2164 {
2165 Info = _WRONG_MESSAGE_FORMAT;
2166 break;
2167 }
2168 if (!plci)
2169 {
2170 Info = _WRONG_IDENTIFIER;
2171 break;
2172 }
2173 relatedPLCIvalue = GET_DWORD(ss_parms[2].info);
2174 relatedPLCIvalue &= 0x0000FFFF;
2175 dbug(1, dprintf("PTY/ECT/addCONF,relPLCI=%lx", relatedPLCIvalue));
2176 /* controller starts with 0 up to (max_adapter - 1) */
2177 if (((relatedPLCIvalue & 0x7f) == 0)
2178 || (MapController((byte)(relatedPLCIvalue & 0x7f)) == 0)
2179 || (MapController((byte)(relatedPLCIvalue & 0x7f)) > max_adapter))
2180 {
2181 if (SSreq == S_3PTY_END)
2182 {
2183 dbug(1, dprintf("wrong Controller use 2nd PLCI=PLCI"));
2184 rplci = plci;
2185 }
2186 else
2187 {
2188 Info = 0x3010; /* wrong state */
2189 break;
2190 }
2191 }
2192 else
2193 {
2194 relatedadapter = &adapter[MapController((byte)(relatedPLCIvalue & 0x7f)) - 1];
2195 relatedPLCIvalue >>= 8;
2196 /* find PLCI PTR*/
2197 for (i = 0, rplci = NULL; i < relatedadapter->max_plci; i++)
2198 {
2199 if (relatedadapter->plci[i].Id == (byte)relatedPLCIvalue)
2200 {
2201 rplci = &relatedadapter->plci[i];
2202 }
2203 }
2204 if (!rplci || !relatedPLCIvalue)
2205 {
2206 if (SSreq == S_3PTY_END)
2207 {
2208 dbug(1, dprintf("use 2nd PLCI=PLCI"));
2209 rplci = plci;
2210 }
2211 else
2212 {
2213 Info = 0x3010; /* wrong state */
2214 break;
2215 }
2216 }
2217 }
2218 /*
2219 dbug(1, dprintf("rplci:%x", rplci));
2220 dbug(1, dprintf("plci:%x", plci));
2221 dbug(1, dprintf("rplci->ptyState:%x", rplci->ptyState));
2222 dbug(1, dprintf("plci->ptyState:%x", plci->ptyState));
2223 dbug(1, dprintf("SSreq:%x", SSreq));
2224 dbug(1, dprintf("rplci->internal_command:%x", rplci->internal_command));
2225 dbug(1, dprintf("rplci->appl:%x", rplci->appl));
2226 dbug(1, dprintf("rplci->Id:%x", rplci->Id));
2227 */
2228 /* send PTY/ECT req, cannot check all states because of US stuff */
2229 if (!rplci->internal_command && rplci->appl)
2230 {
2231 plci->command = 0;
2232 rplci->relatedPTYPLCI = plci;
2233 plci->relatedPTYPLCI = rplci;
2234 rplci->ptyState = (byte)SSreq;
2235 if (SSreq == S_ECT)
2236 {
2237 rplci->internal_command = ECT_REQ_PEND;
2238 cai[1] = ECT_EXECUTE;
2239
2240 rplci->vswitchstate = 0;
2241 rplci->vsprot = 0;
2242 rplci->vsprotdialect = 0;
2243 plci->vswitchstate = 0;
2244 plci->vsprot = 0;
2245 plci->vsprotdialect = 0;
2246
2247 }
2248 else if (SSreq == S_CONF_ADD)
2249 {
2250 rplci->internal_command = CONF_ADD_REQ_PEND;
2251 cai[1] = CONF_ADD;
2252 }
2253 else
2254 {
2255 rplci->internal_command = PTY_REQ_PEND;
2256 cai[1] = (byte)(SSreq - 3);
2257 }
2258 rplci->number = Number;
2259 if (plci != rplci) /* explicit invocation */
2260 {
2261 cai[0] = 2;
2262 cai[2] = plci->Sig.Id;
2263 dbug(1, dprintf("explicit invocation"));
2264 }
2265 else
2266 {
2267 dbug(1, dprintf("implicit invocation"));
2268 cai[0] = 1;
2269 }
2270 add_p(rplci, CAI, cai);
2271 sig_req(rplci, S_SERVICE, 0);
2272 send_req(rplci);
2273 return false;
2274 }
2275 else
2276 {
2277 dbug(0, dprintf("Wrong line"));
2278 Info = 0x3010; /* wrong state */
2279 break;
2280 }
2281 break;
2282
2283 case S_CALL_DEFLECTION:
2284 if (api_parse(&parms->info[1], (word)parms->length, "wbwss", ss_parms))
2285 {
2286 dbug(1, dprintf("format wrong"));
2287 Info = _WRONG_MESSAGE_FORMAT;
2288 break;
2289 }
2290 if (!plci)
2291 {
2292 Info = _WRONG_IDENTIFIER;
2293 break;
2294 }
2295 /* reuse unused screening indicator */
2296 ss_parms[3].info[3] = (byte)GET_WORD(&(ss_parms[2].info[0]));
2297 plci->command = 0;
2298 plci->internal_command = CD_REQ_PEND;
2299 appl->CDEnable = true;
2300 cai[0] = 1;
2301 cai[1] = CALL_DEFLECTION;
2302 add_p(plci, CAI, cai);
2303 add_p(plci, CPN, ss_parms[3].info);
2304 sig_req(plci, S_SERVICE, 0);
2305 send_req(plci);
2306 return false;
2307 break;
2308
2309 case S_CALL_FORWARDING_START:
2310 if (api_parse(&parms->info[1], (word)parms->length, "wbdwwsss", ss_parms))
2311 {
2312 dbug(1, dprintf("format wrong"));
2313 Info = _WRONG_MESSAGE_FORMAT;
2314 break;
2315 }
2316
2317 if ((i = get_plci(a)))
2318 {
2319 rplci = &a->plci[i - 1];
2320 rplci->appl = appl;
2321 add_p(rplci, CAI, "\x01\x80");
2322 add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
2323 sig_req(rplci, ASSIGN, DSIG_ID);
2324 send_req(rplci);
2325 }
2326 else
2327 {
2328 Info = _OUT_OF_PLCI;
2329 break;
2330 }
2331
2332 /* reuse unused screening indicator */
2333 rplci->internal_command = CF_START_PEND;
2334 rplci->appl = appl;
2335 rplci->number = Number;
2336 appl->S_Handle = GET_DWORD(&(ss_parms[2].info[0]));
2337 cai[0] = 2;
2338 cai[1] = 0x70 | (byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */
2339 cai[2] = (byte)GET_WORD(&(ss_parms[4].info[0])); /* Basic Service */
2340 add_p(rplci, CAI, cai);
2341 add_p(rplci, OAD, ss_parms[5].info);
2342 add_p(rplci, CPN, ss_parms[6].info);
2343 sig_req(rplci, S_SERVICE, 0);
2344 send_req(rplci);
2345 return false;
2346 break;
2347
2348 case S_INTERROGATE_DIVERSION:
2349 case S_INTERROGATE_NUMBERS:
2350 case S_CALL_FORWARDING_STOP:
2351 case S_CCBS_REQUEST:
2352 case S_CCBS_DEACTIVATE:
2353 case S_CCBS_INTERROGATE:
2354 switch (SSreq)
2355 {
2356 case S_INTERROGATE_NUMBERS:
2357 if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms))
2358 {
2359 dbug(0, dprintf("format wrong"));
2360 Info = _WRONG_MESSAGE_FORMAT;
2361 }
2362 break;
2363 case S_CCBS_REQUEST:
2364 case S_CCBS_DEACTIVATE:
2365 if (api_parse(&parms->info[1], (word)parms->length, "wbdw", ss_parms))
2366 {
2367 dbug(0, dprintf("format wrong"));
2368 Info = _WRONG_MESSAGE_FORMAT;
2369 }
2370 break;
2371 case S_CCBS_INTERROGATE:
2372 if (api_parse(&parms->info[1], (word)parms->length, "wbdws", ss_parms))
2373 {
2374 dbug(0, dprintf("format wrong"));
2375 Info = _WRONG_MESSAGE_FORMAT;
2376 }
2377 break;
2378 default:
2379 if (api_parse(&parms->info[1], (word)parms->length, "wbdwws", ss_parms))
2380 {
2381 dbug(0, dprintf("format wrong"));
2382 Info = _WRONG_MESSAGE_FORMAT;
2383 break;
2384 }
2385 break;
2386 }
2387
2388 if (Info) break;
2389 if ((i = get_plci(a)))
2390 {
2391 rplci = &a->plci[i - 1];
2392 switch (SSreq)
2393 {
2394 case S_INTERROGATE_DIVERSION: /* use cai with S_SERVICE below */
2395 cai[1] = 0x60 | (byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */
2396 rplci->internal_command = INTERR_DIVERSION_REQ_PEND; /* move to rplci if assigned */
2397 break;
2398 case S_INTERROGATE_NUMBERS: /* use cai with S_SERVICE below */
2399 cai[1] = DIVERSION_INTERROGATE_NUM; /* Function */
2400 rplci->internal_command = INTERR_NUMBERS_REQ_PEND; /* move to rplci if assigned */
2401 break;
2402 case S_CALL_FORWARDING_STOP:
2403 rplci->internal_command = CF_STOP_PEND;
2404 cai[1] = 0x80 | (byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */
2405 break;
2406 case S_CCBS_REQUEST:
2407 cai[1] = CCBS_REQUEST;
2408 rplci->internal_command = CCBS_REQUEST_REQ_PEND;
2409 break;
2410 case S_CCBS_DEACTIVATE:
2411 cai[1] = CCBS_DEACTIVATE;
2412 rplci->internal_command = CCBS_DEACTIVATE_REQ_PEND;
2413 break;
2414 case S_CCBS_INTERROGATE:
2415 cai[1] = CCBS_INTERROGATE;
2416 rplci->internal_command = CCBS_INTERROGATE_REQ_PEND;
2417 break;
2418 default:
2419 cai[1] = 0;
2420 break;
2421 }
2422 rplci->appl = appl;
2423 rplci->number = Number;
2424 add_p(rplci, CAI, "\x01\x80");
2425 add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
2426 sig_req(rplci, ASSIGN, DSIG_ID);
2427 send_req(rplci);
2428 }
2429 else
2430 {
2431 Info = _OUT_OF_PLCI;
2432 break;
2433 }
2434
2435 appl->S_Handle = GET_DWORD(&(ss_parms[2].info[0]));
2436 switch (SSreq)
2437 {
2438 case S_INTERROGATE_NUMBERS:
2439 cai[0] = 1;
2440 add_p(rplci, CAI, cai);
2441 break;
2442 case S_CCBS_REQUEST:
2443 case S_CCBS_DEACTIVATE:
2444 cai[0] = 3;
2445 PUT_WORD(&cai[2], GET_WORD(&(ss_parms[3].info[0])));
2446 add_p(rplci, CAI, cai);
2447 break;
2448 case S_CCBS_INTERROGATE:
2449 cai[0] = 3;
2450 PUT_WORD(&cai[2], GET_WORD(&(ss_parms[3].info[0])));
2451 add_p(rplci, CAI, cai);
2452 add_p(rplci, OAD, ss_parms[4].info);
2453 break;
2454 default:
2455 cai[0] = 2;
2456 cai[2] = (byte)GET_WORD(&(ss_parms[4].info[0])); /* Basic Service */
2457 add_p(rplci, CAI, cai);
2458 add_p(rplci, OAD, ss_parms[5].info);
2459 break;
2460 }
2461
2462 sig_req(rplci, S_SERVICE, 0);
2463 send_req(rplci);
2464 return false;
2465 break;
2466
2467 case S_MWI_ACTIVATE:
2468 if (api_parse(&parms->info[1], (word)parms->length, "wbwdwwwssss", ss_parms))
2469 {
2470 dbug(1, dprintf("format wrong"));
2471 Info = _WRONG_MESSAGE_FORMAT;
2472 break;
2473 }
2474 if (!plci)
2475 {
2476 if ((i = get_plci(a)))
2477 {
2478 rplci = &a->plci[i - 1];
2479 rplci->appl = appl;
2480 rplci->cr_enquiry = true;
2481 add_p(rplci, CAI, "\x01\x80");
2482 add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
2483 sig_req(rplci, ASSIGN, DSIG_ID);
2484 send_req(rplci);
2485 }
2486 else
2487 {
2488 Info = _OUT_OF_PLCI;
2489 break;
2490 }
2491 }
2492 else
2493 {
2494 rplci = plci;
2495 rplci->cr_enquiry = false;
2496 }
2497
2498 rplci->command = 0;
2499 rplci->internal_command = MWI_ACTIVATE_REQ_PEND;
2500 rplci->appl = appl;
2501 rplci->number = Number;
2502
2503 cai[0] = 13;
2504 cai[1] = ACTIVATION_MWI; /* Function */
2505 PUT_WORD(&cai[2], GET_WORD(&(ss_parms[2].info[0]))); /* Basic Service */
2506 PUT_DWORD(&cai[4], GET_DWORD(&(ss_parms[3].info[0]))); /* Number of Messages */
2507 PUT_WORD(&cai[8], GET_WORD(&(ss_parms[4].info[0]))); /* Message Status */
2508 PUT_WORD(&cai[10], GET_WORD(&(ss_parms[5].info[0]))); /* Message Reference */
2509 PUT_WORD(&cai[12], GET_WORD(&(ss_parms[6].info[0]))); /* Invocation Mode */
2510 add_p(rplci, CAI, cai);
2511 add_p(rplci, CPN, ss_parms[7].info); /* Receiving User Number */
2512 add_p(rplci, OAD, ss_parms[8].info); /* Controlling User Number */
2513 add_p(rplci, OSA, ss_parms[9].info); /* Controlling User Provided Number */
2514 add_p(rplci, UID, ss_parms[10].info); /* Time */
2515 sig_req(rplci, S_SERVICE, 0);
2516 send_req(rplci);
2517 return false;
2518
2519 case S_MWI_DEACTIVATE:
2520 if (api_parse(&parms->info[1], (word)parms->length, "wbwwss", ss_parms))
2521 {
2522 dbug(1, dprintf("format wrong"));
2523 Info = _WRONG_MESSAGE_FORMAT;
2524 break;
2525 }
2526 if (!plci)
2527 {
2528 if ((i = get_plci(a)))
2529 {
2530 rplci = &a->plci[i - 1];
2531 rplci->appl = appl;
2532 rplci->cr_enquiry = true;
2533 add_p(rplci, CAI, "\x01\x80");
2534 add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
2535 sig_req(rplci, ASSIGN, DSIG_ID);
2536 send_req(rplci);
2537 }
2538 else
2539 {
2540 Info = _OUT_OF_PLCI;
2541 break;
2542 }
2543 }
2544 else
2545 {
2546 rplci = plci;
2547 rplci->cr_enquiry = false;
2548 }
2549
2550 rplci->command = 0;
2551 rplci->internal_command = MWI_DEACTIVATE_REQ_PEND;
2552 rplci->appl = appl;
2553 rplci->number = Number;
2554
2555 cai[0] = 5;
2556 cai[1] = DEACTIVATION_MWI; /* Function */
2557 PUT_WORD(&cai[2], GET_WORD(&(ss_parms[2].info[0]))); /* Basic Service */
2558 PUT_WORD(&cai[4], GET_WORD(&(ss_parms[3].info[0]))); /* Invocation Mode */
2559 add_p(rplci, CAI, cai);
2560 add_p(rplci, CPN, ss_parms[4].info); /* Receiving User Number */
2561 add_p(rplci, OAD, ss_parms[5].info); /* Controlling User Number */
2562 sig_req(rplci, S_SERVICE, 0);
2563 send_req(rplci);
2564 return false;
2565
2566 default:
2567 Info = 0x300E; /* not supported */
2568 break;
2569 }
2570 break; /* case SELECTOR_SU_SERV: end */
2571
2572
2573 case SELECTOR_DTMF:
2574 return (dtmf_request(Id, Number, a, plci, appl, msg));
2575
2576
2577
2578 case SELECTOR_LINE_INTERCONNECT:
2579 return (mixer_request(Id, Number, a, plci, appl, msg));
2580
2581
2582
2583 case PRIV_SELECTOR_ECHO_CANCELLER:
2584 appl->appl_flags |= APPL_FLAG_PRIV_EC_SPEC;
2585 return (ec_request(Id, Number, a, plci, appl, msg));
2586
2587 case SELECTOR_ECHO_CANCELLER:
2588 appl->appl_flags &= ~APPL_FLAG_PRIV_EC_SPEC;
2589 return (ec_request(Id, Number, a, plci, appl, msg));
2590
2591
2592 case SELECTOR_V42BIS:
2593 default:
2594 Info = _FACILITY_NOT_SUPPORTED;
2595 break;
2596 } /* end of switch (selector) */
2597 }
2598
2599 dbug(1, dprintf("SendFacRc"));
2600 sendf(appl,
2601 _FACILITY_R | CONFIRM,
2602 Id,
2603 Number,
2604 "wws", Info, selector, SSparms);
2605 return false;
2606 }
2607
2608 static byte facility_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2609 PLCI *plci, APPL *appl, API_PARSE *msg)
2610 {
2611 dbug(1, dprintf("facility_res"));
2612 return false;
2613 }
2614
2615 static byte connect_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2616 PLCI *plci, APPL *appl, API_PARSE *parms)
2617 {
2618 word Info = 0;
2619 byte req;
2620 byte len;
2621 word w;
2622 word fax_control_bits, fax_feature_bits, fax_info_change;
2623 API_PARSE *ncpi;
2624 byte pvc[2];
2625
2626 API_PARSE fax_parms[9];
2627 word i;
2628
2629
2630 dbug(1, dprintf("connect_b3_req"));
2631 if (plci)
2632 {
2633 if ((plci->State == IDLE) || (plci->State == OUTG_DIS_PENDING)
2634 || (plci->State == INC_DIS_PENDING) || (plci->SuppState != IDLE))
2635 {
2636 Info = _WRONG_STATE;
2637 }
2638 else
2639 {
2640 /* local reply if assign unsuccessful
2641 or B3 protocol allows only one layer 3 connection
2642 and already connected
2643 or B2 protocol not any LAPD
2644 and connect_b3_req contradicts originate/answer direction */
2645 if (!plci->NL.Id
2646 || (((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE))
2647 && ((plci->channels != 0)
2648 || (((plci->B2_prot != B2_SDLC) && (plci->B2_prot != B2_LAPD) && (plci->B2_prot != B2_LAPD_FREE_SAPI_SEL))
2649 && ((plci->call_dir & CALL_DIR_ANSWER) && !(plci->call_dir & CALL_DIR_FORCE_OUTG_NL))))))
2650 {
2651 dbug(1, dprintf("B3 already connected=%d or no NL.Id=0x%x, dir=%d sstate=0x%x",
2652 plci->channels, plci->NL.Id, plci->call_dir, plci->SuppState));
2653 Info = _WRONG_STATE;
2654 sendf(appl,
2655 _CONNECT_B3_R | CONFIRM,
2656 Id,
2657 Number,
2658 "w", Info);
2659 return false;
2660 }
2661 plci->requested_options_conn = 0;
2662
2663 req = N_CONNECT;
2664 ncpi = &parms[0];
2665 if (plci->B3_prot == 2 || plci->B3_prot == 3)
2666 {
2667 if (ncpi->length > 2)
2668 {
2669 /* check for PVC */
2670 if (ncpi->info[2] || ncpi->info[3])
2671 {
2672 pvc[0] = ncpi->info[3];
2673 pvc[1] = ncpi->info[2];
2674 add_d(plci, 2, pvc);
2675 req = N_RESET;
2676 }
2677 else
2678 {
2679 if (ncpi->info[1] & 1) req = N_CONNECT | N_D_BIT;
2680 add_d(plci, (word)(ncpi->length - 3), &ncpi->info[4]);
2681 }
2682 }
2683 }
2684 else if (plci->B3_prot == 5)
2685 {
2686 if (plci->NL.Id && !plci->nl_remove_id)
2687 {
2688 fax_control_bits = GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low);
2689 fax_feature_bits = GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->feature_bits_low);
2690 if (!(fax_control_bits & T30_CONTROL_BIT_MORE_DOCUMENTS)
2691 || (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS))
2692 {
2693 len = offsetof(T30_INFO, universal_6);
2694 fax_info_change = false;
2695 if (ncpi->length >= 4)
2696 {
2697 w = GET_WORD(&ncpi->info[3]);
2698 if ((w & 0x0001) != ((word)(((T30_INFO *)(plci->fax_connect_info_buffer))->resolution & 0x0001)))
2699 {
2700 ((T30_INFO *)(plci->fax_connect_info_buffer))->resolution =
2701 (byte)((((T30_INFO *)(plci->fax_connect_info_buffer))->resolution & ~T30_RESOLUTION_R8_0770_OR_200) |
2702 ((w & 0x0001) ? T30_RESOLUTION_R8_0770_OR_200 : 0));
2703 fax_info_change = true;
2704 }
2705 fax_control_bits &= ~(T30_CONTROL_BIT_REQUEST_POLLING | T30_CONTROL_BIT_MORE_DOCUMENTS);
2706 if (w & 0x0002) /* Fax-polling request */
2707 fax_control_bits |= T30_CONTROL_BIT_REQUEST_POLLING;
2708 if ((w & 0x0004) /* Request to send / poll another document */
2709 && (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_MORE_DOCUMENTS))
2710 {
2711 fax_control_bits |= T30_CONTROL_BIT_MORE_DOCUMENTS;
2712 }
2713 if (ncpi->length >= 6)
2714 {
2715 w = GET_WORD(&ncpi->info[5]);
2716 if (((byte) w) != ((T30_INFO *)(plci->fax_connect_info_buffer))->data_format)
2717 {
2718 ((T30_INFO *)(plci->fax_connect_info_buffer))->data_format = (byte) w;
2719 fax_info_change = true;
2720 }
2721
2722 if ((a->man_profile.private_options & (1L << PRIVATE_FAX_SUB_SEP_PWD))
2723 && (GET_WORD(&ncpi->info[5]) & 0x8000)) /* Private SEP/SUB/PWD enable */
2724 {
2725 plci->requested_options_conn |= (1L << PRIVATE_FAX_SUB_SEP_PWD);
2726 }
2727 if ((a->man_profile.private_options & (1L << PRIVATE_FAX_NONSTANDARD))
2728 && (GET_WORD(&ncpi->info[5]) & 0x4000)) /* Private non-standard facilities enable */
2729 {
2730 plci->requested_options_conn |= (1L << PRIVATE_FAX_NONSTANDARD);
2731 }
2732 fax_control_bits &= ~(T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_SEL_POLLING |
2733 T30_CONTROL_BIT_ACCEPT_PASSWORD);
2734 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id - 1])
2735 & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
2736 {
2737 if (api_parse(&ncpi->info[1], ncpi->length, "wwwwsss", fax_parms))
2738 Info = _WRONG_MESSAGE_FORMAT;
2739 else
2740 {
2741 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id - 1])
2742 & (1L << PRIVATE_FAX_SUB_SEP_PWD))
2743 {
2744 fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_PASSWORD;
2745 if (fax_control_bits & T30_CONTROL_BIT_ACCEPT_POLLING)
2746 fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SEL_POLLING;
2747 }
2748 w = fax_parms[4].length;
2749 if (w > 20)
2750 w = 20;
2751 ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id_len = (byte) w;
2752 for (i = 0; i < w; i++)
2753 ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id[i] = fax_parms[4].info[1 + i];
2754 ((T30_INFO *)(plci->fax_connect_info_buffer))->head_line_len = 0;
2755 len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
2756 w = fax_parms[5].length;
2757 if (w > 20)
2758 w = 20;
2759 plci->fax_connect_info_buffer[len++] = (byte) w;
2760 for (i = 0; i < w; i++)
2761 plci->fax_connect_info_buffer[len++] = fax_parms[5].info[1 + i];
2762 w = fax_parms[6].length;
2763 if (w > 20)
2764 w = 20;
2765 plci->fax_connect_info_buffer[len++] = (byte) w;
2766 for (i = 0; i < w; i++)
2767 plci->fax_connect_info_buffer[len++] = fax_parms[6].info[1 + i];
2768 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id - 1])
2769 & (1L << PRIVATE_FAX_NONSTANDARD))
2770 {
2771 if (api_parse(&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms))
2772 {
2773 dbug(1, dprintf("non-standard facilities info missing or wrong format"));
2774 plci->fax_connect_info_buffer[len++] = 0;
2775 }
2776 else
2777 {
2778 if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2))
2779 plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]);
2780 plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length);
2781 for (i = 0; i < fax_parms[7].length; i++)
2782 plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1 + i];
2783 }
2784 }
2785 }
2786 }
2787 else
2788 {
2789 len = offsetof(T30_INFO, universal_6);
2790 }
2791 fax_info_change = true;
2792
2793 }
2794 if (fax_control_bits != GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low))
2795 {
2796 PUT_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low, fax_control_bits);
2797 fax_info_change = true;
2798 }
2799 }
2800 if (Info == GOOD)
2801 {
2802 plci->fax_connect_info_length = len;
2803 if (fax_info_change)
2804 {
2805 if (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS)
2806 {
2807 start_internal_command(Id, plci, fax_connect_info_command);
2808 return false;
2809 }
2810 else
2811 {
2812 start_internal_command(Id, plci, fax_adjust_b23_command);
2813 return false;
2814 }
2815 }
2816 }
2817 }
2818 else Info = _WRONG_STATE;
2819 }
2820 else Info = _WRONG_STATE;
2821 }
2822
2823 else if (plci->B3_prot == B3_RTP)
2824 {
2825 plci->internal_req_buffer[0] = ncpi->length + 1;
2826 plci->internal_req_buffer[1] = UDATA_REQUEST_RTP_RECONFIGURE;
2827 for (w = 0; w < ncpi->length; w++)
2828 plci->internal_req_buffer[2 + w] = ncpi->info[1 + w];
2829 start_internal_command(Id, plci, rtp_connect_b3_req_command);
2830 return false;
2831 }
2832
2833 if (!Info)
2834 {
2835 nl_req_ncci(plci, req, 0);
2836 return 1;
2837 }
2838 }
2839 }
2840 else Info = _WRONG_IDENTIFIER;
2841
2842 sendf(appl,
2843 _CONNECT_B3_R | CONFIRM,
2844 Id,
2845 Number,
2846 "w", Info);
2847 return false;
2848 }
2849
2850 static byte connect_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2851 PLCI *plci, APPL *appl, API_PARSE *parms)
2852 {
2853 word ncci;
2854 API_PARSE *ncpi;
2855 byte req;
2856
2857 word w;
2858
2859
2860 API_PARSE fax_parms[9];
2861 word i;
2862 byte len;
2863
2864
2865 dbug(1, dprintf("connect_b3_res"));
2866
2867 ncci = (word)(Id >> 16);
2868 if (plci && ncci) {
2869 if (a->ncci_state[ncci] == INC_CON_PENDING) {
2870 if (GET_WORD(&parms[0].info[0]) != 0)
2871 {
2872 a->ncci_state[ncci] = OUTG_REJ_PENDING;
2873 channel_request_xon(plci, a->ncci_ch[ncci]);
2874 channel_xmit_xon(plci);
2875 cleanup_ncci_data(plci, ncci);
2876 nl_req_ncci(plci, N_DISC, (byte)ncci);
2877 return 1;
2878 }
2879 a->ncci_state[ncci] = INC_ACT_PENDING;
2880
2881 req = N_CONNECT_ACK;
2882 ncpi = &parms[1];
2883 if ((plci->B3_prot == 4) || (plci->B3_prot == 5) || (plci->B3_prot == 7))
2884 {
2885
2886 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id - 1])
2887 & (1L << PRIVATE_FAX_NONSTANDARD))
2888 {
2889 if (((plci->B3_prot == 4) || (plci->B3_prot == 5))
2890 && (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF)
2891 && (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP))
2892 {
2893 len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
2894 if (plci->fax_connect_info_length < len)
2895 {
2896 ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id_len = 0;
2897 ((T30_INFO *)(plci->fax_connect_info_buffer))->head_line_len = 0;
2898 }
2899 if (api_parse(&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms))
2900 {
2901 dbug(1, dprintf("non-standard facilities info missing or wrong format"));
2902 }
2903 else
2904 {
2905 if (plci->fax_connect_info_length <= len)
2906 plci->fax_connect_info_buffer[len] = 0;
2907 len += 1 + plci->fax_connect_info_buffer[len];
2908 if (plci->fax_connect_info_length <= len)
2909 plci->fax_connect_info_buffer[len] = 0;
2910 len += 1 + plci->fax_connect_info_buffer[len];
2911 if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2))
2912 plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]);
2913 plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length);
2914 for (i = 0; i < fax_parms[7].length; i++)
2915 plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1 + i];
2916 }
2917 plci->fax_connect_info_length = len;
2918 ((T30_INFO *)(plci->fax_connect_info_buffer))->code = 0;
2919 start_internal_command(Id, plci, fax_connect_ack_command);
2920 return false;
2921 }
2922 }
2923
2924 nl_req_ncci(plci, req, (byte)ncci);
2925 if ((plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
2926 && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
2927 {
2928 if (plci->B3_prot == 4)
2929 sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
2930 else
2931 sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
2932 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
2933 }
2934 }
2935
2936 else if (plci->B3_prot == B3_RTP)
2937 {
2938 plci->internal_req_buffer[0] = ncpi->length + 1;
2939 plci->internal_req_buffer[1] = UDATA_REQUEST_RTP_RECONFIGURE;
2940 for (w = 0; w < ncpi->length; w++)
2941 plci->internal_req_buffer[2 + w] = ncpi->info[1+w];
2942 start_internal_command(Id, plci, rtp_connect_b3_res_command);
2943 return false;
2944 }
2945
2946 else
2947 {
2948 if (ncpi->length > 2) {
2949 if (ncpi->info[1] & 1) req = N_CONNECT_ACK | N_D_BIT;
2950 add_d(plci, (word)(ncpi->length - 3), &ncpi->info[4]);
2951 }
2952 nl_req_ncci(plci, req, (byte)ncci);
2953 sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
2954 if (plci->adjust_b_restore)
2955 {
2956 plci->adjust_b_restore = false;
2957 start_internal_command(Id, plci, adjust_b_restore);
2958 }
2959 }
2960 return 1;
2961 }
2962 }
2963 return false;
2964 }
2965
2966 static byte connect_b3_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2967 PLCI *plci, APPL *appl, API_PARSE *parms)
2968 {
2969 word ncci;
2970
2971 ncci = (word)(Id >> 16);
2972 dbug(1, dprintf("connect_b3_a_res(ncci=0x%x)", ncci));
2973
2974 if (plci && ncci && (plci->State != IDLE) && (plci->State != INC_DIS_PENDING)
2975 && (plci->State != OUTG_DIS_PENDING))
2976 {
2977 if (a->ncci_state[ncci] == INC_ACT_PENDING) {
2978 a->ncci_state[ncci] = CONNECTED;
2979 if (plci->State != INC_CON_CONNECTED_ALERT) plci->State = CONNECTED;
2980 channel_request_xon(plci, a->ncci_ch[ncci]);
2981 channel_xmit_xon(plci);
2982 }
2983 }
2984 return false;
2985 }
2986
2987 static byte disconnect_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
2988 PLCI *plci, APPL *appl, API_PARSE *parms)
2989 {
2990 word Info;
2991 word ncci;
2992 API_PARSE *ncpi;
2993
2994 dbug(1, dprintf("disconnect_b3_req"));
2995
2996 Info = _WRONG_IDENTIFIER;
2997 ncci = (word)(Id >> 16);
2998 if (plci && ncci)
2999 {
3000 Info = _WRONG_STATE;
3001 if ((a->ncci_state[ncci] == CONNECTED)
3002 || (a->ncci_state[ncci] == OUTG_CON_PENDING)
3003 || (a->ncci_state[ncci] == INC_CON_PENDING)
3004 || (a->ncci_state[ncci] == INC_ACT_PENDING))
3005 {
3006 a->ncci_state[ncci] = OUTG_DIS_PENDING;
3007 channel_request_xon(plci, a->ncci_ch[ncci]);
3008 channel_xmit_xon(plci);
3009
3010 if (a->ncci[ncci].data_pending
3011 && ((plci->B3_prot == B3_TRANSPARENT)
3012 || (plci->B3_prot == B3_T30)
3013 || (plci->B3_prot == B3_T30_WITH_EXTENSIONS)))
3014 {
3015 plci->send_disc = (byte)ncci;
3016 plci->command = 0;
3017 return false;
3018 }
3019 else
3020 {
3021 cleanup_ncci_data(plci, ncci);
3022
3023 if (plci->B3_prot == 2 || plci->B3_prot == 3)
3024 {
3025 ncpi = &parms[0];
3026 if (ncpi->length > 3)
3027 {
3028 add_d(plci, (word)(ncpi->length - 3), (byte *)&(ncpi->info[4]));
3029 }
3030 }
3031 nl_req_ncci(plci, N_DISC, (byte)ncci);
3032 }
3033 return 1;
3034 }
3035 }
3036 sendf(appl,
3037 _DISCONNECT_B3_R | CONFIRM,
3038 Id,
3039 Number,
3040 "w", Info);
3041 return false;
3042 }
3043
3044 static byte disconnect_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3045 PLCI *plci, APPL *appl, API_PARSE *parms)
3046 {
3047 word ncci;
3048 word i;
3049
3050 ncci = (word)(Id >> 16);
3051 dbug(1, dprintf("disconnect_b3_res(ncci=0x%x", ncci));
3052 if (plci && ncci) {
3053 plci->requested_options_conn = 0;
3054 plci->fax_connect_info_length = 0;
3055 plci->ncpi_state = 0x00;
3056 if (((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE))
3057 && ((plci->B2_prot != B2_LAPD) && (plci->B2_prot != B2_LAPD_FREE_SAPI_SEL)))
3058 {
3059 plci->call_dir |= CALL_DIR_FORCE_OUTG_NL;
3060 }
3061 for (i = 0; i < MAX_CHANNELS_PER_PLCI && plci->inc_dis_ncci_table[i] != (byte)ncci; i++);
3062 if (i < MAX_CHANNELS_PER_PLCI) {
3063 if (plci->channels)plci->channels--;
3064 for (; i < MAX_CHANNELS_PER_PLCI - 1; i++) plci->inc_dis_ncci_table[i] = plci->inc_dis_ncci_table[i + 1];
3065 plci->inc_dis_ncci_table[MAX_CHANNELS_PER_PLCI - 1] = 0;
3066
3067 ncci_free_receive_buffers(plci, ncci);
3068
3069 if ((plci->State == IDLE || plci->State == SUSPENDING) && !plci->channels) {
3070 if (plci->State == SUSPENDING) {
3071 sendf(plci->appl,
3072 _FACILITY_I,
3073 Id & 0xffffL,
3074 0,
3075 "ws", (word)3, "\x03\x04\x00\x00");
3076 sendf(plci->appl, _DISCONNECT_I, Id & 0xffffL, 0, "w", 0);
3077 }
3078 plci_remove(plci);
3079 plci->State = IDLE;
3080 }
3081 }
3082 else
3083 {
3084 if ((a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
3085 && ((plci->B3_prot == 4) || (plci->B3_prot == 5))
3086 && (a->ncci_state[ncci] == INC_DIS_PENDING))
3087 {
3088 ncci_free_receive_buffers(plci, ncci);
3089
3090 nl_req_ncci(plci, N_EDATA, (byte)ncci);
3091
3092 plci->adapter->ncci_state[ncci] = IDLE;
3093 start_internal_command(Id, plci, fax_disconnect_command);
3094 return 1;
3095 }
3096 }
3097 }
3098 return false;
3099 }
3100
3101 static byte data_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3102 PLCI *plci, APPL *appl, API_PARSE *parms)
3103 {
3104 NCCI *ncci_ptr;
3105 DATA_B3_DESC *data;
3106 word Info;
3107 word ncci;
3108 word i;
3109
3110 dbug(1, dprintf("data_b3_req"));
3111
3112 Info = _WRONG_IDENTIFIER;
3113 ncci = (word)(Id >> 16);
3114 dbug(1, dprintf("ncci=0x%x, plci=0x%x", ncci, plci));
3115
3116 if (plci && ncci)
3117 {
3118 Info = _WRONG_STATE;
3119 if ((a->ncci_state[ncci] == CONNECTED)
3120 || (a->ncci_state[ncci] == INC_ACT_PENDING))
3121 {
3122 /* queue data */
3123 ncci_ptr = &(a->ncci[ncci]);
3124 i = ncci_ptr->data_out + ncci_ptr->data_pending;
3125 if (i >= MAX_DATA_B3)
3126 i -= MAX_DATA_B3;
3127 data = &(ncci_ptr->DBuffer[i]);
3128 data->Number = Number;
3129 if ((((byte *)(parms[0].info)) >= ((byte *)(plci->msg_in_queue)))
3130 && (((byte *)(parms[0].info)) < ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
3131 {
3132
3133 data->P = (byte *)(long)(*((dword *)(parms[0].info)));
3134
3135 }
3136 else
3137 data->P = TransmitBufferSet(appl, *(dword *)parms[0].info);
3138 data->Length = GET_WORD(parms[1].info);
3139 data->Handle = GET_WORD(parms[2].info);
3140 data->Flags = GET_WORD(parms[3].info);
3141 (ncci_ptr->data_pending)++;
3142
3143 /* check for delivery confirmation */
3144 if (data->Flags & 0x0004)
3145 {
3146 i = ncci_ptr->data_ack_out + ncci_ptr->data_ack_pending;
3147 if (i >= MAX_DATA_ACK)
3148 i -= MAX_DATA_ACK;
3149 ncci_ptr->DataAck[i].Number = data->Number;
3150 ncci_ptr->DataAck[i].Handle = data->Handle;
3151 (ncci_ptr->data_ack_pending)++;
3152 }
3153
3154 send_data(plci);
3155 return false;
3156 }
3157 }
3158 if (appl)
3159 {
3160 if (plci)
3161 {
3162 if ((((byte *)(parms[0].info)) >= ((byte *)(plci->msg_in_queue)))
3163 && (((byte *)(parms[0].info)) < ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
3164 {
3165
3166 TransmitBufferFree(appl, (byte *)(long)(*((dword *)(parms[0].info))));
3167
3168 }
3169 }
3170 sendf(appl,
3171 _DATA_B3_R | CONFIRM,
3172 Id,
3173 Number,
3174 "ww", GET_WORD(parms[2].info), Info);
3175 }
3176 return false;
3177 }
3178
3179 static byte data_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3180 PLCI *plci, APPL *appl, API_PARSE *parms)
3181 {
3182 word n;
3183 word ncci;
3184 word NCCIcode;
3185
3186 dbug(1, dprintf("data_b3_res"));
3187
3188 ncci = (word)(Id >> 16);
3189 if (plci && ncci) {
3190 n = GET_WORD(parms[0].info);
3191 dbug(1, dprintf("free(%d)", n));
3192 NCCIcode = ncci | (((word) a->Id) << 8);
3193 if (n < appl->MaxBuffer &&
3194 appl->DataNCCI[n] == NCCIcode &&
3195 (byte)(appl->DataFlags[n] >> 8) == plci->Id) {
3196 dbug(1, dprintf("found"));
3197 appl->DataNCCI[n] = 0;
3198
3199 if (channel_can_xon(plci, a->ncci_ch[ncci])) {
3200 channel_request_xon(plci, a->ncci_ch[ncci]);
3201 }
3202 channel_xmit_xon(plci);
3203
3204 if (appl->DataFlags[n] & 4) {
3205 nl_req_ncci(plci, N_DATA_ACK, (byte)ncci);
3206 return 1;
3207 }
3208 }
3209 }
3210 return false;
3211 }
3212
3213 static byte reset_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3214 PLCI *plci, APPL *appl, API_PARSE *parms)
3215 {
3216 word Info;
3217 word ncci;
3218
3219 dbug(1, dprintf("reset_b3_req"));
3220
3221 Info = _WRONG_IDENTIFIER;
3222 ncci = (word)(Id >> 16);
3223 if (plci && ncci)
3224 {
3225 Info = _WRONG_STATE;
3226 switch (plci->B3_prot)
3227 {
3228 case B3_ISO8208:
3229 case B3_X25_DCE:
3230 if (a->ncci_state[ncci] == CONNECTED)
3231 {
3232 nl_req_ncci(plci, N_RESET, (byte)ncci);
3233 send_req(plci);
3234 Info = GOOD;
3235 }
3236 break;
3237 case B3_TRANSPARENT:
3238 if (a->ncci_state[ncci] == CONNECTED)
3239 {
3240 start_internal_command(Id, plci, reset_b3_command);
3241 Info = GOOD;
3242 }
3243 break;
3244 }
3245 }
3246 /* reset_b3 must result in a reset_b3_con & reset_b3_Ind */
3247 sendf(appl,
3248 _RESET_B3_R | CONFIRM,
3249 Id,
3250 Number,
3251 "w", Info);
3252 return false;
3253 }
3254
3255 static byte reset_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3256 PLCI *plci, APPL *appl, API_PARSE *parms)
3257 {
3258 word ncci;
3259
3260 dbug(1, dprintf("reset_b3_res"));
3261
3262 ncci = (word)(Id >> 16);
3263 if (plci && ncci) {
3264 switch (plci->B3_prot)
3265 {
3266 case B3_ISO8208:
3267 case B3_X25_DCE:
3268 if (a->ncci_state[ncci] == INC_RES_PENDING)
3269 {
3270 a->ncci_state[ncci] = CONNECTED;
3271 nl_req_ncci(plci, N_RESET_ACK, (byte)ncci);
3272 return true;
3273 }
3274 break;
3275 }
3276 }
3277 return false;
3278 }
3279
3280 static byte connect_b3_t90_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3281 PLCI *plci, APPL *appl, API_PARSE *parms)
3282 {
3283 word ncci;
3284 API_PARSE *ncpi;
3285 byte req;
3286
3287 dbug(1, dprintf("connect_b3_t90_a_res"));
3288
3289 ncci = (word)(Id >> 16);
3290 if (plci && ncci) {
3291 if (a->ncci_state[ncci] == INC_ACT_PENDING) {
3292 a->ncci_state[ncci] = CONNECTED;
3293 }
3294 else if (a->ncci_state[ncci] == INC_CON_PENDING) {
3295 a->ncci_state[ncci] = CONNECTED;
3296
3297 req = N_CONNECT_ACK;
3298
3299 /* parms[0]==0 for CAPI original message definition! */
3300 if (parms[0].info) {
3301 ncpi = &parms[1];
3302 if (ncpi->length > 2) {
3303 if (ncpi->info[1] & 1) req = N_CONNECT_ACK | N_D_BIT;
3304 add_d(plci, (word)(ncpi->length - 3), &ncpi->info[4]);
3305 }
3306 }
3307 nl_req_ncci(plci, req, (byte)ncci);
3308 return 1;
3309 }
3310 }
3311 return false;
3312 }
3313
3314
3315 static byte select_b_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3316 PLCI *plci, APPL *appl, API_PARSE *msg)
3317 {
3318 word Info = 0;
3319 word i;
3320 byte tel;
3321 API_PARSE bp_parms[7];
3322
3323 if (!plci || !msg)
3324 {
3325 Info = _WRONG_IDENTIFIER;
3326 }
3327 else
3328 {
3329 dbug(1, dprintf("select_b_req[%d],PLCI=0x%x,Tel=0x%x,NL=0x%x,appl=0x%x,sstate=0x%x",
3330 msg->length, plci->Id, plci->tel, plci->NL.Id, plci->appl, plci->SuppState));
3331 dbug(1, dprintf("PlciState=0x%x", plci->State));
3332 for (i = 0; i < 7; i++) bp_parms[i].length = 0;
3333
3334 /* check if no channel is open, no B3 connected only */
3335 if ((plci->State == IDLE) || (plci->State == OUTG_DIS_PENDING) || (plci->State == INC_DIS_PENDING)
3336 || (plci->SuppState != IDLE) || plci->channels || plci->nl_remove_id)
3337 {
3338 Info = _WRONG_STATE;
3339 }
3340 /* check message format and fill bp_parms pointer */
3341 else if (msg->length && api_parse(&msg->info[1], (word)msg->length, "wwwsss", bp_parms))
3342 {
3343 Info = _WRONG_MESSAGE_FORMAT;
3344 }
3345 else
3346 {
3347 if ((plci->State == INC_CON_PENDING) || (plci->State == INC_CON_ALERT)) /* send alert tone inband to the network, */
3348 { /* e.g. Qsig or RBS or Cornet-N or xess PRI */
3349 if (Id & EXT_CONTROLLER)
3350 {
3351 sendf(appl, _SELECT_B_REQ | CONFIRM, Id, Number, "w", 0x2002); /* wrong controller */
3352 return 0;
3353 }
3354 plci->State = INC_CON_CONNECTED_ALERT;
3355 plci->appl = appl;
3356 clear_c_ind_mask_bit(plci, (word)(appl->Id - 1));
3357 dump_c_ind_mask(plci);
3358 for (i = 0; i < max_appl; i++) /* disconnect the other appls */
3359 { /* its quasi a connect */
3360 if (test_c_ind_mask_bit(plci, i))
3361 sendf(&application[i], _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED);
3362 }
3363 }
3364
3365 api_save_msg(msg, "s", &plci->saved_msg);
3366 tel = plci->tel;
3367 if (Id & EXT_CONTROLLER)
3368 {
3369 if (tel) /* external controller in use by this PLCI */
3370 {
3371 if (a->AdvSignalAppl && a->AdvSignalAppl != appl)
3372 {
3373 dbug(1, dprintf("Ext_Ctrl in use 1"));
3374 Info = _WRONG_STATE;
3375 }
3376 }
3377 else /* external controller NOT in use by this PLCI ? */
3378 {
3379 if (a->AdvSignalPLCI)
3380 {
3381 dbug(1, dprintf("Ext_Ctrl in use 2"));
3382 Info = _WRONG_STATE;
3383 }
3384 else /* activate the codec */
3385 {
3386 dbug(1, dprintf("Ext_Ctrl start"));
3387 if (AdvCodecSupport(a, plci, appl, 0))
3388 {
3389 dbug(1, dprintf("Error in codec procedures"));
3390 Info = _WRONG_STATE;
3391 }
3392 else if (plci->spoofed_msg == SPOOFING_REQUIRED) /* wait until codec is active */
3393 {
3394 plci->spoofed_msg = AWAITING_SELECT_B;
3395 plci->internal_command = BLOCK_PLCI; /* lock other commands */
3396 plci->command = 0;
3397 dbug(1, dprintf("continue if codec loaded"));
3398 return false;
3399 }
3400 }
3401 }
3402 }
3403 else /* external controller bit is OFF */
3404 {
3405 if (tel) /* external controller in use, need to switch off */
3406 {
3407 if (a->AdvSignalAppl == appl)
3408 {
3409 CodecIdCheck(a, plci);
3410 plci->tel = 0;
3411 plci->adv_nl = 0;
3412 dbug(1, dprintf("Ext_Ctrl disable"));
3413 }
3414 else
3415 {
3416 dbug(1, dprintf("Ext_Ctrl not requested"));
3417 }
3418 }
3419 }
3420 if (!Info)
3421 {
3422 if (plci->call_dir & CALL_DIR_OUT)
3423 plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
3424 else if (plci->call_dir & CALL_DIR_IN)
3425 plci->call_dir = CALL_DIR_IN | CALL_DIR_ANSWER;
3426 start_internal_command(Id, plci, select_b_command);
3427 return false;
3428 }
3429 }
3430 }
3431 sendf(appl, _SELECT_B_REQ | CONFIRM, Id, Number, "w", Info);
3432 return false;
3433 }
3434
3435 static byte manufacturer_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3436 PLCI *plci, APPL *appl, API_PARSE *parms)
3437 {
3438 word command;
3439 word i;
3440 word ncci;
3441 API_PARSE *m;
3442 API_PARSE m_parms[5];
3443 word codec;
3444 byte req;
3445 byte ch;
3446 byte dir;
3447 static byte chi[2] = {0x01, 0x00};
3448 static byte lli[2] = {0x01, 0x00};
3449 static byte codec_cai[2] = {0x01, 0x01};
3450 static byte null_msg = {0};
3451 static API_PARSE null_parms = { 0, &null_msg };
3452 PLCI *v_plci;
3453 word Info = 0;
3454
3455 dbug(1, dprintf("manufacturer_req"));
3456 for (i = 0; i < 5; i++) m_parms[i].length = 0;
3457
3458 if (GET_DWORD(parms[0].info) != _DI_MANU_ID) {
3459 Info = _WRONG_MESSAGE_FORMAT;
3460 }
3461 command = GET_WORD(parms[1].info);
3462 m = &parms[2];
3463 if (!Info)
3464 {
3465 switch (command) {
3466 case _DI_ASSIGN_PLCI:
3467 if (api_parse(&m->info[1], (word)m->length, "wbbs", m_parms)) {
3468 Info = _WRONG_MESSAGE_FORMAT;
3469 break;
3470 }
3471 codec = GET_WORD(m_parms[0].info);
3472 ch = m_parms[1].info[0];
3473 dir = m_parms[2].info[0];
3474 if ((i = get_plci(a))) {
3475 plci = &a->plci[i - 1];
3476 plci->appl = appl;
3477 plci->command = _MANUFACTURER_R;
3478 plci->m_command = command;
3479 plci->number = Number;
3480 plci->State = LOCAL_CONNECT;
3481 Id = (((word)plci->Id << 8) | plci->adapter->Id | 0x80);
3482 dbug(1, dprintf("ManCMD,plci=0x%x", Id));
3483
3484 if ((ch == 1 || ch == 2) && (dir <= 2)) {
3485 chi[1] = (byte)(0x80 | ch);
3486 lli[1] = 0;
3487 plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
3488 switch (codec)
3489 {
3490 case 0:
3491 Info = add_b1(plci, &m_parms[3], 0, 0);
3492 break;
3493 case 1:
3494 add_p(plci, CAI, codec_cai);
3495 break;
3496 /* manual 'swich on' to the codec support without signalling */
3497 /* first 'assign plci' with this function, then use */
3498 case 2:
3499 if (AdvCodecSupport(a, plci, appl, 0)) {
3500 Info = _RESOURCE_ERROR;
3501 }
3502 else {
3503 Info = add_b1(plci, &null_parms, 0, B1_FACILITY_LOCAL);
3504 lli[1] = 0x10; /* local call codec stream */
3505 }
3506 break;
3507 }
3508
3509 plci->State = LOCAL_CONNECT;
3510 plci->manufacturer = true;
3511 plci->command = _MANUFACTURER_R;
3512 plci->m_command = command;
3513 plci->number = Number;
3514
3515 if (!Info)
3516 {
3517 add_p(plci, LLI, lli);
3518 add_p(plci, CHI, chi);
3519 add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
3520 sig_req(plci, ASSIGN, DSIG_ID);
3521
3522 if (!codec)
3523 {
3524 Info = add_b23(plci, &m_parms[3]);
3525 if (!Info)
3526 {
3527 nl_req_ncci(plci, ASSIGN, 0);
3528 send_req(plci);
3529 }
3530 }
3531 if (!Info)
3532 {
3533 dbug(1, dprintf("dir=0x%x,spoof=0x%x", dir, plci->spoofed_msg));
3534 if (plci->spoofed_msg == SPOOFING_REQUIRED)
3535 {
3536 api_save_msg(m_parms, "wbbs", &plci->saved_msg);
3537 plci->spoofed_msg = AWAITING_MANUF_CON;
3538 plci->internal_command = BLOCK_PLCI; /* reject other req meanwhile */
3539 plci->command = 0;
3540 send_req(plci);
3541 return false;
3542 }
3543 if (dir == 1) {
3544 sig_req(plci, CALL_REQ, 0);
3545 }
3546 else if (!dir) {
3547 sig_req(plci, LISTEN_REQ, 0);
3548 }
3549 send_req(plci);
3550 }
3551 else
3552 {
3553 sendf(appl,
3554 _MANUFACTURER_R | CONFIRM,
3555 Id,
3556 Number,
3557 "dww", _DI_MANU_ID, command, Info);
3558 return 2;
3559 }
3560 }
3561 }
3562 }
3563 else Info = _OUT_OF_PLCI;
3564 break;
3565
3566 case _DI_IDI_CTRL:
3567 if (!plci)
3568 {
3569 Info = _WRONG_IDENTIFIER;
3570 break;
3571 }
3572 if (api_parse(&m->info[1], (word)m->length, "bs", m_parms)) {
3573 Info = _WRONG_MESSAGE_FORMAT;
3574 break;
3575 }
3576 req = m_parms[0].info[0];
3577 plci->command = _MANUFACTURER_R;
3578 plci->m_command = command;
3579 plci->number = Number;
3580 if (req == CALL_REQ)
3581 {
3582 plci->b_channel = getChannel(&m_parms[1]);
3583 mixer_set_bchannel_id_esc(plci, plci->b_channel);
3584 if (plci->spoofed_msg == SPOOFING_REQUIRED)
3585 {
3586 plci->spoofed_msg = CALL_REQ | AWAITING_MANUF_CON;
3587 plci->internal_command = BLOCK_PLCI; /* reject other req meanwhile */
3588 plci->command = 0;
3589 break;
3590 }
3591 }
3592 else if (req == LAW_REQ)
3593 {
3594 plci->cr_enquiry = true;
3595 }
3596 add_ss(plci, FTY, &m_parms[1]);
3597 sig_req(plci, req, 0);
3598 send_req(plci);
3599 if (req == HANGUP)
3600 {
3601 if (plci->NL.Id && !plci->nl_remove_id)
3602 {
3603 if (plci->channels)
3604 {
3605 for (ncci = 1; ncci < MAX_NCCI + 1; ncci++)
3606 {
3607 if ((a->ncci_plci[ncci] == plci->Id) && (a->ncci_state[ncci] == CONNECTED))
3608 {
3609 a->ncci_state[ncci] = OUTG_DIS_PENDING;
3610 cleanup_ncci_data(plci, ncci);
3611 nl_req_ncci(plci, N_DISC, (byte)ncci);
3612 }
3613 }
3614 }
3615 mixer_remove(plci);
3616 nl_req_ncci(plci, REMOVE, 0);
3617 send_req(plci);
3618 }
3619 }
3620 break;
3621
3622 case _DI_SIG_CTRL:
3623 /* signalling control for loop activation B-channel */
3624 if (!plci)
3625 {
3626 Info = _WRONG_IDENTIFIER;
3627 break;
3628 }
3629 if (m->length) {
3630 plci->command = _MANUFACTURER_R;
3631 plci->number = Number;
3632 add_ss(plci, FTY, m);
3633 sig_req(plci, SIG_CTRL, 0);
3634 send_req(plci);
3635 }
3636 else Info = _WRONG_MESSAGE_FORMAT;
3637 break;
3638
3639 case _DI_RXT_CTRL:
3640 /* activation control for receiver/transmitter B-channel */
3641 if (!plci)
3642 {
3643 Info = _WRONG_IDENTIFIER;
3644 break;
3645 }
3646 if (m->length) {
3647 plci->command = _MANUFACTURER_R;
3648 plci->number = Number;
3649 add_ss(plci, FTY, m);
3650 sig_req(plci, DSP_CTRL, 0);
3651 send_req(plci);
3652 }
3653 else Info = _WRONG_MESSAGE_FORMAT;
3654 break;
3655
3656 case _DI_ADV_CODEC:
3657 case _DI_DSP_CTRL:
3658 /* TEL_CTRL commands to support non standard adjustments: */
3659 /* Ring on/off, Handset micro volume, external micro vol. */
3660 /* handset+external speaker volume, receiver+transm. gain,*/
3661 /* handsfree on (hookinfo off), set mixer command */
3662
3663 if (command == _DI_ADV_CODEC)
3664 {
3665 if (!a->AdvCodecPLCI) {
3666 Info = _WRONG_STATE;
3667 break;
3668 }
3669 v_plci = a->AdvCodecPLCI;
3670 }
3671 else
3672 {
3673 if (plci
3674 && (m->length >= 3)
3675 && (m->info[1] == 0x1c)
3676 && (m->info[2] >= 1))
3677 {
3678 if (m->info[3] == DSP_CTRL_OLD_SET_MIXER_COEFFICIENTS)
3679 {
3680 if ((plci->tel != ADV_VOICE) || (plci != a->AdvSignalPLCI))
3681 {
3682 Info = _WRONG_STATE;
3683 break;
3684 }
3685 a->adv_voice_coef_length = m->info[2] - 1;
3686 if (a->adv_voice_coef_length > m->length - 3)
3687 a->adv_voice_coef_length = (byte)(m->length - 3);
3688 if (a->adv_voice_coef_length > ADV_VOICE_COEF_BUFFER_SIZE)
3689 a->adv_voice_coef_length = ADV_VOICE_COEF_BUFFER_SIZE;
3690 for (i = 0; i < a->adv_voice_coef_length; i++)
3691 a->adv_voice_coef_buffer[i] = m->info[4 + i];
3692 if (plci->B1_facilities & B1_FACILITY_VOICE)
3693 adv_voice_write_coefs(plci, ADV_VOICE_WRITE_UPDATE);
3694 break;
3695 }
3696 else if (m->info[3] == DSP_CTRL_SET_DTMF_PARAMETERS)
3697 {
3698 if (!(a->manufacturer_features & MANUFACTURER_FEATURE_DTMF_PARAMETERS))
3699 {
3700 Info = _FACILITY_NOT_SUPPORTED;
3701 break;
3702 }
3703
3704 plci->dtmf_parameter_length = m->info[2] - 1;
3705 if (plci->dtmf_parameter_length > m->length - 3)
3706 plci->dtmf_parameter_length = (byte)(m->length - 3);
3707 if (plci->dtmf_parameter_length > DTMF_PARAMETER_BUFFER_SIZE)
3708 plci->dtmf_parameter_length = DTMF_PARAMETER_BUFFER_SIZE;
3709 for (i = 0; i < plci->dtmf_parameter_length; i++)
3710 plci->dtmf_parameter_buffer[i] = m->info[4 + i];
3711 if (plci->B1_facilities & B1_FACILITY_DTMFR)
3712 dtmf_parameter_write(plci);
3713 break;
3714
3715 }
3716 }
3717 v_plci = plci;
3718 }
3719
3720 if (!v_plci)
3721 {
3722 Info = _WRONG_IDENTIFIER;
3723 break;
3724 }
3725 if (m->length) {
3726 add_ss(v_plci, FTY, m);
3727 sig_req(v_plci, TEL_CTRL, 0);
3728 send_req(v_plci);
3729 }
3730 else Info = _WRONG_MESSAGE_FORMAT;
3731
3732 break;
3733
3734 case _DI_OPTIONS_REQUEST:
3735 if (api_parse(&m->info[1], (word)m->length, "d", m_parms)) {
3736 Info = _WRONG_MESSAGE_FORMAT;
3737 break;
3738 }
3739 if (GET_DWORD(m_parms[0].info) & ~a->man_profile.private_options)
3740 {
3741 Info = _FACILITY_NOT_SUPPORTED;
3742 break;
3743 }
3744 a->requested_options_table[appl->Id - 1] = GET_DWORD(m_parms[0].info);
3745 break;
3746
3747
3748
3749 default:
3750 Info = _WRONG_MESSAGE_FORMAT;
3751 break;
3752 }
3753 }
3754
3755 sendf(appl,
3756 _MANUFACTURER_R | CONFIRM,
3757 Id,
3758 Number,
3759 "dww", _DI_MANU_ID, command, Info);
3760 return false;
3761 }
3762
3763
3764 static byte manufacturer_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
3765 PLCI *plci, APPL *appl, API_PARSE *msg)
3766 {
3767 word indication;
3768
3769 API_PARSE m_parms[3];
3770 API_PARSE *ncpi;
3771 API_PARSE fax_parms[9];
3772 word i;
3773 byte len;
3774
3775
3776 dbug(1, dprintf("manufacturer_res"));
3777
3778 if ((msg[0].length == 0)
3779 || (msg[1].length == 0)
3780 || (GET_DWORD(msg[0].info) != _DI_MANU_ID))
3781 {
3782 return false;
3783 }
3784 indication = GET_WORD(msg[1].info);
3785 switch (indication)
3786 {
3787
3788 case _DI_NEGOTIATE_B3:
3789 if (!plci)
3790 break;
3791 if (((plci->B3_prot != 4) && (plci->B3_prot != 5))
3792 || !(plci->ncpi_state & NCPI_NEGOTIATE_B3_SENT))
3793 {
3794 dbug(1, dprintf("wrong state for NEGOTIATE_B3 parameters"));
3795 break;
3796 }
3797 if (api_parse(&msg[2].info[1], msg[2].length, "ws", m_parms))
3798 {
3799 dbug(1, dprintf("wrong format in NEGOTIATE_B3 parameters"));
3800 break;
3801 }
3802 ncpi = &m_parms[1];
3803 len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
3804 if (plci->fax_connect_info_length < len)
3805 {
3806 ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id_len = 0;
3807 ((T30_INFO *)(plci->fax_connect_info_buffer))->head_line_len = 0;
3808 }
3809 if (api_parse(&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms))
3810 {
3811 dbug(1, dprintf("non-standard facilities info missing or wrong format"));
3812 }
3813 else
3814 {
3815 if (plci->fax_connect_info_length <= len)
3816 plci->fax_connect_info_buffer[len] = 0;
3817 len += 1 + plci->fax_connect_info_buffer[len];
3818 if (plci->fax_connect_info_length <= len)
3819 plci->fax_connect_info_buffer[len] = 0;
3820 len += 1 + plci->fax_connect_info_buffer[len];
3821 if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2))
3822 plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]);
3823 plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length);
3824 for (i = 0; i < fax_parms[7].length; i++)
3825 plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1 + i];
3826 }
3827 plci->fax_connect_info_length = len;
3828 plci->fax_edata_ack_length = plci->fax_connect_info_length;
3829 start_internal_command(Id, plci, fax_edata_ack_command);
3830 break;
3831
3832 }
3833 return false;
3834 }
3835
3836 /*------------------------------------------------------------------*/
3837 /* IDI callback function */
3838 /*------------------------------------------------------------------*/
3839
3840 void callback(ENTITY *e)
3841 {
3842 DIVA_CAPI_ADAPTER *a;
3843 APPL *appl;
3844 PLCI *plci;
3845 CAPI_MSG *m;
3846 word i, j;
3847 byte rc;
3848 byte ch;
3849 byte req;
3850 byte global_req;
3851 int no_cancel_rc;
3852
3853 dbug(1, dprintf("%x:CB(%x:Req=%x,Rc=%x,Ind=%x)",
3854 (e->user[0] + 1) & 0x7fff, e->Id, e->Req, e->Rc, e->Ind));
3855
3856 a = &(adapter[(byte)e->user[0]]);
3857 plci = &(a->plci[e->user[1]]);
3858 no_cancel_rc = DIVA_CAPI_SUPPORTS_NO_CANCEL(a);
3859
3860 /*
3861 If new protocol code and new XDI is used then CAPI should work
3862 fully in accordance with IDI cpec an look on callback field instead
3863 of Rc field for return codes.
3864 */
3865 if (((e->complete == 0xff) && no_cancel_rc) ||
3866 (e->Rc && !no_cancel_rc)) {
3867 rc = e->Rc;
3868 ch = e->RcCh;
3869 req = e->Req;
3870 e->Rc = 0;
3871
3872 if (e->user[0] & 0x8000)
3873 {
3874 /*
3875 If REMOVE request was sent then we have to wait until
3876 return code with Id set to zero arrives.
3877 All other return codes should be ignored.
3878 */
3879 if (req == REMOVE)
3880 {
3881 if (e->Id)
3882 {
3883 dbug(1, dprintf("cancel RC in REMOVE state"));
3884 return;
3885 }
3886 channel_flow_control_remove(plci);
3887 for (i = 0; i < 256; i++)
3888 {
3889 if (a->FlowControlIdTable[i] == plci->nl_remove_id)
3890 a->FlowControlIdTable[i] = 0;
3891 }
3892 plci->nl_remove_id = 0;
3893 if (plci->rx_dma_descriptor > 0) {
3894 diva_free_dma_descriptor(plci, plci->rx_dma_descriptor - 1);
3895 plci->rx_dma_descriptor = 0;
3896 }
3897 }
3898 if (rc == OK_FC)
3899 {
3900 a->FlowControlIdTable[ch] = e->Id;
3901 a->FlowControlSkipTable[ch] = 0;
3902
3903 a->ch_flow_control[ch] |= N_OK_FC_PENDING;
3904 a->ch_flow_plci[ch] = plci->Id;
3905 plci->nl_req = 0;
3906 }
3907 else
3908 {
3909 /*
3910 Cancel return codes self, if feature was requested
3911 */
3912 if (no_cancel_rc && (a->FlowControlIdTable[ch] == e->Id) && e->Id) {
3913 a->FlowControlIdTable[ch] = 0;
3914 if ((rc == OK) && a->FlowControlSkipTable[ch]) {
3915 dbug(3, dprintf("XDI CAPI: RC cancelled Id:0x02, Ch:%02x", e->Id, ch));
3916 return;
3917 }
3918 }
3919
3920 if (a->ch_flow_control[ch] & N_OK_FC_PENDING)
3921 {
3922 a->ch_flow_control[ch] &= ~N_OK_FC_PENDING;
3923 if (ch == e->ReqCh)
3924 plci->nl_req = 0;
3925 }
3926 else
3927 plci->nl_req = 0;
3928 }
3929 if (plci->nl_req)
3930 control_rc(plci, 0, rc, ch, 0, true);
3931 else
3932 {
3933 if (req == N_XON)
3934 {
3935 channel_x_on(plci, ch);
3936 if (plci->internal_command)
3937 control_rc(plci, req, rc, ch, 0, true);
3938 }
3939 else
3940 {
3941 if (plci->nl_global_req)
3942 {
3943 global_req = plci->nl_global_req;
3944 plci->nl_global_req = 0;
3945 if (rc != ASSIGN_OK) {
3946 e->Id = 0;
3947 if (plci->rx_dma_descriptor > 0) {
3948 diva_free_dma_descriptor(plci, plci->rx_dma_descriptor - 1);
3949 plci->rx_dma_descriptor = 0;
3950 }
3951 }
3952 channel_xmit_xon(plci);
3953 control_rc(plci, 0, rc, ch, global_req, true);
3954 }
3955 else if (plci->data_sent)
3956 {
3957 channel_xmit_xon(plci);
3958 plci->data_sent = false;
3959 plci->NL.XNum = 1;
3960 data_rc(plci, ch);
3961 if (plci->internal_command)
3962 control_rc(plci, req, rc, ch, 0, true);
3963 }
3964 else
3965 {
3966 channel_xmit_xon(plci);
3967 control_rc(plci, req, rc, ch, 0, true);
3968 }
3969 }
3970 }
3971 }
3972 else
3973 {
3974 /*
3975 If REMOVE request was sent then we have to wait until
3976 return code with Id set to zero arrives.
3977 All other return codes should be ignored.
3978 */
3979 if (req == REMOVE)
3980 {
3981 if (e->Id)
3982 {
3983 dbug(1, dprintf("cancel RC in REMOVE state"));
3984 return;
3985 }
3986 plci->sig_remove_id = 0;
3987 }
3988 plci->sig_req = 0;
3989 if (plci->sig_global_req)
3990 {
3991 global_req = plci->sig_global_req;
3992 plci->sig_global_req = 0;
3993 if (rc != ASSIGN_OK)
3994 e->Id = 0;
3995 channel_xmit_xon(plci);
3996 control_rc(plci, 0, rc, ch, global_req, false);
3997 }
3998 else
3999 {
4000 channel_xmit_xon(plci);
4001 control_rc(plci, req, rc, ch, 0, false);
4002 }
4003 }
4004 /*
4005 Again: in accordance with IDI spec Rc and Ind can't be delivered in the
4006 same callback. Also if new XDI and protocol code used then jump
4007 direct to finish.
4008 */
4009 if (no_cancel_rc) {
4010 channel_xmit_xon(plci);
4011 goto capi_callback_suffix;
4012 }
4013 }
4014
4015 channel_xmit_xon(plci);
4016
4017 if (e->Ind) {
4018 if (e->user[0] & 0x8000) {
4019 byte Ind = e->Ind & 0x0f;
4020 byte Ch = e->IndCh;
4021 if (((Ind == N_DISC) || (Ind == N_DISC_ACK)) &&
4022 (a->ch_flow_plci[Ch] == plci->Id)) {
4023 if (a->ch_flow_control[Ch] & N_RX_FLOW_CONTROL_MASK) {
4024 dbug(3, dprintf("XDI CAPI: I: pending N-XON Ch:%02x", Ch));
4025 }
4026 a->ch_flow_control[Ch] &= ~N_RX_FLOW_CONTROL_MASK;
4027 }
4028 nl_ind(plci);
4029 if ((e->RNR != 1) &&
4030 (a->ch_flow_plci[Ch] == plci->Id) &&
4031 (a->ch_flow_control[Ch] & N_RX_FLOW_CONTROL_MASK)) {
4032 a->ch_flow_control[Ch] &= ~N_RX_FLOW_CONTROL_MASK;
4033 dbug(3, dprintf("XDI CAPI: I: remove faked N-XON Ch:%02x", Ch));
4034 }
4035 } else {
4036 sig_ind(plci);
4037 }
4038 e->Ind = 0;
4039 }
4040
4041 capi_callback_suffix:
4042
4043 while (!plci->req_in
4044 && !plci->internal_command
4045 && (plci->msg_in_write_pos != plci->msg_in_read_pos))
4046 {
4047 j = (plci->msg_in_read_pos == plci->msg_in_wrap_pos) ? 0 : plci->msg_in_read_pos;
4048
4049 i = (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[j]))->header.length + 3) & 0xfffc;
4050
4051 m = (CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[j]);
4052 appl = *((APPL **)(&((byte *)(plci->msg_in_queue))[j + i]));
4053 dbug(1, dprintf("dequeue msg(0x%04x) - write=%d read=%d wrap=%d",
4054 m->header.command, plci->msg_in_write_pos, plci->msg_in_read_pos, plci->msg_in_wrap_pos));
4055 if (plci->msg_in_read_pos == plci->msg_in_wrap_pos)
4056 {
4057 plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
4058 plci->msg_in_read_pos = i + MSG_IN_OVERHEAD;
4059 }
4060 else
4061 {
4062 plci->msg_in_read_pos = j + i + MSG_IN_OVERHEAD;
4063 }
4064 if (plci->msg_in_read_pos == plci->msg_in_write_pos)
4065 {
4066 plci->msg_in_write_pos = MSG_IN_QUEUE_SIZE;
4067 plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
4068 }
4069 else if (plci->msg_in_read_pos == plci->msg_in_wrap_pos)
4070 {
4071 plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
4072 plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
4073 }
4074 i = api_put(appl, m);
4075 if (i != 0)
4076 {
4077 if (m->header.command == _DATA_B3_R)
4078
4079 TransmitBufferFree(appl, (byte *)(long)(m->info.data_b3_req.Data));
4080
4081 dbug(1, dprintf("Error 0x%04x from msg(0x%04x)", i, m->header.command));
4082 break;
4083 }
4084
4085 if (plci->li_notify_update)
4086 {
4087 plci->li_notify_update = false;
4088 mixer_notify_update(plci, false);
4089 }
4090
4091 }
4092 send_data(plci);
4093 send_req(plci);
4094 }
4095
4096
4097 static void control_rc(PLCI *plci, byte req, byte rc, byte ch, byte global_req,
4098 byte nl_rc)
4099 {
4100 dword Id;
4101 dword rId;
4102 word Number;
4103 word Info = 0;
4104 word i;
4105 word ncci;
4106 DIVA_CAPI_ADAPTER *a;
4107 APPL *appl;
4108 PLCI *rplci;
4109 byte SSparms[] = "\x05\x00\x00\x02\x00\x00";
4110 byte SSstruct[] = "\x09\x00\x00\x06\x00\x00\x00\x00\x00\x00";
4111
4112 if (!plci) {
4113 dbug(0, dprintf("A: control_rc, no plci %02x:%02x:%02x:%02x:%02x", req, rc, ch, global_req, nl_rc));
4114 return;
4115 }
4116 dbug(1, dprintf("req0_in/out=%d/%d", plci->req_in, plci->req_out));
4117 if (plci->req_in != plci->req_out)
4118 {
4119 if (nl_rc || (global_req != ASSIGN) || (rc == ASSIGN_OK))
4120 {
4121 dbug(1, dprintf("req_1return"));
4122 return;
4123 }
4124 /* cancel outstanding request on the PLCI after SIG ASSIGN failure */
4125 }
4126 plci->req_in = plci->req_in_start = plci->req_out = 0;
4127 dbug(1, dprintf("control_rc"));
4128
4129 appl = plci->appl;
4130 a = plci->adapter;
4131 ncci = a->ch_ncci[ch];
4132 if (appl)
4133 {
4134 Id = (((dword)(ncci ? ncci : ch)) << 16) | ((word)plci->Id << 8) | a->Id;
4135 if (plci->tel && plci->SuppState != CALL_HELD) Id |= EXT_CONTROLLER;
4136 Number = plci->number;
4137 dbug(1, dprintf("Contr_RC-Id=%08lx,plci=%x,tel=%x, entity=0x%x, command=0x%x, int_command=0x%x", Id, plci->Id, plci->tel, plci->Sig.Id, plci->command, plci->internal_command));
4138 dbug(1, dprintf("channels=0x%x", plci->channels));
4139 if (plci_remove_check(plci))
4140 return;
4141 if (req == REMOVE && rc == ASSIGN_OK)
4142 {
4143 sig_req(plci, HANGUP, 0);
4144 sig_req(plci, REMOVE, 0);
4145 send_req(plci);
4146 }
4147 if (plci->command)
4148 {
4149 switch (plci->command)
4150 {
4151 case C_HOLD_REQ:
4152 dbug(1, dprintf("HoldRC=0x%x", rc));
4153 SSparms[1] = (byte)S_HOLD;
4154 if (rc != OK)
4155 {
4156 plci->SuppState = IDLE;
4157 Info = 0x2001;
4158 }
4159 sendf(appl, _FACILITY_R | CONFIRM, Id, Number, "wws", Info, 3, SSparms);
4160 break;
4161
4162 case C_RETRIEVE_REQ:
4163 dbug(1, dprintf("RetrieveRC=0x%x", rc));
4164 SSparms[1] = (byte)S_RETRIEVE;
4165 if (rc != OK)
4166 {
4167 plci->SuppState = CALL_HELD;
4168 Info = 0x2001;
4169 }
4170 sendf(appl, _FACILITY_R | CONFIRM, Id, Number, "wws", Info, 3, SSparms);
4171 break;
4172
4173 case _INFO_R:
4174 dbug(1, dprintf("InfoRC=0x%x", rc));
4175 if (rc != OK) Info = _WRONG_STATE;
4176 sendf(appl, _INFO_R | CONFIRM, Id, Number, "w", Info);
4177 break;
4178
4179 case _CONNECT_R:
4180 dbug(1, dprintf("Connect_R=0x%x/0x%x/0x%x/0x%x", req, rc, global_req, nl_rc));
4181 if (plci->State == INC_DIS_PENDING)
4182 break;
4183 if (plci->Sig.Id != 0xff)
4184 {
4185 if (((global_req == ASSIGN) && (rc != ASSIGN_OK))
4186 || (!nl_rc && (req == CALL_REQ) && (rc != OK)))
4187 {
4188 dbug(1, dprintf("No more IDs/Call_Req failed"));
4189 sendf(appl, _CONNECT_R | CONFIRM, Id & 0xffL, Number, "w", _OUT_OF_PLCI);
4190 plci_remove(plci);
4191 plci->State = IDLE;
4192 break;
4193 }
4194 if (plci->State != LOCAL_CONNECT) plci->State = OUTG_CON_PENDING;
4195 sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", 0);
4196 }
4197 else /* D-ch activation */
4198 {
4199 if (rc != ASSIGN_OK)
4200 {
4201 dbug(1, dprintf("No more IDs/X.25 Call_Req failed"));
4202 sendf(appl, _CONNECT_R | CONFIRM, Id & 0xffL, Number, "w", _OUT_OF_PLCI);
4203 plci_remove(plci);
4204 plci->State = IDLE;
4205 break;
4206 }
4207 sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", 0);
4208 sendf(plci->appl, _CONNECT_ACTIVE_I, Id, 0, "sss", "", "", "");
4209 plci->State = INC_ACT_PENDING;
4210 }
4211 break;
4212
4213 case _CONNECT_I | RESPONSE:
4214 if (plci->State != INC_DIS_PENDING)
4215 plci->State = INC_CON_ACCEPT;
4216 break;
4217
4218 case _DISCONNECT_R:
4219 if (plci->State == INC_DIS_PENDING)
4220 break;
4221 if (plci->Sig.Id != 0xff)
4222 {
4223 plci->State = OUTG_DIS_PENDING;
4224 sendf(appl, _DISCONNECT_R | CONFIRM, Id, Number, "w", 0);
4225 }
4226 break;
4227
4228 case SUSPEND_REQ:
4229 break;
4230
4231 case RESUME_REQ:
4232 break;
4233
4234 case _CONNECT_B3_R:
4235 if (rc != OK)
4236 {
4237 sendf(appl, _CONNECT_B3_R | CONFIRM, Id, Number, "w", _WRONG_IDENTIFIER);
4238 break;
4239 }
4240 ncci = get_ncci(plci, ch, 0);
4241 Id = (Id & 0xffff) | (((dword) ncci) << 16);
4242 plci->channels++;
4243 if (req == N_RESET)
4244 {
4245 a->ncci_state[ncci] = INC_ACT_PENDING;
4246 sendf(appl, _CONNECT_B3_R | CONFIRM, Id, Number, "w", 0);
4247 sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
4248 }
4249 else
4250 {
4251 a->ncci_state[ncci] = OUTG_CON_PENDING;
4252 sendf(appl, _CONNECT_B3_R | CONFIRM, Id, Number, "w", 0);
4253 }
4254 break;
4255
4256 case _CONNECT_B3_I | RESPONSE:
4257 break;
4258
4259 case _RESET_B3_R:
4260 /* sendf(appl, _RESET_B3_R | CONFIRM, Id, Number, "w", 0);*/
4261 break;
4262
4263 case _DISCONNECT_B3_R:
4264 sendf(appl, _DISCONNECT_B3_R | CONFIRM, Id, Number, "w", 0);
4265 break;
4266
4267 case _MANUFACTURER_R:
4268 break;
4269
4270 case PERM_LIST_REQ:
4271 if (rc != OK)
4272 {
4273 Info = _WRONG_IDENTIFIER;
4274 sendf(plci->appl, _CONNECT_R | CONFIRM, Id, Number, "w", Info);
4275 plci_remove(plci);
4276 }
4277 else
4278 sendf(plci->appl, _CONNECT_R | CONFIRM, Id, Number, "w", Info);
4279 break;
4280
4281 default:
4282 break;
4283 }
4284 plci->command = 0;
4285 }
4286 else if (plci->internal_command)
4287 {
4288 switch (plci->internal_command)
4289 {
4290 case BLOCK_PLCI:
4291 return;
4292
4293 case GET_MWI_STATE:
4294 if (rc == OK) /* command supported, wait for indication */
4295 {
4296 return;
4297 }
4298 plci_remove(plci);
4299 break;
4300
4301 /* Get Supported Services */
4302 case GETSERV_REQ_PEND:
4303 if (rc == OK) /* command supported, wait for indication */
4304 {
4305 break;
4306 }
4307 PUT_DWORD(&SSstruct[6], MASK_TERMINAL_PORTABILITY);
4308 sendf(appl, _FACILITY_R | CONFIRM, Id, Number, "wws", 0, 3, SSstruct);
4309 plci_remove(plci);
4310 break;
4311
4312 case INTERR_DIVERSION_REQ_PEND: /* Interrogate Parameters */
4313 case INTERR_NUMBERS_REQ_PEND:
4314 case CF_START_PEND: /* Call Forwarding Start pending */
4315 case CF_STOP_PEND: /* Call Forwarding Stop pending */
4316 case CCBS_REQUEST_REQ_PEND:
4317 case CCBS_DEACTIVATE_REQ_PEND:
4318 case CCBS_INTERROGATE_REQ_PEND:
4319 switch (plci->internal_command)
4320 {
4321 case INTERR_DIVERSION_REQ_PEND:
4322 SSparms[1] = S_INTERROGATE_DIVERSION;
4323 break;
4324 case INTERR_NUMBERS_REQ_PEND:
4325 SSparms[1] = S_INTERROGATE_NUMBERS;
4326 break;
4327 case CF_START_PEND:
4328 SSparms[1] = S_CALL_FORWARDING_START;
4329 break;
4330 case CF_STOP_PEND:
4331 SSparms[1] = S_CALL_FORWARDING_STOP;
4332 break;
4333 case CCBS_REQUEST_REQ_PEND:
4334 SSparms[1] = S_CCBS_REQUEST;
4335 break;
4336 case CCBS_DEACTIVATE_REQ_PEND:
4337 SSparms[1] = S_CCBS_DEACTIVATE;
4338 break;
4339 case CCBS_INTERROGATE_REQ_PEND:
4340 SSparms[1] = S_CCBS_INTERROGATE;
4341 break;
4342 }
4343 if (global_req == ASSIGN)
4344 {
4345 dbug(1, dprintf("AssignDiversion_RC=0x%x/0x%x", req, rc));
4346 return;
4347 }
4348 if (!plci->appl) break;
4349 if (rc == ISDN_GUARD_REJ)
4350 {
4351 Info = _CAPI_GUARD_ERROR;
4352 }
4353 else if (rc != OK)
4354 {
4355 Info = _SUPPLEMENTARY_SERVICE_NOT_SUPPORTED;
4356 }
4357 sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0x7,
4358 plci->number, "wws", Info, (word)3, SSparms);
4359 if (Info) plci_remove(plci);
4360 break;
4361
4362 /* 3pty conference pending */
4363 case PTY_REQ_PEND:
4364 if (!plci->relatedPTYPLCI) break;
4365 rplci = plci->relatedPTYPLCI;
4366 SSparms[1] = plci->ptyState;
4367 rId = ((word)rplci->Id << 8) | rplci->adapter->Id;
4368 if (rplci->tel) rId |= EXT_CONTROLLER;
4369 if (rc != OK)
4370 {
4371 Info = 0x300E; /* not supported */
4372 plci->relatedPTYPLCI = NULL;
4373 plci->ptyState = 0;
4374 }
4375 sendf(rplci->appl,
4376 _FACILITY_R | CONFIRM,
4377 rId,
4378 plci->number,
4379 "wws", Info, (word)3, SSparms);
4380 break;
4381
4382 /* Explicit Call Transfer pending */
4383 case ECT_REQ_PEND:
4384 dbug(1, dprintf("ECT_RC=0x%x/0x%x", req, rc));
4385 if (!plci->relatedPTYPLCI) break;
4386 rplci = plci->relatedPTYPLCI;
4387 SSparms[1] = S_ECT;
4388 rId = ((word)rplci->Id << 8) | rplci->adapter->Id;
4389 if (rplci->tel) rId |= EXT_CONTROLLER;
4390 if (rc != OK)
4391 {
4392 Info = 0x300E; /* not supported */
4393 plci->relatedPTYPLCI = NULL;
4394 plci->ptyState = 0;
4395 }
4396 sendf(rplci->appl,
4397 _FACILITY_R | CONFIRM,
4398 rId,
4399 plci->number,
4400 "wws", Info, (word)3, SSparms);
4401 break;
4402
4403 case _MANUFACTURER_R:
4404 dbug(1, dprintf("_Manufacturer_R=0x%x/0x%x", req, rc));
4405 if ((global_req == ASSIGN) && (rc != ASSIGN_OK))
4406 {
4407 dbug(1, dprintf("No more IDs"));
4408 sendf(appl, _MANUFACTURER_R | CONFIRM, Id, Number, "dww", _DI_MANU_ID, _MANUFACTURER_R, _OUT_OF_PLCI);
4409 plci_remove(plci); /* after codec init, internal codec commands pending */
4410 }
4411 break;
4412
4413 case _CONNECT_R:
4414 dbug(1, dprintf("_Connect_R=0x%x/0x%x", req, rc));
4415 if ((global_req == ASSIGN) && (rc != ASSIGN_OK))
4416 {
4417 dbug(1, dprintf("No more IDs"));
4418 sendf(appl, _CONNECT_R | CONFIRM, Id & 0xffL, Number, "w", _OUT_OF_PLCI);
4419 plci_remove(plci); /* after codec init, internal codec commands pending */
4420 }
4421 break;
4422
4423 case PERM_COD_HOOK: /* finished with Hook_Ind */
4424 return;
4425
4426 case PERM_COD_CALL:
4427 dbug(1, dprintf("***Codec Connect_Pending A, Rc = 0x%x", rc));
4428 plci->internal_command = PERM_COD_CONN_PEND;
4429 return;
4430
4431 case PERM_COD_ASSIGN:
4432 dbug(1, dprintf("***Codec Assign A, Rc = 0x%x", rc));
4433 if (rc != ASSIGN_OK) break;
4434 sig_req(plci, CALL_REQ, 0);
4435 send_req(plci);
4436 plci->internal_command = PERM_COD_CALL;
4437 return;
4438
4439 /* Null Call Reference Request pending */
4440 case C_NCR_FAC_REQ:
4441 dbug(1, dprintf("NCR_FAC=0x%x/0x%x", req, rc));
4442 if (global_req == ASSIGN)
4443 {
4444 if (rc == ASSIGN_OK)
4445 {
4446 return;
4447 }
4448 else
4449 {
4450 sendf(appl, _INFO_R | CONFIRM, Id & 0xf, Number, "w", _WRONG_STATE);
4451 appl->NullCREnable = false;
4452 plci_remove(plci);
4453 }
4454 }
4455 else if (req == NCR_FACILITY)
4456 {
4457 if (rc == OK)
4458 {
4459 sendf(appl, _INFO_R | CONFIRM, Id & 0xf, Number, "w", 0);
4460 }
4461 else
4462 {
4463 sendf(appl, _INFO_R | CONFIRM, Id & 0xf, Number, "w", _WRONG_STATE);
4464 appl->NullCREnable = false;
4465 }
4466 plci_remove(plci);
4467 }
4468 break;
4469
4470 case HOOK_ON_REQ:
4471 if (plci->channels)
4472 {
4473 if (a->ncci_state[ncci] == CONNECTED)
4474 {
4475 a->ncci_state[ncci] = OUTG_DIS_PENDING;
4476 cleanup_ncci_data(plci, ncci);
4477 nl_req_ncci(plci, N_DISC, (byte)ncci);
4478 }
4479 break;
4480 }
4481 break;
4482
4483 case HOOK_OFF_REQ:
4484 if (plci->State == INC_DIS_PENDING)
4485 break;
4486 sig_req(plci, CALL_REQ, 0);
4487 send_req(plci);
4488 plci->State = OUTG_CON_PENDING;
4489 break;
4490
4491
4492 case MWI_ACTIVATE_REQ_PEND:
4493 case MWI_DEACTIVATE_REQ_PEND:
4494 if (global_req == ASSIGN && rc == ASSIGN_OK)
4495 {
4496 dbug(1, dprintf("MWI_REQ assigned"));
4497 return;
4498 }
4499 else if (rc != OK)
4500 {
4501 if (rc == WRONG_IE)
4502 {
4503 Info = 0x2007; /* Illegal message parameter coding */
4504 dbug(1, dprintf("MWI_REQ invalid parameter"));
4505 }
4506 else
4507 {
4508 Info = 0x300B; /* not supported */
4509 dbug(1, dprintf("MWI_REQ not supported"));
4510 }
4511 /* 0x3010: Request not allowed in this state */
4512 PUT_WORD(&SSparms[4], 0x300E); /* SS not supported */
4513
4514 }
4515 if (plci->internal_command == MWI_ACTIVATE_REQ_PEND)
4516 {
4517 PUT_WORD(&SSparms[1], S_MWI_ACTIVATE);
4518 }
4519 else PUT_WORD(&SSparms[1], S_MWI_DEACTIVATE);
4520
4521 if (plci->cr_enquiry)
4522 {
4523 sendf(plci->appl,
4524 _FACILITY_R | CONFIRM,
4525 Id & 0xf,
4526 plci->number,
4527 "wws", Info, (word)3, SSparms);
4528 if (rc != OK) plci_remove(plci);
4529 }
4530 else
4531 {
4532 sendf(plci->appl,
4533 _FACILITY_R | CONFIRM,
4534 Id,
4535 plci->number,
4536 "wws", Info, (word)3, SSparms);
4537 }
4538 break;
4539
4540 case CONF_BEGIN_REQ_PEND:
4541 case CONF_ADD_REQ_PEND:
4542 case CONF_SPLIT_REQ_PEND:
4543 case CONF_DROP_REQ_PEND:
4544 case CONF_ISOLATE_REQ_PEND:
4545 case CONF_REATTACH_REQ_PEND:
4546 dbug(1, dprintf("CONF_RC=0x%x/0x%x", req, rc));
4547 if ((plci->internal_command == CONF_ADD_REQ_PEND) && (!plci->relatedPTYPLCI)) break;
4548 rplci = plci;
4549 rId = Id;
4550 switch (plci->internal_command)
4551 {
4552 case CONF_BEGIN_REQ_PEND:
4553 SSparms[1] = S_CONF_BEGIN;
4554 break;
4555 case CONF_ADD_REQ_PEND:
4556 SSparms[1] = S_CONF_ADD;
4557 rplci = plci->relatedPTYPLCI;
4558 rId = ((word)rplci->Id << 8) | rplci->adapter->Id;
4559 break;
4560 case CONF_SPLIT_REQ_PEND:
4561 SSparms[1] = S_CONF_SPLIT;
4562 break;
4563 case CONF_DROP_REQ_PEND:
4564 SSparms[1] = S_CONF_DROP;
4565 break;
4566 case CONF_ISOLATE_REQ_PEND:
4567 SSparms[1] = S_CONF_ISOLATE;
4568 break;
4569 case CONF_REATTACH_REQ_PEND:
4570 SSparms[1] = S_CONF_REATTACH;
4571 break;
4572 }
4573
4574 if (rc != OK)
4575 {
4576 Info = 0x300E; /* not supported */
4577 plci->relatedPTYPLCI = NULL;
4578 plci->ptyState = 0;
4579 }
4580 sendf(rplci->appl,
4581 _FACILITY_R | CONFIRM,
4582 rId,
4583 plci->number,
4584 "wws", Info, (word)3, SSparms);
4585 break;
4586
4587 case VSWITCH_REQ_PEND:
4588 if (rc != OK)
4589 {
4590 if (plci->relatedPTYPLCI)
4591 {
4592 plci->relatedPTYPLCI->vswitchstate = 0;
4593 plci->relatedPTYPLCI->vsprot = 0;
4594 plci->relatedPTYPLCI->vsprotdialect = 0;
4595 }
4596 plci->vswitchstate = 0;
4597 plci->vsprot = 0;
4598 plci->vsprotdialect = 0;
4599 }
4600 else
4601 {
4602 if (plci->relatedPTYPLCI &&
4603 plci->vswitchstate == 1 &&
4604 plci->relatedPTYPLCI->vswitchstate == 3) /* join complete */
4605 plci->vswitchstate = 3;
4606 }
4607 break;
4608
4609 /* Call Deflection Request pending (SSCT) */
4610 case CD_REQ_PEND:
4611 SSparms[1] = S_CALL_DEFLECTION;
4612 if (rc != OK)
4613 {
4614 Info = 0x300E; /* not supported */
4615 plci->appl->CDEnable = 0;
4616 }
4617 sendf(plci->appl, _FACILITY_R | CONFIRM, Id,
4618 plci->number, "wws", Info, (word)3, SSparms);
4619 break;
4620
4621 case RTP_CONNECT_B3_REQ_COMMAND_2:
4622 if (rc == OK)
4623 {
4624 ncci = get_ncci(plci, ch, 0);
4625 Id = (Id & 0xffff) | (((dword) ncci) << 16);
4626 plci->channels++;
4627 a->ncci_state[ncci] = OUTG_CON_PENDING;
4628 }
4629
4630 default:
4631 if (plci->internal_command_queue[0])
4632 {
4633 (*(plci->internal_command_queue[0]))(Id, plci, rc);
4634 if (plci->internal_command)
4635 return;
4636 }
4637 break;
4638 }
4639 next_internal_command(Id, plci);
4640 }
4641 }
4642 else /* appl==0 */
4643 {
4644 Id = ((word)plci->Id << 8) | plci->adapter->Id;
4645 if (plci->tel) Id |= EXT_CONTROLLER;
4646
4647 switch (plci->internal_command)
4648 {
4649 case BLOCK_PLCI:
4650 return;
4651
4652 case START_L1_SIG_ASSIGN_PEND:
4653 case REM_L1_SIG_ASSIGN_PEND:
4654 if (global_req == ASSIGN)
4655 {
4656 break;
4657 }
4658 else
4659 {
4660 dbug(1, dprintf("***L1 Req rem PLCI"));
4661 plci->internal_command = 0;
4662 sig_req(plci, REMOVE, 0);
4663 send_req(plci);
4664 }
4665 break;
4666
4667 /* Call Deflection Request pending, just no appl ptr assigned */
4668 case CD_REQ_PEND:
4669 SSparms[1] = S_CALL_DEFLECTION;
4670 if (rc != OK)
4671 {
4672 Info = 0x300E; /* not supported */
4673 }
4674 for (i = 0; i < max_appl; i++)
4675 {
4676 if (application[i].CDEnable)
4677 {
4678 if (!application[i].Id) application[i].CDEnable = 0;
4679 else
4680 {
4681 sendf(&application[i], _FACILITY_R | CONFIRM, Id,
4682 plci->number, "wws", Info, (word)3, SSparms);
4683 if (Info) application[i].CDEnable = 0;
4684 }
4685 }
4686 }
4687 plci->internal_command = 0;
4688 break;
4689
4690 case PERM_COD_HOOK: /* finished with Hook_Ind */
4691 return;
4692
4693 case PERM_COD_CALL:
4694 plci->internal_command = PERM_COD_CONN_PEND;
4695 dbug(1, dprintf("***Codec Connect_Pending, Rc = 0x%x", rc));
4696 return;
4697
4698 case PERM_COD_ASSIGN:
4699 dbug(1, dprintf("***Codec Assign, Rc = 0x%x", rc));
4700 plci->internal_command = 0;
4701 if (rc != ASSIGN_OK) break;
4702 plci->internal_command = PERM_COD_CALL;
4703 sig_req(plci, CALL_REQ, 0);
4704 send_req(plci);
4705 return;
4706
4707 case LISTEN_SIG_ASSIGN_PEND:
4708 if (rc == ASSIGN_OK)
4709 {
4710 plci->internal_command = 0;
4711 dbug(1, dprintf("ListenCheck, new SIG_ID = 0x%x", plci->Sig.Id));
4712 add_p(plci, ESC, "\x02\x18\x00"); /* support call waiting */
4713 sig_req(plci, INDICATE_REQ, 0);
4714 send_req(plci);
4715 }
4716 else
4717 {
4718 dbug(1, dprintf("ListenCheck failed (assignRc=0x%x)", rc));
4719 a->listen_active--;
4720 plci_remove(plci);
4721 plci->State = IDLE;
4722 }
4723 break;
4724
4725 case USELAW_REQ:
4726 if (global_req == ASSIGN)
4727 {
4728 if (rc == ASSIGN_OK)
4729 {
4730 sig_req(plci, LAW_REQ, 0);
4731 send_req(plci);
4732 dbug(1, dprintf("Auto-Law assigned"));
4733 }
4734 else
4735 {
4736 dbug(1, dprintf("Auto-Law assign failed"));
4737 a->automatic_law = 3;
4738 plci->internal_command = 0;
4739 a->automatic_lawPLCI = NULL;
4740 }
4741 break;
4742 }
4743 else if (req == LAW_REQ && rc == OK)
4744 {
4745 dbug(1, dprintf("Auto-Law initiated"));
4746 a->automatic_law = 2;
4747 plci->internal_command = 0;
4748 }
4749 else
4750 {
4751 dbug(1, dprintf("Auto-Law not supported"));
4752 a->automatic_law = 3;
4753 plci->internal_command = 0;
4754 sig_req(plci, REMOVE, 0);
4755 send_req(plci);
4756 a->automatic_lawPLCI = NULL;
4757 }
4758 break;
4759 }
4760 plci_remove_check(plci);
4761 }
4762 }
4763
4764 static void data_rc(PLCI *plci, byte ch)
4765 {
4766 dword Id;
4767 DIVA_CAPI_ADAPTER *a;
4768 NCCI *ncci_ptr;
4769 DATA_B3_DESC *data;
4770 word ncci;
4771
4772 if (plci->appl)
4773 {
4774 TransmitBufferFree(plci->appl, plci->data_sent_ptr);
4775 a = plci->adapter;
4776 ncci = a->ch_ncci[ch];
4777 if (ncci && (a->ncci_plci[ncci] == plci->Id))
4778 {
4779 ncci_ptr = &(a->ncci[ncci]);
4780 dbug(1, dprintf("data_out=%d, data_pending=%d", ncci_ptr->data_out, ncci_ptr->data_pending));
4781 if (ncci_ptr->data_pending)
4782 {
4783 data = &(ncci_ptr->DBuffer[ncci_ptr->data_out]);
4784 if (!(data->Flags & 4) && a->ncci_state[ncci])
4785 {
4786 Id = (((dword)ncci) << 16) | ((word)plci->Id << 8) | a->Id;
4787 if (plci->tel) Id |= EXT_CONTROLLER;
4788 sendf(plci->appl, _DATA_B3_R | CONFIRM, Id, data->Number,
4789 "ww", data->Handle, 0);
4790 }
4791 (ncci_ptr->data_out)++;
4792 if (ncci_ptr->data_out == MAX_DATA_B3)
4793 ncci_ptr->data_out = 0;
4794 (ncci_ptr->data_pending)--;
4795 }
4796 }
4797 }
4798 }
4799
4800 static void data_ack(PLCI *plci, byte ch)
4801 {
4802 dword Id;
4803 DIVA_CAPI_ADAPTER *a;
4804 NCCI *ncci_ptr;
4805 word ncci;
4806
4807 a = plci->adapter;
4808 ncci = a->ch_ncci[ch];
4809 ncci_ptr = &(a->ncci[ncci]);
4810 if (ncci_ptr->data_ack_pending)
4811 {
4812 if (a->ncci_state[ncci] && (a->ncci_plci[ncci] == plci->Id))
4813 {
4814 Id = (((dword)ncci) << 16) | ((word)plci->Id << 8) | a->Id;
4815 if (plci->tel) Id |= EXT_CONTROLLER;
4816 sendf(plci->appl, _DATA_B3_R | CONFIRM, Id, ncci_ptr->DataAck[ncci_ptr->data_ack_out].Number,
4817 "ww", ncci_ptr->DataAck[ncci_ptr->data_ack_out].Handle, 0);
4818 }
4819 (ncci_ptr->data_ack_out)++;
4820 if (ncci_ptr->data_ack_out == MAX_DATA_ACK)
4821 ncci_ptr->data_ack_out = 0;
4822 (ncci_ptr->data_ack_pending)--;
4823 }
4824 }
4825
4826 static void sig_ind(PLCI *plci)
4827 {
4828 dword x_Id;
4829 dword Id;
4830 dword rId;
4831 word i;
4832 word cip;
4833 dword cip_mask;
4834 byte *ie;
4835 DIVA_CAPI_ADAPTER *a;
4836 API_PARSE saved_parms[MAX_MSG_PARMS + 1];
4837 #define MAXPARMSIDS 31
4838 byte *parms[MAXPARMSIDS];
4839 byte *add_i[4];
4840 byte *multi_fac_parms[MAX_MULTI_IE];
4841 byte *multi_pi_parms[MAX_MULTI_IE];
4842 byte *multi_ssext_parms[MAX_MULTI_IE];
4843 byte *multi_CiPN_parms[MAX_MULTI_IE];
4844
4845 byte *multi_vswitch_parms[MAX_MULTI_IE];
4846
4847 byte ai_len;
4848 byte *esc_chi = "";
4849 byte *esc_law = "";
4850 byte *pty_cai = "";
4851 byte *esc_cr = "";
4852 byte *esc_profile = "";
4853
4854 byte facility[256];
4855 PLCI *tplci = NULL;
4856 byte chi[] = "\x02\x18\x01";
4857 byte voice_cai[] = "\x06\x14\x00\x00\x00\x00\x08";
4858 byte resume_cau[] = "\x05\x05\x00\x02\x00\x00";
4859 /* ESC_MSGTYPE must be the last but one message, a new IE has to be */
4860 /* included before the ESC_MSGTYPE and MAXPARMSIDS has to be incremented */
4861 /* SMSG is situated at the end because its 0 (for compatibility reasons */
4862 /* (see Info_Mask Bit 4, first IE. then the message type) */
4863 word parms_id[] =
4864 {MAXPARMSIDS, CPN, 0xff, DSA, OSA, BC, LLC, HLC, ESC_CAUSE, DSP, DT, CHA,
4865 UUI, CONG_RR, CONG_RNR, ESC_CHI, KEY, CHI, CAU, ESC_LAW,
4866 RDN, RDX, CONN_NR, RIN, NI, CAI, ESC_CR,
4867 CST, ESC_PROFILE, 0xff, ESC_MSGTYPE, SMSG};
4868 /* 14 FTY repl by ESC_CHI */
4869 /* 18 PI repl by ESC_LAW */
4870 /* removed OAD changed to 0xff for future use, OAD is multiIE now */
4871 word multi_fac_id[] = {1, FTY};
4872 word multi_pi_id[] = {1, PI};
4873 word multi_CiPN_id[] = {1, OAD};
4874 word multi_ssext_id[] = {1, ESC_SSEXT};
4875
4876 word multi_vswitch_id[] = {1, ESC_VSWITCH};
4877
4878 byte *cau;
4879 word ncci;
4880 byte SS_Ind[] = "\x05\x02\x00\x02\x00\x00"; /* Hold_Ind struct*/
4881 byte CF_Ind[] = "\x09\x02\x00\x06\x00\x00\x00\x00\x00\x00";
4882 byte Interr_Err_Ind[] = "\x0a\x02\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
4883 byte CONF_Ind[] = "\x09\x16\x00\x06\x00\x00\0x00\0x00\0x00\0x00";
4884 byte force_mt_info = false;
4885 byte dir;
4886 dword d;
4887 word w;
4888
4889 a = plci->adapter;
4890 Id = ((word)plci->Id << 8) | a->Id;
4891 PUT_WORD(&SS_Ind[4], 0x0000);
4892
4893 if (plci->sig_remove_id)
4894 {
4895 plci->Sig.RNR = 2; /* discard */
4896 dbug(1, dprintf("SIG discard while remove pending"));
4897 return;
4898 }
4899 if (plci->tel && plci->SuppState != CALL_HELD) Id |= EXT_CONTROLLER;
4900 dbug(1, dprintf("SigInd-Id=%08lx,plci=%x,tel=%x,state=0x%x,channels=%d,Discflowcl=%d",
4901 Id, plci->Id, plci->tel, plci->State, plci->channels, plci->hangup_flow_ctrl_timer));
4902 if (plci->Sig.Ind == CALL_HOLD_ACK && plci->channels)
4903 {
4904 plci->Sig.RNR = 1;
4905 return;
4906 }
4907 if (plci->Sig.Ind == HANGUP && plci->channels)
4908 {
4909 plci->Sig.RNR = 1;
4910 plci->hangup_flow_ctrl_timer++;
4911 /* recover the network layer after timeout */
4912 if (plci->hangup_flow_ctrl_timer == 100)
4913 {
4914 dbug(1, dprintf("Exceptional disc"));
4915 plci->Sig.RNR = 0;
4916 plci->hangup_flow_ctrl_timer = 0;
4917 for (ncci = 1; ncci < MAX_NCCI + 1; ncci++)
4918 {
4919 if (a->ncci_plci[ncci] == plci->Id)
4920 {
4921 cleanup_ncci_data(plci, ncci);
4922 if (plci->channels)plci->channels--;
4923 if (plci->appl)
4924 sendf(plci->appl, _DISCONNECT_B3_I, (((dword) ncci) << 16) | Id, 0, "ws", 0, "");
4925 }
4926 }
4927 if (plci->appl)
4928 sendf(plci->appl, _DISCONNECT_I, Id, 0, "w", 0);
4929 plci_remove(plci);
4930 plci->State = IDLE;
4931 }
4932 return;
4933 }
4934
4935 /* do first parse the info with no OAD in, because OAD will be converted */
4936 /* first the multiple facility IE, then mult. progress ind. */
4937 /* then the parameters for the info_ind + conn_ind */
4938 IndParse(plci, multi_fac_id, multi_fac_parms, MAX_MULTI_IE);
4939 IndParse(plci, multi_pi_id, multi_pi_parms, MAX_MULTI_IE);
4940 IndParse(plci, multi_ssext_id, multi_ssext_parms, MAX_MULTI_IE);
4941
4942 IndParse(plci, multi_vswitch_id, multi_vswitch_parms, MAX_MULTI_IE);
4943
4944 IndParse(plci, parms_id, parms, 0);
4945 IndParse(plci, multi_CiPN_id, multi_CiPN_parms, MAX_MULTI_IE);
4946 esc_chi = parms[14];
4947 esc_law = parms[18];
4948 pty_cai = parms[24];
4949 esc_cr = parms[25];
4950 esc_profile = parms[27];
4951 if (esc_cr[0] && plci)
4952 {
4953 if (plci->cr_enquiry && plci->appl)
4954 {
4955 plci->cr_enquiry = false;
4956 /* d = MANU_ID */
4957 /* w = m_command */
4958 /* b = total length */
4959 /* b = indication type */
4960 /* b = length of all IEs */
4961 /* b = IE1 */
4962 /* S = IE1 length + cont. */
4963 /* b = IE2 */
4964 /* S = IE2 length + cont. */
4965 sendf(plci->appl,
4966 _MANUFACTURER_I,
4967 Id,
4968 0,
4969 "dwbbbbSbS", _DI_MANU_ID, plci->m_command,
4970 2 + 1 + 1 + esc_cr[0] + 1 + 1 + esc_law[0], plci->Sig.Ind, 1 + 1 + esc_cr[0] + 1 + 1 + esc_law[0], ESC, esc_cr, ESC, esc_law);
4971 }
4972 }
4973 /* create the additional info structure */
4974 add_i[1] = parms[15]; /* KEY of additional info */
4975 add_i[2] = parms[11]; /* UUI of additional info */
4976 ai_len = AddInfo(add_i, multi_fac_parms, esc_chi, facility);
4977
4978 /* the ESC_LAW indicates if u-Law or a-Law is actually used by the card */
4979 /* indication returns by the card if requested by the function */
4980 /* AutomaticLaw() after driver init */
4981 if (a->automatic_law < 4)
4982 {
4983 if (esc_law[0]) {
4984 if (esc_law[2]) {
4985 dbug(0, dprintf("u-Law selected"));
4986 a->u_law = 1;
4987 }
4988 else {
4989 dbug(0, dprintf("a-Law selected"));
4990 a->u_law = 0;
4991 }
4992 a->automatic_law = 4;
4993 if (plci == a->automatic_lawPLCI) {
4994 plci->internal_command = 0;
4995 sig_req(plci, REMOVE, 0);
4996 send_req(plci);
4997 a->automatic_lawPLCI = NULL;
4998 }
4999 }
5000 if (esc_profile[0])
5001 {
5002 dbug(1, dprintf("[%06x] CardProfile: %lx %lx %lx %lx %lx",
5003 UnMapController(a->Id), GET_DWORD(&esc_profile[6]),
5004 GET_DWORD(&esc_profile[10]), GET_DWORD(&esc_profile[14]),
5005 GET_DWORD(&esc_profile[18]), GET_DWORD(&esc_profile[46])));
5006
5007 a->profile.Global_Options &= 0x000000ffL;
5008 a->profile.B1_Protocols &= 0x000003ffL;
5009 a->profile.B2_Protocols &= 0x00001fdfL;
5010 a->profile.B3_Protocols &= 0x000000b7L;
5011
5012 a->profile.Global_Options &= GET_DWORD(&esc_profile[6]) |
5013 GL_BCHANNEL_OPERATION_SUPPORTED;
5014 a->profile.B1_Protocols &= GET_DWORD(&esc_profile[10]);
5015 a->profile.B2_Protocols &= GET_DWORD(&esc_profile[14]);
5016 a->profile.B3_Protocols &= GET_DWORD(&esc_profile[18]);
5017 a->manufacturer_features = GET_DWORD(&esc_profile[46]);
5018 a->man_profile.private_options = 0;
5019
5020 if (a->manufacturer_features & MANUFACTURER_FEATURE_ECHO_CANCELLER)
5021 {
5022 a->man_profile.private_options |= 1L << PRIVATE_ECHO_CANCELLER;
5023 a->profile.Global_Options |= GL_ECHO_CANCELLER_SUPPORTED;
5024 }
5025
5026
5027 if (a->manufacturer_features & MANUFACTURER_FEATURE_RTP)
5028 a->man_profile.private_options |= 1L << PRIVATE_RTP;
5029 a->man_profile.rtp_primary_payloads = GET_DWORD(&esc_profile[50]);
5030 a->man_profile.rtp_additional_payloads = GET_DWORD(&esc_profile[54]);
5031
5032
5033 if (a->manufacturer_features & MANUFACTURER_FEATURE_T38)
5034 a->man_profile.private_options |= 1L << PRIVATE_T38;
5035
5036
5037 if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_SUB_SEP_PWD)
5038 a->man_profile.private_options |= 1L << PRIVATE_FAX_SUB_SEP_PWD;
5039
5040
5041 if (a->manufacturer_features & MANUFACTURER_FEATURE_V18)
5042 a->man_profile.private_options |= 1L << PRIVATE_V18;
5043
5044
5045 if (a->manufacturer_features & MANUFACTURER_FEATURE_DTMF_TONE)
5046 a->man_profile.private_options |= 1L << PRIVATE_DTMF_TONE;
5047
5048
5049 if (a->manufacturer_features & MANUFACTURER_FEATURE_PIAFS)
5050 a->man_profile.private_options |= 1L << PRIVATE_PIAFS;
5051
5052
5053 if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
5054 a->man_profile.private_options |= 1L << PRIVATE_FAX_PAPER_FORMATS;
5055
5056
5057 if (a->manufacturer_features & MANUFACTURER_FEATURE_VOWN)
5058 a->man_profile.private_options |= 1L << PRIVATE_VOWN;
5059
5060
5061 if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_NONSTANDARD)
5062 a->man_profile.private_options |= 1L << PRIVATE_FAX_NONSTANDARD;
5063
5064 }
5065 else
5066 {
5067 a->profile.Global_Options &= 0x0000007fL;
5068 a->profile.B1_Protocols &= 0x000003dfL;
5069 a->profile.B2_Protocols &= 0x00001adfL;
5070 a->profile.B3_Protocols &= 0x000000b7L;
5071 a->manufacturer_features &= MANUFACTURER_FEATURE_HARDDTMF;
5072 }
5073 if (a->manufacturer_features & (MANUFACTURER_FEATURE_HARDDTMF |
5074 MANUFACTURER_FEATURE_SOFTDTMF_SEND | MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE))
5075 {
5076 a->profile.Global_Options |= GL_DTMF_SUPPORTED;
5077 }
5078 a->manufacturer_features &= ~MANUFACTURER_FEATURE_OOB_CHANNEL;
5079 dbug(1, dprintf("[%06x] Profile: %lx %lx %lx %lx %lx",
5080 UnMapController(a->Id), a->profile.Global_Options,
5081 a->profile.B1_Protocols, a->profile.B2_Protocols,
5082 a->profile.B3_Protocols, a->manufacturer_features));
5083 }
5084 /* codec plci for the handset/hook state support is just an internal id */
5085 if (plci != a->AdvCodecPLCI)
5086 {
5087 force_mt_info = SendMultiIE(plci, Id, multi_fac_parms, FTY, 0x20, 0);
5088 force_mt_info |= SendMultiIE(plci, Id, multi_pi_parms, PI, 0x210, 0);
5089 SendSSExtInd(NULL, plci, Id, multi_ssext_parms);
5090 SendInfo(plci, Id, parms, force_mt_info);
5091
5092 VSwitchReqInd(plci, Id, multi_vswitch_parms);
5093
5094 }
5095
5096 /* switch the codec to the b-channel */
5097 if (esc_chi[0] && plci && !plci->SuppState) {
5098 plci->b_channel = esc_chi[esc_chi[0]]&0x1f;
5099 mixer_set_bchannel_id_esc(plci, plci->b_channel);
5100 dbug(1, dprintf("storeChannel=0x%x", plci->b_channel));
5101 if (plci->tel == ADV_VOICE && plci->appl) {
5102 SetVoiceChannel(a->AdvCodecPLCI, esc_chi, a);
5103 }
5104 }
5105
5106 if (plci->appl) plci->appl->Number++;
5107
5108 switch (plci->Sig.Ind) {
5109 /* Response to Get_Supported_Services request */
5110 case S_SUPPORTED:
5111 dbug(1, dprintf("S_Supported"));
5112 if (!plci->appl) break;
5113 if (pty_cai[0] == 4)
5114 {
5115 PUT_DWORD(&CF_Ind[6], GET_DWORD(&pty_cai[1]));
5116 }
5117 else
5118 {
5119 PUT_DWORD(&CF_Ind[6], MASK_TERMINAL_PORTABILITY | MASK_HOLD_RETRIEVE);
5120 }
5121 PUT_WORD(&CF_Ind[1], 0);
5122 PUT_WORD(&CF_Ind[4], 0);
5123 sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0x7, plci->number, "wws", 0, 3, CF_Ind);
5124 plci_remove(plci);
5125 break;
5126
5127 /* Supplementary Service rejected */
5128 case S_SERVICE_REJ:
5129 dbug(1, dprintf("S_Reject=0x%x", pty_cai[5]));
5130 if (!pty_cai[0]) break;
5131 switch (pty_cai[5])
5132 {
5133 case ECT_EXECUTE:
5134 case THREE_PTY_END:
5135 case THREE_PTY_BEGIN:
5136 if (!plci->relatedPTYPLCI) break;
5137 tplci = plci->relatedPTYPLCI;
5138 rId = ((word)tplci->Id << 8) | tplci->adapter->Id;
5139 if (tplci->tel) rId |= EXT_CONTROLLER;
5140 if (pty_cai[5] == ECT_EXECUTE)
5141 {
5142 PUT_WORD(&SS_Ind[1], S_ECT);
5143
5144 plci->vswitchstate = 0;
5145 plci->relatedPTYPLCI->vswitchstate = 0;
5146
5147 }
5148 else
5149 {
5150 PUT_WORD(&SS_Ind[1], pty_cai[5] + 3);
5151 }
5152 if (pty_cai[2] != 0xff)
5153 {
5154 PUT_WORD(&SS_Ind[4], 0x3600 | (word)pty_cai[2]);
5155 }
5156 else
5157 {
5158 PUT_WORD(&SS_Ind[4], 0x300E);
5159 }
5160 plci->relatedPTYPLCI = NULL;
5161 plci->ptyState = 0;
5162 sendf(tplci->appl, _FACILITY_I, rId, 0, "ws", 3, SS_Ind);
5163 break;
5164
5165 case CALL_DEFLECTION:
5166 if (pty_cai[2] != 0xff)
5167 {
5168 PUT_WORD(&SS_Ind[4], 0x3600 | (word)pty_cai[2]);
5169 }
5170 else
5171 {
5172 PUT_WORD(&SS_Ind[4], 0x300E);
5173 }
5174 PUT_WORD(&SS_Ind[1], pty_cai[5]);
5175 for (i = 0; i < max_appl; i++)
5176 {
5177 if (application[i].CDEnable)
5178 {
5179 if (application[i].Id) sendf(&application[i], _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5180 application[i].CDEnable = false;
5181 }
5182 }
5183 break;
5184
5185 case DEACTIVATION_DIVERSION:
5186 case ACTIVATION_DIVERSION:
5187 case DIVERSION_INTERROGATE_CFU:
5188 case DIVERSION_INTERROGATE_CFB:
5189 case DIVERSION_INTERROGATE_CFNR:
5190 case DIVERSION_INTERROGATE_NUM:
5191 case CCBS_REQUEST:
5192 case CCBS_DEACTIVATE:
5193 case CCBS_INTERROGATE:
5194 if (!plci->appl) break;
5195 if (pty_cai[2] != 0xff)
5196 {
5197 PUT_WORD(&Interr_Err_Ind[4], 0x3600 | (word)pty_cai[2]);
5198 }
5199 else
5200 {
5201 PUT_WORD(&Interr_Err_Ind[4], 0x300E);
5202 }
5203 switch (pty_cai[5])
5204 {
5205 case DEACTIVATION_DIVERSION:
5206 dbug(1, dprintf("Deact_Div"));
5207 Interr_Err_Ind[0] = 0x9;
5208 Interr_Err_Ind[3] = 0x6;
5209 PUT_WORD(&Interr_Err_Ind[1], S_CALL_FORWARDING_STOP);
5210 break;
5211 case ACTIVATION_DIVERSION:
5212 dbug(1, dprintf("Act_Div"));
5213 Interr_Err_Ind[0] = 0x9;
5214 Interr_Err_Ind[3] = 0x6;
5215 PUT_WORD(&Interr_Err_Ind[1], S_CALL_FORWARDING_START);
5216 break;
5217 case DIVERSION_INTERROGATE_CFU:
5218 case DIVERSION_INTERROGATE_CFB:
5219 case DIVERSION_INTERROGATE_CFNR:
5220 dbug(1, dprintf("Interr_Div"));
5221 Interr_Err_Ind[0] = 0xa;
5222 Interr_Err_Ind[3] = 0x7;
5223 PUT_WORD(&Interr_Err_Ind[1], S_INTERROGATE_DIVERSION);
5224 break;
5225 case DIVERSION_INTERROGATE_NUM:
5226 dbug(1, dprintf("Interr_Num"));
5227 Interr_Err_Ind[0] = 0xa;
5228 Interr_Err_Ind[3] = 0x7;
5229 PUT_WORD(&Interr_Err_Ind[1], S_INTERROGATE_NUMBERS);
5230 break;
5231 case CCBS_REQUEST:
5232 dbug(1, dprintf("CCBS Request"));
5233 Interr_Err_Ind[0] = 0xd;
5234 Interr_Err_Ind[3] = 0xa;
5235 PUT_WORD(&Interr_Err_Ind[1], S_CCBS_REQUEST);
5236 break;
5237 case CCBS_DEACTIVATE:
5238 dbug(1, dprintf("CCBS Deactivate"));
5239 Interr_Err_Ind[0] = 0x9;
5240 Interr_Err_Ind[3] = 0x6;
5241 PUT_WORD(&Interr_Err_Ind[1], S_CCBS_DEACTIVATE);
5242 break;
5243 case CCBS_INTERROGATE:
5244 dbug(1, dprintf("CCBS Interrogate"));
5245 Interr_Err_Ind[0] = 0xb;
5246 Interr_Err_Ind[3] = 0x8;
5247 PUT_WORD(&Interr_Err_Ind[1], S_CCBS_INTERROGATE);
5248 break;
5249 }
5250 PUT_DWORD(&Interr_Err_Ind[6], plci->appl->S_Handle);
5251 sendf(plci->appl, _FACILITY_I, Id & 0x7, 0, "ws", 3, Interr_Err_Ind);
5252 plci_remove(plci);
5253 break;
5254 case ACTIVATION_MWI:
5255 case DEACTIVATION_MWI:
5256 if (pty_cai[5] == ACTIVATION_MWI)
5257 {
5258 PUT_WORD(&SS_Ind[1], S_MWI_ACTIVATE);
5259 }
5260 else PUT_WORD(&SS_Ind[1], S_MWI_DEACTIVATE);
5261
5262 if (pty_cai[2] != 0xff)
5263 {
5264 PUT_WORD(&SS_Ind[4], 0x3600 | (word)pty_cai[2]);
5265 }
5266 else
5267 {
5268 PUT_WORD(&SS_Ind[4], 0x300E);
5269 }
5270
5271 if (plci->cr_enquiry)
5272 {
5273 sendf(plci->appl, _FACILITY_I, Id & 0xf, 0, "ws", 3, SS_Ind);
5274 plci_remove(plci);
5275 }
5276 else
5277 {
5278 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5279 }
5280 break;
5281 case CONF_ADD: /* ERROR */
5282 case CONF_BEGIN:
5283 case CONF_DROP:
5284 case CONF_ISOLATE:
5285 case CONF_REATTACH:
5286 CONF_Ind[0] = 9;
5287 CONF_Ind[3] = 6;
5288 switch (pty_cai[5])
5289 {
5290 case CONF_BEGIN:
5291 PUT_WORD(&CONF_Ind[1], S_CONF_BEGIN);
5292 plci->ptyState = 0;
5293 break;
5294 case CONF_DROP:
5295 CONF_Ind[0] = 5;
5296 CONF_Ind[3] = 2;
5297 PUT_WORD(&CONF_Ind[1], S_CONF_DROP);
5298 plci->ptyState = CONNECTED;
5299 break;
5300 case CONF_ISOLATE:
5301 CONF_Ind[0] = 5;
5302 CONF_Ind[3] = 2;
5303 PUT_WORD(&CONF_Ind[1], S_CONF_ISOLATE);
5304 plci->ptyState = CONNECTED;
5305 break;
5306 case CONF_REATTACH:
5307 CONF_Ind[0] = 5;
5308 CONF_Ind[3] = 2;
5309 PUT_WORD(&CONF_Ind[1], S_CONF_REATTACH);
5310 plci->ptyState = CONNECTED;
5311 break;
5312 case CONF_ADD:
5313 PUT_WORD(&CONF_Ind[1], S_CONF_ADD);
5314 plci->relatedPTYPLCI = NULL;
5315 tplci = plci->relatedPTYPLCI;
5316 if (tplci) tplci->ptyState = CONNECTED;
5317 plci->ptyState = CONNECTED;
5318 break;
5319 }
5320
5321 if (pty_cai[2] != 0xff)
5322 {
5323 PUT_WORD(&CONF_Ind[4], 0x3600 | (word)pty_cai[2]);
5324 }
5325 else
5326 {
5327 PUT_WORD(&CONF_Ind[4], 0x3303); /* Time-out: network did not respond
5328 within the required time */
5329 }
5330
5331 PUT_DWORD(&CONF_Ind[6], 0x0);
5332 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, CONF_Ind);
5333 break;
5334 }
5335 break;
5336
5337 /* Supplementary Service indicates success */
5338 case S_SERVICE:
5339 dbug(1, dprintf("Service_Ind"));
5340 PUT_WORD(&CF_Ind[4], 0);
5341 switch (pty_cai[5])
5342 {
5343 case THREE_PTY_END:
5344 case THREE_PTY_BEGIN:
5345 case ECT_EXECUTE:
5346 if (!plci->relatedPTYPLCI) break;
5347 tplci = plci->relatedPTYPLCI;
5348 rId = ((word)tplci->Id << 8) | tplci->adapter->Id;
5349 if (tplci->tel) rId |= EXT_CONTROLLER;
5350 if (pty_cai[5] == ECT_EXECUTE)
5351 {
5352 PUT_WORD(&SS_Ind[1], S_ECT);
5353
5354 if (plci->vswitchstate != 3)
5355 {
5356
5357 plci->ptyState = IDLE;
5358 plci->relatedPTYPLCI = NULL;
5359 plci->ptyState = 0;
5360
5361 }
5362
5363 dbug(1, dprintf("ECT OK"));
5364 sendf(tplci->appl, _FACILITY_I, rId, 0, "ws", 3, SS_Ind);
5365
5366
5367
5368 }
5369 else
5370 {
5371 switch (plci->ptyState)
5372 {
5373 case S_3PTY_BEGIN:
5374 plci->ptyState = CONNECTED;
5375 dbug(1, dprintf("3PTY ON"));
5376 break;
5377
5378 case S_3PTY_END:
5379 plci->ptyState = IDLE;
5380 plci->relatedPTYPLCI = NULL;
5381 plci->ptyState = 0;
5382 dbug(1, dprintf("3PTY OFF"));
5383 break;
5384 }
5385 PUT_WORD(&SS_Ind[1], pty_cai[5] + 3);
5386 sendf(tplci->appl, _FACILITY_I, rId, 0, "ws", 3, SS_Ind);
5387 }
5388 break;
5389
5390 case CALL_DEFLECTION:
5391 PUT_WORD(&SS_Ind[1], pty_cai[5]);
5392 for (i = 0; i < max_appl; i++)
5393 {
5394 if (application[i].CDEnable)
5395 {
5396 if (application[i].Id) sendf(&application[i], _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5397 application[i].CDEnable = false;
5398 }
5399 }
5400 break;
5401
5402 case DEACTIVATION_DIVERSION:
5403 case ACTIVATION_DIVERSION:
5404 if (!plci->appl) break;
5405 PUT_WORD(&CF_Ind[1], pty_cai[5] + 2);
5406 PUT_DWORD(&CF_Ind[6], plci->appl->S_Handle);
5407 sendf(plci->appl, _FACILITY_I, Id & 0x7, 0, "ws", 3, CF_Ind);
5408 plci_remove(plci);
5409 break;
5410
5411 case DIVERSION_INTERROGATE_CFU:
5412 case DIVERSION_INTERROGATE_CFB:
5413 case DIVERSION_INTERROGATE_CFNR:
5414 case DIVERSION_INTERROGATE_NUM:
5415 case CCBS_REQUEST:
5416 case CCBS_DEACTIVATE:
5417 case CCBS_INTERROGATE:
5418 if (!plci->appl) break;
5419 switch (pty_cai[5])
5420 {
5421 case DIVERSION_INTERROGATE_CFU:
5422 case DIVERSION_INTERROGATE_CFB:
5423 case DIVERSION_INTERROGATE_CFNR:
5424 dbug(1, dprintf("Interr_Div"));
5425 PUT_WORD(&pty_cai[1], S_INTERROGATE_DIVERSION);
5426 pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
5427 break;
5428 case DIVERSION_INTERROGATE_NUM:
5429 dbug(1, dprintf("Interr_Num"));
5430 PUT_WORD(&pty_cai[1], S_INTERROGATE_NUMBERS);
5431 pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
5432 break;
5433 case CCBS_REQUEST:
5434 dbug(1, dprintf("CCBS Request"));
5435 PUT_WORD(&pty_cai[1], S_CCBS_REQUEST);
5436 pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
5437 break;
5438 case CCBS_DEACTIVATE:
5439 dbug(1, dprintf("CCBS Deactivate"));
5440 PUT_WORD(&pty_cai[1], S_CCBS_DEACTIVATE);
5441 pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
5442 break;
5443 case CCBS_INTERROGATE:
5444 dbug(1, dprintf("CCBS Interrogate"));
5445 PUT_WORD(&pty_cai[1], S_CCBS_INTERROGATE);
5446 pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
5447 break;
5448 }
5449 PUT_WORD(&pty_cai[4], 0); /* Supplementary Service Reason */
5450 PUT_DWORD(&pty_cai[6], plci->appl->S_Handle);
5451 sendf(plci->appl, _FACILITY_I, Id & 0x7, 0, "wS", 3, pty_cai);
5452 plci_remove(plci);
5453 break;
5454
5455 case ACTIVATION_MWI:
5456 case DEACTIVATION_MWI:
5457 if (pty_cai[5] == ACTIVATION_MWI)
5458 {
5459 PUT_WORD(&SS_Ind[1], S_MWI_ACTIVATE);
5460 }
5461 else PUT_WORD(&SS_Ind[1], S_MWI_DEACTIVATE);
5462 if (plci->cr_enquiry)
5463 {
5464 sendf(plci->appl, _FACILITY_I, Id & 0xf, 0, "ws", 3, SS_Ind);
5465 plci_remove(plci);
5466 }
5467 else
5468 {
5469 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5470 }
5471 break;
5472 case MWI_INDICATION:
5473 if (pty_cai[0] >= 0x12)
5474 {
5475 PUT_WORD(&pty_cai[3], S_MWI_INDICATE);
5476 pty_cai[2] = pty_cai[0] - 2; /* len Parameter */
5477 pty_cai[5] = pty_cai[0] - 5; /* Supplementary Service-specific parameter len */
5478 if (plci->appl && (a->Notification_Mask[plci->appl->Id - 1] & SMASK_MWI))
5479 {
5480 if (plci->internal_command == GET_MWI_STATE) /* result on Message Waiting Listen */
5481 {
5482 sendf(plci->appl, _FACILITY_I, Id & 0xf, 0, "wS", 3, &pty_cai[2]);
5483 plci_remove(plci);
5484 return;
5485 }
5486 else sendf(plci->appl, _FACILITY_I, Id, 0, "wS", 3, &pty_cai[2]);
5487 pty_cai[0] = 0;
5488 }
5489 else
5490 {
5491 for (i = 0; i < max_appl; i++)
5492 {
5493 if (a->Notification_Mask[i]&SMASK_MWI)
5494 {
5495 sendf(&application[i], _FACILITY_I, Id & 0x7, 0, "wS", 3, &pty_cai[2]);
5496 pty_cai[0] = 0;
5497 }
5498 }
5499 }
5500
5501 if (!pty_cai[0])
5502 { /* acknowledge */
5503 facility[2] = 0; /* returncode */
5504 }
5505 else facility[2] = 0xff;
5506 }
5507 else
5508 {
5509 /* reject */
5510 facility[2] = 0xff; /* returncode */
5511 }
5512 facility[0] = 2;
5513 facility[1] = MWI_RESPONSE; /* Function */
5514 add_p(plci, CAI, facility);
5515 add_p(plci, ESC, multi_ssext_parms[0]); /* remembered parameter -> only one possible */
5516 sig_req(plci, S_SERVICE, 0);
5517 send_req(plci);
5518 plci->command = 0;
5519 next_internal_command(Id, plci);
5520 break;
5521 case CONF_ADD: /* OK */
5522 case CONF_BEGIN:
5523 case CONF_DROP:
5524 case CONF_ISOLATE:
5525 case CONF_REATTACH:
5526 case CONF_PARTYDISC:
5527 CONF_Ind[0] = 9;
5528 CONF_Ind[3] = 6;
5529 switch (pty_cai[5])
5530 {
5531 case CONF_BEGIN:
5532 PUT_WORD(&CONF_Ind[1], S_CONF_BEGIN);
5533 if (pty_cai[0] == 6)
5534 {
5535 d = pty_cai[6];
5536 PUT_DWORD(&CONF_Ind[6], d); /* PartyID */
5537 }
5538 else
5539 {
5540 PUT_DWORD(&CONF_Ind[6], 0x0);
5541 }
5542 break;
5543 case CONF_ISOLATE:
5544 PUT_WORD(&CONF_Ind[1], S_CONF_ISOLATE);
5545 CONF_Ind[0] = 5;
5546 CONF_Ind[3] = 2;
5547 break;
5548 case CONF_REATTACH:
5549 PUT_WORD(&CONF_Ind[1], S_CONF_REATTACH);
5550 CONF_Ind[0] = 5;
5551 CONF_Ind[3] = 2;
5552 break;
5553 case CONF_DROP:
5554 PUT_WORD(&CONF_Ind[1], S_CONF_DROP);
5555 CONF_Ind[0] = 5;
5556 CONF_Ind[3] = 2;
5557 break;
5558 case CONF_ADD:
5559 PUT_WORD(&CONF_Ind[1], S_CONF_ADD);
5560 d = pty_cai[6];
5561 PUT_DWORD(&CONF_Ind[6], d); /* PartyID */
5562 tplci = plci->relatedPTYPLCI;
5563 if (tplci) tplci->ptyState = CONNECTED;
5564 break;
5565 case CONF_PARTYDISC:
5566 CONF_Ind[0] = 7;
5567 CONF_Ind[3] = 4;
5568 PUT_WORD(&CONF_Ind[1], S_CONF_PARTYDISC);
5569 d = pty_cai[6];
5570 PUT_DWORD(&CONF_Ind[4], d); /* PartyID */
5571 break;
5572 }
5573 plci->ptyState = CONNECTED;
5574 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, CONF_Ind);
5575 break;
5576 case CCBS_INFO_RETAIN:
5577 case CCBS_ERASECALLLINKAGEID:
5578 case CCBS_STOP_ALERTING:
5579 CONF_Ind[0] = 5;
5580 CONF_Ind[3] = 2;
5581 switch (pty_cai[5])
5582 {
5583 case CCBS_INFO_RETAIN:
5584 PUT_WORD(&CONF_Ind[1], S_CCBS_INFO_RETAIN);
5585 break;
5586 case CCBS_STOP_ALERTING:
5587 PUT_WORD(&CONF_Ind[1], S_CCBS_STOP_ALERTING);
5588 break;
5589 case CCBS_ERASECALLLINKAGEID:
5590 PUT_WORD(&CONF_Ind[1], S_CCBS_ERASECALLLINKAGEID);
5591 CONF_Ind[0] = 7;
5592 CONF_Ind[3] = 4;
5593 CONF_Ind[6] = 0;
5594 CONF_Ind[7] = 0;
5595 break;
5596 }
5597 w = pty_cai[6];
5598 PUT_WORD(&CONF_Ind[4], w); /* PartyID */
5599
5600 if (plci->appl && (a->Notification_Mask[plci->appl->Id - 1] & SMASK_CCBS))
5601 {
5602 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, CONF_Ind);
5603 }
5604 else
5605 {
5606 for (i = 0; i < max_appl; i++)
5607 if (a->Notification_Mask[i] & SMASK_CCBS)
5608 sendf(&application[i], _FACILITY_I, Id & 0x7, 0, "ws", 3, CONF_Ind);
5609 }
5610 break;
5611 }
5612 break;
5613 case CALL_HOLD_REJ:
5614 cau = parms[7];
5615 if (cau)
5616 {
5617 i = _L3_CAUSE | cau[2];
5618 if (cau[2] == 0) i = 0x3603;
5619 }
5620 else
5621 {
5622 i = 0x3603;
5623 }
5624 PUT_WORD(&SS_Ind[1], S_HOLD);
5625 PUT_WORD(&SS_Ind[4], i);
5626 if (plci->SuppState == HOLD_REQUEST)
5627 {
5628 plci->SuppState = IDLE;
5629 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5630 }
5631 break;
5632
5633 case CALL_HOLD_ACK:
5634 if (plci->SuppState == HOLD_REQUEST)
5635 {
5636 plci->SuppState = CALL_HELD;
5637 CodecIdCheck(a, plci);
5638 start_internal_command(Id, plci, hold_save_command);
5639 }
5640 break;
5641
5642 case CALL_RETRIEVE_REJ:
5643 cau = parms[7];
5644 if (cau)
5645 {
5646 i = _L3_CAUSE | cau[2];
5647 if (cau[2] == 0) i = 0x3603;
5648 }
5649 else
5650 {
5651 i = 0x3603;
5652 }
5653 PUT_WORD(&SS_Ind[1], S_RETRIEVE);
5654 PUT_WORD(&SS_Ind[4], i);
5655 if (plci->SuppState == RETRIEVE_REQUEST)
5656 {
5657 plci->SuppState = CALL_HELD;
5658 CodecIdCheck(a, plci);
5659 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5660 }
5661 break;
5662
5663 case CALL_RETRIEVE_ACK:
5664 PUT_WORD(&SS_Ind[1], S_RETRIEVE);
5665 if (plci->SuppState == RETRIEVE_REQUEST)
5666 {
5667 plci->SuppState = IDLE;
5668 plci->call_dir |= CALL_DIR_FORCE_OUTG_NL;
5669 plci->b_channel = esc_chi[esc_chi[0]]&0x1f;
5670 if (plci->tel)
5671 {
5672 mixer_set_bchannel_id_esc(plci, plci->b_channel);
5673 dbug(1, dprintf("RetrChannel=0x%x", plci->b_channel));
5674 SetVoiceChannel(a->AdvCodecPLCI, esc_chi, a);
5675 if (plci->B2_prot == B2_TRANSPARENT && plci->B3_prot == B3_TRANSPARENT)
5676 {
5677 dbug(1, dprintf("Get B-ch"));
5678 start_internal_command(Id, plci, retrieve_restore_command);
5679 }
5680 else
5681 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
5682 }
5683 else
5684 start_internal_command(Id, plci, retrieve_restore_command);
5685 }
5686 break;
5687
5688 case INDICATE_IND:
5689 if (plci->State != LISTENING) {
5690 sig_req(plci, HANGUP, 0);
5691 send_req(plci);
5692 break;
5693 }
5694 cip = find_cip(a, parms[4], parms[6]);
5695 cip_mask = 1L << cip;
5696 dbug(1, dprintf("cip=%d,cip_mask=%lx", cip, cip_mask));
5697 clear_c_ind_mask(plci);
5698 if (!remove_started && !a->adapter_disabled)
5699 {
5700 set_c_ind_mask_bit(plci, MAX_APPL);
5701 group_optimization(a, plci);
5702 for (i = 0; i < max_appl; i++) {
5703 if (application[i].Id
5704 && (a->CIP_Mask[i] & 1 || a->CIP_Mask[i] & cip_mask)
5705 && CPN_filter_ok(parms[0], a, i)
5706 && test_group_ind_mask_bit(plci, i)) {
5707 dbug(1, dprintf("storedcip_mask[%d]=0x%lx", i, a->CIP_Mask[i]));
5708 set_c_ind_mask_bit(plci, i);
5709 dump_c_ind_mask(plci);
5710 plci->State = INC_CON_PENDING;
5711 plci->call_dir = (plci->call_dir & ~(CALL_DIR_OUT | CALL_DIR_ORIGINATE)) |
5712 CALL_DIR_IN | CALL_DIR_ANSWER;
5713 if (esc_chi[0]) {
5714 plci->b_channel = esc_chi[esc_chi[0]] & 0x1f;
5715 mixer_set_bchannel_id_esc(plci, plci->b_channel);
5716 }
5717 /* if a listen on the ext controller is done, check if hook states */
5718 /* are supported or if just a on board codec must be activated */
5719 if (a->codec_listen[i] && !a->AdvSignalPLCI) {
5720 if (a->profile.Global_Options & HANDSET)
5721 plci->tel = ADV_VOICE;
5722 else if (a->profile.Global_Options & ON_BOARD_CODEC)
5723 plci->tel = CODEC;
5724 if (plci->tel) Id |= EXT_CONTROLLER;
5725 a->codec_listen[i] = plci;
5726 }
5727
5728 sendf(&application[i], _CONNECT_I, Id, 0,
5729 "wSSSSSSSbSSSSS", cip, /* CIP */
5730 parms[0], /* CalledPartyNumber */
5731 multi_CiPN_parms[0], /* CallingPartyNumber */
5732 parms[2], /* CalledPartySubad */
5733 parms[3], /* CallingPartySubad */
5734 parms[4], /* BearerCapability */
5735 parms[5], /* LowLC */
5736 parms[6], /* HighLC */
5737 ai_len, /* nested struct add_i */
5738 add_i[0], /* B channel info */
5739 add_i[1], /* keypad facility */
5740 add_i[2], /* user user data */
5741 add_i[3], /* nested facility */
5742 multi_CiPN_parms[1] /* second CiPN(SCR) */
5743 );
5744 SendSSExtInd(&application[i],
5745 plci,
5746 Id,
5747 multi_ssext_parms);
5748 SendSetupInfo(&application[i],
5749 plci,
5750 Id,
5751 parms,
5752 SendMultiIE(plci, Id, multi_pi_parms, PI, 0x210, true));
5753 }
5754 }
5755 clear_c_ind_mask_bit(plci, MAX_APPL);
5756 dump_c_ind_mask(plci);
5757 }
5758 if (c_ind_mask_empty(plci)) {
5759 sig_req(plci, HANGUP, 0);
5760 send_req(plci);
5761 plci->State = IDLE;
5762 }
5763 plci->notifiedcall = 0;
5764 a->listen_active--;
5765 listen_check(a);
5766 break;
5767
5768 case CALL_PEND_NOTIFY:
5769 plci->notifiedcall = 1;
5770 listen_check(a);
5771 break;
5772
5773 case CALL_IND:
5774 case CALL_CON:
5775 if (plci->State == ADVANCED_VOICE_SIG || plci->State == ADVANCED_VOICE_NOSIG)
5776 {
5777 if (plci->internal_command == PERM_COD_CONN_PEND)
5778 {
5779 if (plci->State == ADVANCED_VOICE_NOSIG)
5780 {
5781 dbug(1, dprintf("***Codec OK"));
5782 if (a->AdvSignalPLCI)
5783 {
5784 tplci = a->AdvSignalPLCI;
5785 if (tplci->spoofed_msg)
5786 {
5787 dbug(1, dprintf("***Spoofed Msg(0x%x)", tplci->spoofed_msg));
5788 tplci->command = 0;
5789 tplci->internal_command = 0;
5790 x_Id = ((word)tplci->Id << 8) | tplci->adapter->Id | 0x80;
5791 switch (tplci->spoofed_msg)
5792 {
5793 case CALL_RES:
5794 tplci->command = _CONNECT_I | RESPONSE;
5795 api_load_msg(&tplci->saved_msg, saved_parms);
5796 add_b1(tplci, &saved_parms[1], 0, tplci->B1_facilities);
5797 if (tplci->adapter->Info_Mask[tplci->appl->Id - 1] & 0x200)
5798 {
5799 /* early B3 connect (CIP mask bit 9) no release after a disc */
5800 add_p(tplci, LLI, "\x01\x01");
5801 }
5802 add_s(tplci, CONN_NR, &saved_parms[2]);
5803 add_s(tplci, LLC, &saved_parms[4]);
5804 add_ai(tplci, &saved_parms[5]);
5805 tplci->State = INC_CON_ACCEPT;
5806 sig_req(tplci, CALL_RES, 0);
5807 send_req(tplci);
5808 break;
5809
5810 case AWAITING_SELECT_B:
5811 dbug(1, dprintf("Select_B continue"));
5812 start_internal_command(x_Id, tplci, select_b_command);
5813 break;
5814
5815 case AWAITING_MANUF_CON: /* Get_Plci per Manufacturer_Req to ext controller */
5816 if (!tplci->Sig.Id)
5817 {
5818 dbug(1, dprintf("No SigID!"));
5819 sendf(tplci->appl, _MANUFACTURER_R | CONFIRM, x_Id, tplci->number, "dww", _DI_MANU_ID, _MANUFACTURER_R, _OUT_OF_PLCI);
5820 plci_remove(tplci);
5821 break;
5822 }
5823 tplci->command = _MANUFACTURER_R;
5824 api_load_msg(&tplci->saved_msg, saved_parms);
5825 dir = saved_parms[2].info[0];
5826 if (dir == 1) {
5827 sig_req(tplci, CALL_REQ, 0);
5828 }
5829 else if (!dir) {
5830 sig_req(tplci, LISTEN_REQ, 0);
5831 }
5832 send_req(tplci);
5833 sendf(tplci->appl, _MANUFACTURER_R | CONFIRM, x_Id, tplci->number, "dww", _DI_MANU_ID, _MANUFACTURER_R, 0);
5834 break;
5835
5836 case (CALL_REQ | AWAITING_MANUF_CON):
5837 sig_req(tplci, CALL_REQ, 0);
5838 send_req(tplci);
5839 break;
5840
5841 case CALL_REQ:
5842 if (!tplci->Sig.Id)
5843 {
5844 dbug(1, dprintf("No SigID!"));
5845 sendf(tplci->appl, _CONNECT_R | CONFIRM, tplci->adapter->Id, 0, "w", _OUT_OF_PLCI);
5846 plci_remove(tplci);
5847 break;
5848 }
5849 tplci->command = _CONNECT_R;
5850 api_load_msg(&tplci->saved_msg, saved_parms);
5851 add_s(tplci, CPN, &saved_parms[1]);
5852 add_s(tplci, DSA, &saved_parms[3]);
5853 add_ai(tplci, &saved_parms[9]);
5854 sig_req(tplci, CALL_REQ, 0);
5855 send_req(tplci);
5856 break;
5857
5858 case CALL_RETRIEVE:
5859 tplci->command = C_RETRIEVE_REQ;
5860 sig_req(tplci, CALL_RETRIEVE, 0);
5861 send_req(tplci);
5862 break;
5863 }
5864 tplci->spoofed_msg = 0;
5865 if (tplci->internal_command == 0)
5866 next_internal_command(x_Id, tplci);
5867 }
5868 }
5869 next_internal_command(Id, plci);
5870 break;
5871 }
5872 dbug(1, dprintf("***Codec Hook Init Req"));
5873 plci->internal_command = PERM_COD_HOOK;
5874 add_p(plci, FTY, "\x01\x09"); /* Get Hook State*/
5875 sig_req(plci, TEL_CTRL, 0);
5876 send_req(plci);
5877 }
5878 }
5879 else if (plci->command != _MANUFACTURER_R /* old style permanent connect */
5880 && plci->State != INC_ACT_PENDING)
5881 {
5882 mixer_set_bchannel_id_esc(plci, plci->b_channel);
5883 if (plci->tel == ADV_VOICE && plci->SuppState == IDLE) /* with permanent codec switch on immediately */
5884 {
5885 chi[2] = plci->b_channel;
5886 SetVoiceChannel(a->AdvCodecPLCI, chi, a);
5887 }
5888 sendf(plci->appl, _CONNECT_ACTIVE_I, Id, 0, "Sss", parms[21], "", "");
5889 plci->State = INC_ACT_PENDING;
5890 }
5891 break;
5892
5893 case TEL_CTRL:
5894 ie = multi_fac_parms[0]; /* inspect the facility hook indications */
5895 if (plci->State == ADVANCED_VOICE_SIG && ie[0]) {
5896 switch (ie[1] & 0x91) {
5897 case 0x80: /* hook off */
5898 case 0x81:
5899 if (plci->internal_command == PERM_COD_HOOK)
5900 {
5901 dbug(1, dprintf("init:hook_off"));
5902 plci->hook_state = ie[1];
5903 next_internal_command(Id, plci);
5904 break;
5905 }
5906 else /* ignore doubled hook indications */
5907 {
5908 if (((plci->hook_state) & 0xf0) == 0x80)
5909 {
5910 dbug(1, dprintf("ignore hook"));
5911 break;
5912 }
5913 plci->hook_state = ie[1]&0x91;
5914 }
5915 /* check for incoming call pending */
5916 /* and signal '+'.Appl must decide */
5917 /* with connect_res if call must */
5918 /* accepted or not */
5919 for (i = 0, tplci = NULL; i < max_appl; i++) {
5920 if (a->codec_listen[i]
5921 && (a->codec_listen[i]->State == INC_CON_PENDING
5922 || a->codec_listen[i]->State == INC_CON_ALERT)) {
5923 tplci = a->codec_listen[i];
5924 tplci->appl = &application[i];
5925 }
5926 }
5927 /* no incoming call, do outgoing call */
5928 /* and signal '+' if outg. setup */
5929 if (!a->AdvSignalPLCI && !tplci) {
5930 if ((i = get_plci(a))) {
5931 a->AdvSignalPLCI = &a->plci[i - 1];
5932 tplci = a->AdvSignalPLCI;
5933 tplci->tel = ADV_VOICE;
5934 PUT_WORD(&voice_cai[5], a->AdvSignalAppl->MaxDataLength);
5935 if (a->Info_Mask[a->AdvSignalAppl->Id - 1] & 0x200) {
5936 /* early B3 connect (CIP mask bit 9) no release after a disc */
5937 add_p(tplci, LLI, "\x01\x01");
5938 }
5939 add_p(tplci, CAI, voice_cai);
5940 add_p(tplci, OAD, a->TelOAD);
5941 add_p(tplci, OSA, a->TelOSA);
5942 add_p(tplci, SHIFT | 6, NULL);
5943 add_p(tplci, SIN, "\x02\x01\x00");
5944 add_p(tplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
5945 sig_req(tplci, ASSIGN, DSIG_ID);
5946 a->AdvSignalPLCI->internal_command = HOOK_OFF_REQ;
5947 a->AdvSignalPLCI->command = 0;
5948 tplci->appl = a->AdvSignalAppl;
5949 tplci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
5950 send_req(tplci);
5951 }
5952
5953 }
5954
5955 if (!tplci) break;
5956 Id = ((word)tplci->Id << 8) | a->Id;
5957 Id |= EXT_CONTROLLER;
5958 sendf(tplci->appl,
5959 _FACILITY_I,
5960 Id,
5961 0,
5962 "ws", (word)0, "\x01+");
5963 break;
5964
5965 case 0x90: /* hook on */
5966 case 0x91:
5967 if (plci->internal_command == PERM_COD_HOOK)
5968 {
5969 dbug(1, dprintf("init:hook_on"));
5970 plci->hook_state = ie[1] & 0x91;
5971 next_internal_command(Id, plci);
5972 break;
5973 }
5974 else /* ignore doubled hook indications */
5975 {
5976 if (((plci->hook_state) & 0xf0) == 0x90) break;
5977 plci->hook_state = ie[1] & 0x91;
5978 }
5979 /* hangup the adv. voice call and signal '-' to the appl */
5980 if (a->AdvSignalPLCI) {
5981 Id = ((word)a->AdvSignalPLCI->Id << 8) | a->Id;
5982 if (plci->tel) Id |= EXT_CONTROLLER;
5983 sendf(a->AdvSignalAppl,
5984 _FACILITY_I,
5985 Id,
5986 0,
5987 "ws", (word)0, "\x01-");
5988 a->AdvSignalPLCI->internal_command = HOOK_ON_REQ;
5989 a->AdvSignalPLCI->command = 0;
5990 sig_req(a->AdvSignalPLCI, HANGUP, 0);
5991 send_req(a->AdvSignalPLCI);
5992 }
5993 break;
5994 }
5995 }
5996 break;
5997
5998 case RESUME:
5999 clear_c_ind_mask_bit(plci, (word)(plci->appl->Id - 1));
6000 PUT_WORD(&resume_cau[4], GOOD);
6001 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", (word)3, resume_cau);
6002 break;
6003
6004 case SUSPEND:
6005 clear_c_ind_mask(plci);
6006
6007 if (plci->NL.Id && !plci->nl_remove_id) {
6008 mixer_remove(plci);
6009 nl_req_ncci(plci, REMOVE, 0);
6010 }
6011 if (!plci->sig_remove_id) {
6012 plci->internal_command = 0;
6013 sig_req(plci, REMOVE, 0);
6014 }
6015 send_req(plci);
6016 if (!plci->channels) {
6017 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", (word)3, "\x05\x04\x00\x02\x00\x00");
6018 sendf(plci->appl, _DISCONNECT_I, Id, 0, "w", 0);
6019 }
6020 break;
6021
6022 case SUSPEND_REJ:
6023 break;
6024
6025 case HANGUP:
6026 plci->hangup_flow_ctrl_timer = 0;
6027 if (plci->manufacturer && plci->State == LOCAL_CONNECT) break;
6028 cau = parms[7];
6029 if (cau) {
6030 i = _L3_CAUSE | cau[2];
6031 if (cau[2] == 0) i = 0;
6032 else if (cau[2] == 8) i = _L1_ERROR;
6033 else if (cau[2] == 9 || cau[2] == 10) i = _L2_ERROR;
6034 else if (cau[2] == 5) i = _CAPI_GUARD_ERROR;
6035 }
6036 else {
6037 i = _L3_ERROR;
6038 }
6039
6040 if (plci->State == INC_CON_PENDING || plci->State == INC_CON_ALERT)
6041 {
6042 for (i = 0; i < max_appl; i++)
6043 {
6044 if (test_c_ind_mask_bit(plci, i))
6045 sendf(&application[i], _DISCONNECT_I, Id, 0, "w", 0);
6046 }
6047 }
6048 else
6049 {
6050 clear_c_ind_mask(plci);
6051 }
6052 if (!plci->appl)
6053 {
6054 if (plci->State == LISTENING)
6055 {
6056 plci->notifiedcall = 0;
6057 a->listen_active--;
6058 }
6059 plci->State = INC_DIS_PENDING;
6060 if (c_ind_mask_empty(plci))
6061 {
6062 plci->State = IDLE;
6063 if (plci->NL.Id && !plci->nl_remove_id)
6064 {
6065 mixer_remove(plci);
6066 nl_req_ncci(plci, REMOVE, 0);
6067 }
6068 if (!plci->sig_remove_id)
6069 {
6070 plci->internal_command = 0;
6071 sig_req(plci, REMOVE, 0);
6072 }
6073 send_req(plci);
6074 }
6075 }
6076 else
6077 {
6078 /* collision of DISCONNECT or CONNECT_RES with HANGUP can */
6079 /* result in a second HANGUP! Don't generate another */
6080 /* DISCONNECT */
6081 if (plci->State != IDLE && plci->State != INC_DIS_PENDING)
6082 {
6083 if (plci->State == RESUMING)
6084 {
6085 PUT_WORD(&resume_cau[4], i);
6086 sendf(plci->appl, _FACILITY_I, Id, 0, "ws", (word)3, resume_cau);
6087 }
6088 plci->State = INC_DIS_PENDING;
6089 sendf(plci->appl, _DISCONNECT_I, Id, 0, "w", i);
6090 }
6091 }
6092 break;
6093
6094 case SSEXT_IND:
6095 SendSSExtInd(NULL, plci, Id, multi_ssext_parms);
6096 break;
6097
6098 case VSWITCH_REQ:
6099 VSwitchReqInd(plci, Id, multi_vswitch_parms);
6100 break;
6101 case VSWITCH_IND:
6102 if (plci->relatedPTYPLCI &&
6103 plci->vswitchstate == 3 &&
6104 plci->relatedPTYPLCI->vswitchstate == 3 &&
6105 parms[MAXPARMSIDS - 1][0])
6106 {
6107 add_p(plci->relatedPTYPLCI, SMSG, parms[MAXPARMSIDS - 1]);
6108 sig_req(plci->relatedPTYPLCI, VSWITCH_REQ, 0);
6109 send_req(plci->relatedPTYPLCI);
6110 }
6111 else VSwitchReqInd(plci, Id, multi_vswitch_parms);
6112 break;
6113
6114 }
6115 }
6116
6117
6118 static void SendSetupInfo(APPL *appl, PLCI *plci, dword Id, byte **parms, byte Info_Sent_Flag)
6119 {
6120 word i;
6121 byte *ie;
6122 word Info_Number;
6123 byte *Info_Element;
6124 word Info_Mask = 0;
6125
6126 dbug(1, dprintf("SetupInfo"));
6127
6128 for (i = 0; i < MAXPARMSIDS; i++) {
6129 ie = parms[i];
6130 Info_Number = 0;
6131 Info_Element = ie;
6132 if (ie[0]) {
6133 switch (i) {
6134 case 0:
6135 dbug(1, dprintf("CPN "));
6136 Info_Number = 0x0070;
6137 Info_Mask = 0x80;
6138 Info_Sent_Flag = true;
6139 break;
6140 case 8: /* display */
6141 dbug(1, dprintf("display(%d)", i));
6142 Info_Number = 0x0028;
6143 Info_Mask = 0x04;
6144 Info_Sent_Flag = true;
6145 break;
6146 case 16: /* Channel Id */
6147 dbug(1, dprintf("CHI"));
6148 Info_Number = 0x0018;
6149 Info_Mask = 0x100;
6150 Info_Sent_Flag = true;
6151 mixer_set_bchannel_id(plci, Info_Element);
6152 break;
6153 case 19: /* Redirected Number */
6154 dbug(1, dprintf("RDN"));
6155 Info_Number = 0x0074;
6156 Info_Mask = 0x400;
6157 Info_Sent_Flag = true;
6158 break;
6159 case 20: /* Redirected Number extended */
6160 dbug(1, dprintf("RDX"));
6161 Info_Number = 0x0073;
6162 Info_Mask = 0x400;
6163 Info_Sent_Flag = true;
6164 break;
6165 case 22: /* Redirecing Number */
6166 dbug(1, dprintf("RIN"));
6167 Info_Number = 0x0076;
6168 Info_Mask = 0x400;
6169 Info_Sent_Flag = true;
6170 break;
6171 default:
6172 Info_Number = 0;
6173 break;
6174 }
6175 }
6176
6177 if (i == MAXPARMSIDS - 2) { /* to indicate the message type "Setup" */
6178 Info_Number = 0x8000 | 5;
6179 Info_Mask = 0x10;
6180 Info_Element = "";
6181 }
6182
6183 if (Info_Sent_Flag && Info_Number) {
6184 if (plci->adapter->Info_Mask[appl->Id - 1] & Info_Mask) {
6185 sendf(appl, _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
6186 }
6187 }
6188 }
6189 }
6190
6191
6192 static void SendInfo(PLCI *plci, dword Id, byte **parms, byte iesent)
6193 {
6194 word i;
6195 word j;
6196 word k;
6197 byte *ie;
6198 word Info_Number;
6199 byte *Info_Element;
6200 word Info_Mask = 0;
6201 static byte charges[5] = {4, 0, 0, 0, 0};
6202 static byte cause[] = {0x02, 0x80, 0x00};
6203 APPL *appl;
6204
6205 dbug(1, dprintf("InfoParse "));
6206
6207 if (
6208 !plci->appl
6209 && !plci->State
6210 && plci->Sig.Ind != NCR_FACILITY
6211 )
6212 {
6213 dbug(1, dprintf("NoParse "));
6214 return;
6215 }
6216 cause[2] = 0;
6217 for (i = 0; i < MAXPARMSIDS; i++) {
6218 ie = parms[i];
6219 Info_Number = 0;
6220 Info_Element = ie;
6221 if (ie[0]) {
6222 switch (i) {
6223 case 0:
6224 dbug(1, dprintf("CPN "));
6225 Info_Number = 0x0070;
6226 Info_Mask = 0x80;
6227 break;
6228 case 7: /* ESC_CAU */
6229 dbug(1, dprintf("cau(0x%x)", ie[2]));
6230 Info_Number = 0x0008;
6231 Info_Mask = 0x00;
6232 cause[2] = ie[2];
6233 Info_Element = NULL;
6234 break;
6235 case 8: /* display */
6236 dbug(1, dprintf("display(%d)", i));
6237 Info_Number = 0x0028;
6238 Info_Mask = 0x04;
6239 break;
6240 case 9: /* Date display */
6241 dbug(1, dprintf("date(%d)", i));
6242 Info_Number = 0x0029;
6243 Info_Mask = 0x02;
6244 break;
6245 case 10: /* charges */
6246 for (j = 0; j < 4; j++) charges[1 + j] = 0;
6247 for (j = 0; j < ie[0] && !(ie[1 + j] & 0x80); j++);
6248 for (k = 1, j++; j < ie[0] && k <= 4; j++, k++) charges[k] = ie[1 + j];
6249 Info_Number = 0x4000;
6250 Info_Mask = 0x40;
6251 Info_Element = charges;
6252 break;
6253 case 11: /* user user info */
6254 dbug(1, dprintf("uui"));
6255 Info_Number = 0x007E;
6256 Info_Mask = 0x08;
6257 break;
6258 case 12: /* congestion receiver ready */
6259 dbug(1, dprintf("clRDY"));
6260 Info_Number = 0x00B0;
6261 Info_Mask = 0x08;
6262 Info_Element = "";
6263 break;
6264 case 13: /* congestion receiver not ready */
6265 dbug(1, dprintf("clNRDY"));
6266 Info_Number = 0x00BF;
6267 Info_Mask = 0x08;
6268 Info_Element = "";
6269 break;
6270 case 15: /* Keypad Facility */
6271 dbug(1, dprintf("KEY"));
6272 Info_Number = 0x002C;
6273 Info_Mask = 0x20;
6274 break;
6275 case 16: /* Channel Id */
6276 dbug(1, dprintf("CHI"));
6277 Info_Number = 0x0018;
6278 Info_Mask = 0x100;
6279 mixer_set_bchannel_id(plci, Info_Element);
6280 break;
6281 case 17: /* if no 1tr6 cause, send full cause, else esc_cause */
6282 dbug(1, dprintf("q9cau(0x%x)", ie[2]));
6283 if (!cause[2] || cause[2] < 0x80) break; /* eg. layer 1 error */
6284 Info_Number = 0x0008;
6285 Info_Mask = 0x01;
6286 if (cause[2] != ie[2]) Info_Element = cause;
6287 break;
6288 case 19: /* Redirected Number */
6289 dbug(1, dprintf("RDN"));
6290 Info_Number = 0x0074;
6291 Info_Mask = 0x400;
6292 break;
6293 case 22: /* Redirecing Number */
6294 dbug(1, dprintf("RIN"));
6295 Info_Number = 0x0076;
6296 Info_Mask = 0x400;
6297 break;
6298 case 23: /* Notification Indicator */
6299 dbug(1, dprintf("NI"));
6300 Info_Number = (word)NI;
6301 Info_Mask = 0x210;
6302 break;
6303 case 26: /* Call State */
6304 dbug(1, dprintf("CST"));
6305 Info_Number = (word)CST;
6306 Info_Mask = 0x01; /* do with cause i.e. for now */
6307 break;
6308 case MAXPARMSIDS - 2: /* Escape Message Type, must be the last indication */
6309 dbug(1, dprintf("ESC/MT[0x%x]", ie[3]));
6310 Info_Number = 0x8000 | ie[3];
6311 if (iesent) Info_Mask = 0xffff;
6312 else Info_Mask = 0x10;
6313 Info_Element = "";
6314 break;
6315 default:
6316 Info_Number = 0;
6317 Info_Mask = 0;
6318 Info_Element = "";
6319 break;
6320 }
6321 }
6322
6323 if (plci->Sig.Ind == NCR_FACILITY) /* check controller broadcast */
6324 {
6325 for (j = 0; j < max_appl; j++)
6326 {
6327 appl = &application[j];
6328 if (Info_Number
6329 && appl->Id
6330 && plci->adapter->Info_Mask[appl->Id - 1] & Info_Mask)
6331 {
6332 dbug(1, dprintf("NCR_Ind"));
6333 iesent = true;
6334 sendf(&application[j], _INFO_I, Id & 0x0f, 0, "wS", Info_Number, Info_Element);
6335 }
6336 }
6337 }
6338 else if (!plci->appl)
6339 { /* overlap receiving broadcast */
6340 if (Info_Number == CPN
6341 || Info_Number == KEY
6342 || Info_Number == NI
6343 || Info_Number == DSP
6344 || Info_Number == UUI)
6345 {
6346 for (j = 0; j < max_appl; j++)
6347 {
6348 if (test_c_ind_mask_bit(plci, j))
6349 {
6350 dbug(1, dprintf("Ovl_Ind"));
6351 iesent = true;
6352 sendf(&application[j], _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
6353 }
6354 }
6355 }
6356 } /* all other signalling states */
6357 else if (Info_Number
6358 && plci->adapter->Info_Mask[plci->appl->Id - 1] & Info_Mask)
6359 {
6360 dbug(1, dprintf("Std_Ind"));
6361 iesent = true;
6362 sendf(plci->appl, _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
6363 }
6364 }
6365 }
6366
6367
6368 static byte SendMultiIE(PLCI *plci, dword Id, byte **parms, byte ie_type,
6369 dword info_mask, byte setupParse)
6370 {
6371 word i;
6372 word j;
6373 byte *ie;
6374 word Info_Number;
6375 byte *Info_Element;
6376 APPL *appl;
6377 word Info_Mask = 0;
6378 byte iesent = 0;
6379
6380 if (
6381 !plci->appl
6382 && !plci->State
6383 && plci->Sig.Ind != NCR_FACILITY
6384 && !setupParse
6385 )
6386 {
6387 dbug(1, dprintf("NoM-IEParse "));
6388 return 0;
6389 }
6390 dbug(1, dprintf("M-IEParse "));
6391
6392 for (i = 0; i < MAX_MULTI_IE; i++)
6393 {
6394 ie = parms[i];
6395 Info_Number = 0;
6396 Info_Element = ie;
6397 if (ie[0])
6398 {
6399 dbug(1, dprintf("[Ind0x%x]:IE=0x%x", plci->Sig.Ind, ie_type));
6400 Info_Number = (word)ie_type;
6401 Info_Mask = (word)info_mask;
6402 }
6403
6404 if (plci->Sig.Ind == NCR_FACILITY) /* check controller broadcast */
6405 {
6406 for (j = 0; j < max_appl; j++)
6407 {
6408 appl = &application[j];
6409 if (Info_Number
6410 && appl->Id
6411 && plci->adapter->Info_Mask[appl->Id - 1] & Info_Mask)
6412 {
6413 iesent = true;
6414 dbug(1, dprintf("Mlt_NCR_Ind"));
6415 sendf(&application[j], _INFO_I, Id & 0x0f, 0, "wS", Info_Number, Info_Element);
6416 }
6417 }
6418 }
6419 else if (!plci->appl && Info_Number)
6420 { /* overlap receiving broadcast */
6421 for (j = 0; j < max_appl; j++)
6422 {
6423 if (test_c_ind_mask_bit(plci, j))
6424 {
6425 iesent = true;
6426 dbug(1, dprintf("Mlt_Ovl_Ind"));
6427 sendf(&application[j] , _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
6428 }
6429 }
6430 } /* all other signalling states */
6431 else if (Info_Number
6432 && plci->adapter->Info_Mask[plci->appl->Id - 1] & Info_Mask)
6433 {
6434 iesent = true;
6435 dbug(1, dprintf("Mlt_Std_Ind"));
6436 sendf(plci->appl, _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
6437 }
6438 }
6439 return iesent;
6440 }
6441
6442 static void SendSSExtInd(APPL *appl, PLCI *plci, dword Id, byte **parms)
6443 {
6444 word i;
6445 /* Format of multi_ssext_parms[i][]:
6446 0 byte length
6447 1 byte SSEXTIE
6448 2 byte SSEXT_REQ/SSEXT_IND
6449 3 byte length
6450 4 word SSExtCommand
6451 6... Params
6452 */
6453 if (
6454 plci
6455 && plci->State
6456 && plci->Sig.Ind != NCR_FACILITY
6457 )
6458 for (i = 0; i < MAX_MULTI_IE; i++)
6459 {
6460 if (parms[i][0] < 6) continue;
6461 if (parms[i][2] == SSEXT_REQ) continue;
6462
6463 if (appl)
6464 {
6465 parms[i][0] = 0; /* kill it */
6466 sendf(appl, _MANUFACTURER_I,
6467 Id,
6468 0,
6469 "dwS",
6470 _DI_MANU_ID,
6471 _DI_SSEXT_CTRL,
6472 &parms[i][3]);
6473 }
6474 else if (plci->appl)
6475 {
6476 parms[i][0] = 0; /* kill it */
6477 sendf(plci->appl, _MANUFACTURER_I,
6478 Id,
6479 0,
6480 "dwS",
6481 _DI_MANU_ID,
6482 _DI_SSEXT_CTRL,
6483 &parms[i][3]);
6484 }
6485 }
6486 };
6487
6488 static void nl_ind(PLCI *plci)
6489 {
6490 byte ch;
6491 word ncci;
6492 dword Id;
6493 DIVA_CAPI_ADAPTER *a;
6494 word NCCIcode;
6495 APPL *APPLptr;
6496 word count;
6497 word Num;
6498 word i, ncpi_state;
6499 byte len, ncci_state;
6500 word msg;
6501 word info = 0;
6502 word fax_feature_bits;
6503 byte fax_send_edata_ack;
6504 static byte v120_header_buffer[2 + 3];
6505 static word fax_info[] = {
6506 0, /* T30_SUCCESS */
6507 _FAX_NO_CONNECTION, /* T30_ERR_NO_DIS_RECEIVED */
6508 _FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_NO_RESPONSE */
6509 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_RESPONSE */
6510 _FAX_PROTOCOL_ERROR, /* T30_ERR_TOO_MANY_REPEATS */
6511 _FAX_PROTOCOL_ERROR, /* T30_ERR_UNEXPECTED_MESSAGE */
6512 _FAX_REMOTE_ABORT, /* T30_ERR_UNEXPECTED_DCN */
6513 _FAX_LOCAL_ABORT, /* T30_ERR_DTC_UNSUPPORTED */
6514 _FAX_TRAINING_ERROR, /* T30_ERR_ALL_RATES_FAILED */
6515 _FAX_TRAINING_ERROR, /* T30_ERR_TOO_MANY_TRAINS */
6516 _FAX_PARAMETER_ERROR, /* T30_ERR_RECEIVE_CORRUPTED */
6517 _FAX_REMOTE_ABORT, /* T30_ERR_UNEXPECTED_DISC */
6518 _FAX_LOCAL_ABORT, /* T30_ERR_APPLICATION_DISC */
6519 _FAX_REMOTE_REJECT, /* T30_ERR_INCOMPATIBLE_DIS */
6520 _FAX_LOCAL_ABORT, /* T30_ERR_INCOMPATIBLE_DCS */
6521 _FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_NO_COMMAND */
6522 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_COMMAND */
6523 _FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_COMMAND_TOO_LONG */
6524 _FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_RESPONSE_TOO_LONG */
6525 _FAX_NO_CONNECTION, /* T30_ERR_NOT_IDENTIFIED */
6526 _FAX_PROTOCOL_ERROR, /* T30_ERR_SUPERVISORY_TIMEOUT */
6527 _FAX_PARAMETER_ERROR, /* T30_ERR_TOO_LONG_SCAN_LINE */
6528 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_PAGE_AFTER_MPS */
6529 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_PAGE_AFTER_CFR */
6530 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCS_AFTER_FTT */
6531 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCS_AFTER_EOM */
6532 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCS_AFTER_MPS */
6533 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCN_AFTER_MCF */
6534 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCN_AFTER_RTN */
6535 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_CFR */
6536 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_MCF_AFTER_EOP */
6537 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_MCF_AFTER_EOM */
6538 _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_MCF_AFTER_MPS */
6539 0x331d, /* T30_ERR_SUB_SEP_UNSUPPORTED */
6540 0x331e, /* T30_ERR_PWD_UNSUPPORTED */
6541 0x331f, /* T30_ERR_SUB_SEP_PWD_UNSUPPORTED */
6542 _FAX_PROTOCOL_ERROR, /* T30_ERR_INVALID_COMMAND_FRAME */
6543 _FAX_PARAMETER_ERROR, /* T30_ERR_UNSUPPORTED_PAGE_CODING */
6544 _FAX_PARAMETER_ERROR, /* T30_ERR_INVALID_PAGE_CODING */
6545 _FAX_REMOTE_REJECT, /* T30_ERR_INCOMPATIBLE_PAGE_CONFIG */
6546 _FAX_LOCAL_ABORT, /* T30_ERR_TIMEOUT_FROM_APPLICATION */
6547 _FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_NO_REACTION_ON_MARK */
6548 _FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_TRAINING_TIMEOUT */
6549 _FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_UNEXPECTED_V21 */
6550 _FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_PRIMARY_CTS_ON */
6551 _FAX_LOCAL_ABORT, /* T30_ERR_V34FAX_TURNAROUND_POLLING */
6552 _FAX_LOCAL_ABORT /* T30_ERR_V34FAX_V8_INCOMPATIBILITY */
6553 };
6554
6555 byte dtmf_code_buffer[CAPIDTMF_RECV_DIGIT_BUFFER_SIZE + 1];
6556
6557
6558 static word rtp_info[] = {
6559 GOOD, /* RTP_SUCCESS */
6560 0x3600 /* RTP_ERR_SSRC_OR_PAYLOAD_CHANGE */
6561 };
6562
6563 static dword udata_forwarding_table[0x100 / sizeof(dword)] =
6564 {
6565 0x0020301e, 0x00000000, 0x00000000, 0x00000000,
6566 0x00000000, 0x00000000, 0x00000000, 0x00000000
6567 };
6568
6569 ch = plci->NL.IndCh;
6570 a = plci->adapter;
6571 ncci = a->ch_ncci[ch];
6572 Id = (((dword)(ncci ? ncci : ch)) << 16) | (((word) plci->Id) << 8) | a->Id;
6573 if (plci->tel) Id |= EXT_CONTROLLER;
6574 APPLptr = plci->appl;
6575 dbug(1, dprintf("NL_IND-Id(NL:0x%x)=0x%08lx,plci=%x,tel=%x,state=0x%x,ch=0x%x,chs=%d,Ind=%x",
6576 plci->NL.Id, Id, plci->Id, plci->tel, plci->State, ch, plci->channels, plci->NL.Ind & 0x0f));
6577
6578 /* in the case if no connect_active_Ind was sent to the appl we wait for */
6579
6580 if (plci->nl_remove_id)
6581 {
6582 plci->NL.RNR = 2; /* discard */
6583 dbug(1, dprintf("NL discard while remove pending"));
6584 return;
6585 }
6586 if ((plci->NL.Ind & 0x0f) == N_CONNECT)
6587 {
6588 if (plci->State == INC_DIS_PENDING
6589 || plci->State == OUTG_DIS_PENDING
6590 || plci->State == IDLE)
6591 {
6592 plci->NL.RNR = 2; /* discard */
6593 dbug(1, dprintf("discard n_connect"));
6594 return;
6595 }
6596 if (plci->State < INC_ACT_PENDING)
6597 {
6598 plci->NL.RNR = 1; /* flow control */
6599 channel_x_off(plci, ch, N_XON_CONNECT_IND);
6600 return;
6601 }
6602 }
6603
6604 if (!APPLptr) /* no application or invalid data */
6605 { /* while reloading the DSP */
6606 dbug(1, dprintf("discard1"));
6607 plci->NL.RNR = 2;
6608 return;
6609 }
6610
6611 if (((plci->NL.Ind & 0x0f) == N_UDATA)
6612 && (((plci->B2_prot != B2_SDLC) && ((plci->B1_resource == 17) || (plci->B1_resource == 18)))
6613 || (plci->B2_prot == 7)
6614 || (plci->B3_prot == 7)))
6615 {
6616 plci->ncpi_buffer[0] = 0;
6617
6618 ncpi_state = plci->ncpi_state;
6619 if (plci->NL.complete == 1)
6620 {
6621 byte *data = &plci->NL.RBuffer->P[0];
6622
6623 if ((plci->NL.RBuffer->length >= 12)
6624 && ((*data == DSP_UDATA_INDICATION_DCD_ON)
6625 || (*data == DSP_UDATA_INDICATION_CTS_ON)))
6626 {
6627 word conn_opt, ncpi_opt = 0x00;
6628 /* HexDump ("MDM N_UDATA:", plci->NL.RBuffer->length, data); */
6629
6630 if (*data == DSP_UDATA_INDICATION_DCD_ON)
6631 plci->ncpi_state |= NCPI_MDM_DCD_ON_RECEIVED;
6632 if (*data == DSP_UDATA_INDICATION_CTS_ON)
6633 plci->ncpi_state |= NCPI_MDM_CTS_ON_RECEIVED;
6634
6635 data++; /* indication code */
6636 data += 2; /* timestamp */
6637 if ((*data == DSP_CONNECTED_NORM_V18) || (*data == DSP_CONNECTED_NORM_VOWN))
6638 ncpi_state &= ~(NCPI_MDM_DCD_ON_RECEIVED | NCPI_MDM_CTS_ON_RECEIVED);
6639 data++; /* connected norm */
6640 conn_opt = GET_WORD(data);
6641 data += 2; /* connected options */
6642
6643 PUT_WORD(&(plci->ncpi_buffer[1]), (word)(GET_DWORD(data) & 0x0000FFFF));
6644
6645 if (conn_opt & DSP_CONNECTED_OPTION_MASK_V42)
6646 {
6647 ncpi_opt |= MDM_NCPI_ECM_V42;
6648 }
6649 else if (conn_opt & DSP_CONNECTED_OPTION_MASK_MNP)
6650 {
6651 ncpi_opt |= MDM_NCPI_ECM_MNP;
6652 }
6653 else
6654 {
6655 ncpi_opt |= MDM_NCPI_TRANSPARENT;
6656 }
6657 if (conn_opt & DSP_CONNECTED_OPTION_MASK_COMPRESSION)
6658 {
6659 ncpi_opt |= MDM_NCPI_COMPRESSED;
6660 }
6661 PUT_WORD(&(plci->ncpi_buffer[3]), ncpi_opt);
6662 plci->ncpi_buffer[0] = 4;
6663
6664 plci->ncpi_state |= NCPI_VALID_CONNECT_B3_IND | NCPI_VALID_CONNECT_B3_ACT | NCPI_VALID_DISC_B3_IND;
6665 }
6666 }
6667 if (plci->B3_prot == 7)
6668 {
6669 if (((a->ncci_state[ncci] == INC_ACT_PENDING) || (a->ncci_state[ncci] == OUTG_CON_PENDING))
6670 && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6671 && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6672 {
6673 a->ncci_state[ncci] = INC_ACT_PENDING;
6674 sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
6675 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6676 }
6677 }
6678
6679 if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
6680 & ((1L << PRIVATE_V18) | (1L << PRIVATE_VOWN)))
6681 || !(ncpi_state & NCPI_MDM_DCD_ON_RECEIVED)
6682 || !(ncpi_state & NCPI_MDM_CTS_ON_RECEIVED))
6683
6684 {
6685 plci->NL.RNR = 2;
6686 return;
6687 }
6688 }
6689
6690 if (plci->NL.complete == 2)
6691 {
6692 if (((plci->NL.Ind & 0x0f) == N_UDATA)
6693 && !(udata_forwarding_table[plci->RData[0].P[0] >> 5] & (1L << (plci->RData[0].P[0] & 0x1f))))
6694 {
6695 switch (plci->RData[0].P[0])
6696 {
6697
6698 case DTMF_UDATA_INDICATION_FAX_CALLING_TONE:
6699 if (plci->dtmf_rec_active & DTMF_LISTEN_ACTIVE_FLAG)
6700 sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", SELECTOR_DTMF, "\x01X");
6701 break;
6702 case DTMF_UDATA_INDICATION_ANSWER_TONE:
6703 if (plci->dtmf_rec_active & DTMF_LISTEN_ACTIVE_FLAG)
6704 sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", SELECTOR_DTMF, "\x01Y");
6705 break;
6706 case DTMF_UDATA_INDICATION_DIGITS_RECEIVED:
6707 dtmf_indication(Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6708 break;
6709 case DTMF_UDATA_INDICATION_DIGITS_SENT:
6710 dtmf_confirmation(Id, plci);
6711 break;
6712
6713
6714 case UDATA_INDICATION_MIXER_TAP_DATA:
6715 capidtmf_recv_process_block(&(plci->capidtmf_state), plci->RData[0].P + 1, (word)(plci->RData[0].PLength - 1));
6716 i = capidtmf_indication(&(plci->capidtmf_state), dtmf_code_buffer + 1);
6717 if (i != 0)
6718 {
6719 dtmf_code_buffer[0] = DTMF_UDATA_INDICATION_DIGITS_RECEIVED;
6720 dtmf_indication(Id, plci, dtmf_code_buffer, (word)(i + 1));
6721 }
6722 break;
6723
6724
6725 case UDATA_INDICATION_MIXER_COEFS_SET:
6726 mixer_indication_coefs_set(Id, plci);
6727 break;
6728 case UDATA_INDICATION_XCONNECT_FROM:
6729 mixer_indication_xconnect_from(Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6730 break;
6731 case UDATA_INDICATION_XCONNECT_TO:
6732 mixer_indication_xconnect_to(Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6733 break;
6734
6735
6736 case LEC_UDATA_INDICATION_DISABLE_DETECT:
6737 ec_indication(Id, plci, plci->RData[0].P, plci->RData[0].PLength);
6738 break;
6739
6740
6741
6742 default:
6743 break;
6744 }
6745 }
6746 else
6747 {
6748 if ((plci->RData[0].PLength != 0)
6749 && ((plci->B2_prot == B2_V120_ASYNC)
6750 || (plci->B2_prot == B2_V120_ASYNC_V42BIS)
6751 || (plci->B2_prot == B2_V120_BIT_TRANSPARENT)))
6752 {
6753
6754 sendf(plci->appl, _DATA_B3_I, Id, 0,
6755 "dwww",
6756 plci->RData[1].P,
6757 (plci->NL.RNum < 2) ? 0 : plci->RData[1].PLength,
6758 plci->RNum,
6759 plci->RFlags);
6760
6761 }
6762 else
6763 {
6764
6765 sendf(plci->appl, _DATA_B3_I, Id, 0,
6766 "dwww",
6767 plci->RData[0].P,
6768 plci->RData[0].PLength,
6769 plci->RNum,
6770 plci->RFlags);
6771
6772 }
6773 }
6774 return;
6775 }
6776
6777 fax_feature_bits = 0;
6778 if ((plci->NL.Ind & 0x0f) == N_CONNECT ||
6779 (plci->NL.Ind & 0x0f) == N_CONNECT_ACK ||
6780 (plci->NL.Ind & 0x0f) == N_DISC ||
6781 (plci->NL.Ind & 0x0f) == N_EDATA ||
6782 (plci->NL.Ind & 0x0f) == N_DISC_ACK)
6783 {
6784 info = 0;
6785 plci->ncpi_buffer[0] = 0;
6786 switch (plci->B3_prot) {
6787 case 0: /*XPARENT*/
6788 case 1: /*T.90 NL*/
6789 break; /* no network control protocol info - jfr */
6790 case 2: /*ISO8202*/
6791 case 3: /*X25 DCE*/
6792 for (i = 0; i < plci->NL.RLength; i++) plci->ncpi_buffer[4 + i] = plci->NL.RBuffer->P[i];
6793 plci->ncpi_buffer[0] = (byte)(i + 3);
6794 plci->ncpi_buffer[1] = (byte)(plci->NL.Ind & N_D_BIT ? 1 : 0);
6795 plci->ncpi_buffer[2] = 0;
6796 plci->ncpi_buffer[3] = 0;
6797 break;
6798 case 4: /*T.30 - FAX*/
6799 case 5: /*T.30 - FAX*/
6800 if (plci->NL.RLength >= sizeof(T30_INFO))
6801 {
6802 dbug(1, dprintf("FaxStatus %04x", ((T30_INFO *)plci->NL.RBuffer->P)->code));
6803 len = 9;
6804 PUT_WORD(&(plci->ncpi_buffer[1]), ((T30_INFO *)plci->NL.RBuffer->P)->rate_div_2400 * 2400);
6805 fax_feature_bits = GET_WORD(&((T30_INFO *)plci->NL.RBuffer->P)->feature_bits_low);
6806 i = (((T30_INFO *)plci->NL.RBuffer->P)->resolution & T30_RESOLUTION_R8_0770_OR_200) ? 0x0001 : 0x0000;
6807 if (plci->B3_prot == 5)
6808 {
6809 if (!(fax_feature_bits & T30_FEATURE_BIT_ECM))
6810 i |= 0x8000; /* This is not an ECM connection */
6811 if (fax_feature_bits & T30_FEATURE_BIT_T6_CODING)
6812 i |= 0x4000; /* This is a connection with MMR compression */
6813 if (fax_feature_bits & T30_FEATURE_BIT_2D_CODING)
6814 i |= 0x2000; /* This is a connection with MR compression */
6815 if (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS)
6816 i |= 0x0004; /* More documents */
6817 if (fax_feature_bits & T30_FEATURE_BIT_POLLING)
6818 i |= 0x0002; /* Fax-polling indication */
6819 }
6820 dbug(1, dprintf("FAX Options %04x %04x", fax_feature_bits, i));
6821 PUT_WORD(&(plci->ncpi_buffer[3]), i);
6822 PUT_WORD(&(plci->ncpi_buffer[5]), ((T30_INFO *)plci->NL.RBuffer->P)->data_format);
6823 plci->ncpi_buffer[7] = ((T30_INFO *)plci->NL.RBuffer->P)->pages_low;
6824 plci->ncpi_buffer[8] = ((T30_INFO *)plci->NL.RBuffer->P)->pages_high;
6825 plci->ncpi_buffer[len] = 0;
6826 if (((T30_INFO *)plci->NL.RBuffer->P)->station_id_len)
6827 {
6828 plci->ncpi_buffer[len] = 20;
6829 for (i = 0; i < T30_MAX_STATION_ID_LENGTH; i++)
6830 plci->ncpi_buffer[++len] = ((T30_INFO *)plci->NL.RBuffer->P)->station_id[i];
6831 }
6832 if (((plci->NL.Ind & 0x0f) == N_DISC) || ((plci->NL.Ind & 0x0f) == N_DISC_ACK))
6833 {
6834 if (((T30_INFO *)plci->NL.RBuffer->P)->code < ARRAY_SIZE(fax_info))
6835 info = fax_info[((T30_INFO *)plci->NL.RBuffer->P)->code];
6836 else
6837 info = _FAX_PROTOCOL_ERROR;
6838 }
6839
6840 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id - 1])
6841 & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
6842 {
6843 i = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + ((T30_INFO *)plci->NL.RBuffer->P)->head_line_len;
6844 while (i < plci->NL.RBuffer->length)
6845 plci->ncpi_buffer[++len] = plci->NL.RBuffer->P[i++];
6846 }
6847
6848 plci->ncpi_buffer[0] = len;
6849 fax_feature_bits = GET_WORD(&((T30_INFO *)plci->NL.RBuffer->P)->feature_bits_low);
6850 PUT_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->feature_bits_low, fax_feature_bits);
6851
6852 plci->ncpi_state |= NCPI_VALID_CONNECT_B3_IND;
6853 if (((plci->NL.Ind & 0x0f) == N_CONNECT_ACK)
6854 || (((plci->NL.Ind & 0x0f) == N_CONNECT)
6855 && (fax_feature_bits & T30_FEATURE_BIT_POLLING))
6856 || (((plci->NL.Ind & 0x0f) == N_EDATA)
6857 && ((((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_TRAIN_OK)
6858 || (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_DIS)
6859 || (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_DTC))))
6860 {
6861 plci->ncpi_state |= NCPI_VALID_CONNECT_B3_ACT;
6862 }
6863 if (((plci->NL.Ind & 0x0f) == N_DISC)
6864 || ((plci->NL.Ind & 0x0f) == N_DISC_ACK)
6865 || (((plci->NL.Ind & 0x0f) == N_EDATA)
6866 && (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_EOP_CAPI)))
6867 {
6868 plci->ncpi_state |= NCPI_VALID_CONNECT_B3_ACT | NCPI_VALID_DISC_B3_IND;
6869 }
6870 }
6871 break;
6872
6873 case B3_RTP:
6874 if (((plci->NL.Ind & 0x0f) == N_DISC) || ((plci->NL.Ind & 0x0f) == N_DISC_ACK))
6875 {
6876 if (plci->NL.RLength != 0)
6877 {
6878 info = rtp_info[plci->NL.RBuffer->P[0]];
6879 plci->ncpi_buffer[0] = plci->NL.RLength - 1;
6880 for (i = 1; i < plci->NL.RLength; i++)
6881 plci->ncpi_buffer[i] = plci->NL.RBuffer->P[i];
6882 }
6883 }
6884 break;
6885
6886 }
6887 plci->NL.RNR = 2;
6888 }
6889 switch (plci->NL.Ind & 0x0f) {
6890 case N_EDATA:
6891 if ((plci->B3_prot == 4) || (plci->B3_prot == 5))
6892 {
6893 dbug(1, dprintf("EDATA ncci=0x%x state=%d code=%02x", ncci, a->ncci_state[ncci],
6894 ((T30_INFO *)plci->NL.RBuffer->P)->code));
6895 fax_send_edata_ack = (((T30_INFO *)(plci->fax_connect_info_buffer))->operating_mode == T30_OPERATING_MODE_CAPI_NEG);
6896
6897 if ((plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF)
6898 && (plci->nsf_control_bits & (T30_NSF_CONTROL_BIT_NEGOTIATE_IND | T30_NSF_CONTROL_BIT_NEGOTIATE_RESP))
6899 && (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_DIS)
6900 && (a->ncci_state[ncci] == OUTG_CON_PENDING)
6901 && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6902 && !(plci->ncpi_state & NCPI_NEGOTIATE_B3_SENT))
6903 {
6904 ((T30_INFO *)(plci->fax_connect_info_buffer))->code = ((T30_INFO *)plci->NL.RBuffer->P)->code;
6905 sendf(plci->appl, _MANUFACTURER_I, Id, 0, "dwbS", _DI_MANU_ID, _DI_NEGOTIATE_B3,
6906 (byte)(plci->ncpi_buffer[0] + 1), plci->ncpi_buffer);
6907 plci->ncpi_state |= NCPI_NEGOTIATE_B3_SENT;
6908 if (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP)
6909 fax_send_edata_ack = false;
6910 }
6911
6912 if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
6913 {
6914 switch (((T30_INFO *)plci->NL.RBuffer->P)->code)
6915 {
6916 case EDATA_T30_DIS:
6917 if ((a->ncci_state[ncci] == OUTG_CON_PENDING)
6918 && !(GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low) & T30_CONTROL_BIT_REQUEST_POLLING)
6919 && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6920 && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6921 {
6922 a->ncci_state[ncci] = INC_ACT_PENDING;
6923 if (plci->B3_prot == 4)
6924 sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
6925 else
6926 sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
6927 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6928 }
6929 break;
6930
6931 case EDATA_T30_TRAIN_OK:
6932 if ((a->ncci_state[ncci] == INC_ACT_PENDING)
6933 && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6934 && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6935 {
6936 if (plci->B3_prot == 4)
6937 sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
6938 else
6939 sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
6940 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6941 }
6942 break;
6943
6944 case EDATA_T30_EOP_CAPI:
6945 if (a->ncci_state[ncci] == CONNECTED)
6946 {
6947 sendf(plci->appl, _DISCONNECT_B3_I, Id, 0, "wS", GOOD, plci->ncpi_buffer);
6948 a->ncci_state[ncci] = INC_DIS_PENDING;
6949 plci->ncpi_state = 0;
6950 fax_send_edata_ack = false;
6951 }
6952 break;
6953 }
6954 }
6955 else
6956 {
6957 switch (((T30_INFO *)plci->NL.RBuffer->P)->code)
6958 {
6959 case EDATA_T30_TRAIN_OK:
6960 if ((a->ncci_state[ncci] == INC_ACT_PENDING)
6961 && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
6962 && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
6963 {
6964 if (plci->B3_prot == 4)
6965 sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
6966 else
6967 sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
6968 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
6969 }
6970 break;
6971 }
6972 }
6973 if (fax_send_edata_ack)
6974 {
6975 ((T30_INFO *)(plci->fax_connect_info_buffer))->code = ((T30_INFO *)plci->NL.RBuffer->P)->code;
6976 plci->fax_edata_ack_length = 1;
6977 start_internal_command(Id, plci, fax_edata_ack_command);
6978 }
6979 }
6980 else
6981 {
6982 dbug(1, dprintf("EDATA ncci=0x%x state=%d", ncci, a->ncci_state[ncci]));
6983 }
6984 break;
6985 case N_CONNECT:
6986 if (!a->ch_ncci[ch])
6987 {
6988 ncci = get_ncci(plci, ch, 0);
6989 Id = (Id & 0xffff) | (((dword) ncci) << 16);
6990 }
6991 dbug(1, dprintf("N_CONNECT: ch=%d state=%d plci=%lx plci_Id=%lx plci_State=%d",
6992 ch, a->ncci_state[ncci], a->ncci_plci[ncci], plci->Id, plci->State));
6993
6994 msg = _CONNECT_B3_I;
6995 if (a->ncci_state[ncci] == IDLE)
6996 plci->channels++;
6997 else if (plci->B3_prot == 1)
6998 msg = _CONNECT_B3_T90_ACTIVE_I;
6999
7000 a->ncci_state[ncci] = INC_CON_PENDING;
7001 if (plci->B3_prot == 4)
7002 sendf(plci->appl, msg, Id, 0, "s", "");
7003 else
7004 sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer);
7005 break;
7006 case N_CONNECT_ACK:
7007 dbug(1, dprintf("N_connect_Ack"));
7008 if (plci->internal_command_queue[0]
7009 && ((plci->adjust_b_state == ADJUST_B_CONNECT_2)
7010 || (plci->adjust_b_state == ADJUST_B_CONNECT_3)
7011 || (plci->adjust_b_state == ADJUST_B_CONNECT_4)))
7012 {
7013 (*(plci->internal_command_queue[0]))(Id, plci, 0);
7014 if (!plci->internal_command)
7015 next_internal_command(Id, plci);
7016 break;
7017 }
7018 msg = _CONNECT_B3_ACTIVE_I;
7019 if (plci->B3_prot == 1)
7020 {
7021 if (a->ncci_state[ncci] != OUTG_CON_PENDING)
7022 msg = _CONNECT_B3_T90_ACTIVE_I;
7023 a->ncci_state[ncci] = INC_ACT_PENDING;
7024 sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer);
7025 }
7026 else if ((plci->B3_prot == 4) || (plci->B3_prot == 5) || (plci->B3_prot == 7))
7027 {
7028 if ((a->ncci_state[ncci] == OUTG_CON_PENDING)
7029 && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
7030 && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
7031 {
7032 a->ncci_state[ncci] = INC_ACT_PENDING;
7033 if (plci->B3_prot == 4)
7034 sendf(plci->appl, msg, Id, 0, "s", "");
7035 else
7036 sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer);
7037 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
7038 }
7039 }
7040 else
7041 {
7042 a->ncci_state[ncci] = INC_ACT_PENDING;
7043 sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer);
7044 }
7045 if (plci->adjust_b_restore)
7046 {
7047 plci->adjust_b_restore = false;
7048 start_internal_command(Id, plci, adjust_b_restore);
7049 }
7050 break;
7051 case N_DISC:
7052 case N_DISC_ACK:
7053 if (plci->internal_command_queue[0]
7054 && ((plci->internal_command == FAX_DISCONNECT_COMMAND_1)
7055 || (plci->internal_command == FAX_DISCONNECT_COMMAND_2)
7056 || (plci->internal_command == FAX_DISCONNECT_COMMAND_3)))
7057 {
7058 (*(plci->internal_command_queue[0]))(Id, plci, 0);
7059 if (!plci->internal_command)
7060 next_internal_command(Id, plci);
7061 }
7062 ncci_state = a->ncci_state[ncci];
7063 ncci_remove(plci, ncci, false);
7064
7065 /* with N_DISC or N_DISC_ACK the IDI frees the respective */
7066 /* channel, so we cannot store the state in ncci_state! The */
7067 /* information which channel we received a N_DISC is thus */
7068 /* stored in the inc_dis_ncci_table buffer. */
7069 for (i = 0; plci->inc_dis_ncci_table[i]; i++);
7070 plci->inc_dis_ncci_table[i] = (byte) ncci;
7071
7072 /* need a connect_b3_ind before a disconnect_b3_ind with FAX */
7073 if (!plci->channels
7074 && (plci->B1_resource == 16)
7075 && (plci->State <= CONNECTED))
7076 {
7077 len = 9;
7078 i = ((T30_INFO *)plci->fax_connect_info_buffer)->rate_div_2400 * 2400;
7079 PUT_WORD(&plci->ncpi_buffer[1], i);
7080 PUT_WORD(&plci->ncpi_buffer[3], 0);
7081 i = ((T30_INFO *)plci->fax_connect_info_buffer)->data_format;
7082 PUT_WORD(&plci->ncpi_buffer[5], i);
7083 PUT_WORD(&plci->ncpi_buffer[7], 0);
7084 plci->ncpi_buffer[len] = 0;
7085 plci->ncpi_buffer[0] = len;
7086 if (plci->B3_prot == 4)
7087 sendf(plci->appl, _CONNECT_B3_I, Id, 0, "s", "");
7088 else
7089 {
7090
7091 if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id - 1])
7092 & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
7093 {
7094 plci->ncpi_buffer[++len] = 0;
7095 plci->ncpi_buffer[++len] = 0;
7096 plci->ncpi_buffer[++len] = 0;
7097 plci->ncpi_buffer[0] = len;
7098 }
7099
7100 sendf(plci->appl, _CONNECT_B3_I, Id, 0, "S", plci->ncpi_buffer);
7101 }
7102 sendf(plci->appl, _DISCONNECT_B3_I, Id, 0, "wS", info, plci->ncpi_buffer);
7103 plci->ncpi_state = 0;
7104 sig_req(plci, HANGUP, 0);
7105 send_req(plci);
7106 plci->State = OUTG_DIS_PENDING;
7107 /* disc here */
7108 }
7109 else if ((a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
7110 && ((plci->B3_prot == 4) || (plci->B3_prot == 5))
7111 && ((ncci_state == INC_DIS_PENDING) || (ncci_state == IDLE)))
7112 {
7113 if (ncci_state == IDLE)
7114 {
7115 if (plci->channels)
7116 plci->channels--;
7117 if ((plci->State == IDLE || plci->State == SUSPENDING) && !plci->channels) {
7118 if (plci->State == SUSPENDING) {
7119 sendf(plci->appl,
7120 _FACILITY_I,
7121 Id & 0xffffL,
7122 0,
7123 "ws", (word)3, "\x03\x04\x00\x00");
7124 sendf(plci->appl, _DISCONNECT_I, Id & 0xffffL, 0, "w", 0);
7125 }
7126 plci_remove(plci);
7127 plci->State = IDLE;
7128 }
7129 }
7130 }
7131 else if (plci->channels)
7132 {
7133 sendf(plci->appl, _DISCONNECT_B3_I, Id, 0, "wS", info, plci->ncpi_buffer);
7134 plci->ncpi_state = 0;
7135 if ((ncci_state == OUTG_REJ_PENDING)
7136 && ((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE)))
7137 {
7138 sig_req(plci, HANGUP, 0);
7139 send_req(plci);
7140 plci->State = OUTG_DIS_PENDING;
7141 }
7142 }
7143 break;
7144 case N_RESET:
7145 a->ncci_state[ncci] = INC_RES_PENDING;
7146 sendf(plci->appl, _RESET_B3_I, Id, 0, "S", plci->ncpi_buffer);
7147 break;
7148 case N_RESET_ACK:
7149 a->ncci_state[ncci] = CONNECTED;
7150 sendf(plci->appl, _RESET_B3_I, Id, 0, "S", plci->ncpi_buffer);
7151 break;
7152
7153 case N_UDATA:
7154 if (!(udata_forwarding_table[plci->NL.RBuffer->P[0] >> 5] & (1L << (plci->NL.RBuffer->P[0] & 0x1f))))
7155 {
7156 plci->RData[0].P = plci->internal_ind_buffer + (-((int)(long)(plci->internal_ind_buffer)) & 3);
7157 plci->RData[0].PLength = INTERNAL_IND_BUFFER_SIZE;
7158 plci->NL.R = plci->RData;
7159 plci->NL.RNum = 1;
7160 return;
7161 }
7162 case N_BDATA:
7163 case N_DATA:
7164 if (((a->ncci_state[ncci] != CONNECTED) && (plci->B2_prot == 1)) /* transparent */
7165 || (a->ncci_state[ncci] == IDLE)
7166 || (a->ncci_state[ncci] == INC_DIS_PENDING))
7167 {
7168 plci->NL.RNR = 2;
7169 break;
7170 }
7171 if ((a->ncci_state[ncci] != CONNECTED)
7172 && (a->ncci_state[ncci] != OUTG_DIS_PENDING)
7173 && (a->ncci_state[ncci] != OUTG_REJ_PENDING))
7174 {
7175 dbug(1, dprintf("flow control"));
7176 plci->NL.RNR = 1; /* flow control */
7177 channel_x_off(plci, ch, 0);
7178 break;
7179 }
7180
7181 NCCIcode = ncci | (((word)a->Id) << 8);
7182
7183 /* count all buffers within the Application pool */
7184 /* belonging to the same NCCI. If this is below the */
7185 /* number of buffers available per NCCI we accept */
7186 /* this packet, otherwise we reject it */
7187 count = 0;
7188 Num = 0xffff;
7189 for (i = 0; i < APPLptr->MaxBuffer; i++) {
7190 if (NCCIcode == APPLptr->DataNCCI[i]) count++;
7191 if (!APPLptr->DataNCCI[i] && Num == 0xffff) Num = i;
7192 }
7193
7194 if (count >= APPLptr->MaxNCCIData || Num == 0xffff)
7195 {
7196 dbug(3, dprintf("Flow-Control"));
7197 plci->NL.RNR = 1;
7198 if (++(APPLptr->NCCIDataFlowCtrlTimer) >=
7199 (word)((a->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL) ? 40 : 2000))
7200 {
7201 plci->NL.RNR = 2;
7202 dbug(3, dprintf("DiscardData"));
7203 } else {
7204 channel_x_off(plci, ch, 0);
7205 }
7206 break;
7207 }
7208 else
7209 {
7210 APPLptr->NCCIDataFlowCtrlTimer = 0;
7211 }
7212
7213 plci->RData[0].P = ReceiveBufferGet(APPLptr, Num);
7214 if (!plci->RData[0].P) {
7215 plci->NL.RNR = 1;
7216 channel_x_off(plci, ch, 0);
7217 break;
7218 }
7219
7220 APPLptr->DataNCCI[Num] = NCCIcode;
7221 APPLptr->DataFlags[Num] = (plci->Id << 8) | (plci->NL.Ind >> 4);
7222 dbug(3, dprintf("Buffer(%d), Max = %d", Num, APPLptr->MaxBuffer));
7223
7224 plci->RNum = Num;
7225 plci->RFlags = plci->NL.Ind >> 4;
7226 plci->RData[0].PLength = APPLptr->MaxDataLength;
7227 plci->NL.R = plci->RData;
7228 if ((plci->NL.RLength != 0)
7229 && ((plci->B2_prot == B2_V120_ASYNC)
7230 || (plci->B2_prot == B2_V120_ASYNC_V42BIS)
7231 || (plci->B2_prot == B2_V120_BIT_TRANSPARENT)))
7232 {
7233 plci->RData[1].P = plci->RData[0].P;
7234 plci->RData[1].PLength = plci->RData[0].PLength;
7235 plci->RData[0].P = v120_header_buffer + (-((unsigned long)v120_header_buffer) & 3);
7236 if ((plci->NL.RBuffer->P[0] & V120_HEADER_EXTEND_BIT) || (plci->NL.RLength == 1))
7237 plci->RData[0].PLength = 1;
7238 else
7239 plci->RData[0].PLength = 2;
7240 if (plci->NL.RBuffer->P[0] & V120_HEADER_BREAK_BIT)
7241 plci->RFlags |= 0x0010;
7242 if (plci->NL.RBuffer->P[0] & (V120_HEADER_C1_BIT | V120_HEADER_C2_BIT))
7243 plci->RFlags |= 0x8000;
7244 plci->NL.RNum = 2;
7245 }
7246 else
7247 {
7248 if ((plci->NL.Ind & 0x0f) == N_UDATA)
7249 plci->RFlags |= 0x0010;
7250
7251 else if ((plci->B3_prot == B3_RTP) && ((plci->NL.Ind & 0x0f) == N_BDATA))
7252 plci->RFlags |= 0x0001;
7253
7254 plci->NL.RNum = 1;
7255 }
7256 break;
7257 case N_DATA_ACK:
7258 data_ack(plci, ch);
7259 break;
7260 default:
7261 plci->NL.RNR = 2;
7262 break;
7263 }
7264 }
7265
7266 /*------------------------------------------------------------------*/
7267 /* find a free PLCI */
7268 /*------------------------------------------------------------------*/
7269
7270 static word get_plci(DIVA_CAPI_ADAPTER *a)
7271 {
7272 word i, j;
7273 PLCI *plci;
7274
7275 dump_plcis(a);
7276 for (i = 0; i < a->max_plci && a->plci[i].Id; i++);
7277 if (i == a->max_plci) {
7278 dbug(1, dprintf("get_plci: out of PLCIs"));
7279 return 0;
7280 }
7281 plci = &a->plci[i];
7282 plci->Id = (byte)(i + 1);
7283
7284 plci->Sig.Id = 0;
7285 plci->NL.Id = 0;
7286 plci->sig_req = 0;
7287 plci->nl_req = 0;
7288
7289 plci->appl = NULL;
7290 plci->relatedPTYPLCI = NULL;
7291 plci->State = IDLE;
7292 plci->SuppState = IDLE;
7293 plci->channels = 0;
7294 plci->tel = 0;
7295 plci->B1_resource = 0;
7296 plci->B2_prot = 0;
7297 plci->B3_prot = 0;
7298
7299 plci->command = 0;
7300 plci->m_command = 0;
7301 init_internal_command_queue(plci);
7302 plci->number = 0;
7303 plci->req_in_start = 0;
7304 plci->req_in = 0;
7305 plci->req_out = 0;
7306 plci->msg_in_write_pos = MSG_IN_QUEUE_SIZE;
7307 plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
7308 plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
7309
7310 plci->data_sent = false;
7311 plci->send_disc = 0;
7312 plci->sig_global_req = 0;
7313 plci->sig_remove_id = 0;
7314 plci->nl_global_req = 0;
7315 plci->nl_remove_id = 0;
7316 plci->adv_nl = 0;
7317 plci->manufacturer = false;
7318 plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
7319 plci->spoofed_msg = 0;
7320 plci->ptyState = 0;
7321 plci->cr_enquiry = false;
7322 plci->hangup_flow_ctrl_timer = 0;
7323
7324 plci->ncci_ring_list = 0;
7325 for (j = 0; j < MAX_CHANNELS_PER_PLCI; j++) plci->inc_dis_ncci_table[j] = 0;
7326 clear_c_ind_mask(plci);
7327 set_group_ind_mask(plci);
7328 plci->fax_connect_info_length = 0;
7329 plci->nsf_control_bits = 0;
7330 plci->ncpi_state = 0x00;
7331 plci->ncpi_buffer[0] = 0;
7332
7333 plci->requested_options_conn = 0;
7334 plci->requested_options = 0;
7335 plci->notifiedcall = 0;
7336 plci->vswitchstate = 0;
7337 plci->vsprot = 0;
7338 plci->vsprotdialect = 0;
7339 init_b1_config(plci);
7340 dbug(1, dprintf("get_plci(%x)", plci->Id));
7341 return i + 1;
7342 }
7343
7344 /*------------------------------------------------------------------*/
7345 /* put a parameter in the parameter buffer */
7346 /*------------------------------------------------------------------*/
7347
7348 static void add_p(PLCI *plci, byte code, byte *p)
7349 {
7350 word p_length;
7351
7352 p_length = 0;
7353 if (p) p_length = p[0];
7354 add_ie(plci, code, p, p_length);
7355 }
7356
7357 /*------------------------------------------------------------------*/
7358 /* put a structure in the parameter buffer */
7359 /*------------------------------------------------------------------*/
7360 static void add_s(PLCI *plci, byte code, API_PARSE *p)
7361 {
7362 if (p) add_ie(plci, code, p->info, (word)p->length);
7363 }
7364
7365 /*------------------------------------------------------------------*/
7366 /* put multiple structures in the parameter buffer */
7367 /*------------------------------------------------------------------*/
7368 static void add_ss(PLCI *plci, byte code, API_PARSE *p)
7369 {
7370 byte i;
7371
7372 if (p) {
7373 dbug(1, dprintf("add_ss(%x,len=%d)", code, p->length));
7374 for (i = 2; i < (byte)p->length; i += p->info[i] + 2) {
7375 dbug(1, dprintf("add_ss_ie(%x,len=%d)", p->info[i - 1], p->info[i]));
7376 add_ie(plci, p->info[i - 1], (byte *)&(p->info[i]), (word)p->info[i]);
7377 }
7378 }
7379 }
7380
7381 /*------------------------------------------------------------------*/
7382 /* return the channel number sent by the application in a esc_chi */
7383 /*------------------------------------------------------------------*/
7384 static byte getChannel(API_PARSE *p)
7385 {
7386 byte i;
7387
7388 if (p) {
7389 for (i = 2; i < (byte)p->length; i += p->info[i] + 2) {
7390 if (p->info[i] == 2) {
7391 if (p->info[i - 1] == ESC && p->info[i + 1] == CHI) return (p->info[i + 2]);
7392 }
7393 }
7394 }
7395 return 0;
7396 }
7397
7398
7399 /*------------------------------------------------------------------*/
7400 /* put an information element in the parameter buffer */
7401 /*------------------------------------------------------------------*/
7402
7403 static void add_ie(PLCI *plci, byte code, byte *p, word p_length)
7404 {
7405 word i;
7406
7407 if (!(code & 0x80) && !p_length) return;
7408
7409 if (plci->req_in == plci->req_in_start) {
7410 plci->req_in += 2;
7411 }
7412 else {
7413 plci->req_in--;
7414 }
7415 plci->RBuffer[plci->req_in++] = code;
7416
7417 if (p) {
7418 plci->RBuffer[plci->req_in++] = (byte)p_length;
7419 for (i = 0; i < p_length; i++) plci->RBuffer[plci->req_in++] = p[1 + i];
7420 }
7421
7422 plci->RBuffer[plci->req_in++] = 0;
7423 }
7424
7425 /*------------------------------------------------------------------*/
7426 /* put a unstructured data into the buffer */
7427 /*------------------------------------------------------------------*/
7428
7429 static void add_d(PLCI *plci, word length, byte *p)
7430 {
7431 word i;
7432
7433 if (plci->req_in == plci->req_in_start) {
7434 plci->req_in += 2;
7435 }
7436 else {
7437 plci->req_in--;
7438 }
7439 for (i = 0; i < length; i++) plci->RBuffer[plci->req_in++] = p[i];
7440 }
7441
7442 /*------------------------------------------------------------------*/
7443 /* put parameters from the Additional Info parameter in the */
7444 /* parameter buffer */
7445 /*------------------------------------------------------------------*/
7446
7447 static void add_ai(PLCI *plci, API_PARSE *ai)
7448 {
7449 word i;
7450 API_PARSE ai_parms[5];
7451
7452 for (i = 0; i < 5; i++) ai_parms[i].length = 0;
7453
7454 if (!ai->length)
7455 return;
7456 if (api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms))
7457 return;
7458
7459 add_s(plci, KEY, &ai_parms[1]);
7460 add_s(plci, UUI, &ai_parms[2]);
7461 add_ss(plci, FTY, &ai_parms[3]);
7462 }
7463
7464 /*------------------------------------------------------------------*/
7465 /* put parameter for b1 protocol in the parameter buffer */
7466 /*------------------------------------------------------------------*/
7467
7468 static word add_b1(PLCI *plci, API_PARSE *bp, word b_channel_info,
7469 word b1_facilities)
7470 {
7471 API_PARSE bp_parms[8];
7472 API_PARSE mdm_cfg[9];
7473 API_PARSE global_config[2];
7474 byte cai[256];
7475 byte resource[] = {5, 9, 13, 12, 16, 39, 9, 17, 17, 18};
7476 byte voice_cai[] = "\x06\x14\x00\x00\x00\x00\x08";
7477 word i;
7478
7479 API_PARSE mdm_cfg_v18[4];
7480 word j, n, w;
7481 dword d;
7482
7483
7484 for (i = 0; i < 8; i++) bp_parms[i].length = 0;
7485 for (i = 0; i < 2; i++) global_config[i].length = 0;
7486
7487 dbug(1, dprintf("add_b1"));
7488 api_save_msg(bp, "s", &plci->B_protocol);
7489
7490 if (b_channel_info == 2) {
7491 plci->B1_resource = 0;
7492 adjust_b1_facilities(plci, plci->B1_resource, b1_facilities);
7493 add_p(plci, CAI, "\x01\x00");
7494 dbug(1, dprintf("Cai=1,0 (no resource)"));
7495 return 0;
7496 }
7497
7498 if (plci->tel == CODEC_PERMANENT) return 0;
7499 else if (plci->tel == CODEC) {
7500 plci->B1_resource = 1;
7501 adjust_b1_facilities(plci, plci->B1_resource, b1_facilities);
7502 add_p(plci, CAI, "\x01\x01");
7503 dbug(1, dprintf("Cai=1,1 (Codec)"));
7504 return 0;
7505 }
7506 else if (plci->tel == ADV_VOICE) {
7507 plci->B1_resource = add_b1_facilities(plci, 9, (word)(b1_facilities | B1_FACILITY_VOICE));
7508 adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities | B1_FACILITY_VOICE));
7509 voice_cai[1] = plci->B1_resource;
7510 PUT_WORD(&voice_cai[5], plci->appl->MaxDataLength);
7511 add_p(plci, CAI, voice_cai);
7512 dbug(1, dprintf("Cai=1,0x%x (AdvVoice)", voice_cai[1]));
7513 return 0;
7514 }
7515 plci->call_dir &= ~(CALL_DIR_ORIGINATE | CALL_DIR_ANSWER);
7516 if (plci->call_dir & CALL_DIR_OUT)
7517 plci->call_dir |= CALL_DIR_ORIGINATE;
7518 else if (plci->call_dir & CALL_DIR_IN)
7519 plci->call_dir |= CALL_DIR_ANSWER;
7520
7521 if (!bp->length) {
7522 plci->B1_resource = 0x5;
7523 adjust_b1_facilities(plci, plci->B1_resource, b1_facilities);
7524 add_p(plci, CAI, "\x01\x05");
7525 return 0;
7526 }
7527
7528 dbug(1, dprintf("b_prot_len=%d", (word)bp->length));
7529 if (bp->length > 256) return _WRONG_MESSAGE_FORMAT;
7530 if (api_parse(&bp->info[1], (word)bp->length, "wwwsssb", bp_parms))
7531 {
7532 bp_parms[6].length = 0;
7533 if (api_parse(&bp->info[1], (word)bp->length, "wwwsss", bp_parms))
7534 {
7535 dbug(1, dprintf("b-form.!"));
7536 return _WRONG_MESSAGE_FORMAT;
7537 }
7538 }
7539 else if (api_parse(&bp->info[1], (word)bp->length, "wwwssss", bp_parms))
7540 {
7541 dbug(1, dprintf("b-form.!"));
7542 return _WRONG_MESSAGE_FORMAT;
7543 }
7544
7545 if (bp_parms[6].length)
7546 {
7547 if (api_parse(&bp_parms[6].info[1], (word)bp_parms[6].length, "w", global_config))
7548 {
7549 return _WRONG_MESSAGE_FORMAT;
7550 }
7551 switch (GET_WORD(global_config[0].info))
7552 {
7553 case 1:
7554 plci->call_dir = (plci->call_dir & ~CALL_DIR_ANSWER) | CALL_DIR_ORIGINATE;
7555 break;
7556 case 2:
7557 plci->call_dir = (plci->call_dir & ~CALL_DIR_ORIGINATE) | CALL_DIR_ANSWER;
7558 break;
7559 }
7560 }
7561 dbug(1, dprintf("call_dir=%04x", plci->call_dir));
7562
7563
7564 if ((GET_WORD(bp_parms[0].info) == B1_RTP)
7565 && (plci->adapter->man_profile.private_options & (1L << PRIVATE_RTP)))
7566 {
7567 plci->B1_resource = add_b1_facilities(plci, 31, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7568 adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7569 cai[1] = plci->B1_resource;
7570 cai[2] = 0;
7571 cai[3] = 0;
7572 cai[4] = 0;
7573 PUT_WORD(&cai[5], plci->appl->MaxDataLength);
7574 for (i = 0; i < bp_parms[3].length; i++)
7575 cai[7 + i] = bp_parms[3].info[1 + i];
7576 cai[0] = 6 + bp_parms[3].length;
7577 add_p(plci, CAI, cai);
7578 return 0;
7579 }
7580
7581
7582 if ((GET_WORD(bp_parms[0].info) == B1_PIAFS)
7583 && (plci->adapter->man_profile.private_options & (1L << PRIVATE_PIAFS)))
7584 {
7585 plci->B1_resource = add_b1_facilities(plci, 35/* PIAFS HARDWARE FACILITY */, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7586 adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7587 cai[1] = plci->B1_resource;
7588 cai[2] = 0;
7589 cai[3] = 0;
7590 cai[4] = 0;
7591 PUT_WORD(&cai[5], plci->appl->MaxDataLength);
7592 cai[0] = 6;
7593 add_p(plci, CAI, cai);
7594 return 0;
7595 }
7596
7597
7598 if ((GET_WORD(bp_parms[0].info) >= 32)
7599 || (!((1L << GET_WORD(bp_parms[0].info)) & plci->adapter->profile.B1_Protocols)
7600 && ((GET_WORD(bp_parms[0].info) != 3)
7601 || !((1L << B1_HDLC) & plci->adapter->profile.B1_Protocols)
7602 || ((bp_parms[3].length != 0) && (GET_WORD(&bp_parms[3].info[1]) != 0) && (GET_WORD(&bp_parms[3].info[1]) != 56000)))))
7603 {
7604 return _B1_NOT_SUPPORTED;
7605 }
7606 plci->B1_resource = add_b1_facilities(plci, resource[GET_WORD(bp_parms[0].info)],
7607 (word)(b1_facilities & ~B1_FACILITY_VOICE));
7608 adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE));
7609 cai[0] = 6;
7610 cai[1] = plci->B1_resource;
7611 for (i = 2; i < sizeof(cai); i++) cai[i] = 0;
7612
7613 if ((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE)
7614 || (GET_WORD(bp_parms[0].info) == B1_MODEM_ASYNC)
7615 || (GET_WORD(bp_parms[0].info) == B1_MODEM_SYNC_HDLC))
7616 { /* B1 - modem */
7617 for (i = 0; i < 7; i++) mdm_cfg[i].length = 0;
7618
7619 if (bp_parms[3].length)
7620 {
7621 if (api_parse(&bp_parms[3].info[1], (word)bp_parms[3].length, "wwwwww", mdm_cfg))
7622 {
7623 return (_WRONG_MESSAGE_FORMAT);
7624 }
7625
7626 cai[2] = 0; /* Bit rate for adaptation */
7627
7628 dbug(1, dprintf("MDM Max Bit Rate:<%d>", GET_WORD(mdm_cfg[0].info)));
7629
7630 PUT_WORD(&cai[13], 0); /* Min Tx speed */
7631 PUT_WORD(&cai[15], GET_WORD(mdm_cfg[0].info)); /* Max Tx speed */
7632 PUT_WORD(&cai[17], 0); /* Min Rx speed */
7633 PUT_WORD(&cai[19], GET_WORD(mdm_cfg[0].info)); /* Max Rx speed */
7634
7635 cai[3] = 0; /* Async framing parameters */
7636 switch (GET_WORD(mdm_cfg[2].info))
7637 { /* Parity */
7638 case 1: /* odd parity */
7639 cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_ODD);
7640 dbug(1, dprintf("MDM: odd parity"));
7641 break;
7642
7643 case 2: /* even parity */
7644 cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_EVEN);
7645 dbug(1, dprintf("MDM: even parity"));
7646 break;
7647
7648 default:
7649 dbug(1, dprintf("MDM: no parity"));
7650 break;
7651 }
7652
7653 switch (GET_WORD(mdm_cfg[3].info))
7654 { /* stop bits */
7655 case 1: /* 2 stop bits */
7656 cai[3] |= DSP_CAI_ASYNC_TWO_STOP_BITS;
7657 dbug(1, dprintf("MDM: 2 stop bits"));
7658 break;
7659
7660 default:
7661 dbug(1, dprintf("MDM: 1 stop bit"));
7662 break;
7663 }
7664
7665 switch (GET_WORD(mdm_cfg[1].info))
7666 { /* char length */
7667 case 5:
7668 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_5;
7669 dbug(1, dprintf("MDM: 5 bits"));
7670 break;
7671
7672 case 6:
7673 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_6;
7674 dbug(1, dprintf("MDM: 6 bits"));
7675 break;
7676
7677 case 7:
7678 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_7;
7679 dbug(1, dprintf("MDM: 7 bits"));
7680 break;
7681
7682 default:
7683 dbug(1, dprintf("MDM: 8 bits"));
7684 break;
7685 }
7686
7687 cai[7] = 0; /* Line taking options */
7688 cai[8] = 0; /* Modulation negotiation options */
7689 cai[9] = 0; /* Modulation options */
7690
7691 if (((plci->call_dir & CALL_DIR_ORIGINATE) != 0) ^ ((plci->call_dir & CALL_DIR_OUT) != 0))
7692 {
7693 cai[9] |= DSP_CAI_MODEM_REVERSE_DIRECTION;
7694 dbug(1, dprintf("MDM: Reverse direction"));
7695 }
7696
7697 if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_DISABLE_RETRAIN)
7698 {
7699 cai[9] |= DSP_CAI_MODEM_DISABLE_RETRAIN;
7700 dbug(1, dprintf("MDM: Disable retrain"));
7701 }
7702
7703 if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_DISABLE_RING_TONE)
7704 {
7705 cai[7] |= DSP_CAI_MODEM_DISABLE_CALLING_TONE | DSP_CAI_MODEM_DISABLE_ANSWER_TONE;
7706 dbug(1, dprintf("MDM: Disable ring tone"));
7707 }
7708
7709 if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_GUARD_1800)
7710 {
7711 cai[8] |= DSP_CAI_MODEM_GUARD_TONE_1800HZ;
7712 dbug(1, dprintf("MDM: 1800 guard tone"));
7713 }
7714 else if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_GUARD_550)
7715 {
7716 cai[8] |= DSP_CAI_MODEM_GUARD_TONE_550HZ;
7717 dbug(1, dprintf("MDM: 550 guard tone"));
7718 }
7719
7720 if ((GET_WORD(mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_V100)
7721 {
7722 cai[8] |= DSP_CAI_MODEM_NEGOTIATE_V100;
7723 dbug(1, dprintf("MDM: V100"));
7724 }
7725 else if ((GET_WORD(mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_MOD_CLASS)
7726 {
7727 cai[8] |= DSP_CAI_MODEM_NEGOTIATE_IN_CLASS;
7728 dbug(1, dprintf("MDM: IN CLASS"));
7729 }
7730 else if ((GET_WORD(mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_DISABLED)
7731 {
7732 cai[8] |= DSP_CAI_MODEM_NEGOTIATE_DISABLED;
7733 dbug(1, dprintf("MDM: DISABLED"));
7734 }
7735 cai[0] = 20;
7736
7737 if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_V18))
7738 && (GET_WORD(mdm_cfg[5].info) & 0x8000)) /* Private V.18 enable */
7739 {
7740 plci->requested_options |= 1L << PRIVATE_V18;
7741 }
7742 if (GET_WORD(mdm_cfg[5].info) & 0x4000) /* Private VOWN enable */
7743 plci->requested_options |= 1L << PRIVATE_VOWN;
7744
7745 if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
7746 & ((1L << PRIVATE_V18) | (1L << PRIVATE_VOWN)))
7747 {
7748 if (!api_parse(&bp_parms[3].info[1], (word)bp_parms[3].length, "wwwwwws", mdm_cfg))
7749 {
7750 i = 27;
7751 if (mdm_cfg[6].length >= 4)
7752 {
7753 d = GET_DWORD(&mdm_cfg[6].info[1]);
7754 cai[7] |= (byte) d; /* line taking options */
7755 cai[9] |= (byte)(d >> 8); /* modulation options */
7756 cai[++i] = (byte)(d >> 16); /* vown modulation options */
7757 cai[++i] = (byte)(d >> 24);
7758 if (mdm_cfg[6].length >= 8)
7759 {
7760 d = GET_DWORD(&mdm_cfg[6].info[5]);
7761 cai[10] |= (byte) d; /* disabled modulations mask */
7762 cai[11] |= (byte)(d >> 8);
7763 if (mdm_cfg[6].length >= 12)
7764 {
7765 d = GET_DWORD(&mdm_cfg[6].info[9]);
7766 cai[12] = (byte) d; /* enabled modulations mask */
7767 cai[++i] = (byte)(d >> 8); /* vown enabled modulations */
7768 cai[++i] = (byte)(d >> 16);
7769 cai[++i] = (byte)(d >> 24);
7770 cai[++i] = 0;
7771 if (mdm_cfg[6].length >= 14)
7772 {
7773 w = GET_WORD(&mdm_cfg[6].info[13]);
7774 if (w != 0)
7775 PUT_WORD(&cai[13], w); /* min tx speed */
7776 if (mdm_cfg[6].length >= 16)
7777 {
7778 w = GET_WORD(&mdm_cfg[6].info[15]);
7779 if (w != 0)
7780 PUT_WORD(&cai[15], w); /* max tx speed */
7781 if (mdm_cfg[6].length >= 18)
7782 {
7783 w = GET_WORD(&mdm_cfg[6].info[17]);
7784 if (w != 0)
7785 PUT_WORD(&cai[17], w); /* min rx speed */
7786 if (mdm_cfg[6].length >= 20)
7787 {
7788 w = GET_WORD(&mdm_cfg[6].info[19]);
7789 if (w != 0)
7790 PUT_WORD(&cai[19], w); /* max rx speed */
7791 if (mdm_cfg[6].length >= 22)
7792 {
7793 w = GET_WORD(&mdm_cfg[6].info[21]);
7794 cai[23] = (byte)(-((short) w)); /* transmit level */
7795 if (mdm_cfg[6].length >= 24)
7796 {
7797 w = GET_WORD(&mdm_cfg[6].info[23]);
7798 cai[22] |= (byte) w; /* info options mask */
7799 cai[21] |= (byte)(w >> 8); /* disabled symbol rates */
7800 }
7801 }
7802 }
7803 }
7804 }
7805 }
7806 }
7807 }
7808 }
7809 cai[27] = i - 27;
7810 i++;
7811 if (!api_parse(&bp_parms[3].info[1], (word)bp_parms[3].length, "wwwwwwss", mdm_cfg))
7812 {
7813 if (!api_parse(&mdm_cfg[7].info[1], (word)mdm_cfg[7].length, "sss", mdm_cfg_v18))
7814 {
7815 for (n = 0; n < 3; n++)
7816 {
7817 cai[i] = (byte)(mdm_cfg_v18[n].length);
7818 for (j = 1; j < ((word)(cai[i] + 1)); j++)
7819 cai[i + j] = mdm_cfg_v18[n].info[j];
7820 i += cai[i] + 1;
7821 }
7822 }
7823 }
7824 cai[0] = (byte)(i - 1);
7825 }
7826 }
7827
7828 }
7829 }
7830 if (GET_WORD(bp_parms[0].info) == 2 || /* V.110 async */
7831 GET_WORD(bp_parms[0].info) == 3) /* V.110 sync */
7832 {
7833 if (bp_parms[3].length) {
7834 dbug(1, dprintf("V.110,%d", GET_WORD(&bp_parms[3].info[1])));
7835 switch (GET_WORD(&bp_parms[3].info[1])) { /* Rate */
7836 case 0:
7837 case 56000:
7838 if (GET_WORD(bp_parms[0].info) == 3) { /* V.110 sync 56k */
7839 dbug(1, dprintf("56k sync HSCX"));
7840 cai[1] = 8;
7841 cai[2] = 0;
7842 cai[3] = 0;
7843 }
7844 else if (GET_WORD(bp_parms[0].info) == 2) {
7845 dbug(1, dprintf("56k async DSP"));
7846 cai[2] = 9;
7847 }
7848 break;
7849 case 50: cai[2] = 1; break;
7850 case 75: cai[2] = 1; break;
7851 case 110: cai[2] = 1; break;
7852 case 150: cai[2] = 1; break;
7853 case 200: cai[2] = 1; break;
7854 case 300: cai[2] = 1; break;
7855 case 600: cai[2] = 1; break;
7856 case 1200: cai[2] = 2; break;
7857 case 2400: cai[2] = 3; break;
7858 case 4800: cai[2] = 4; break;
7859 case 7200: cai[2] = 10; break;
7860 case 9600: cai[2] = 5; break;
7861 case 12000: cai[2] = 13; break;
7862 case 24000: cai[2] = 0; break;
7863 case 14400: cai[2] = 11; break;
7864 case 19200: cai[2] = 6; break;
7865 case 28800: cai[2] = 12; break;
7866 case 38400: cai[2] = 7; break;
7867 case 48000: cai[2] = 8; break;
7868 case 76: cai[2] = 15; break; /* 75/1200 */
7869 case 1201: cai[2] = 14; break; /* 1200/75 */
7870 case 56001: cai[2] = 9; break; /* V.110 56000 */
7871
7872 default:
7873 return _B1_PARM_NOT_SUPPORTED;
7874 }
7875 cai[3] = 0;
7876 if (cai[1] == 13) /* v.110 async */
7877 {
7878 if (bp_parms[3].length >= 8)
7879 {
7880 switch (GET_WORD(&bp_parms[3].info[3]))
7881 { /* char length */
7882 case 5:
7883 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_5;
7884 break;
7885 case 6:
7886 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_6;
7887 break;
7888 case 7:
7889 cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_7;
7890 break;
7891 }
7892 switch (GET_WORD(&bp_parms[3].info[5]))
7893 { /* Parity */
7894 case 1: /* odd parity */
7895 cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_ODD);
7896 break;
7897 case 2: /* even parity */
7898 cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_EVEN);
7899 break;
7900 }
7901 switch (GET_WORD(&bp_parms[3].info[7]))
7902 { /* stop bits */
7903 case 1: /* 2 stop bits */
7904 cai[3] |= DSP_CAI_ASYNC_TWO_STOP_BITS;
7905 break;
7906 }
7907 }
7908 }
7909 }
7910 else if (cai[1] == 8 || GET_WORD(bp_parms[0].info) == 3) {
7911 dbug(1, dprintf("V.110 default 56k sync"));
7912 cai[1] = 8;
7913 cai[2] = 0;
7914 cai[3] = 0;
7915 }
7916 else {
7917 dbug(1, dprintf("V.110 default 9600 async"));
7918 cai[2] = 5;
7919 }
7920 }
7921 PUT_WORD(&cai[5], plci->appl->MaxDataLength);
7922 dbug(1, dprintf("CAI[%d]=%x,%x,%x,%x,%x,%x", cai[0], cai[1], cai[2], cai[3], cai[4], cai[5], cai[6]));
7923 /* HexDump ("CAI", sizeof(cai), &cai[0]); */
7924
7925 add_p(plci, CAI, cai);
7926 return 0;
7927 }
7928
7929 /*------------------------------------------------------------------*/
7930 /* put parameter for b2 and B3 protocol in the parameter buffer */
7931 /*------------------------------------------------------------------*/
7932
7933 static word add_b23(PLCI *plci, API_PARSE *bp)
7934 {
7935 word i, fax_control_bits;
7936 byte pos, len;
7937 byte SAPI = 0x40; /* default SAPI 16 for x.31 */
7938 API_PARSE bp_parms[8];
7939 API_PARSE *b1_config;
7940 API_PARSE *b2_config;
7941 API_PARSE b2_config_parms[8];
7942 API_PARSE *b3_config;
7943 API_PARSE b3_config_parms[6];
7944 API_PARSE global_config[2];
7945
7946 static byte llc[3] = {2,0,0};
7947 static byte dlc[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
7948 static byte nlc[256];
7949 static byte lli[12] = {1,1};
7950
7951 const byte llc2_out[] = {1,2,4,6,2,0,0,0, X75_V42BIS,V120_L2,V120_V42BIS,V120_L2,6};
7952 const byte llc2_in[] = {1,3,4,6,3,0,0,0, X75_V42BIS,V120_L2,V120_V42BIS,V120_L2,6};
7953
7954 const byte llc3[] = {4,3,2,2,6,6,0};
7955 const byte header[] = {0,2,3,3,0,0,0};
7956
7957 for (i = 0; i < 8; i++) bp_parms[i].length = 0;
7958 for (i = 0; i < 6; i++) b2_config_parms[i].length = 0;
7959 for (i = 0; i < 5; i++) b3_config_parms[i].length = 0;
7960
7961 lli[0] = 1;
7962 lli[1] = 1;
7963 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL)
7964 lli[1] |= 2;
7965 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL)
7966 lli[1] |= 4;
7967
7968 if ((lli[1] & 0x02) && (diva_xdi_extended_features & DIVA_CAPI_USE_CMA)) {
7969 lli[1] |= 0x10;
7970 if (plci->rx_dma_descriptor <= 0) {
7971 plci->rx_dma_descriptor = diva_get_dma_descriptor(plci, &plci->rx_dma_magic);
7972 if (plci->rx_dma_descriptor >= 0)
7973 plci->rx_dma_descriptor++;
7974 }
7975 if (plci->rx_dma_descriptor > 0) {
7976 lli[0] = 6;
7977 lli[1] |= 0x40;
7978 lli[2] = (byte)(plci->rx_dma_descriptor - 1);
7979 lli[3] = (byte)plci->rx_dma_magic;
7980 lli[4] = (byte)(plci->rx_dma_magic >> 8);
7981 lli[5] = (byte)(plci->rx_dma_magic >> 16);
7982 lli[6] = (byte)(plci->rx_dma_magic >> 24);
7983 }
7984 }
7985
7986 if (DIVA_CAPI_SUPPORTS_NO_CANCEL(plci->adapter)) {
7987 lli[1] |= 0x20;
7988 }
7989
7990 dbug(1, dprintf("add_b23"));
7991 api_save_msg(bp, "s", &plci->B_protocol);
7992
7993 if (!bp->length && plci->tel)
7994 {
7995 plci->adv_nl = true;
7996 dbug(1, dprintf("Default adv.Nl"));
7997 add_p(plci, LLI, lli);
7998 plci->B2_prot = 1 /*XPARENT*/;
7999 plci->B3_prot = 0 /*XPARENT*/;
8000 llc[1] = 2;
8001 llc[2] = 4;
8002 add_p(plci, LLC, llc);
8003 dlc[0] = 2;
8004 PUT_WORD(&dlc[1], plci->appl->MaxDataLength);
8005 add_p(plci, DLC, dlc);
8006 return 0;
8007 }
8008
8009 if (!bp->length) /*default*/
8010 {
8011 dbug(1, dprintf("ret default"));
8012 add_p(plci, LLI, lli);
8013 plci->B2_prot = 0 /*X.75 */;
8014 plci->B3_prot = 0 /*XPARENT*/;
8015 llc[1] = 1;
8016 llc[2] = 4;
8017 add_p(plci, LLC, llc);
8018 dlc[0] = 2;
8019 PUT_WORD(&dlc[1], plci->appl->MaxDataLength);
8020 add_p(plci, DLC, dlc);
8021 return 0;
8022 }
8023 dbug(1, dprintf("b_prot_len=%d", (word)bp->length));
8024 if ((word)bp->length > 256) return _WRONG_MESSAGE_FORMAT;
8025
8026 if (api_parse(&bp->info[1], (word)bp->length, "wwwsssb", bp_parms))
8027 {
8028 bp_parms[6].length = 0;
8029 if (api_parse(&bp->info[1], (word)bp->length, "wwwsss", bp_parms))
8030 {
8031 dbug(1, dprintf("b-form.!"));
8032 return _WRONG_MESSAGE_FORMAT;
8033 }
8034 }
8035 else if (api_parse(&bp->info[1], (word)bp->length, "wwwssss", bp_parms))
8036 {
8037 dbug(1, dprintf("b-form.!"));
8038 return _WRONG_MESSAGE_FORMAT;
8039 }
8040
8041 if (plci->tel == ADV_VOICE) /* transparent B on advanced voice */
8042 {
8043 if (GET_WORD(bp_parms[1].info) != 1
8044 || GET_WORD(bp_parms[2].info) != 0) return _B2_NOT_SUPPORTED;
8045 plci->adv_nl = true;
8046 }
8047 else if (plci->tel) return _B2_NOT_SUPPORTED;
8048
8049
8050 if ((GET_WORD(bp_parms[1].info) == B2_RTP)
8051 && (GET_WORD(bp_parms[2].info) == B3_RTP)
8052 && (plci->adapter->man_profile.private_options & (1L << PRIVATE_RTP)))
8053 {
8054 add_p(plci, LLI, lli);
8055 plci->B2_prot = (byte) GET_WORD(bp_parms[1].info);
8056 plci->B3_prot = (byte) GET_WORD(bp_parms[2].info);
8057 llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ? 14 : 13;
8058 llc[2] = 4;
8059 add_p(plci, LLC, llc);
8060 dlc[0] = 2;
8061 PUT_WORD(&dlc[1], plci->appl->MaxDataLength);
8062 dlc[3] = 3; /* Addr A */
8063 dlc[4] = 1; /* Addr B */
8064 dlc[5] = 7; /* modulo mode */
8065 dlc[6] = 7; /* window size */
8066 dlc[7] = 0; /* XID len Lo */
8067 dlc[8] = 0; /* XID len Hi */
8068 for (i = 0; i < bp_parms[4].length; i++)
8069 dlc[9 + i] = bp_parms[4].info[1 + i];
8070 dlc[0] = (byte)(8 + bp_parms[4].length);
8071 add_p(plci, DLC, dlc);
8072 for (i = 0; i < bp_parms[5].length; i++)
8073 nlc[1 + i] = bp_parms[5].info[1 + i];
8074 nlc[0] = (byte)(bp_parms[5].length);
8075 add_p(plci, NLC, nlc);
8076 return 0;
8077 }
8078
8079
8080
8081 if ((GET_WORD(bp_parms[1].info) >= 32)
8082 || (!((1L << GET_WORD(bp_parms[1].info)) & plci->adapter->profile.B2_Protocols)
8083 && ((GET_WORD(bp_parms[1].info) != B2_PIAFS)
8084 || !(plci->adapter->man_profile.private_options & (1L << PRIVATE_PIAFS)))))
8085
8086 {
8087 return _B2_NOT_SUPPORTED;
8088 }
8089 if ((GET_WORD(bp_parms[2].info) >= 32)
8090 || !((1L << GET_WORD(bp_parms[2].info)) & plci->adapter->profile.B3_Protocols))
8091 {
8092 return _B3_NOT_SUPPORTED;
8093 }
8094 if ((GET_WORD(bp_parms[1].info) != B2_SDLC)
8095 && ((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE)
8096 || (GET_WORD(bp_parms[0].info) == B1_MODEM_ASYNC)
8097 || (GET_WORD(bp_parms[0].info) == B1_MODEM_SYNC_HDLC)))
8098 {
8099 return (add_modem_b23(plci, bp_parms));
8100 }
8101
8102 add_p(plci, LLI, lli);
8103
8104 plci->B2_prot = (byte)GET_WORD(bp_parms[1].info);
8105 plci->B3_prot = (byte)GET_WORD(bp_parms[2].info);
8106 if (plci->B2_prot == 12) SAPI = 0; /* default SAPI D-channel */
8107
8108 if (bp_parms[6].length)
8109 {
8110 if (api_parse(&bp_parms[6].info[1], (word)bp_parms[6].length, "w", global_config))
8111 {
8112 return _WRONG_MESSAGE_FORMAT;
8113 }
8114 switch (GET_WORD(global_config[0].info))
8115 {
8116 case 1:
8117 plci->call_dir = (plci->call_dir & ~CALL_DIR_ANSWER) | CALL_DIR_ORIGINATE;
8118 break;
8119 case 2:
8120 plci->call_dir = (plci->call_dir & ~CALL_DIR_ORIGINATE) | CALL_DIR_ANSWER;
8121 break;
8122 }
8123 }
8124 dbug(1, dprintf("call_dir=%04x", plci->call_dir));
8125
8126
8127 if (plci->B2_prot == B2_PIAFS)
8128 llc[1] = PIAFS_CRC;
8129 else
8130 /* IMPLEMENT_PIAFS */
8131 {
8132 llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ?
8133 llc2_out[GET_WORD(bp_parms[1].info)] : llc2_in[GET_WORD(bp_parms[1].info)];
8134 }
8135 llc[2] = llc3[GET_WORD(bp_parms[2].info)];
8136
8137 add_p(plci, LLC, llc);
8138
8139 dlc[0] = 2;
8140 PUT_WORD(&dlc[1], plci->appl->MaxDataLength +
8141 header[GET_WORD(bp_parms[2].info)]);
8142
8143 b1_config = &bp_parms[3];
8144 nlc[0] = 0;
8145 if (plci->B3_prot == 4
8146 || plci->B3_prot == 5)
8147 {
8148 for (i = 0; i < sizeof(T30_INFO); i++) nlc[i] = 0;
8149 nlc[0] = sizeof(T30_INFO);
8150 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
8151 ((T30_INFO *)&nlc[1])->operating_mode = T30_OPERATING_MODE_CAPI;
8152 ((T30_INFO *)&nlc[1])->rate_div_2400 = 0xff;
8153 if (b1_config->length >= 2)
8154 {
8155 ((T30_INFO *)&nlc[1])->rate_div_2400 = (byte)(GET_WORD(&b1_config->info[1]) / 2400);
8156 }
8157 }
8158 b2_config = &bp_parms[4];
8159
8160
8161 if (llc[1] == PIAFS_CRC)
8162 {
8163 if (plci->B3_prot != B3_TRANSPARENT)
8164 {
8165 return _B_STACK_NOT_SUPPORTED;
8166 }
8167 if (b2_config->length && api_parse(&b2_config->info[1], (word)b2_config->length, "bwww", b2_config_parms)) {
8168 return _WRONG_MESSAGE_FORMAT;
8169 }
8170 PUT_WORD(&dlc[1], plci->appl->MaxDataLength);
8171 dlc[3] = 0; /* Addr A */
8172 dlc[4] = 0; /* Addr B */
8173 dlc[5] = 0; /* modulo mode */
8174 dlc[6] = 0; /* window size */
8175 if (b2_config->length >= 7) {
8176 dlc[7] = 7;
8177 dlc[8] = 0;
8178 dlc[9] = b2_config_parms[0].info[0]; /* PIAFS protocol Speed configuration */
8179 dlc[10] = b2_config_parms[1].info[0]; /* V.42bis P0 */
8180 dlc[11] = b2_config_parms[1].info[1]; /* V.42bis P0 */
8181 dlc[12] = b2_config_parms[2].info[0]; /* V.42bis P1 */
8182 dlc[13] = b2_config_parms[2].info[1]; /* V.42bis P1 */
8183 dlc[14] = b2_config_parms[3].info[0]; /* V.42bis P2 */
8184 dlc[15] = b2_config_parms[3].info[1]; /* V.42bis P2 */
8185 dlc[0] = 15;
8186 if (b2_config->length >= 8) { /* PIAFS control abilities */
8187 dlc[7] = 10;
8188 dlc[16] = 2; /* Length of PIAFS extension */
8189 dlc[17] = PIAFS_UDATA_ABILITIES; /* control (UDATA) ability */
8190 dlc[18] = b2_config_parms[4].info[0]; /* value */
8191 dlc[0] = 18;
8192 }
8193 }
8194 else /* default values, 64K, variable, no compression */
8195 {
8196 dlc[7] = 7;
8197 dlc[8] = 0;
8198 dlc[9] = 0x03; /* PIAFS protocol Speed configuration */
8199 dlc[10] = 0x03; /* V.42bis P0 */
8200 dlc[11] = 0; /* V.42bis P0 */
8201 dlc[12] = 0; /* V.42bis P1 */
8202 dlc[13] = 0; /* V.42bis P1 */
8203 dlc[14] = 0; /* V.42bis P2 */
8204 dlc[15] = 0; /* V.42bis P2 */
8205 dlc[0] = 15;
8206 }
8207 add_p(plci, DLC, dlc);
8208 }
8209 else
8210
8211 if ((llc[1] == V120_L2) || (llc[1] == V120_V42BIS))
8212 {
8213 if (plci->B3_prot != B3_TRANSPARENT)
8214 return _B_STACK_NOT_SUPPORTED;
8215
8216 dlc[0] = 6;
8217 PUT_WORD(&dlc[1], GET_WORD(&dlc[1]) + 2);
8218 dlc[3] = 0x08;
8219 dlc[4] = 0x01;
8220 dlc[5] = 127;
8221 dlc[6] = 7;
8222 if (b2_config->length != 0)
8223 {
8224 if ((llc[1] == V120_V42BIS) && api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbwww", b2_config_parms)) {
8225 return _WRONG_MESSAGE_FORMAT;
8226 }
8227 dlc[3] = (byte)((b2_config->info[2] << 3) | ((b2_config->info[1] >> 5) & 0x04));
8228 dlc[4] = (byte)((b2_config->info[1] << 1) | 0x01);
8229 if (b2_config->info[3] != 128)
8230 {
8231 dbug(1, dprintf("1D-dlc= %x %x %x %x %x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4]));
8232 return _B2_PARM_NOT_SUPPORTED;
8233 }
8234 dlc[5] = (byte)(b2_config->info[3] - 1);
8235 dlc[6] = b2_config->info[4];
8236 if (llc[1] == V120_V42BIS) {
8237 if (b2_config->length >= 10) {
8238 dlc[7] = 6;
8239 dlc[8] = 0;
8240 dlc[9] = b2_config_parms[4].info[0];
8241 dlc[10] = b2_config_parms[4].info[1];
8242 dlc[11] = b2_config_parms[5].info[0];
8243 dlc[12] = b2_config_parms[5].info[1];
8244 dlc[13] = b2_config_parms[6].info[0];
8245 dlc[14] = b2_config_parms[6].info[1];
8246 dlc[0] = 14;
8247 dbug(1, dprintf("b2_config_parms[4].info[0] [1]: %x %x", b2_config_parms[4].info[0], b2_config_parms[4].info[1]));
8248 dbug(1, dprintf("b2_config_parms[5].info[0] [1]: %x %x", b2_config_parms[5].info[0], b2_config_parms[5].info[1]));
8249 dbug(1, dprintf("b2_config_parms[6].info[0] [1]: %x %x", b2_config_parms[6].info[0], b2_config_parms[6].info[1]));
8250 }
8251 else {
8252 dlc[6] = 14;
8253 }
8254 }
8255 }
8256 }
8257 else
8258 {
8259 if (b2_config->length)
8260 {
8261 dbug(1, dprintf("B2-Config"));
8262 if (llc[1] == X75_V42BIS) {
8263 if (api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbwww", b2_config_parms))
8264 {
8265 return _WRONG_MESSAGE_FORMAT;
8266 }
8267 }
8268 else {
8269 if (api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbs", b2_config_parms))
8270 {
8271 return _WRONG_MESSAGE_FORMAT;
8272 }
8273 }
8274 /* if B2 Protocol is LAPD, b2_config structure is different */
8275 if (llc[1] == 6)
8276 {
8277 dlc[0] = 4;
8278 if (b2_config->length >= 1) dlc[2] = b2_config->info[1]; /* TEI */
8279 else dlc[2] = 0x01;
8280 if ((b2_config->length >= 2) && (plci->B2_prot == 12))
8281 {
8282 SAPI = b2_config->info[2]; /* SAPI */
8283 }
8284 dlc[1] = SAPI;
8285 if ((b2_config->length >= 3) && (b2_config->info[3] == 128))
8286 {
8287 dlc[3] = 127; /* Mode */
8288 }
8289 else
8290 {
8291 dlc[3] = 7; /* Mode */
8292 }
8293
8294 if (b2_config->length >= 4) dlc[4] = b2_config->info[4]; /* Window */
8295 else dlc[4] = 1;
8296 dbug(1, dprintf("D-dlc[%d]=%x,%x,%x,%x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4]));
8297 if (b2_config->length > 5) return _B2_PARM_NOT_SUPPORTED;
8298 }
8299 else
8300 {
8301 dlc[0] = (byte)(b2_config_parms[4].length + 6);
8302 dlc[3] = b2_config->info[1];
8303 dlc[4] = b2_config->info[2];
8304 if (b2_config->info[3] != 8 && b2_config->info[3] != 128) {
8305 dbug(1, dprintf("1D-dlc= %x %x %x %x %x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4]));
8306 return _B2_PARM_NOT_SUPPORTED;
8307 }
8308
8309 dlc[5] = (byte)(b2_config->info[3] - 1);
8310 dlc[6] = b2_config->info[4];
8311 if (dlc[6] > dlc[5]) {
8312 dbug(1, dprintf("2D-dlc= %x %x %x %x %x %x %x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4], dlc[5], dlc[6]));
8313 return _B2_PARM_NOT_SUPPORTED;
8314 }
8315
8316 if (llc[1] == X75_V42BIS) {
8317 if (b2_config->length >= 10) {
8318 dlc[7] = 6;
8319 dlc[8] = 0;
8320 dlc[9] = b2_config_parms[4].info[0];
8321 dlc[10] = b2_config_parms[4].info[1];
8322 dlc[11] = b2_config_parms[5].info[0];
8323 dlc[12] = b2_config_parms[5].info[1];
8324 dlc[13] = b2_config_parms[6].info[0];
8325 dlc[14] = b2_config_parms[6].info[1];
8326 dlc[0] = 14;
8327 dbug(1, dprintf("b2_config_parms[4].info[0] [1]: %x %x", b2_config_parms[4].info[0], b2_config_parms[4].info[1]));
8328 dbug(1, dprintf("b2_config_parms[5].info[0] [1]: %x %x", b2_config_parms[5].info[0], b2_config_parms[5].info[1]));
8329 dbug(1, dprintf("b2_config_parms[6].info[0] [1]: %x %x", b2_config_parms[6].info[0], b2_config_parms[6].info[1]));
8330 }
8331 else {
8332 dlc[6] = 14;
8333 }
8334
8335 }
8336 else {
8337 PUT_WORD(&dlc[7], (word)b2_config_parms[4].length);
8338 for (i = 0; i < b2_config_parms[4].length; i++)
8339 dlc[11 + i] = b2_config_parms[4].info[1 + i];
8340 }
8341 }
8342 }
8343 }
8344 add_p(plci, DLC, dlc);
8345
8346 b3_config = &bp_parms[5];
8347 if (b3_config->length)
8348 {
8349 if (plci->B3_prot == 4
8350 || plci->B3_prot == 5)
8351 {
8352 if (api_parse(&b3_config->info[1], (word)b3_config->length, "wwss", b3_config_parms))
8353 {
8354 return _WRONG_MESSAGE_FORMAT;
8355 }
8356 i = GET_WORD((byte *)(b3_config_parms[0].info));
8357 ((T30_INFO *)&nlc[1])->resolution = (byte)(((i & 0x0001) ||
8358 ((plci->B3_prot == 4) && (((byte)(GET_WORD((byte *)b3_config_parms[1].info))) != 5))) ? T30_RESOLUTION_R8_0770_OR_200 : 0);
8359 ((T30_INFO *)&nlc[1])->data_format = (byte)(GET_WORD((byte *)b3_config_parms[1].info));
8360 fax_control_bits = T30_CONTROL_BIT_ALL_FEATURES;
8361 if ((((T30_INFO *)&nlc[1])->rate_div_2400 != 0) && (((T30_INFO *)&nlc[1])->rate_div_2400 <= 6))
8362 fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_V34FAX;
8363 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
8364 {
8365
8366 if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
8367 & (1L << PRIVATE_FAX_PAPER_FORMATS))
8368 {
8369 ((T30_INFO *)&nlc[1])->resolution |= T30_RESOLUTION_R8_1540 |
8370 T30_RESOLUTION_R16_1540_OR_400 | T30_RESOLUTION_300_300 |
8371 T30_RESOLUTION_INCH_BASED | T30_RESOLUTION_METRIC_BASED;
8372 }
8373
8374 ((T30_INFO *)&nlc[1])->recording_properties =
8375 T30_RECORDING_WIDTH_ISO_A3 |
8376 (T30_RECORDING_LENGTH_UNLIMITED << 2) |
8377 (T30_MIN_SCANLINE_TIME_00_00_00 << 4);
8378 }
8379 if (plci->B3_prot == 5)
8380 {
8381 if (i & 0x0002) /* Accept incoming fax-polling requests */
8382 fax_control_bits |= T30_CONTROL_BIT_ACCEPT_POLLING;
8383 if (i & 0x2000) /* Do not use MR compression */
8384 fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_2D_CODING;
8385 if (i & 0x4000) /* Do not use MMR compression */
8386 fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_T6_CODING;
8387 if (i & 0x8000) /* Do not use ECM */
8388 fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_ECM;
8389 if (plci->fax_connect_info_length != 0)
8390 {
8391 ((T30_INFO *)&nlc[1])->resolution = ((T30_INFO *)plci->fax_connect_info_buffer)->resolution;
8392 ((T30_INFO *)&nlc[1])->data_format = ((T30_INFO *)plci->fax_connect_info_buffer)->data_format;
8393 ((T30_INFO *)&nlc[1])->recording_properties = ((T30_INFO *)plci->fax_connect_info_buffer)->recording_properties;
8394 fax_control_bits |= GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low) &
8395 (T30_CONTROL_BIT_REQUEST_POLLING | T30_CONTROL_BIT_MORE_DOCUMENTS);
8396 }
8397 }
8398 /* copy station id to NLC */
8399 for (i = 0; i < T30_MAX_STATION_ID_LENGTH; i++)
8400 {
8401 if (i < b3_config_parms[2].length)
8402 {
8403 ((T30_INFO *)&nlc[1])->station_id[i] = ((byte *)b3_config_parms[2].info)[1 + i];
8404 }
8405 else
8406 {
8407 ((T30_INFO *)&nlc[1])->station_id[i] = ' ';
8408 }
8409 }
8410 ((T30_INFO *)&nlc[1])->station_id_len = T30_MAX_STATION_ID_LENGTH;
8411 /* copy head line to NLC */
8412 if (b3_config_parms[3].length)
8413 {
8414
8415 pos = (byte)(fax_head_line_time(&(((T30_INFO *)&nlc[1])->station_id[T30_MAX_STATION_ID_LENGTH])));
8416 if (pos != 0)
8417 {
8418 if (CAPI_MAX_DATE_TIME_LENGTH + 2 + b3_config_parms[3].length > CAPI_MAX_HEAD_LINE_SPACE)
8419 pos = 0;
8420 else
8421 {
8422 nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
8423 nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
8424 len = (byte)b3_config_parms[2].length;
8425 if (len > 20)
8426 len = 20;
8427 if (CAPI_MAX_DATE_TIME_LENGTH + 2 + len + 2 + b3_config_parms[3].length <= CAPI_MAX_HEAD_LINE_SPACE)
8428 {
8429 for (i = 0; i < len; i++)
8430 nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ((byte *)b3_config_parms[2].info)[1 + i];
8431 nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
8432 nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
8433 }
8434 }
8435 }
8436
8437 len = (byte)b3_config_parms[3].length;
8438 if (len > CAPI_MAX_HEAD_LINE_SPACE - pos)
8439 len = (byte)(CAPI_MAX_HEAD_LINE_SPACE - pos);
8440 ((T30_INFO *)&nlc[1])->head_line_len = (byte)(pos + len);
8441 nlc[0] += (byte)(pos + len);
8442 for (i = 0; i < len; i++)
8443 nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ((byte *)b3_config_parms[3].info)[1 + i];
8444 } else
8445 ((T30_INFO *)&nlc[1])->head_line_len = 0;
8446
8447 plci->nsf_control_bits = 0;
8448 if (plci->B3_prot == 5)
8449 {
8450 if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_FAX_SUB_SEP_PWD))
8451 && (GET_WORD((byte *)b3_config_parms[1].info) & 0x8000)) /* Private SUB/SEP/PWD enable */
8452 {
8453 plci->requested_options |= 1L << PRIVATE_FAX_SUB_SEP_PWD;
8454 }
8455 if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_FAX_NONSTANDARD))
8456 && (GET_WORD((byte *)b3_config_parms[1].info) & 0x4000)) /* Private non-standard facilities enable */
8457 {
8458 plci->requested_options |= 1L << PRIVATE_FAX_NONSTANDARD;
8459 }
8460 if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
8461 & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
8462 {
8463 if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
8464 & (1L << PRIVATE_FAX_SUB_SEP_PWD))
8465 {
8466 fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_PASSWORD;
8467 if (fax_control_bits & T30_CONTROL_BIT_ACCEPT_POLLING)
8468 fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SEL_POLLING;
8469 }
8470 len = nlc[0];
8471 pos = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
8472 if (pos < plci->fax_connect_info_length)
8473 {
8474 for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--)
8475 nlc[++len] = plci->fax_connect_info_buffer[pos++];
8476 }
8477 else
8478 nlc[++len] = 0;
8479 if (pos < plci->fax_connect_info_length)
8480 {
8481 for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--)
8482 nlc[++len] = plci->fax_connect_info_buffer[pos++];
8483 }
8484 else
8485 nlc[++len] = 0;
8486 if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
8487 & (1L << PRIVATE_FAX_NONSTANDARD))
8488 {
8489 if ((pos < plci->fax_connect_info_length) && (plci->fax_connect_info_buffer[pos] != 0))
8490 {
8491 if ((plci->fax_connect_info_buffer[pos] >= 3) && (plci->fax_connect_info_buffer[pos + 1] >= 2))
8492 plci->nsf_control_bits = GET_WORD(&plci->fax_connect_info_buffer[pos + 2]);
8493 for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--)
8494 nlc[++len] = plci->fax_connect_info_buffer[pos++];
8495 }
8496 else
8497 {
8498 if (api_parse(&b3_config->info[1], (word)b3_config->length, "wwsss", b3_config_parms))
8499 {
8500 dbug(1, dprintf("non-standard facilities info missing or wrong format"));
8501 nlc[++len] = 0;
8502 }
8503 else
8504 {
8505 if ((b3_config_parms[4].length >= 3) && (b3_config_parms[4].info[1] >= 2))
8506 plci->nsf_control_bits = GET_WORD(&b3_config_parms[4].info[2]);
8507 nlc[++len] = (byte)(b3_config_parms[4].length);
8508 for (i = 0; i < b3_config_parms[4].length; i++)
8509 nlc[++len] = b3_config_parms[4].info[1 + i];
8510 }
8511 }
8512 }
8513 nlc[0] = len;
8514 if ((plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF)
8515 && (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP))
8516 {
8517 ((T30_INFO *)&nlc[1])->operating_mode = T30_OPERATING_MODE_CAPI_NEG;
8518 }
8519 }
8520 }
8521
8522 PUT_WORD(&(((T30_INFO *)&nlc[1])->control_bits_low), fax_control_bits);
8523 len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
8524 for (i = 0; i < len; i++)
8525 plci->fax_connect_info_buffer[i] = nlc[1 + i];
8526 ((T30_INFO *) plci->fax_connect_info_buffer)->head_line_len = 0;
8527 i += ((T30_INFO *)&nlc[1])->head_line_len;
8528 while (i < nlc[0])
8529 plci->fax_connect_info_buffer[len++] = nlc[++i];
8530 plci->fax_connect_info_length = len;
8531 }
8532 else
8533 {
8534 nlc[0] = 14;
8535 if (b3_config->length != 16)
8536 return _B3_PARM_NOT_SUPPORTED;
8537 for (i = 0; i < 12; i++) nlc[1 + i] = b3_config->info[1 + i];
8538 if (GET_WORD(&b3_config->info[13]) != 8 && GET_WORD(&b3_config->info[13]) != 128)
8539 return _B3_PARM_NOT_SUPPORTED;
8540 nlc[13] = b3_config->info[13];
8541 if (GET_WORD(&b3_config->info[15]) >= nlc[13])
8542 return _B3_PARM_NOT_SUPPORTED;
8543 nlc[14] = b3_config->info[15];
8544 }
8545 }
8546 else
8547 {
8548 if (plci->B3_prot == 4
8549 || plci->B3_prot == 5 /*T.30 - FAX*/) return _B3_PARM_NOT_SUPPORTED;
8550 }
8551 add_p(plci, NLC, nlc);
8552 return 0;
8553 }
8554
8555 /*----------------------------------------------------------------*/
8556 /* make the same as add_b23, but only for the modem related */
8557 /* L2 and L3 B-Chan protocol. */
8558 /* */
8559 /* Enabled L2 and L3 Configurations: */
8560 /* If L1 == Modem all negotiation */
8561 /* only L2 == Modem with full negotiation is allowed */
8562 /* If L1 == Modem async or sync */
8563 /* only L2 == Transparent is allowed */
8564 /* L3 == Modem or L3 == Transparent are allowed */
8565 /* B2 Configuration for modem: */
8566 /* word : enable/disable compression, bitoptions */
8567 /* B3 Configuration for modem: */
8568 /* empty */
8569 /*----------------------------------------------------------------*/
8570 static word add_modem_b23(PLCI *plci, API_PARSE *bp_parms)
8571 {
8572 static byte lli[12] = {1,1};
8573 static byte llc[3] = {2,0,0};
8574 static byte dlc[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
8575 API_PARSE mdm_config[2];
8576 word i;
8577 word b2_config = 0;
8578
8579 for (i = 0; i < 2; i++) mdm_config[i].length = 0;
8580 for (i = 0; i < sizeof(dlc); i++) dlc[i] = 0;
8581
8582 if (((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE)
8583 && (GET_WORD(bp_parms[1].info) != B2_MODEM_EC_COMPRESSION))
8584 || ((GET_WORD(bp_parms[0].info) != B1_MODEM_ALL_NEGOTIATE)
8585 && (GET_WORD(bp_parms[1].info) != B2_TRANSPARENT)))
8586 {
8587 return (_B_STACK_NOT_SUPPORTED);
8588 }
8589 if ((GET_WORD(bp_parms[2].info) != B3_MODEM)
8590 && (GET_WORD(bp_parms[2].info) != B3_TRANSPARENT))
8591 {
8592 return (_B_STACK_NOT_SUPPORTED);
8593 }
8594
8595 plci->B2_prot = (byte) GET_WORD(bp_parms[1].info);
8596 plci->B3_prot = (byte) GET_WORD(bp_parms[2].info);
8597
8598 if ((GET_WORD(bp_parms[1].info) == B2_MODEM_EC_COMPRESSION) && bp_parms[4].length)
8599 {
8600 if (api_parse(&bp_parms[4].info[1],
8601 (word)bp_parms[4].length, "w",
8602 mdm_config))
8603 {
8604 return (_WRONG_MESSAGE_FORMAT);
8605 }
8606 b2_config = GET_WORD(mdm_config[0].info);
8607 }
8608
8609 /* OK, L2 is modem */
8610
8611 lli[0] = 1;
8612 lli[1] = 1;
8613 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL)
8614 lli[1] |= 2;
8615 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL)
8616 lli[1] |= 4;
8617
8618 if ((lli[1] & 0x02) && (diva_xdi_extended_features & DIVA_CAPI_USE_CMA)) {
8619 lli[1] |= 0x10;
8620 if (plci->rx_dma_descriptor <= 0) {
8621 plci->rx_dma_descriptor = diva_get_dma_descriptor(plci, &plci->rx_dma_magic);
8622 if (plci->rx_dma_descriptor >= 0)
8623 plci->rx_dma_descriptor++;
8624 }
8625 if (plci->rx_dma_descriptor > 0) {
8626 lli[1] |= 0x40;
8627 lli[0] = 6;
8628 lli[2] = (byte)(plci->rx_dma_descriptor - 1);
8629 lli[3] = (byte)plci->rx_dma_magic;
8630 lli[4] = (byte)(plci->rx_dma_magic >> 8);
8631 lli[5] = (byte)(plci->rx_dma_magic >> 16);
8632 lli[6] = (byte)(plci->rx_dma_magic >> 24);
8633 }
8634 }
8635
8636 if (DIVA_CAPI_SUPPORTS_NO_CANCEL(plci->adapter)) {
8637 lli[1] |= 0x20;
8638 }
8639
8640 llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ?
8641 /*V42*/ 10 : /*V42_IN*/ 9;
8642 llc[2] = 4; /* pass L3 always transparent */
8643 add_p(plci, LLI, lli);
8644 add_p(plci, LLC, llc);
8645 i = 1;
8646 PUT_WORD(&dlc[i], plci->appl->MaxDataLength);
8647 i += 2;
8648 if (GET_WORD(bp_parms[1].info) == B2_MODEM_EC_COMPRESSION)
8649 {
8650 if (bp_parms[4].length)
8651 {
8652 dbug(1, dprintf("MDM b2_config=%02x", b2_config));
8653 dlc[i++] = 3; /* Addr A */
8654 dlc[i++] = 1; /* Addr B */
8655 dlc[i++] = 7; /* modulo mode */
8656 dlc[i++] = 7; /* window size */
8657 dlc[i++] = 0; /* XID len Lo */
8658 dlc[i++] = 0; /* XID len Hi */
8659
8660 if (b2_config & MDM_B2_DISABLE_V42bis)
8661 {
8662 dlc[i] |= DLC_MODEMPROT_DISABLE_V42_V42BIS;
8663 }
8664 if (b2_config & MDM_B2_DISABLE_MNP)
8665 {
8666 dlc[i] |= DLC_MODEMPROT_DISABLE_MNP_MNP5;
8667 }
8668 if (b2_config & MDM_B2_DISABLE_TRANS)
8669 {
8670 dlc[i] |= DLC_MODEMPROT_REQUIRE_PROTOCOL;
8671 }
8672 if (b2_config & MDM_B2_DISABLE_V42)
8673 {
8674 dlc[i] |= DLC_MODEMPROT_DISABLE_V42_DETECT;
8675 }
8676 if (b2_config & MDM_B2_DISABLE_COMP)
8677 {
8678 dlc[i] |= DLC_MODEMPROT_DISABLE_COMPRESSION;
8679 }
8680 i++;
8681 }
8682 }
8683 else
8684 {
8685 dlc[i++] = 3; /* Addr A */
8686 dlc[i++] = 1; /* Addr B */
8687 dlc[i++] = 7; /* modulo mode */
8688 dlc[i++] = 7; /* window size */
8689 dlc[i++] = 0; /* XID len Lo */
8690 dlc[i++] = 0; /* XID len Hi */
8691 dlc[i++] = DLC_MODEMPROT_DISABLE_V42_V42BIS |
8692 DLC_MODEMPROT_DISABLE_MNP_MNP5 |
8693 DLC_MODEMPROT_DISABLE_V42_DETECT |
8694 DLC_MODEMPROT_DISABLE_COMPRESSION;
8695 }
8696 dlc[0] = (byte)(i - 1);
8697 /* HexDump ("DLC", sizeof(dlc), &dlc[0]); */
8698 add_p(plci, DLC, dlc);
8699 return (0);
8700 }
8701
8702
8703 /*------------------------------------------------------------------*/
8704 /* send a request for the signaling entity */
8705 /*------------------------------------------------------------------*/
8706
8707 static void sig_req(PLCI *plci, byte req, byte Id)
8708 {
8709 if (!plci) return;
8710 if (plci->adapter->adapter_disabled) return;
8711 dbug(1, dprintf("sig_req(%x)", req));
8712 if (req == REMOVE)
8713 plci->sig_remove_id = plci->Sig.Id;
8714 if (plci->req_in == plci->req_in_start) {
8715 plci->req_in += 2;
8716 plci->RBuffer[plci->req_in++] = 0;
8717 }
8718 PUT_WORD(&plci->RBuffer[plci->req_in_start], plci->req_in-plci->req_in_start - 2);
8719 plci->RBuffer[plci->req_in++] = Id; /* sig/nl flag */
8720 plci->RBuffer[plci->req_in++] = req; /* request */
8721 plci->RBuffer[plci->req_in++] = 0; /* channel */
8722 plci->req_in_start = plci->req_in;
8723 }
8724
8725 /*------------------------------------------------------------------*/
8726 /* send a request for the network layer entity */
8727 /*------------------------------------------------------------------*/
8728
8729 static void nl_req_ncci(PLCI *plci, byte req, byte ncci)
8730 {
8731 if (!plci) return;
8732 if (plci->adapter->adapter_disabled) return;
8733 dbug(1, dprintf("nl_req %02x %02x %02x", plci->Id, req, ncci));
8734 if (req == REMOVE)
8735 {
8736 plci->nl_remove_id = plci->NL.Id;
8737 ncci_remove(plci, 0, (byte)(ncci != 0));
8738 ncci = 0;
8739 }
8740 if (plci->req_in == plci->req_in_start) {
8741 plci->req_in += 2;
8742 plci->RBuffer[plci->req_in++] = 0;
8743 }
8744 PUT_WORD(&plci->RBuffer[plci->req_in_start], plci->req_in-plci->req_in_start - 2);
8745 plci->RBuffer[plci->req_in++] = 1; /* sig/nl flag */
8746 plci->RBuffer[plci->req_in++] = req; /* request */
8747 plci->RBuffer[plci->req_in++] = plci->adapter->ncci_ch[ncci]; /* channel */
8748 plci->req_in_start = plci->req_in;
8749 }
8750
8751 static void send_req(PLCI *plci)
8752 {
8753 ENTITY *e;
8754 word l;
8755 /* word i; */
8756
8757 if (!plci) return;
8758 if (plci->adapter->adapter_disabled) return;
8759 channel_xmit_xon(plci);
8760
8761 /* if nothing to do, return */
8762 if (plci->req_in == plci->req_out) return;
8763 dbug(1, dprintf("send_req(in=%d,out=%d)", plci->req_in, plci->req_out));
8764
8765 if (plci->nl_req || plci->sig_req) return;
8766
8767 l = GET_WORD(&plci->RBuffer[plci->req_out]);
8768 plci->req_out += 2;
8769 plci->XData[0].P = &plci->RBuffer[plci->req_out];
8770 plci->req_out += l;
8771 if (plci->RBuffer[plci->req_out] == 1)
8772 {
8773 e = &plci->NL;
8774 plci->req_out++;
8775 e->Req = plci->nl_req = plci->RBuffer[plci->req_out++];
8776 e->ReqCh = plci->RBuffer[plci->req_out++];
8777 if (!(e->Id & 0x1f))
8778 {
8779 e->Id = NL_ID;
8780 plci->RBuffer[plci->req_out - 4] = CAI;
8781 plci->RBuffer[plci->req_out - 3] = 1;
8782 plci->RBuffer[plci->req_out - 2] = (plci->Sig.Id == 0xff) ? 0 : plci->Sig.Id;
8783 plci->RBuffer[plci->req_out - 1] = 0;
8784 l += 3;
8785 plci->nl_global_req = plci->nl_req;
8786 }
8787 dbug(1, dprintf("%x:NLREQ(%x:%x:%x)", plci->adapter->Id, e->Id, e->Req, e->ReqCh));
8788 }
8789 else
8790 {
8791 e = &plci->Sig;
8792 if (plci->RBuffer[plci->req_out])
8793 e->Id = plci->RBuffer[plci->req_out];
8794 plci->req_out++;
8795 e->Req = plci->sig_req = plci->RBuffer[plci->req_out++];
8796 e->ReqCh = plci->RBuffer[plci->req_out++];
8797 if (!(e->Id & 0x1f))
8798 plci->sig_global_req = plci->sig_req;
8799 dbug(1, dprintf("%x:SIGREQ(%x:%x:%x)", plci->adapter->Id, e->Id, e->Req, e->ReqCh));
8800 }
8801 plci->XData[0].PLength = l;
8802 e->X = plci->XData;
8803 plci->adapter->request(e);
8804 dbug(1, dprintf("send_ok"));
8805 }
8806
8807 static void send_data(PLCI *plci)
8808 {
8809 DIVA_CAPI_ADAPTER *a;
8810 DATA_B3_DESC *data;
8811 NCCI *ncci_ptr;
8812 word ncci;
8813
8814 if (!plci->nl_req && plci->ncci_ring_list)
8815 {
8816 a = plci->adapter;
8817 ncci = plci->ncci_ring_list;
8818 do
8819 {
8820 ncci = a->ncci_next[ncci];
8821 ncci_ptr = &(a->ncci[ncci]);
8822 if (!(a->ncci_ch[ncci]
8823 && (a->ch_flow_control[a->ncci_ch[ncci]] & N_OK_FC_PENDING)))
8824 {
8825 if (ncci_ptr->data_pending)
8826 {
8827 if ((a->ncci_state[ncci] == CONNECTED)
8828 || (a->ncci_state[ncci] == INC_ACT_PENDING)
8829 || (plci->send_disc == ncci))
8830 {
8831 data = &(ncci_ptr->DBuffer[ncci_ptr->data_out]);
8832 if ((plci->B2_prot == B2_V120_ASYNC)
8833 || (plci->B2_prot == B2_V120_ASYNC_V42BIS)
8834 || (plci->B2_prot == B2_V120_BIT_TRANSPARENT))
8835 {
8836 plci->NData[1].P = TransmitBufferGet(plci->appl, data->P);
8837 plci->NData[1].PLength = data->Length;
8838 if (data->Flags & 0x10)
8839 plci->NData[0].P = v120_break_header;
8840 else
8841 plci->NData[0].P = v120_default_header;
8842 plci->NData[0].PLength = 1;
8843 plci->NL.XNum = 2;
8844 plci->NL.Req = plci->nl_req = (byte)((data->Flags & 0x07) << 4 | N_DATA);
8845 }
8846 else
8847 {
8848 plci->NData[0].P = TransmitBufferGet(plci->appl, data->P);
8849 plci->NData[0].PLength = data->Length;
8850 if (data->Flags & 0x10)
8851 plci->NL.Req = plci->nl_req = (byte)N_UDATA;
8852
8853 else if ((plci->B3_prot == B3_RTP) && (data->Flags & 0x01))
8854 plci->NL.Req = plci->nl_req = (byte)N_BDATA;
8855
8856 else
8857 plci->NL.Req = plci->nl_req = (byte)((data->Flags & 0x07) << 4 | N_DATA);
8858 }
8859 plci->NL.X = plci->NData;
8860 plci->NL.ReqCh = a->ncci_ch[ncci];
8861 dbug(1, dprintf("%x:DREQ(%x:%x)", a->Id, plci->NL.Id, plci->NL.Req));
8862 plci->data_sent = true;
8863 plci->data_sent_ptr = data->P;
8864 a->request(&plci->NL);
8865 }
8866 else {
8867 cleanup_ncci_data(plci, ncci);
8868 }
8869 }
8870 else if (plci->send_disc == ncci)
8871 {
8872 /* dprintf("N_DISC"); */
8873 plci->NData[0].PLength = 0;
8874 plci->NL.ReqCh = a->ncci_ch[ncci];
8875 plci->NL.Req = plci->nl_req = N_DISC;
8876 a->request(&plci->NL);
8877 plci->command = _DISCONNECT_B3_R;
8878 plci->send_disc = 0;
8879 }
8880 }
8881 } while (!plci->nl_req && (ncci != plci->ncci_ring_list));
8882 plci->ncci_ring_list = ncci;
8883 }
8884 }
8885
8886 static void listen_check(DIVA_CAPI_ADAPTER *a)
8887 {
8888 word i, j;
8889 PLCI *plci;
8890 byte activnotifiedcalls = 0;
8891
8892 dbug(1, dprintf("listen_check(%d,%d)", a->listen_active, a->max_listen));
8893 if (!remove_started && !a->adapter_disabled)
8894 {
8895 for (i = 0; i < a->max_plci; i++)
8896 {
8897 plci = &(a->plci[i]);
8898 if (plci->notifiedcall) activnotifiedcalls++;
8899 }
8900 dbug(1, dprintf("listen_check(%d)", activnotifiedcalls));
8901
8902 for (i = a->listen_active; i < ((word)(a->max_listen + activnotifiedcalls)); i++) {
8903 if ((j = get_plci(a))) {
8904 a->listen_active++;
8905 plci = &a->plci[j - 1];
8906 plci->State = LISTENING;
8907
8908 add_p(plci, OAD, "\x01\xfd");
8909
8910 add_p(plci, KEY, "\x04\x43\x41\x32\x30");
8911
8912 add_p(plci, CAI, "\x01\xc0");
8913 add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
8914 add_p(plci, LLI, "\x01\xc4"); /* support Dummy CR FAC + MWI + SpoofNotify */
8915 add_p(plci, SHIFT | 6, NULL);
8916 add_p(plci, SIN, "\x02\x00\x00");
8917 plci->internal_command = LISTEN_SIG_ASSIGN_PEND; /* do indicate_req if OK */
8918 sig_req(plci, ASSIGN, DSIG_ID);
8919 send_req(plci);
8920 }
8921 }
8922 }
8923 }
8924
8925 /*------------------------------------------------------------------*/
8926 /* functions for all parameters sent in INDs */
8927 /*------------------------------------------------------------------*/
8928
8929 static void IndParse(PLCI *plci, word *parms_id, byte **parms, byte multiIEsize)
8930 {
8931 word ploc; /* points to current location within packet */
8932 byte w;
8933 byte wlen;
8934 byte codeset, lock;
8935 byte *in;
8936 word i;
8937 word code;
8938 word mIEindex = 0;
8939 ploc = 0;
8940 codeset = 0;
8941 lock = 0;
8942
8943 in = plci->Sig.RBuffer->P;
8944 for (i = 0; i < parms_id[0]; i++) /* multiIE parms_id contains just the 1st */
8945 { /* element but parms array is larger */
8946 parms[i] = (byte *)"";
8947 }
8948 for (i = 0; i < multiIEsize; i++)
8949 {
8950 parms[i] = (byte *)"";
8951 }
8952
8953 while (ploc < plci->Sig.RBuffer->length - 1) {
8954
8955 /* read information element id and length */
8956 w = in[ploc];
8957
8958 if (w & 0x80) {
8959 /* w &=0xf0; removed, cannot detect congestion levels */
8960 /* upper 4 bit masked with w==SHIFT now */
8961 wlen = 0;
8962 }
8963 else {
8964 wlen = (byte)(in[ploc + 1] + 1);
8965 }
8966 /* check if length valid (not exceeding end of packet) */
8967 if ((ploc + wlen) > 270) return;
8968 if (lock & 0x80) lock &= 0x7f;
8969 else codeset = lock;
8970
8971 if ((w & 0xf0) == SHIFT) {
8972 codeset = in[ploc];
8973 if (!(codeset & 0x08)) lock = (byte)(codeset & 7);
8974 codeset &= 7;
8975 lock |= 0x80;
8976 }
8977 else {
8978 if (w == ESC && wlen >= 3) code = in[ploc + 2] | 0x800;
8979 else code = w;
8980 code |= (codeset << 8);
8981
8982 for (i = 1; i < parms_id[0] + 1 && parms_id[i] != code; i++);
8983
8984 if (i < parms_id[0] + 1) {
8985 if (!multiIEsize) { /* with multiIEs use next field index, */
8986 mIEindex = i - 1; /* with normal IEs use same index like parms_id */
8987 }
8988
8989 parms[mIEindex] = &in[ploc + 1];
8990 dbug(1, dprintf("mIE[%d]=0x%x", *parms[mIEindex], in[ploc]));
8991 if (parms_id[i] == OAD
8992 || parms_id[i] == CONN_NR
8993 || parms_id[i] == CAD) {
8994 if (in[ploc + 2] & 0x80) {
8995 in[ploc + 0] = (byte)(in[ploc + 1] + 1);
8996 in[ploc + 1] = (byte)(in[ploc + 2] & 0x7f);
8997 in[ploc + 2] = 0x80;
8998 parms[mIEindex] = &in[ploc];
8999 }
9000 }
9001 mIEindex++; /* effects multiIEs only */
9002 }
9003 }
9004
9005 ploc += (wlen + 1);
9006 }
9007 return;
9008 }
9009
9010 /*------------------------------------------------------------------*/
9011 /* try to match a cip from received BC and HLC */
9012 /*------------------------------------------------------------------*/
9013
9014 static byte ie_compare(byte *ie1, byte *ie2)
9015 {
9016 word i;
9017 if (!ie1 || !ie2) return false;
9018 if (!ie1[0]) return false;
9019 for (i = 0; i < (word)(ie1[0] + 1); i++) if (ie1[i] != ie2[i]) return false;
9020 return true;
9021 }
9022
9023 static word find_cip(DIVA_CAPI_ADAPTER *a, byte *bc, byte *hlc)
9024 {
9025 word i;
9026 word j;
9027
9028 for (i = 9; i && !ie_compare(bc, cip_bc[i][a->u_law]); i--);
9029
9030 for (j = 16; j < 29 &&
9031 (!ie_compare(bc, cip_bc[j][a->u_law]) || !ie_compare(hlc, cip_hlc[j])); j++);
9032 if (j == 29) return i;
9033 return j;
9034 }
9035
9036
9037 static byte AddInfo(byte **add_i,
9038 byte **fty_i,
9039 byte *esc_chi,
9040 byte *facility)
9041 {
9042 byte i;
9043 byte j;
9044 byte k;
9045 byte flen;
9046 byte len = 0;
9047 /* facility is a nested structure */
9048 /* FTY can be more than once */
9049
9050 if (esc_chi[0] && !(esc_chi[esc_chi[0]] & 0x7f))
9051 {
9052 add_i[0] = (byte *)"\x02\x02\x00"; /* use neither b nor d channel */
9053 }
9054
9055 else
9056 {
9057 add_i[0] = (byte *)"";
9058 }
9059 if (!fty_i[0][0])
9060 {
9061 add_i[3] = (byte *)"";
9062 }
9063 else
9064 { /* facility array found */
9065 for (i = 0, j = 1; i < MAX_MULTI_IE && fty_i[i][0]; i++)
9066 {
9067 dbug(1, dprintf("AddIFac[%d]", fty_i[i][0]));
9068 len += fty_i[i][0];
9069 len += 2;
9070 flen = fty_i[i][0];
9071 facility[j++] = 0x1c; /* copy fac IE */
9072 for (k = 0; k <= flen; k++, j++)
9073 {
9074 facility[j] = fty_i[i][k];
9075 /* dbug(1, dprintf("%x ",facility[j])); */
9076 }
9077 }
9078 facility[0] = len;
9079 add_i[3] = facility;
9080 }
9081 /* dbug(1, dprintf("FacArrLen=%d ",len)); */
9082 len = add_i[0][0] + add_i[1][0] + add_i[2][0] + add_i[3][0];
9083 len += 4; /* calculate length of all */
9084 return (len);
9085 }
9086
9087 /*------------------------------------------------------------------*/
9088 /* voice and codec features */
9089 /*------------------------------------------------------------------*/
9090
9091 static void SetVoiceChannel(PLCI *plci, byte *chi, DIVA_CAPI_ADAPTER *a)
9092 {
9093 byte voice_chi[] = "\x02\x18\x01";
9094 byte channel;
9095
9096 channel = chi[chi[0]] & 0x3;
9097 dbug(1, dprintf("ExtDevON(Ch=0x%x)", channel));
9098 voice_chi[2] = (channel) ? channel : 1;
9099 add_p(plci, FTY, "\x02\x01\x07"); /* B On, default on 1 */
9100 add_p(plci, ESC, voice_chi); /* Channel */
9101 sig_req(plci, TEL_CTRL, 0);
9102 send_req(plci);
9103 if (a->AdvSignalPLCI)
9104 {
9105 adv_voice_write_coefs(a->AdvSignalPLCI, ADV_VOICE_WRITE_ACTIVATION);
9106 }
9107 }
9108
9109 static void VoiceChannelOff(PLCI *plci)
9110 {
9111 dbug(1, dprintf("ExtDevOFF"));
9112 add_p(plci, FTY, "\x02\x01\x08"); /* B Off */
9113 sig_req(plci, TEL_CTRL, 0);
9114 send_req(plci);
9115 if (plci->adapter->AdvSignalPLCI)
9116 {
9117 adv_voice_clear_config(plci->adapter->AdvSignalPLCI);
9118 }
9119 }
9120
9121
9122 static word AdvCodecSupport(DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl,
9123 byte hook_listen)
9124 {
9125 word j;
9126 PLCI *splci;
9127
9128 /* check if hardware supports handset with hook states (adv.codec) */
9129 /* or if just a on board codec is supported */
9130 /* the advanced codec plci is just for internal use */
9131
9132 /* diva Pro with on-board codec: */
9133 if (a->profile.Global_Options & HANDSET)
9134 {
9135 /* new call, but hook states are already signalled */
9136 if (a->AdvCodecFLAG)
9137 {
9138 if (a->AdvSignalAppl != appl || a->AdvSignalPLCI)
9139 {
9140 dbug(1, dprintf("AdvSigPlci=0x%x", a->AdvSignalPLCI));
9141 return 0x2001; /* codec in use by another application */
9142 }
9143 if (plci != NULL)
9144 {
9145 a->AdvSignalPLCI = plci;
9146 plci->tel = ADV_VOICE;
9147 }
9148 return 0; /* adv codec still used */
9149 }
9150 if ((j = get_plci(a)))
9151 {
9152 splci = &a->plci[j - 1];
9153 splci->tel = CODEC_PERMANENT;
9154 /* hook_listen indicates if a facility_req with handset/hook support */
9155 /* was sent. Otherwise if just a call on an external device was made */
9156 /* the codec will be used but the hook info will be discarded (just */
9157 /* the external controller is in use */
9158 if (hook_listen) splci->State = ADVANCED_VOICE_SIG;
9159 else
9160 {
9161 splci->State = ADVANCED_VOICE_NOSIG;
9162 if (plci)
9163 {
9164 plci->spoofed_msg = SPOOFING_REQUIRED;
9165 }
9166 /* indicate D-ch connect if */
9167 } /* codec is connected OK */
9168 if (plci != NULL)
9169 {
9170 a->AdvSignalPLCI = plci;
9171 plci->tel = ADV_VOICE;
9172 }
9173 a->AdvSignalAppl = appl;
9174 a->AdvCodecFLAG = true;
9175 a->AdvCodecPLCI = splci;
9176 add_p(splci, CAI, "\x01\x15");
9177 add_p(splci, LLI, "\x01\x00");
9178 add_p(splci, ESC, "\x02\x18\x00");
9179 add_p(splci, UID, "\x06\x43\x61\x70\x69\x32\x30");
9180 splci->internal_command = PERM_COD_ASSIGN;
9181 dbug(1, dprintf("Codec Assign"));
9182 sig_req(splci, ASSIGN, DSIG_ID);
9183 send_req(splci);
9184 }
9185 else
9186 {
9187 return 0x2001; /* wrong state, no more plcis */
9188 }
9189 }
9190 else if (a->profile.Global_Options & ON_BOARD_CODEC)
9191 {
9192 if (hook_listen) return 0x300B; /* Facility not supported */
9193 /* no hook with SCOM */
9194 if (plci != NULL) plci->tel = CODEC;
9195 dbug(1, dprintf("S/SCOM codec"));
9196 /* first time we use the scom-s codec we must shut down the internal */
9197 /* handset application of the card. This can be done by an assign with */
9198 /* a cai with the 0x80 bit set. Assign return code is 'out of resource'*/
9199 if (!a->scom_appl_disable) {
9200 if ((j = get_plci(a))) {
9201 splci = &a->plci[j - 1];
9202 add_p(splci, CAI, "\x01\x80");
9203 add_p(splci, UID, "\x06\x43\x61\x70\x69\x32\x30");
9204 sig_req(splci, ASSIGN, 0xC0); /* 0xc0 is the TEL_ID */
9205 send_req(splci);
9206 a->scom_appl_disable = true;
9207 }
9208 else{
9209 return 0x2001; /* wrong state, no more plcis */
9210 }
9211 }
9212 }
9213 else return 0x300B; /* Facility not supported */
9214
9215 return 0;
9216 }
9217
9218
9219 static void CodecIdCheck(DIVA_CAPI_ADAPTER *a, PLCI *plci)
9220 {
9221
9222 dbug(1, dprintf("CodecIdCheck"));
9223
9224 if (a->AdvSignalPLCI == plci)
9225 {
9226 dbug(1, dprintf("PLCI owns codec"));
9227 VoiceChannelOff(a->AdvCodecPLCI);
9228 if (a->AdvCodecPLCI->State == ADVANCED_VOICE_NOSIG)
9229 {
9230 dbug(1, dprintf("remove temp codec PLCI"));
9231 plci_remove(a->AdvCodecPLCI);
9232 a->AdvCodecFLAG = 0;
9233 a->AdvCodecPLCI = NULL;
9234 a->AdvSignalAppl = NULL;
9235 }
9236 a->AdvSignalPLCI = NULL;
9237 }
9238 }
9239
9240 /* -------------------------------------------------------------------
9241 Ask for physical address of card on PCI bus
9242 ------------------------------------------------------------------- */
9243 static void diva_ask_for_xdi_sdram_bar(DIVA_CAPI_ADAPTER *a,
9244 IDI_SYNC_REQ *preq) {
9245 a->sdram_bar = 0;
9246 if (diva_xdi_extended_features & DIVA_CAPI_XDI_PROVIDES_SDRAM_BAR) {
9247 ENTITY *e = (ENTITY *)preq;
9248
9249 e->user[0] = a->Id - 1;
9250 preq->xdi_sdram_bar.info.bar = 0;
9251 preq->xdi_sdram_bar.Req = 0;
9252 preq->xdi_sdram_bar.Rc = IDI_SYNC_REQ_XDI_GET_ADAPTER_SDRAM_BAR;
9253
9254 (*(a->request))(e);
9255
9256 a->sdram_bar = preq->xdi_sdram_bar.info.bar;
9257 dbug(3, dprintf("A(%d) SDRAM BAR = %08x", a->Id, a->sdram_bar));
9258 }
9259 }
9260
9261 /* -------------------------------------------------------------------
9262 Ask XDI about extended features
9263 ------------------------------------------------------------------- */
9264 static void diva_get_extended_adapter_features(DIVA_CAPI_ADAPTER *a) {
9265 IDI_SYNC_REQ *preq;
9266 char buffer[((sizeof(preq->xdi_extended_features) + 4) > sizeof(ENTITY)) ? (sizeof(preq->xdi_extended_features) + 4) : sizeof(ENTITY)];
9267
9268 char features[4];
9269 preq = (IDI_SYNC_REQ *)&buffer[0];
9270
9271 if (!diva_xdi_extended_features) {
9272 ENTITY *e = (ENTITY *)preq;
9273 diva_xdi_extended_features |= 0x80000000;
9274
9275 e->user[0] = a->Id - 1;
9276 preq->xdi_extended_features.Req = 0;
9277 preq->xdi_extended_features.Rc = IDI_SYNC_REQ_XDI_GET_EXTENDED_FEATURES;
9278 preq->xdi_extended_features.info.buffer_length_in_bytes = sizeof(features);
9279 preq->xdi_extended_features.info.features = &features[0];
9280
9281 (*(a->request))(e);
9282
9283 if (features[0] & DIVA_XDI_EXTENDED_FEATURES_VALID) {
9284 /*
9285 Check features located in the byte '0'
9286 */
9287 if (features[0] & DIVA_XDI_EXTENDED_FEATURE_CMA) {
9288 diva_xdi_extended_features |= DIVA_CAPI_USE_CMA;
9289 }
9290 if (features[0] & DIVA_XDI_EXTENDED_FEATURE_RX_DMA) {
9291 diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_RX_DMA;
9292 dbug(1, dprintf("XDI provides RxDMA"));
9293 }
9294 if (features[0] & DIVA_XDI_EXTENDED_FEATURE_SDRAM_BAR) {
9295 diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_SDRAM_BAR;
9296 }
9297 if (features[0] & DIVA_XDI_EXTENDED_FEATURE_NO_CANCEL_RC) {
9298 diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_NO_CANCEL;
9299 dbug(3, dprintf("XDI provides NO_CANCEL_RC feature"));
9300 }
9301
9302 }
9303 }
9304
9305 diva_ask_for_xdi_sdram_bar(a, preq);
9306 }
9307
9308 /*------------------------------------------------------------------*/
9309 /* automatic law */
9310 /*------------------------------------------------------------------*/
9311 /* called from OS specific part after init time to get the Law */
9312 /* a-law (Euro) and u-law (us,japan) use different BCs in the Setup message */
9313 void AutomaticLaw(DIVA_CAPI_ADAPTER *a)
9314 {
9315 word j;
9316 PLCI *splci;
9317
9318 if (a->automatic_law) {
9319 return;
9320 }
9321 if ((j = get_plci(a))) {
9322 diva_get_extended_adapter_features(a);
9323 splci = &a->plci[j - 1];
9324 a->automatic_lawPLCI = splci;
9325 a->automatic_law = 1;
9326 add_p(splci, CAI, "\x01\x80");
9327 add_p(splci, UID, "\x06\x43\x61\x70\x69\x32\x30");
9328 splci->internal_command = USELAW_REQ;
9329 splci->command = 0;
9330 splci->number = 0;
9331 sig_req(splci, ASSIGN, DSIG_ID);
9332 send_req(splci);
9333 }
9334 }
9335
9336 /* called from OS specific part if an application sends an Capi20Release */
9337 word CapiRelease(word Id)
9338 {
9339 word i, j, appls_found;
9340 PLCI *plci;
9341 APPL *this;
9342 DIVA_CAPI_ADAPTER *a;
9343
9344 if (!Id)
9345 {
9346 dbug(0, dprintf("A: CapiRelease(Id==0)"));
9347 return (_WRONG_APPL_ID);
9348 }
9349
9350 this = &application[Id - 1]; /* get application pointer */
9351
9352 for (i = 0, appls_found = 0; i < max_appl; i++)
9353 {
9354 if (application[i].Id) /* an application has been found */
9355 {
9356 appls_found++;
9357 }
9358 }
9359
9360 for (i = 0; i < max_adapter; i++) /* scan all adapters... */
9361 {
9362 a = &adapter[i];
9363 if (a->request)
9364 {
9365 a->Info_Mask[Id - 1] = 0;
9366 a->CIP_Mask[Id - 1] = 0;
9367 a->Notification_Mask[Id - 1] = 0;
9368 a->codec_listen[Id - 1] = NULL;
9369 a->requested_options_table[Id - 1] = 0;
9370 for (j = 0; j < a->max_plci; j++) /* and all PLCIs connected */
9371 { /* with this application */
9372 plci = &a->plci[j];
9373 if (plci->Id) /* if plci owns no application */
9374 { /* it may be not jet connected */
9375 if (plci->State == INC_CON_PENDING
9376 || plci->State == INC_CON_ALERT)
9377 {
9378 if (test_c_ind_mask_bit(plci, (word)(Id - 1)))
9379 {
9380 clear_c_ind_mask_bit(plci, (word)(Id - 1));
9381 if (c_ind_mask_empty(plci))
9382 {
9383 sig_req(plci, HANGUP, 0);
9384 send_req(plci);
9385 plci->State = OUTG_DIS_PENDING;
9386 }
9387 }
9388 }
9389 if (test_c_ind_mask_bit(plci, (word)(Id - 1)))
9390 {
9391 clear_c_ind_mask_bit(plci, (word)(Id - 1));
9392 if (c_ind_mask_empty(plci))
9393 {
9394 if (!plci->appl)
9395 {
9396 plci_remove(plci);
9397 plci->State = IDLE;
9398 }
9399 }
9400 }
9401 if (plci->appl == this)
9402 {
9403 plci->appl = NULL;
9404 plci_remove(plci);
9405 plci->State = IDLE;
9406 }
9407 }
9408 }
9409 listen_check(a);
9410
9411 if (a->flag_dynamic_l1_down)
9412 {
9413 if (appls_found == 1) /* last application does a capi release */
9414 {
9415 if ((j = get_plci(a)))
9416 {
9417 plci = &a->plci[j - 1];
9418 plci->command = 0;
9419 add_p(plci, OAD, "\x01\xfd");
9420 add_p(plci, CAI, "\x01\x80");
9421 add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
9422 add_p(plci, SHIFT | 6, NULL);
9423 add_p(plci, SIN, "\x02\x00\x00");
9424 plci->internal_command = REM_L1_SIG_ASSIGN_PEND;
9425 sig_req(plci, ASSIGN, DSIG_ID);
9426 add_p(plci, FTY, "\x02\xff\x06"); /* l1 down */
9427 sig_req(plci, SIG_CTRL, 0);
9428 send_req(plci);
9429 }
9430 }
9431 }
9432 if (a->AdvSignalAppl == this)
9433 {
9434 this->NullCREnable = false;
9435 if (a->AdvCodecPLCI)
9436 {
9437 plci_remove(a->AdvCodecPLCI);
9438 a->AdvCodecPLCI->tel = 0;
9439 a->AdvCodecPLCI->adv_nl = 0;
9440 }
9441 a->AdvSignalAppl = NULL;
9442 a->AdvSignalPLCI = NULL;
9443 a->AdvCodecFLAG = 0;
9444 a->AdvCodecPLCI = NULL;
9445 }
9446 }
9447 }
9448
9449 this->Id = 0;
9450
9451 return GOOD;
9452 }
9453
9454 static word plci_remove_check(PLCI *plci)
9455 {
9456 if (!plci) return true;
9457 if (!plci->NL.Id && c_ind_mask_empty(plci))
9458 {
9459 if (plci->Sig.Id == 0xff)
9460 plci->Sig.Id = 0;
9461 if (!plci->Sig.Id)
9462 {
9463 dbug(1, dprintf("plci_remove_complete(%x)", plci->Id));
9464 dbug(1, dprintf("tel=0x%x,Sig=0x%x", plci->tel, plci->Sig.Id));
9465 if (plci->Id)
9466 {
9467 CodecIdCheck(plci->adapter, plci);
9468 clear_b1_config(plci);
9469 ncci_remove(plci, 0, false);
9470 plci_free_msg_in_queue(plci);
9471 channel_flow_control_remove(plci);
9472 plci->Id = 0;
9473 plci->State = IDLE;
9474 plci->channels = 0;
9475 plci->appl = NULL;
9476 plci->notifiedcall = 0;
9477 }
9478 listen_check(plci->adapter);
9479 return true;
9480 }
9481 }
9482 return false;
9483 }
9484
9485
9486 /*------------------------------------------------------------------*/
9487
9488 static byte plci_nl_busy(PLCI *plci)
9489 {
9490 /* only applicable for non-multiplexed protocols */
9491 return (plci->nl_req
9492 || (plci->ncci_ring_list
9493 && plci->adapter->ncci_ch[plci->ncci_ring_list]
9494 && (plci->adapter->ch_flow_control[plci->adapter->ncci_ch[plci->ncci_ring_list]] & N_OK_FC_PENDING)));
9495 }
9496
9497
9498 /*------------------------------------------------------------------*/
9499 /* DTMF facilities */
9500 /*------------------------------------------------------------------*/
9501
9502
9503 static struct
9504 {
9505 byte send_mask;
9506 byte listen_mask;
9507 byte character;
9508 byte code;
9509 } dtmf_digit_map[] =
9510 {
9511 { 0x01, 0x01, 0x23, DTMF_DIGIT_TONE_CODE_HASHMARK },
9512 { 0x01, 0x01, 0x2a, DTMF_DIGIT_TONE_CODE_STAR },
9513 { 0x01, 0x01, 0x30, DTMF_DIGIT_TONE_CODE_0 },
9514 { 0x01, 0x01, 0x31, DTMF_DIGIT_TONE_CODE_1 },
9515 { 0x01, 0x01, 0x32, DTMF_DIGIT_TONE_CODE_2 },
9516 { 0x01, 0x01, 0x33, DTMF_DIGIT_TONE_CODE_3 },
9517 { 0x01, 0x01, 0x34, DTMF_DIGIT_TONE_CODE_4 },
9518 { 0x01, 0x01, 0x35, DTMF_DIGIT_TONE_CODE_5 },
9519 { 0x01, 0x01, 0x36, DTMF_DIGIT_TONE_CODE_6 },
9520 { 0x01, 0x01, 0x37, DTMF_DIGIT_TONE_CODE_7 },
9521 { 0x01, 0x01, 0x38, DTMF_DIGIT_TONE_CODE_8 },
9522 { 0x01, 0x01, 0x39, DTMF_DIGIT_TONE_CODE_9 },
9523 { 0x01, 0x01, 0x41, DTMF_DIGIT_TONE_CODE_A },
9524 { 0x01, 0x01, 0x42, DTMF_DIGIT_TONE_CODE_B },
9525 { 0x01, 0x01, 0x43, DTMF_DIGIT_TONE_CODE_C },
9526 { 0x01, 0x01, 0x44, DTMF_DIGIT_TONE_CODE_D },
9527 { 0x01, 0x00, 0x61, DTMF_DIGIT_TONE_CODE_A },
9528 { 0x01, 0x00, 0x62, DTMF_DIGIT_TONE_CODE_B },
9529 { 0x01, 0x00, 0x63, DTMF_DIGIT_TONE_CODE_C },
9530 { 0x01, 0x00, 0x64, DTMF_DIGIT_TONE_CODE_D },
9531
9532 { 0x04, 0x04, 0x80, DTMF_SIGNAL_NO_TONE },
9533 { 0x00, 0x04, 0x81, DTMF_SIGNAL_UNIDENTIFIED_TONE },
9534 { 0x04, 0x04, 0x82, DTMF_SIGNAL_DIAL_TONE },
9535 { 0x04, 0x04, 0x83, DTMF_SIGNAL_PABX_INTERNAL_DIAL_TONE },
9536 { 0x04, 0x04, 0x84, DTMF_SIGNAL_SPECIAL_DIAL_TONE },
9537 { 0x04, 0x04, 0x85, DTMF_SIGNAL_SECOND_DIAL_TONE },
9538 { 0x04, 0x04, 0x86, DTMF_SIGNAL_RINGING_TONE },
9539 { 0x04, 0x04, 0x87, DTMF_SIGNAL_SPECIAL_RINGING_TONE },
9540 { 0x04, 0x04, 0x88, DTMF_SIGNAL_BUSY_TONE },
9541 { 0x04, 0x04, 0x89, DTMF_SIGNAL_CONGESTION_TONE },
9542 { 0x04, 0x04, 0x8a, DTMF_SIGNAL_SPECIAL_INFORMATION_TONE },
9543 { 0x04, 0x04, 0x8b, DTMF_SIGNAL_COMFORT_TONE },
9544 { 0x04, 0x04, 0x8c, DTMF_SIGNAL_HOLD_TONE },
9545 { 0x04, 0x04, 0x8d, DTMF_SIGNAL_RECORD_TONE },
9546 { 0x04, 0x04, 0x8e, DTMF_SIGNAL_CALLER_WAITING_TONE },
9547 { 0x04, 0x04, 0x8f, DTMF_SIGNAL_CALL_WAITING_TONE },
9548 { 0x04, 0x04, 0x90, DTMF_SIGNAL_PAY_TONE },
9549 { 0x04, 0x04, 0x91, DTMF_SIGNAL_POSITIVE_INDICATION_TONE },
9550 { 0x04, 0x04, 0x92, DTMF_SIGNAL_NEGATIVE_INDICATION_TONE },
9551 { 0x04, 0x04, 0x93, DTMF_SIGNAL_WARNING_TONE },
9552 { 0x04, 0x04, 0x94, DTMF_SIGNAL_INTRUSION_TONE },
9553 { 0x04, 0x04, 0x95, DTMF_SIGNAL_CALLING_CARD_SERVICE_TONE },
9554 { 0x04, 0x04, 0x96, DTMF_SIGNAL_PAYPHONE_RECOGNITION_TONE },
9555 { 0x04, 0x04, 0x97, DTMF_SIGNAL_CPE_ALERTING_SIGNAL },
9556 { 0x04, 0x04, 0x98, DTMF_SIGNAL_OFF_HOOK_WARNING_TONE },
9557 { 0x04, 0x04, 0xbf, DTMF_SIGNAL_INTERCEPT_TONE },
9558 { 0x04, 0x04, 0xc0, DTMF_SIGNAL_MODEM_CALLING_TONE },
9559 { 0x04, 0x04, 0xc1, DTMF_SIGNAL_FAX_CALLING_TONE },
9560 { 0x04, 0x04, 0xc2, DTMF_SIGNAL_ANSWER_TONE },
9561 { 0x04, 0x04, 0xc3, DTMF_SIGNAL_REVERSED_ANSWER_TONE },
9562 { 0x04, 0x04, 0xc4, DTMF_SIGNAL_ANSAM_TONE },
9563 { 0x04, 0x04, 0xc5, DTMF_SIGNAL_REVERSED_ANSAM_TONE },
9564 { 0x04, 0x04, 0xc6, DTMF_SIGNAL_BELL103_ANSWER_TONE },
9565 { 0x04, 0x04, 0xc7, DTMF_SIGNAL_FAX_FLAGS },
9566 { 0x04, 0x04, 0xc8, DTMF_SIGNAL_G2_FAX_GROUP_ID },
9567 { 0x00, 0x04, 0xc9, DTMF_SIGNAL_HUMAN_SPEECH },
9568 { 0x04, 0x04, 0xca, DTMF_SIGNAL_ANSWERING_MACHINE_390 },
9569 { 0x02, 0x02, 0xf1, DTMF_MF_DIGIT_TONE_CODE_1 },
9570 { 0x02, 0x02, 0xf2, DTMF_MF_DIGIT_TONE_CODE_2 },
9571 { 0x02, 0x02, 0xf3, DTMF_MF_DIGIT_TONE_CODE_3 },
9572 { 0x02, 0x02, 0xf4, DTMF_MF_DIGIT_TONE_CODE_4 },
9573 { 0x02, 0x02, 0xf5, DTMF_MF_DIGIT_TONE_CODE_5 },
9574 { 0x02, 0x02, 0xf6, DTMF_MF_DIGIT_TONE_CODE_6 },
9575 { 0x02, 0x02, 0xf7, DTMF_MF_DIGIT_TONE_CODE_7 },
9576 { 0x02, 0x02, 0xf8, DTMF_MF_DIGIT_TONE_CODE_8 },
9577 { 0x02, 0x02, 0xf9, DTMF_MF_DIGIT_TONE_CODE_9 },
9578 { 0x02, 0x02, 0xfa, DTMF_MF_DIGIT_TONE_CODE_0 },
9579 { 0x02, 0x02, 0xfb, DTMF_MF_DIGIT_TONE_CODE_K1 },
9580 { 0x02, 0x02, 0xfc, DTMF_MF_DIGIT_TONE_CODE_K2 },
9581 { 0x02, 0x02, 0xfd, DTMF_MF_DIGIT_TONE_CODE_KP },
9582 { 0x02, 0x02, 0xfe, DTMF_MF_DIGIT_TONE_CODE_S1 },
9583 { 0x02, 0x02, 0xff, DTMF_MF_DIGIT_TONE_CODE_ST },
9584
9585 };
9586
9587 #define DTMF_DIGIT_MAP_ENTRIES ARRAY_SIZE(dtmf_digit_map)
9588
9589
9590 static void dtmf_enable_receiver(PLCI *plci, byte enable_mask)
9591 {
9592 word min_digit_duration, min_gap_duration;
9593
9594 dbug(1, dprintf("[%06lx] %s,%d: dtmf_enable_receiver %02x",
9595 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
9596 (char *)(FILE_), __LINE__, enable_mask));
9597
9598 if (enable_mask != 0)
9599 {
9600 min_digit_duration = (plci->dtmf_rec_pulse_ms == 0) ? 40 : plci->dtmf_rec_pulse_ms;
9601 min_gap_duration = (plci->dtmf_rec_pause_ms == 0) ? 40 : plci->dtmf_rec_pause_ms;
9602 plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_ENABLE_RECEIVER;
9603 PUT_WORD(&plci->internal_req_buffer[1], min_digit_duration);
9604 PUT_WORD(&plci->internal_req_buffer[3], min_gap_duration);
9605 plci->NData[0].PLength = 5;
9606
9607 PUT_WORD(&plci->internal_req_buffer[5], INTERNAL_IND_BUFFER_SIZE);
9608 plci->NData[0].PLength += 2;
9609 capidtmf_recv_enable(&(plci->capidtmf_state), min_digit_duration, min_gap_duration);
9610
9611 }
9612 else
9613 {
9614 plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_DISABLE_RECEIVER;
9615 plci->NData[0].PLength = 1;
9616
9617 capidtmf_recv_disable(&(plci->capidtmf_state));
9618
9619 }
9620 plci->NData[0].P = plci->internal_req_buffer;
9621 plci->NL.X = plci->NData;
9622 plci->NL.ReqCh = 0;
9623 plci->NL.Req = plci->nl_req = (byte) N_UDATA;
9624 plci->adapter->request(&plci->NL);
9625 }
9626
9627
9628 static void dtmf_send_digits(PLCI *plci, byte *digit_buffer, word digit_count)
9629 {
9630 word w, i;
9631
9632 dbug(1, dprintf("[%06lx] %s,%d: dtmf_send_digits %d",
9633 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
9634 (char *)(FILE_), __LINE__, digit_count));
9635
9636 plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_SEND_DIGITS;
9637 w = (plci->dtmf_send_pulse_ms == 0) ? 40 : plci->dtmf_send_pulse_ms;
9638 PUT_WORD(&plci->internal_req_buffer[1], w);
9639 w = (plci->dtmf_send_pause_ms == 0) ? 40 : plci->dtmf_send_pause_ms;
9640 PUT_WORD(&plci->internal_req_buffer[3], w);
9641 for (i = 0; i < digit_count; i++)
9642 {
9643 w = 0;
9644 while ((w < DTMF_DIGIT_MAP_ENTRIES)
9645 && (digit_buffer[i] != dtmf_digit_map[w].character))
9646 {
9647 w++;
9648 }
9649 plci->internal_req_buffer[5 + i] = (w < DTMF_DIGIT_MAP_ENTRIES) ?
9650 dtmf_digit_map[w].code : DTMF_DIGIT_TONE_CODE_STAR;
9651 }
9652 plci->NData[0].PLength = 5 + digit_count;
9653 plci->NData[0].P = plci->internal_req_buffer;
9654 plci->NL.X = plci->NData;
9655 plci->NL.ReqCh = 0;
9656 plci->NL.Req = plci->nl_req = (byte) N_UDATA;
9657 plci->adapter->request(&plci->NL);
9658 }
9659
9660
9661 static void dtmf_rec_clear_config(PLCI *plci)
9662 {
9663
9664 dbug(1, dprintf("[%06lx] %s,%d: dtmf_rec_clear_config",
9665 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
9666 (char *)(FILE_), __LINE__));
9667
9668 plci->dtmf_rec_active = 0;
9669 plci->dtmf_rec_pulse_ms = 0;
9670 plci->dtmf_rec_pause_ms = 0;
9671
9672 capidtmf_init(&(plci->capidtmf_state), plci->adapter->u_law);
9673
9674 }
9675
9676
9677 static void dtmf_send_clear_config(PLCI *plci)
9678 {
9679
9680 dbug(1, dprintf("[%06lx] %s,%d: dtmf_send_clear_config",
9681 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
9682 (char *)(FILE_), __LINE__));
9683
9684 plci->dtmf_send_requests = 0;
9685 plci->dtmf_send_pulse_ms = 0;
9686 plci->dtmf_send_pause_ms = 0;
9687 }
9688
9689
9690 static void dtmf_prepare_switch(dword Id, PLCI *plci)
9691 {
9692
9693 dbug(1, dprintf("[%06lx] %s,%d: dtmf_prepare_switch",
9694 UnMapId(Id), (char *)(FILE_), __LINE__));
9695
9696 while (plci->dtmf_send_requests != 0)
9697 dtmf_confirmation(Id, plci);
9698 }
9699
9700
9701 static word dtmf_save_config(dword Id, PLCI *plci, byte Rc)
9702 {
9703
9704 dbug(1, dprintf("[%06lx] %s,%d: dtmf_save_config %02x %d",
9705 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
9706
9707 return (GOOD);
9708 }
9709
9710
9711 static word dtmf_restore_config(dword Id, PLCI *plci, byte Rc)
9712 {
9713 word Info;
9714
9715 dbug(1, dprintf("[%06lx] %s,%d: dtmf_restore_config %02x %d",
9716 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
9717
9718 Info = GOOD;
9719 if (plci->B1_facilities & B1_FACILITY_DTMFR)
9720 {
9721 switch (plci->adjust_b_state)
9722 {
9723 case ADJUST_B_RESTORE_DTMF_1:
9724 plci->internal_command = plci->adjust_b_command;
9725 if (plci_nl_busy(plci))
9726 {
9727 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
9728 break;
9729 }
9730 dtmf_enable_receiver(plci, plci->dtmf_rec_active);
9731 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_2;
9732 break;
9733 case ADJUST_B_RESTORE_DTMF_2:
9734 if ((Rc != OK) && (Rc != OK_FC))
9735 {
9736 dbug(1, dprintf("[%06lx] %s,%d: Reenable DTMF receiver failed %02x",
9737 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
9738 Info = _WRONG_STATE;
9739 break;
9740 }
9741 break;
9742 }
9743 }
9744 return (Info);
9745 }
9746
9747
9748 static void dtmf_command(dword Id, PLCI *plci, byte Rc)
9749 {
9750 word internal_command, Info;
9751 byte mask;
9752 byte result[4];
9753
9754 dbug(1, dprintf("[%06lx] %s,%d: dtmf_command %02x %04x %04x %d %d %d %d",
9755 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command,
9756 plci->dtmf_cmd, plci->dtmf_rec_pulse_ms, plci->dtmf_rec_pause_ms,
9757 plci->dtmf_send_pulse_ms, plci->dtmf_send_pause_ms));
9758
9759 Info = GOOD;
9760 result[0] = 2;
9761 PUT_WORD(&result[1], DTMF_SUCCESS);
9762 internal_command = plci->internal_command;
9763 plci->internal_command = 0;
9764 mask = 0x01;
9765 switch (plci->dtmf_cmd)
9766 {
9767
9768 case DTMF_LISTEN_TONE_START:
9769 mask <<= 1;
9770 case DTMF_LISTEN_MF_START:
9771 mask <<= 1;
9772
9773 case DTMF_LISTEN_START:
9774 switch (internal_command)
9775 {
9776 default:
9777 adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities |
9778 B1_FACILITY_DTMFR), DTMF_COMMAND_1);
9779 case DTMF_COMMAND_1:
9780 if (adjust_b_process(Id, plci, Rc) != GOOD)
9781 {
9782 dbug(1, dprintf("[%06lx] %s,%d: Load DTMF failed",
9783 UnMapId(Id), (char *)(FILE_), __LINE__));
9784 Info = _FACILITY_NOT_SUPPORTED;
9785 break;
9786 }
9787 if (plci->internal_command)
9788 return;
9789 case DTMF_COMMAND_2:
9790 if (plci_nl_busy(plci))
9791 {
9792 plci->internal_command = DTMF_COMMAND_2;
9793 return;
9794 }
9795 plci->internal_command = DTMF_COMMAND_3;
9796 dtmf_enable_receiver(plci, (byte)(plci->dtmf_rec_active | mask));
9797 return;
9798 case DTMF_COMMAND_3:
9799 if ((Rc != OK) && (Rc != OK_FC))
9800 {
9801 dbug(1, dprintf("[%06lx] %s,%d: Enable DTMF receiver failed %02x",
9802 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
9803 Info = _FACILITY_NOT_SUPPORTED;
9804 break;
9805 }
9806
9807 plci->tone_last_indication_code = DTMF_SIGNAL_NO_TONE;
9808
9809 plci->dtmf_rec_active |= mask;
9810 break;
9811 }
9812 break;
9813
9814
9815 case DTMF_LISTEN_TONE_STOP:
9816 mask <<= 1;
9817 case DTMF_LISTEN_MF_STOP:
9818 mask <<= 1;
9819
9820 case DTMF_LISTEN_STOP:
9821 switch (internal_command)
9822 {
9823 default:
9824 plci->dtmf_rec_active &= ~mask;
9825 if (plci->dtmf_rec_active)
9826 break;
9827 /*
9828 case DTMF_COMMAND_1:
9829 if (plci->dtmf_rec_active)
9830 {
9831 if (plci_nl_busy (plci))
9832 {
9833 plci->internal_command = DTMF_COMMAND_1;
9834 return;
9835 }
9836 plci->dtmf_rec_active &= ~mask;
9837 plci->internal_command = DTMF_COMMAND_2;
9838 dtmf_enable_receiver (plci, false);
9839 return;
9840 }
9841 Rc = OK;
9842 case DTMF_COMMAND_2:
9843 if ((Rc != OK) && (Rc != OK_FC))
9844 {
9845 dbug (1, dprintf("[%06lx] %s,%d: Disable DTMF receiver failed %02x",
9846 UnMapId (Id), (char far *)(FILE_), __LINE__, Rc));
9847 Info = _FACILITY_NOT_SUPPORTED;
9848 break;
9849 }
9850 */
9851 adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities &
9852 ~(B1_FACILITY_DTMFX | B1_FACILITY_DTMFR)), DTMF_COMMAND_3);
9853 case DTMF_COMMAND_3:
9854 if (adjust_b_process(Id, plci, Rc) != GOOD)
9855 {
9856 dbug(1, dprintf("[%06lx] %s,%d: Unload DTMF failed",
9857 UnMapId(Id), (char *)(FILE_), __LINE__));
9858 Info = _FACILITY_NOT_SUPPORTED;
9859 break;
9860 }
9861 if (plci->internal_command)
9862 return;
9863 break;
9864 }
9865 break;
9866
9867
9868 case DTMF_SEND_TONE:
9869 mask <<= 1;
9870 case DTMF_SEND_MF:
9871 mask <<= 1;
9872
9873 case DTMF_DIGITS_SEND:
9874 switch (internal_command)
9875 {
9876 default:
9877 adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities |
9878 ((plci->dtmf_parameter_length != 0) ? B1_FACILITY_DTMFX | B1_FACILITY_DTMFR : B1_FACILITY_DTMFX)),
9879 DTMF_COMMAND_1);
9880 case DTMF_COMMAND_1:
9881 if (adjust_b_process(Id, plci, Rc) != GOOD)
9882 {
9883 dbug(1, dprintf("[%06lx] %s,%d: Load DTMF failed",
9884 UnMapId(Id), (char *)(FILE_), __LINE__));
9885 Info = _FACILITY_NOT_SUPPORTED;
9886 break;
9887 }
9888 if (plci->internal_command)
9889 return;
9890 case DTMF_COMMAND_2:
9891 if (plci_nl_busy(plci))
9892 {
9893 plci->internal_command = DTMF_COMMAND_2;
9894 return;
9895 }
9896 plci->dtmf_msg_number_queue[(plci->dtmf_send_requests)++] = plci->number;
9897 plci->internal_command = DTMF_COMMAND_3;
9898 dtmf_send_digits(plci, &plci->saved_msg.parms[3].info[1], plci->saved_msg.parms[3].length);
9899 return;
9900 case DTMF_COMMAND_3:
9901 if ((Rc != OK) && (Rc != OK_FC))
9902 {
9903 dbug(1, dprintf("[%06lx] %s,%d: Send DTMF digits failed %02x",
9904 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
9905 if (plci->dtmf_send_requests != 0)
9906 (plci->dtmf_send_requests)--;
9907 Info = _FACILITY_NOT_SUPPORTED;
9908 break;
9909 }
9910 return;
9911 }
9912 break;
9913 }
9914 sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->number,
9915 "wws", Info, SELECTOR_DTMF, result);
9916 }
9917
9918
9919 static byte dtmf_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg)
9920 {
9921 word Info;
9922 word i, j;
9923 byte mask;
9924 API_PARSE dtmf_parms[5];
9925 byte result[40];
9926
9927 dbug(1, dprintf("[%06lx] %s,%d: dtmf_request",
9928 UnMapId(Id), (char *)(FILE_), __LINE__));
9929
9930 Info = GOOD;
9931 result[0] = 2;
9932 PUT_WORD(&result[1], DTMF_SUCCESS);
9933 if (!(a->profile.Global_Options & GL_DTMF_SUPPORTED))
9934 {
9935 dbug(1, dprintf("[%06lx] %s,%d: Facility not supported",
9936 UnMapId(Id), (char *)(FILE_), __LINE__));
9937 Info = _FACILITY_NOT_SUPPORTED;
9938 }
9939 else if (api_parse(&msg[1].info[1], msg[1].length, "w", dtmf_parms))
9940 {
9941 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
9942 UnMapId(Id), (char *)(FILE_), __LINE__));
9943 Info = _WRONG_MESSAGE_FORMAT;
9944 }
9945
9946 else if ((GET_WORD(dtmf_parms[0].info) == DTMF_GET_SUPPORTED_DETECT_CODES)
9947 || (GET_WORD(dtmf_parms[0].info) == DTMF_GET_SUPPORTED_SEND_CODES))
9948 {
9949 if (!((a->requested_options_table[appl->Id - 1])
9950 & (1L << PRIVATE_DTMF_TONE)))
9951 {
9952 dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x",
9953 UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(dtmf_parms[0].info)));
9954 PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST);
9955 }
9956 else
9957 {
9958 for (i = 0; i < 32; i++)
9959 result[4 + i] = 0;
9960 if (GET_WORD(dtmf_parms[0].info) == DTMF_GET_SUPPORTED_DETECT_CODES)
9961 {
9962 for (i = 0; i < DTMF_DIGIT_MAP_ENTRIES; i++)
9963 {
9964 if (dtmf_digit_map[i].listen_mask != 0)
9965 result[4 + (dtmf_digit_map[i].character >> 3)] |= (1 << (dtmf_digit_map[i].character & 0x7));
9966 }
9967 }
9968 else
9969 {
9970 for (i = 0; i < DTMF_DIGIT_MAP_ENTRIES; i++)
9971 {
9972 if (dtmf_digit_map[i].send_mask != 0)
9973 result[4 + (dtmf_digit_map[i].character >> 3)] |= (1 << (dtmf_digit_map[i].character & 0x7));
9974 }
9975 }
9976 result[0] = 3 + 32;
9977 result[3] = 32;
9978 }
9979 }
9980
9981 else if (plci == NULL)
9982 {
9983 dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI",
9984 UnMapId(Id), (char *)(FILE_), __LINE__));
9985 Info = _WRONG_IDENTIFIER;
9986 }
9987 else
9988 {
9989 if (!plci->State
9990 || !plci->NL.Id || plci->nl_remove_id)
9991 {
9992 dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
9993 UnMapId(Id), (char *)(FILE_), __LINE__));
9994 Info = _WRONG_STATE;
9995 }
9996 else
9997 {
9998 plci->command = 0;
9999 plci->dtmf_cmd = GET_WORD(dtmf_parms[0].info);
10000 mask = 0x01;
10001 switch (plci->dtmf_cmd)
10002 {
10003
10004 case DTMF_LISTEN_TONE_START:
10005 case DTMF_LISTEN_TONE_STOP:
10006 mask <<= 1;
10007 case DTMF_LISTEN_MF_START:
10008 case DTMF_LISTEN_MF_STOP:
10009 mask <<= 1;
10010 if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[appl->Id - 1])
10011 & (1L << PRIVATE_DTMF_TONE)))
10012 {
10013 dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x",
10014 UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(dtmf_parms[0].info)));
10015 PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST);
10016 break;
10017 }
10018
10019 case DTMF_LISTEN_START:
10020 case DTMF_LISTEN_STOP:
10021 if (!(a->manufacturer_features & MANUFACTURER_FEATURE_HARDDTMF)
10022 && !(a->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE))
10023 {
10024 dbug(1, dprintf("[%06lx] %s,%d: Facility not supported",
10025 UnMapId(Id), (char *)(FILE_), __LINE__));
10026 Info = _FACILITY_NOT_SUPPORTED;
10027 break;
10028 }
10029 if (mask & DTMF_LISTEN_ACTIVE_FLAG)
10030 {
10031 if (api_parse(&msg[1].info[1], msg[1].length, "wwws", dtmf_parms))
10032 {
10033 plci->dtmf_rec_pulse_ms = 0;
10034 plci->dtmf_rec_pause_ms = 0;
10035 }
10036 else
10037 {
10038 plci->dtmf_rec_pulse_ms = GET_WORD(dtmf_parms[1].info);
10039 plci->dtmf_rec_pause_ms = GET_WORD(dtmf_parms[2].info);
10040 }
10041 }
10042 start_internal_command(Id, plci, dtmf_command);
10043 return (false);
10044
10045
10046 case DTMF_SEND_TONE:
10047 mask <<= 1;
10048 case DTMF_SEND_MF:
10049 mask <<= 1;
10050 if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[appl->Id - 1])
10051 & (1L << PRIVATE_DTMF_TONE)))
10052 {
10053 dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x",
10054 UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(dtmf_parms[0].info)));
10055 PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST);
10056 break;
10057 }
10058
10059 case DTMF_DIGITS_SEND:
10060 if (api_parse(&msg[1].info[1], msg[1].length, "wwws", dtmf_parms))
10061 {
10062 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
10063 UnMapId(Id), (char *)(FILE_), __LINE__));
10064 Info = _WRONG_MESSAGE_FORMAT;
10065 break;
10066 }
10067 if (mask & DTMF_LISTEN_ACTIVE_FLAG)
10068 {
10069 plci->dtmf_send_pulse_ms = GET_WORD(dtmf_parms[1].info);
10070 plci->dtmf_send_pause_ms = GET_WORD(dtmf_parms[2].info);
10071 }
10072 i = 0;
10073 j = 0;
10074 while ((i < dtmf_parms[3].length) && (j < DTMF_DIGIT_MAP_ENTRIES))
10075 {
10076 j = 0;
10077 while ((j < DTMF_DIGIT_MAP_ENTRIES)
10078 && ((dtmf_parms[3].info[i + 1] != dtmf_digit_map[j].character)
10079 || ((dtmf_digit_map[j].send_mask & mask) == 0)))
10080 {
10081 j++;
10082 }
10083 i++;
10084 }
10085 if (j == DTMF_DIGIT_MAP_ENTRIES)
10086 {
10087 dbug(1, dprintf("[%06lx] %s,%d: Incorrect DTMF digit %02x",
10088 UnMapId(Id), (char *)(FILE_), __LINE__, dtmf_parms[3].info[i]));
10089 PUT_WORD(&result[1], DTMF_INCORRECT_DIGIT);
10090 break;
10091 }
10092 if (plci->dtmf_send_requests >= ARRAY_SIZE(plci->dtmf_msg_number_queue))
10093 {
10094 dbug(1, dprintf("[%06lx] %s,%d: DTMF request overrun",
10095 UnMapId(Id), (char *)(FILE_), __LINE__));
10096 Info = _WRONG_STATE;
10097 break;
10098 }
10099 api_save_msg(dtmf_parms, "wwws", &plci->saved_msg);
10100 start_internal_command(Id, plci, dtmf_command);
10101 return (false);
10102
10103 default:
10104 dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x",
10105 UnMapId(Id), (char *)(FILE_), __LINE__, plci->dtmf_cmd));
10106 PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST);
10107 }
10108 }
10109 }
10110 sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
10111 "wws", Info, SELECTOR_DTMF, result);
10112 return (false);
10113 }
10114
10115
10116 static void dtmf_confirmation(dword Id, PLCI *plci)
10117 {
10118 word i;
10119 byte result[4];
10120
10121 dbug(1, dprintf("[%06lx] %s,%d: dtmf_confirmation",
10122 UnMapId(Id), (char *)(FILE_), __LINE__));
10123
10124 result[0] = 2;
10125 PUT_WORD(&result[1], DTMF_SUCCESS);
10126 if (plci->dtmf_send_requests != 0)
10127 {
10128 sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->dtmf_msg_number_queue[0],
10129 "wws", GOOD, SELECTOR_DTMF, result);
10130 (plci->dtmf_send_requests)--;
10131 for (i = 0; i < plci->dtmf_send_requests; i++)
10132 plci->dtmf_msg_number_queue[i] = plci->dtmf_msg_number_queue[i + 1];
10133 }
10134 }
10135
10136
10137 static void dtmf_indication(dword Id, PLCI *plci, byte *msg, word length)
10138 {
10139 word i, j, n;
10140
10141 dbug(1, dprintf("[%06lx] %s,%d: dtmf_indication",
10142 UnMapId(Id), (char *)(FILE_), __LINE__));
10143
10144 n = 0;
10145 for (i = 1; i < length; i++)
10146 {
10147 j = 0;
10148 while ((j < DTMF_DIGIT_MAP_ENTRIES)
10149 && ((msg[i] != dtmf_digit_map[j].code)
10150 || ((dtmf_digit_map[j].listen_mask & plci->dtmf_rec_active) == 0)))
10151 {
10152 j++;
10153 }
10154 if (j < DTMF_DIGIT_MAP_ENTRIES)
10155 {
10156
10157 if ((dtmf_digit_map[j].listen_mask & DTMF_TONE_LISTEN_ACTIVE_FLAG)
10158 && (plci->tone_last_indication_code == DTMF_SIGNAL_NO_TONE)
10159 && (dtmf_digit_map[j].character != DTMF_SIGNAL_UNIDENTIFIED_TONE))
10160 {
10161 if (n + 1 == i)
10162 {
10163 for (i = length; i > n + 1; i--)
10164 msg[i] = msg[i - 1];
10165 length++;
10166 i++;
10167 }
10168 msg[++n] = DTMF_SIGNAL_UNIDENTIFIED_TONE;
10169 }
10170 plci->tone_last_indication_code = dtmf_digit_map[j].character;
10171
10172 msg[++n] = dtmf_digit_map[j].character;
10173 }
10174 }
10175 if (n != 0)
10176 {
10177 msg[0] = (byte) n;
10178 sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "wS", SELECTOR_DTMF, msg);
10179 }
10180 }
10181
10182
10183 /*------------------------------------------------------------------*/
10184 /* DTMF parameters */
10185 /*------------------------------------------------------------------*/
10186
10187 static void dtmf_parameter_write(PLCI *plci)
10188 {
10189 word i;
10190 byte parameter_buffer[DTMF_PARAMETER_BUFFER_SIZE + 2];
10191
10192 dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_write",
10193 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10194 (char *)(FILE_), __LINE__));
10195
10196 parameter_buffer[0] = plci->dtmf_parameter_length + 1;
10197 parameter_buffer[1] = DSP_CTRL_SET_DTMF_PARAMETERS;
10198 for (i = 0; i < plci->dtmf_parameter_length; i++)
10199 parameter_buffer[2 + i] = plci->dtmf_parameter_buffer[i];
10200 add_p(plci, FTY, parameter_buffer);
10201 sig_req(plci, TEL_CTRL, 0);
10202 send_req(plci);
10203 }
10204
10205
10206 static void dtmf_parameter_clear_config(PLCI *plci)
10207 {
10208
10209 dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_clear_config",
10210 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10211 (char *)(FILE_), __LINE__));
10212
10213 plci->dtmf_parameter_length = 0;
10214 }
10215
10216
10217 static void dtmf_parameter_prepare_switch(dword Id, PLCI *plci)
10218 {
10219
10220 dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_prepare_switch",
10221 UnMapId(Id), (char *)(FILE_), __LINE__));
10222
10223 }
10224
10225
10226 static word dtmf_parameter_save_config(dword Id, PLCI *plci, byte Rc)
10227 {
10228
10229 dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_save_config %02x %d",
10230 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
10231
10232 return (GOOD);
10233 }
10234
10235
10236 static word dtmf_parameter_restore_config(dword Id, PLCI *plci, byte Rc)
10237 {
10238 word Info;
10239
10240 dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_restore_config %02x %d",
10241 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
10242
10243 Info = GOOD;
10244 if ((plci->B1_facilities & B1_FACILITY_DTMFR)
10245 && (plci->dtmf_parameter_length != 0))
10246 {
10247 switch (plci->adjust_b_state)
10248 {
10249 case ADJUST_B_RESTORE_DTMF_PARAMETER_1:
10250 plci->internal_command = plci->adjust_b_command;
10251 if (plci->sig_req)
10252 {
10253 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_1;
10254 break;
10255 }
10256 dtmf_parameter_write(plci);
10257 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_2;
10258 break;
10259 case ADJUST_B_RESTORE_DTMF_PARAMETER_2:
10260 if ((Rc != OK) && (Rc != OK_FC))
10261 {
10262 dbug(1, dprintf("[%06lx] %s,%d: Restore DTMF parameters failed %02x",
10263 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
10264 Info = _WRONG_STATE;
10265 break;
10266 }
10267 break;
10268 }
10269 }
10270 return (Info);
10271 }
10272
10273
10274 /*------------------------------------------------------------------*/
10275 /* Line interconnect facilities */
10276 /*------------------------------------------------------------------*/
10277
10278
10279 LI_CONFIG *li_config_table;
10280 word li_total_channels;
10281
10282
10283 /*------------------------------------------------------------------*/
10284 /* translate a CHI information element to a channel number */
10285 /* returns 0xff - any channel */
10286 /* 0xfe - chi wrong coding */
10287 /* 0xfd - D-channel */
10288 /* 0x00 - no channel */
10289 /* else channel number / PRI: timeslot */
10290 /* if channels is provided we accept more than one channel. */
10291 /*------------------------------------------------------------------*/
10292
10293 static byte chi_to_channel(byte *chi, dword *pchannelmap)
10294 {
10295 int p;
10296 int i;
10297 dword map;
10298 byte excl;
10299 byte ofs;
10300 byte ch;
10301
10302 if (pchannelmap) *pchannelmap = 0;
10303 if (!chi[0]) return 0xff;
10304 excl = 0;
10305
10306 if (chi[1] & 0x20) {
10307 if (chi[0] == 1 && chi[1] == 0xac) return 0xfd; /* exclusive d-channel */
10308 for (i = 1; i < chi[0] && !(chi[i] & 0x80); i++);
10309 if (i == chi[0] || !(chi[i] & 0x80)) return 0xfe;
10310 if ((chi[1] | 0xc8) != 0xe9) return 0xfe;
10311 if (chi[1] & 0x08) excl = 0x40;
10312
10313 /* int. id present */
10314 if (chi[1] & 0x40) {
10315 p = i + 1;
10316 for (i = p; i < chi[0] && !(chi[i] & 0x80); i++);
10317 if (i == chi[0] || !(chi[i] & 0x80)) return 0xfe;
10318 }
10319
10320 /* coding standard, Number/Map, Channel Type */
10321 p = i + 1;
10322 for (i = p; i < chi[0] && !(chi[i] & 0x80); i++);
10323 if (i == chi[0] || !(chi[i] & 0x80)) return 0xfe;
10324 if ((chi[p] | 0xd0) != 0xd3) return 0xfe;
10325
10326 /* Number/Map */
10327 if (chi[p] & 0x10) {
10328
10329 /* map */
10330 if ((chi[0] - p) == 4) ofs = 0;
10331 else if ((chi[0] - p) == 3) ofs = 1;
10332 else return 0xfe;
10333 ch = 0;
10334 map = 0;
10335 for (i = 0; i < 4 && p < chi[0]; i++) {
10336 p++;
10337 ch += 8;
10338 map <<= 8;
10339 if (chi[p]) {
10340 for (ch = 0; !(chi[p] & (1 << ch)); ch++);
10341 map |= chi[p];
10342 }
10343 }
10344 ch += ofs;
10345 map <<= ofs;
10346 }
10347 else {
10348
10349 /* number */
10350 p = i + 1;
10351 ch = chi[p] & 0x3f;
10352 if (pchannelmap) {
10353 if ((byte)(chi[0] - p) > 30) return 0xfe;
10354 map = 0;
10355 for (i = p; i <= chi[0]; i++) {
10356 if ((chi[i] & 0x7f) > 31) return 0xfe;
10357 map |= (1L << (chi[i] & 0x7f));
10358 }
10359 }
10360 else {
10361 if (p != chi[0]) return 0xfe;
10362 if (ch > 31) return 0xfe;
10363 map = (1L << ch);
10364 }
10365 if (chi[p] & 0x40) return 0xfe;
10366 }
10367 if (pchannelmap) *pchannelmap = map;
10368 else if (map != ((dword)(1L << ch))) return 0xfe;
10369 return (byte)(excl | ch);
10370 }
10371 else { /* not PRI */
10372 for (i = 1; i < chi[0] && !(chi[i] & 0x80); i++);
10373 if (i != chi[0] || !(chi[i] & 0x80)) return 0xfe;
10374 if (chi[1] & 0x08) excl = 0x40;
10375
10376 switch (chi[1] | 0x98) {
10377 case 0x98: return 0;
10378 case 0x99:
10379 if (pchannelmap) *pchannelmap = 2;
10380 return excl | 1;
10381 case 0x9a:
10382 if (pchannelmap) *pchannelmap = 4;
10383 return excl | 2;
10384 case 0x9b: return 0xff;
10385 case 0x9c: return 0xfd; /* d-ch */
10386 default: return 0xfe;
10387 }
10388 }
10389 }
10390
10391
10392 static void mixer_set_bchannel_id_esc(PLCI *plci, byte bchannel_id)
10393 {
10394 DIVA_CAPI_ADAPTER *a;
10395 PLCI *splci;
10396 byte old_id;
10397
10398 a = plci->adapter;
10399 old_id = plci->li_bchannel_id;
10400 if (a->li_pri)
10401 {
10402 if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10403 li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10404 plci->li_bchannel_id = (bchannel_id & 0x1f) + 1;
10405 if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10406 li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10407 }
10408 else
10409 {
10410 if (((bchannel_id & 0x03) == 1) || ((bchannel_id & 0x03) == 2))
10411 {
10412 if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10413 li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10414 plci->li_bchannel_id = bchannel_id & 0x03;
10415 if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI != plci) && (a->AdvSignalPLCI->tel == ADV_VOICE))
10416 {
10417 splci = a->AdvSignalPLCI;
10418 if (li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci == NULL)
10419 {
10420 if ((splci->li_bchannel_id != 0)
10421 && (li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci == splci))
10422 {
10423 li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci = NULL;
10424 }
10425 splci->li_bchannel_id = 3 - plci->li_bchannel_id;
10426 li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci = splci;
10427 dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id_esc %d",
10428 (dword)((splci->Id << 8) | UnMapController(splci->adapter->Id)),
10429 (char *)(FILE_), __LINE__, splci->li_bchannel_id));
10430 }
10431 }
10432 if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10433 li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10434 }
10435 }
10436 if ((old_id == 0) && (plci->li_bchannel_id != 0)
10437 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
10438 {
10439 mixer_clear_config(plci);
10440 }
10441 dbug(1, dprintf("[%06lx] %s,%d: mixer_set_bchannel_id_esc %d %d",
10442 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10443 (char *)(FILE_), __LINE__, bchannel_id, plci->li_bchannel_id));
10444 }
10445
10446
10447 static void mixer_set_bchannel_id(PLCI *plci, byte *chi)
10448 {
10449 DIVA_CAPI_ADAPTER *a;
10450 PLCI *splci;
10451 byte ch, old_id;
10452
10453 a = plci->adapter;
10454 old_id = plci->li_bchannel_id;
10455 ch = chi_to_channel(chi, NULL);
10456 if (!(ch & 0x80))
10457 {
10458 if (a->li_pri)
10459 {
10460 if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10461 li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10462 plci->li_bchannel_id = (ch & 0x1f) + 1;
10463 if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10464 li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10465 }
10466 else
10467 {
10468 if (((ch & 0x1f) == 1) || ((ch & 0x1f) == 2))
10469 {
10470 if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
10471 li_config_table[a->li_base + (old_id - 1)].plci = NULL;
10472 plci->li_bchannel_id = ch & 0x1f;
10473 if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI != plci) && (a->AdvSignalPLCI->tel == ADV_VOICE))
10474 {
10475 splci = a->AdvSignalPLCI;
10476 if (li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci == NULL)
10477 {
10478 if ((splci->li_bchannel_id != 0)
10479 && (li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci == splci))
10480 {
10481 li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci = NULL;
10482 }
10483 splci->li_bchannel_id = 3 - plci->li_bchannel_id;
10484 li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci = splci;
10485 dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id %d",
10486 (dword)((splci->Id << 8) | UnMapController(splci->adapter->Id)),
10487 (char *)(FILE_), __LINE__, splci->li_bchannel_id));
10488 }
10489 }
10490 if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
10491 li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
10492 }
10493 }
10494 }
10495 if ((old_id == 0) && (plci->li_bchannel_id != 0)
10496 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
10497 {
10498 mixer_clear_config(plci);
10499 }
10500 dbug(1, dprintf("[%06lx] %s,%d: mixer_set_bchannel_id %02x %d",
10501 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10502 (char *)(FILE_), __LINE__, ch, plci->li_bchannel_id));
10503 }
10504
10505
10506 #define MIXER_MAX_DUMP_CHANNELS 34
10507
10508 static void mixer_calculate_coefs(DIVA_CAPI_ADAPTER *a)
10509 {
10510 static char hex_digit_table[0x10] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
10511 word n, i, j;
10512 char *p;
10513 char hex_line[2 * MIXER_MAX_DUMP_CHANNELS + MIXER_MAX_DUMP_CHANNELS / 8 + 4];
10514
10515 dbug(1, dprintf("[%06lx] %s,%d: mixer_calculate_coefs",
10516 (dword)(UnMapController(a->Id)), (char *)(FILE_), __LINE__));
10517
10518 for (i = 0; i < li_total_channels; i++)
10519 {
10520 li_config_table[i].channel &= LI_CHANNEL_ADDRESSES_SET;
10521 if (li_config_table[i].chflags != 0)
10522 li_config_table[i].channel |= LI_CHANNEL_INVOLVED;
10523 else
10524 {
10525 for (j = 0; j < li_total_channels; j++)
10526 {
10527 if (((li_config_table[i].flag_table[j]) != 0)
10528 || ((li_config_table[j].flag_table[i]) != 0))
10529 {
10530 li_config_table[i].channel |= LI_CHANNEL_INVOLVED;
10531 }
10532 if (((li_config_table[i].flag_table[j] & LI_FLAG_CONFERENCE) != 0)
10533 || ((li_config_table[j].flag_table[i] & LI_FLAG_CONFERENCE) != 0))
10534 {
10535 li_config_table[i].channel |= LI_CHANNEL_CONFERENCE;
10536 }
10537 }
10538 }
10539 }
10540 for (i = 0; i < li_total_channels; i++)
10541 {
10542 for (j = 0; j < li_total_channels; j++)
10543 {
10544 li_config_table[i].coef_table[j] &= ~(LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC);
10545 if (li_config_table[i].flag_table[j] & LI_FLAG_CONFERENCE)
10546 li_config_table[i].coef_table[j] |= LI_COEF_CH_CH;
10547 }
10548 }
10549 for (n = 0; n < li_total_channels; n++)
10550 {
10551 if (li_config_table[n].channel & LI_CHANNEL_CONFERENCE)
10552 {
10553 for (i = 0; i < li_total_channels; i++)
10554 {
10555 if (li_config_table[i].channel & LI_CHANNEL_CONFERENCE)
10556 {
10557 for (j = 0; j < li_total_channels; j++)
10558 {
10559 li_config_table[i].coef_table[j] |=
10560 li_config_table[i].coef_table[n] & li_config_table[n].coef_table[j];
10561 }
10562 }
10563 }
10564 }
10565 }
10566 for (i = 0; i < li_total_channels; i++)
10567 {
10568 if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10569 {
10570 li_config_table[i].coef_table[i] &= ~LI_COEF_CH_CH;
10571 for (j = 0; j < li_total_channels; j++)
10572 {
10573 if (li_config_table[i].coef_table[j] & LI_COEF_CH_CH)
10574 li_config_table[i].flag_table[j] |= LI_FLAG_CONFERENCE;
10575 }
10576 if (li_config_table[i].flag_table[i] & LI_FLAG_CONFERENCE)
10577 li_config_table[i].coef_table[i] |= LI_COEF_CH_CH;
10578 }
10579 }
10580 for (i = 0; i < li_total_channels; i++)
10581 {
10582 if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10583 {
10584 for (j = 0; j < li_total_channels; j++)
10585 {
10586 if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
10587 li_config_table[i].coef_table[j] |= LI_COEF_CH_CH;
10588 if (li_config_table[i].flag_table[j] & LI_FLAG_MONITOR)
10589 li_config_table[i].coef_table[j] |= LI_COEF_CH_PC;
10590 if (li_config_table[i].flag_table[j] & LI_FLAG_MIX)
10591 li_config_table[i].coef_table[j] |= LI_COEF_PC_CH;
10592 if (li_config_table[i].flag_table[j] & LI_FLAG_PCCONNECT)
10593 li_config_table[i].coef_table[j] |= LI_COEF_PC_PC;
10594 }
10595 if (li_config_table[i].chflags & LI_CHFLAG_MONITOR)
10596 {
10597 for (j = 0; j < li_total_channels; j++)
10598 {
10599 if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
10600 {
10601 li_config_table[i].coef_table[j] |= LI_COEF_CH_PC;
10602 if (li_config_table[j].chflags & LI_CHFLAG_MIX)
10603 li_config_table[i].coef_table[j] |= LI_COEF_PC_CH | LI_COEF_PC_PC;
10604 }
10605 }
10606 }
10607 if (li_config_table[i].chflags & LI_CHFLAG_MIX)
10608 {
10609 for (j = 0; j < li_total_channels; j++)
10610 {
10611 if (li_config_table[j].flag_table[i] & LI_FLAG_INTERCONNECT)
10612 li_config_table[j].coef_table[i] |= LI_COEF_PC_CH;
10613 }
10614 }
10615 if (li_config_table[i].chflags & LI_CHFLAG_LOOP)
10616 {
10617 for (j = 0; j < li_total_channels; j++)
10618 {
10619 if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
10620 {
10621 for (n = 0; n < li_total_channels; n++)
10622 {
10623 if (li_config_table[n].flag_table[i] & LI_FLAG_INTERCONNECT)
10624 {
10625 li_config_table[n].coef_table[j] |= LI_COEF_CH_CH;
10626 if (li_config_table[j].chflags & LI_CHFLAG_MIX)
10627 {
10628 li_config_table[n].coef_table[j] |= LI_COEF_PC_CH;
10629 if (li_config_table[n].chflags & LI_CHFLAG_MONITOR)
10630 li_config_table[n].coef_table[j] |= LI_COEF_CH_PC | LI_COEF_PC_PC;
10631 }
10632 else if (li_config_table[n].chflags & LI_CHFLAG_MONITOR)
10633 li_config_table[n].coef_table[j] |= LI_COEF_CH_PC;
10634 }
10635 }
10636 }
10637 }
10638 }
10639 }
10640 }
10641 for (i = 0; i < li_total_channels; i++)
10642 {
10643 if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10644 {
10645 if (li_config_table[i].chflags & (LI_CHFLAG_MONITOR | LI_CHFLAG_MIX | LI_CHFLAG_LOOP))
10646 li_config_table[i].channel |= LI_CHANNEL_ACTIVE;
10647 if (li_config_table[i].chflags & LI_CHFLAG_MONITOR)
10648 li_config_table[i].channel |= LI_CHANNEL_RX_DATA;
10649 if (li_config_table[i].chflags & LI_CHFLAG_MIX)
10650 li_config_table[i].channel |= LI_CHANNEL_TX_DATA;
10651 for (j = 0; j < li_total_channels; j++)
10652 {
10653 if ((li_config_table[i].flag_table[j] &
10654 (LI_FLAG_INTERCONNECT | LI_FLAG_PCCONNECT | LI_FLAG_CONFERENCE | LI_FLAG_MONITOR))
10655 || (li_config_table[j].flag_table[i] &
10656 (LI_FLAG_INTERCONNECT | LI_FLAG_PCCONNECT | LI_FLAG_CONFERENCE | LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX)))
10657 {
10658 li_config_table[i].channel |= LI_CHANNEL_ACTIVE;
10659 }
10660 if (li_config_table[i].flag_table[j] & (LI_FLAG_PCCONNECT | LI_FLAG_MONITOR))
10661 li_config_table[i].channel |= LI_CHANNEL_RX_DATA;
10662 if (li_config_table[j].flag_table[i] & (LI_FLAG_PCCONNECT | LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX))
10663 li_config_table[i].channel |= LI_CHANNEL_TX_DATA;
10664 }
10665 if (!(li_config_table[i].channel & LI_CHANNEL_ACTIVE))
10666 {
10667 li_config_table[i].coef_table[i] |= LI_COEF_PC_CH | LI_COEF_CH_PC;
10668 li_config_table[i].channel |= LI_CHANNEL_TX_DATA | LI_CHANNEL_RX_DATA;
10669 }
10670 }
10671 }
10672 for (i = 0; i < li_total_channels; i++)
10673 {
10674 if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
10675 {
10676 j = 0;
10677 while ((j < li_total_channels) && !(li_config_table[i].flag_table[j] & LI_FLAG_ANNOUNCEMENT))
10678 j++;
10679 if (j < li_total_channels)
10680 {
10681 for (j = 0; j < li_total_channels; j++)
10682 {
10683 li_config_table[i].coef_table[j] &= ~(LI_COEF_CH_CH | LI_COEF_PC_CH);
10684 if (li_config_table[i].flag_table[j] & LI_FLAG_ANNOUNCEMENT)
10685 li_config_table[i].coef_table[j] |= LI_COEF_PC_CH;
10686 }
10687 }
10688 }
10689 }
10690 n = li_total_channels;
10691 if (n > MIXER_MAX_DUMP_CHANNELS)
10692 n = MIXER_MAX_DUMP_CHANNELS;
10693 p = hex_line;
10694 for (j = 0; j < n; j++)
10695 {
10696 if ((j & 0x7) == 0)
10697 *(p++) = ' ';
10698 *(p++) = hex_digit_table[li_config_table[j].curchnl >> 4];
10699 *(p++) = hex_digit_table[li_config_table[j].curchnl & 0xf];
10700 }
10701 *p = '\0';
10702 dbug(1, dprintf("[%06lx] CURRENT %s",
10703 (dword)(UnMapController(a->Id)), (char *)hex_line));
10704 p = hex_line;
10705 for (j = 0; j < n; j++)
10706 {
10707 if ((j & 0x7) == 0)
10708 *(p++) = ' ';
10709 *(p++) = hex_digit_table[li_config_table[j].channel >> 4];
10710 *(p++) = hex_digit_table[li_config_table[j].channel & 0xf];
10711 }
10712 *p = '\0';
10713 dbug(1, dprintf("[%06lx] CHANNEL %s",
10714 (dword)(UnMapController(a->Id)), (char *)hex_line));
10715 p = hex_line;
10716 for (j = 0; j < n; j++)
10717 {
10718 if ((j & 0x7) == 0)
10719 *(p++) = ' ';
10720 *(p++) = hex_digit_table[li_config_table[j].chflags >> 4];
10721 *(p++) = hex_digit_table[li_config_table[j].chflags & 0xf];
10722 }
10723 *p = '\0';
10724 dbug(1, dprintf("[%06lx] CHFLAG %s",
10725 (dword)(UnMapController(a->Id)), (char *)hex_line));
10726 for (i = 0; i < n; i++)
10727 {
10728 p = hex_line;
10729 for (j = 0; j < n; j++)
10730 {
10731 if ((j & 0x7) == 0)
10732 *(p++) = ' ';
10733 *(p++) = hex_digit_table[li_config_table[i].flag_table[j] >> 4];
10734 *(p++) = hex_digit_table[li_config_table[i].flag_table[j] & 0xf];
10735 }
10736 *p = '\0';
10737 dbug(1, dprintf("[%06lx] FLAG[%02x]%s",
10738 (dword)(UnMapController(a->Id)), i, (char *)hex_line));
10739 }
10740 for (i = 0; i < n; i++)
10741 {
10742 p = hex_line;
10743 for (j = 0; j < n; j++)
10744 {
10745 if ((j & 0x7) == 0)
10746 *(p++) = ' ';
10747 *(p++) = hex_digit_table[li_config_table[i].coef_table[j] >> 4];
10748 *(p++) = hex_digit_table[li_config_table[i].coef_table[j] & 0xf];
10749 }
10750 *p = '\0';
10751 dbug(1, dprintf("[%06lx] COEF[%02x]%s",
10752 (dword)(UnMapController(a->Id)), i, (char *)hex_line));
10753 }
10754 }
10755
10756
10757 static struct
10758 {
10759 byte mask;
10760 byte line_flags;
10761 } mixer_write_prog_pri[] =
10762 {
10763 { LI_COEF_CH_CH, 0 },
10764 { LI_COEF_CH_PC, MIXER_COEF_LINE_TO_PC_FLAG },
10765 { LI_COEF_PC_CH, MIXER_COEF_LINE_FROM_PC_FLAG },
10766 { LI_COEF_PC_PC, MIXER_COEF_LINE_TO_PC_FLAG | MIXER_COEF_LINE_FROM_PC_FLAG }
10767 };
10768
10769 static struct
10770 {
10771 byte from_ch;
10772 byte to_ch;
10773 byte mask;
10774 byte xconnect_override;
10775 } mixer_write_prog_bri[] =
10776 {
10777 { 0, 0, LI_COEF_CH_CH, 0x01 }, /* B to B */
10778 { 1, 0, LI_COEF_CH_CH, 0x01 }, /* Alt B to B */
10779 { 0, 0, LI_COEF_PC_CH, 0x80 }, /* PC to B */
10780 { 1, 0, LI_COEF_PC_CH, 0x01 }, /* Alt PC to B */
10781 { 2, 0, LI_COEF_CH_CH, 0x00 }, /* IC to B */
10782 { 3, 0, LI_COEF_CH_CH, 0x00 }, /* Alt IC to B */
10783 { 0, 0, LI_COEF_CH_PC, 0x80 }, /* B to PC */
10784 { 1, 0, LI_COEF_CH_PC, 0x01 }, /* Alt B to PC */
10785 { 0, 0, LI_COEF_PC_PC, 0x01 }, /* PC to PC */
10786 { 1, 0, LI_COEF_PC_PC, 0x01 }, /* Alt PC to PC */
10787 { 2, 0, LI_COEF_CH_PC, 0x00 }, /* IC to PC */
10788 { 3, 0, LI_COEF_CH_PC, 0x00 }, /* Alt IC to PC */
10789 { 0, 2, LI_COEF_CH_CH, 0x00 }, /* B to IC */
10790 { 1, 2, LI_COEF_CH_CH, 0x00 }, /* Alt B to IC */
10791 { 0, 2, LI_COEF_PC_CH, 0x00 }, /* PC to IC */
10792 { 1, 2, LI_COEF_PC_CH, 0x00 }, /* Alt PC to IC */
10793 { 2, 2, LI_COEF_CH_CH, 0x00 }, /* IC to IC */
10794 { 3, 2, LI_COEF_CH_CH, 0x00 }, /* Alt IC to IC */
10795 { 1, 1, LI_COEF_CH_CH, 0x01 }, /* Alt B to Alt B */
10796 { 0, 1, LI_COEF_CH_CH, 0x01 }, /* B to Alt B */
10797 { 1, 1, LI_COEF_PC_CH, 0x80 }, /* Alt PC to Alt B */
10798 { 0, 1, LI_COEF_PC_CH, 0x01 }, /* PC to Alt B */
10799 { 3, 1, LI_COEF_CH_CH, 0x00 }, /* Alt IC to Alt B */
10800 { 2, 1, LI_COEF_CH_CH, 0x00 }, /* IC to Alt B */
10801 { 1, 1, LI_COEF_CH_PC, 0x80 }, /* Alt B to Alt PC */
10802 { 0, 1, LI_COEF_CH_PC, 0x01 }, /* B to Alt PC */
10803 { 1, 1, LI_COEF_PC_PC, 0x01 }, /* Alt PC to Alt PC */
10804 { 0, 1, LI_COEF_PC_PC, 0x01 }, /* PC to Alt PC */
10805 { 3, 1, LI_COEF_CH_PC, 0x00 }, /* Alt IC to Alt PC */
10806 { 2, 1, LI_COEF_CH_PC, 0x00 }, /* IC to Alt PC */
10807 { 1, 3, LI_COEF_CH_CH, 0x00 }, /* Alt B to Alt IC */
10808 { 0, 3, LI_COEF_CH_CH, 0x00 }, /* B to Alt IC */
10809 { 1, 3, LI_COEF_PC_CH, 0x00 }, /* Alt PC to Alt IC */
10810 { 0, 3, LI_COEF_PC_CH, 0x00 }, /* PC to Alt IC */
10811 { 3, 3, LI_COEF_CH_CH, 0x00 }, /* Alt IC to Alt IC */
10812 { 2, 3, LI_COEF_CH_CH, 0x00 } /* IC to Alt IC */
10813 };
10814
10815 static byte mixer_swapped_index_bri[] =
10816 {
10817 18, /* B to B */
10818 19, /* Alt B to B */
10819 20, /* PC to B */
10820 21, /* Alt PC to B */
10821 22, /* IC to B */
10822 23, /* Alt IC to B */
10823 24, /* B to PC */
10824 25, /* Alt B to PC */
10825 26, /* PC to PC */
10826 27, /* Alt PC to PC */
10827 28, /* IC to PC */
10828 29, /* Alt IC to PC */
10829 30, /* B to IC */
10830 31, /* Alt B to IC */
10831 32, /* PC to IC */
10832 33, /* Alt PC to IC */
10833 34, /* IC to IC */
10834 35, /* Alt IC to IC */
10835 0, /* Alt B to Alt B */
10836 1, /* B to Alt B */
10837 2, /* Alt PC to Alt B */
10838 3, /* PC to Alt B */
10839 4, /* Alt IC to Alt B */
10840 5, /* IC to Alt B */
10841 6, /* Alt B to Alt PC */
10842 7, /* B to Alt PC */
10843 8, /* Alt PC to Alt PC */
10844 9, /* PC to Alt PC */
10845 10, /* Alt IC to Alt PC */
10846 11, /* IC to Alt PC */
10847 12, /* Alt B to Alt IC */
10848 13, /* B to Alt IC */
10849 14, /* Alt PC to Alt IC */
10850 15, /* PC to Alt IC */
10851 16, /* Alt IC to Alt IC */
10852 17 /* IC to Alt IC */
10853 };
10854
10855 static struct
10856 {
10857 byte mask;
10858 byte from_pc;
10859 byte to_pc;
10860 } xconnect_write_prog[] =
10861 {
10862 { LI_COEF_CH_CH, false, false },
10863 { LI_COEF_CH_PC, false, true },
10864 { LI_COEF_PC_CH, true, false },
10865 { LI_COEF_PC_PC, true, true }
10866 };
10867
10868
10869 static void xconnect_query_addresses(PLCI *plci)
10870 {
10871 DIVA_CAPI_ADAPTER *a;
10872 word w, ch;
10873 byte *p;
10874
10875 dbug(1, dprintf("[%06lx] %s,%d: xconnect_query_addresses",
10876 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10877 (char *)(FILE_), __LINE__));
10878
10879 a = plci->adapter;
10880 if (a->li_pri && ((plci->li_bchannel_id == 0)
10881 || (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci)))
10882 {
10883 dbug(1, dprintf("[%06x] %s,%d: Channel id wiped out",
10884 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10885 (char *)(FILE_), __LINE__));
10886 return;
10887 }
10888 p = plci->internal_req_buffer;
10889 ch = (a->li_pri) ? plci->li_bchannel_id - 1 : 0;
10890 *(p++) = UDATA_REQUEST_XCONNECT_FROM;
10891 w = ch;
10892 *(p++) = (byte) w;
10893 *(p++) = (byte)(w >> 8);
10894 w = ch | XCONNECT_CHANNEL_PORT_PC;
10895 *(p++) = (byte) w;
10896 *(p++) = (byte)(w >> 8);
10897 plci->NData[0].P = plci->internal_req_buffer;
10898 plci->NData[0].PLength = p - plci->internal_req_buffer;
10899 plci->NL.X = plci->NData;
10900 plci->NL.ReqCh = 0;
10901 plci->NL.Req = plci->nl_req = (byte) N_UDATA;
10902 plci->adapter->request(&plci->NL);
10903 }
10904
10905
10906 static void xconnect_write_coefs(PLCI *plci, word internal_command)
10907 {
10908
10909 dbug(1, dprintf("[%06lx] %s,%d: xconnect_write_coefs %04x",
10910 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
10911 (char *)(FILE_), __LINE__, internal_command));
10912
10913 plci->li_write_command = internal_command;
10914 plci->li_write_channel = 0;
10915 }
10916
10917
10918 static byte xconnect_write_coefs_process(dword Id, PLCI *plci, byte Rc)
10919 {
10920 DIVA_CAPI_ADAPTER *a;
10921 word w, n, i, j, r, s, to_ch;
10922 dword d;
10923 byte *p;
10924 struct xconnect_transfer_address_s *transfer_address;
10925 byte ch_map[MIXER_CHANNELS_BRI];
10926
10927 dbug(1, dprintf("[%06x] %s,%d: xconnect_write_coefs_process %02x %d",
10928 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->li_write_channel));
10929
10930 a = plci->adapter;
10931 if ((plci->li_bchannel_id == 0)
10932 || (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci))
10933 {
10934 dbug(1, dprintf("[%06x] %s,%d: Channel id wiped out",
10935 UnMapId(Id), (char *)(FILE_), __LINE__));
10936 return (true);
10937 }
10938 i = a->li_base + (plci->li_bchannel_id - 1);
10939 j = plci->li_write_channel;
10940 p = plci->internal_req_buffer;
10941 if (j != 0)
10942 {
10943 if ((Rc != OK) && (Rc != OK_FC))
10944 {
10945 dbug(1, dprintf("[%06lx] %s,%d: LI write coefs failed %02x",
10946 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
10947 return (false);
10948 }
10949 }
10950 if (li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
10951 {
10952 r = 0;
10953 s = 0;
10954 if (j < li_total_channels)
10955 {
10956 if (li_config_table[i].channel & LI_CHANNEL_ADDRESSES_SET)
10957 {
10958 s = ((li_config_table[i].send_b.card_address.low | li_config_table[i].send_b.card_address.high) ?
10959 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_PC | LI_COEF_PC_PC)) &
10960 ((li_config_table[i].send_pc.card_address.low | li_config_table[i].send_pc.card_address.high) ?
10961 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_PC_CH));
10962 }
10963 r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
10964 while ((j < li_total_channels)
10965 && ((r == 0)
10966 || (!(li_config_table[j].channel & LI_CHANNEL_ADDRESSES_SET))
10967 || (!li_config_table[j].adapter->li_pri
10968 && (j >= li_config_table[j].adapter->li_base + MIXER_BCHANNELS_BRI))
10969 || (((li_config_table[j].send_b.card_address.low != li_config_table[i].send_b.card_address.low)
10970 || (li_config_table[j].send_b.card_address.high != li_config_table[i].send_b.card_address.high))
10971 && (!(a->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)
10972 || !(li_config_table[j].adapter->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)))
10973 || ((li_config_table[j].adapter->li_base != a->li_base)
10974 && !(r & s &
10975 ((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ?
10976 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) &
10977 ((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ?
10978 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC))))))
10979 {
10980 j++;
10981 if (j < li_total_channels)
10982 r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
10983 }
10984 }
10985 if (j < li_total_channels)
10986 {
10987 plci->internal_command = plci->li_write_command;
10988 if (plci_nl_busy(plci))
10989 return (true);
10990 to_ch = (a->li_pri) ? plci->li_bchannel_id - 1 : 0;
10991 *(p++) = UDATA_REQUEST_XCONNECT_TO;
10992 do
10993 {
10994 if (li_config_table[j].adapter->li_base != a->li_base)
10995 {
10996 r &= s &
10997 ((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ?
10998 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) &
10999 ((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ?
11000 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC));
11001 }
11002 n = 0;
11003 do
11004 {
11005 if (r & xconnect_write_prog[n].mask)
11006 {
11007 if (xconnect_write_prog[n].from_pc)
11008 transfer_address = &(li_config_table[j].send_pc);
11009 else
11010 transfer_address = &(li_config_table[j].send_b);
11011 d = transfer_address->card_address.low;
11012 *(p++) = (byte) d;
11013 *(p++) = (byte)(d >> 8);
11014 *(p++) = (byte)(d >> 16);
11015 *(p++) = (byte)(d >> 24);
11016 d = transfer_address->card_address.high;
11017 *(p++) = (byte) d;
11018 *(p++) = (byte)(d >> 8);
11019 *(p++) = (byte)(d >> 16);
11020 *(p++) = (byte)(d >> 24);
11021 d = transfer_address->offset;
11022 *(p++) = (byte) d;
11023 *(p++) = (byte)(d >> 8);
11024 *(p++) = (byte)(d >> 16);
11025 *(p++) = (byte)(d >> 24);
11026 w = xconnect_write_prog[n].to_pc ? to_ch | XCONNECT_CHANNEL_PORT_PC : to_ch;
11027 *(p++) = (byte) w;
11028 *(p++) = (byte)(w >> 8);
11029 w = ((li_config_table[i].coef_table[j] & xconnect_write_prog[n].mask) == 0) ? 0x01 :
11030 (li_config_table[i].adapter->u_law ?
11031 (li_config_table[j].adapter->u_law ? 0x80 : 0x86) :
11032 (li_config_table[j].adapter->u_law ? 0x7a : 0x80));
11033 *(p++) = (byte) w;
11034 *(p++) = (byte) 0;
11035 li_config_table[i].coef_table[j] ^= xconnect_write_prog[n].mask << 4;
11036 }
11037 n++;
11038 } while ((n < ARRAY_SIZE(xconnect_write_prog))
11039 && ((p - plci->internal_req_buffer) + 16 < INTERNAL_REQ_BUFFER_SIZE));
11040 if (n == ARRAY_SIZE(xconnect_write_prog))
11041 {
11042 do
11043 {
11044 j++;
11045 if (j < li_total_channels)
11046 r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
11047 } while ((j < li_total_channels)
11048 && ((r == 0)
11049 || (!(li_config_table[j].channel & LI_CHANNEL_ADDRESSES_SET))
11050 || (!li_config_table[j].adapter->li_pri
11051 && (j >= li_config_table[j].adapter->li_base + MIXER_BCHANNELS_BRI))
11052 || (((li_config_table[j].send_b.card_address.low != li_config_table[i].send_b.card_address.low)
11053 || (li_config_table[j].send_b.card_address.high != li_config_table[i].send_b.card_address.high))
11054 && (!(a->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)
11055 || !(li_config_table[j].adapter->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)))
11056 || ((li_config_table[j].adapter->li_base != a->li_base)
11057 && !(r & s &
11058 ((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ?
11059 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) &
11060 ((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ?
11061 (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC))))));
11062 }
11063 } while ((j < li_total_channels)
11064 && ((p - plci->internal_req_buffer) + 16 < INTERNAL_REQ_BUFFER_SIZE));
11065 }
11066 else if (j == li_total_channels)
11067 {
11068 plci->internal_command = plci->li_write_command;
11069 if (plci_nl_busy(plci))
11070 return (true);
11071 if (a->li_pri)
11072 {
11073 *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_PRI_SYNC;
11074 w = 0;
11075 if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
11076 w |= MIXER_FEATURE_ENABLE_TX_DATA;
11077 if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
11078 w |= MIXER_FEATURE_ENABLE_RX_DATA;
11079 *(p++) = (byte) w;
11080 *(p++) = (byte)(w >> 8);
11081 }
11082 else
11083 {
11084 *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_BRI;
11085 w = 0;
11086 if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI)
11087 && (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length))
11088 {
11089 w = GET_WORD(a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE);
11090 }
11091 if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
11092 w |= MIXER_FEATURE_ENABLE_TX_DATA;
11093 if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
11094 w |= MIXER_FEATURE_ENABLE_RX_DATA;
11095 *(p++) = (byte) w;
11096 *(p++) = (byte)(w >> 8);
11097 for (j = 0; j < sizeof(ch_map); j += 2)
11098 {
11099 if (plci->li_bchannel_id == 2)
11100 {
11101 ch_map[j] = (byte)(j + 1);
11102 ch_map[j + 1] = (byte) j;
11103 }
11104 else
11105 {
11106 ch_map[j] = (byte) j;
11107 ch_map[j + 1] = (byte)(j + 1);
11108 }
11109 }
11110 for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++)
11111 {
11112 i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch];
11113 j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch];
11114 if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED)
11115 {
11116 *p = (mixer_write_prog_bri[n].xconnect_override != 0) ?
11117 mixer_write_prog_bri[n].xconnect_override :
11118 ((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01);
11119 if ((i >= a->li_base + MIXER_BCHANNELS_BRI) || (j >= a->li_base + MIXER_BCHANNELS_BRI))
11120 {
11121 w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
11122 li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4;
11123 }
11124 }
11125 else
11126 {
11127 *p = 0x00;
11128 if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI->tel == ADV_VOICE))
11129 {
11130 w = (plci == a->AdvSignalPLCI) ? n : mixer_swapped_index_bri[n];
11131 if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w < a->adv_voice_coef_length)
11132 *p = a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w];
11133 }
11134 }
11135 p++;
11136 }
11137 }
11138 j = li_total_channels + 1;
11139 }
11140 }
11141 else
11142 {
11143 if (j <= li_total_channels)
11144 {
11145 plci->internal_command = plci->li_write_command;
11146 if (plci_nl_busy(plci))
11147 return (true);
11148 if (j < a->li_base)
11149 j = a->li_base;
11150 if (a->li_pri)
11151 {
11152 *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_PRI_SYNC;
11153 w = 0;
11154 if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
11155 w |= MIXER_FEATURE_ENABLE_TX_DATA;
11156 if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
11157 w |= MIXER_FEATURE_ENABLE_RX_DATA;
11158 *(p++) = (byte) w;
11159 *(p++) = (byte)(w >> 8);
11160 for (n = 0; n < ARRAY_SIZE(mixer_write_prog_pri); n++)
11161 {
11162 *(p++) = (byte)((plci->li_bchannel_id - 1) | mixer_write_prog_pri[n].line_flags);
11163 for (j = a->li_base; j < a->li_base + MIXER_CHANNELS_PRI; j++)
11164 {
11165 w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
11166 if (w & mixer_write_prog_pri[n].mask)
11167 {
11168 *(p++) = (li_config_table[i].coef_table[j] & mixer_write_prog_pri[n].mask) ? 0x80 : 0x01;
11169 li_config_table[i].coef_table[j] ^= mixer_write_prog_pri[n].mask << 4;
11170 }
11171 else
11172 *(p++) = 0x00;
11173 }
11174 *(p++) = (byte)((plci->li_bchannel_id - 1) | MIXER_COEF_LINE_ROW_FLAG | mixer_write_prog_pri[n].line_flags);
11175 for (j = a->li_base; j < a->li_base + MIXER_CHANNELS_PRI; j++)
11176 {
11177 w = ((li_config_table[j].coef_table[i] & 0xf) ^ (li_config_table[j].coef_table[i] >> 4));
11178 if (w & mixer_write_prog_pri[n].mask)
11179 {
11180 *(p++) = (li_config_table[j].coef_table[i] & mixer_write_prog_pri[n].mask) ? 0x80 : 0x01;
11181 li_config_table[j].coef_table[i] ^= mixer_write_prog_pri[n].mask << 4;
11182 }
11183 else
11184 *(p++) = 0x00;
11185 }
11186 }
11187 }
11188 else
11189 {
11190 *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_BRI;
11191 w = 0;
11192 if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI)
11193 && (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length))
11194 {
11195 w = GET_WORD(a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE);
11196 }
11197 if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
11198 w |= MIXER_FEATURE_ENABLE_TX_DATA;
11199 if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
11200 w |= MIXER_FEATURE_ENABLE_RX_DATA;
11201 *(p++) = (byte) w;
11202 *(p++) = (byte)(w >> 8);
11203 for (j = 0; j < sizeof(ch_map); j += 2)
11204 {
11205 if (plci->li_bchannel_id == 2)
11206 {
11207 ch_map[j] = (byte)(j + 1);
11208 ch_map[j + 1] = (byte) j;
11209 }
11210 else
11211 {
11212 ch_map[j] = (byte) j;
11213 ch_map[j + 1] = (byte)(j + 1);
11214 }
11215 }
11216 for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++)
11217 {
11218 i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch];
11219 j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch];
11220 if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED)
11221 {
11222 *p = ((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01);
11223 w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
11224 li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4;
11225 }
11226 else
11227 {
11228 *p = 0x00;
11229 if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI->tel == ADV_VOICE))
11230 {
11231 w = (plci == a->AdvSignalPLCI) ? n : mixer_swapped_index_bri[n];
11232 if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w < a->adv_voice_coef_length)
11233 *p = a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w];
11234 }
11235 }
11236 p++;
11237 }
11238 }
11239 j = li_total_channels + 1;
11240 }
11241 }
11242 plci->li_write_channel = j;
11243 if (p != plci->internal_req_buffer)
11244 {
11245 plci->NData[0].P = plci->internal_req_buffer;
11246 plci->NData[0].PLength = p - plci->internal_req_buffer;
11247 plci->NL.X = plci->NData;
11248 plci->NL.ReqCh = 0;
11249 plci->NL.Req = plci->nl_req = (byte) N_UDATA;
11250 plci->adapter->request(&plci->NL);
11251 }
11252 return (true);
11253 }
11254
11255
11256 static void mixer_notify_update(PLCI *plci, byte others)
11257 {
11258 DIVA_CAPI_ADAPTER *a;
11259 word i, w;
11260 PLCI *notify_plci;
11261 byte msg[sizeof(CAPI_MSG_HEADER) + 6];
11262
11263 dbug(1, dprintf("[%06lx] %s,%d: mixer_notify_update %d",
11264 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
11265 (char *)(FILE_), __LINE__, others));
11266
11267 a = plci->adapter;
11268 if (a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED)
11269 {
11270 if (others)
11271 plci->li_notify_update = true;
11272 i = 0;
11273 do
11274 {
11275 notify_plci = NULL;
11276 if (others)
11277 {
11278 while ((i < li_total_channels) && (li_config_table[i].plci == NULL))
11279 i++;
11280 if (i < li_total_channels)
11281 notify_plci = li_config_table[i++].plci;
11282 }
11283 else
11284 {
11285 if ((plci->li_bchannel_id != 0)
11286 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11287 {
11288 notify_plci = plci;
11289 }
11290 }
11291 if ((notify_plci != NULL)
11292 && !notify_plci->li_notify_update
11293 && (notify_plci->appl != NULL)
11294 && (notify_plci->State)
11295 && notify_plci->NL.Id && !notify_plci->nl_remove_id)
11296 {
11297 notify_plci->li_notify_update = true;
11298 ((CAPI_MSG *) msg)->header.length = 18;
11299 ((CAPI_MSG *) msg)->header.appl_id = notify_plci->appl->Id;
11300 ((CAPI_MSG *) msg)->header.command = _FACILITY_R;
11301 ((CAPI_MSG *) msg)->header.number = 0;
11302 ((CAPI_MSG *) msg)->header.controller = notify_plci->adapter->Id;
11303 ((CAPI_MSG *) msg)->header.plci = notify_plci->Id;
11304 ((CAPI_MSG *) msg)->header.ncci = 0;
11305 ((CAPI_MSG *) msg)->info.facility_req.Selector = SELECTOR_LINE_INTERCONNECT;
11306 ((CAPI_MSG *) msg)->info.facility_req.structs[0] = 3;
11307 PUT_WORD(&(((CAPI_MSG *) msg)->info.facility_req.structs[1]), LI_REQ_SILENT_UPDATE);
11308 ((CAPI_MSG *) msg)->info.facility_req.structs[3] = 0;
11309 w = api_put(notify_plci->appl, (CAPI_MSG *) msg);
11310 if (w != _QUEUE_FULL)
11311 {
11312 if (w != 0)
11313 {
11314 dbug(1, dprintf("[%06lx] %s,%d: Interconnect notify failed %06x %d",
11315 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
11316 (char *)(FILE_), __LINE__,
11317 (dword)((notify_plci->Id << 8) | UnMapController(notify_plci->adapter->Id)), w));
11318 }
11319 notify_plci->li_notify_update = false;
11320 }
11321 }
11322 } while (others && (notify_plci != NULL));
11323 if (others)
11324 plci->li_notify_update = false;
11325 }
11326 }
11327
11328
11329 static void mixer_clear_config(PLCI *plci)
11330 {
11331 DIVA_CAPI_ADAPTER *a;
11332 word i, j;
11333
11334 dbug(1, dprintf("[%06lx] %s,%d: mixer_clear_config",
11335 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
11336 (char *)(FILE_), __LINE__));
11337
11338 plci->li_notify_update = false;
11339 plci->li_plci_b_write_pos = 0;
11340 plci->li_plci_b_read_pos = 0;
11341 plci->li_plci_b_req_pos = 0;
11342 a = plci->adapter;
11343 if ((plci->li_bchannel_id != 0)
11344 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11345 {
11346 i = a->li_base + (plci->li_bchannel_id - 1);
11347 li_config_table[i].curchnl = 0;
11348 li_config_table[i].channel = 0;
11349 li_config_table[i].chflags = 0;
11350 for (j = 0; j < li_total_channels; j++)
11351 {
11352 li_config_table[j].flag_table[i] = 0;
11353 li_config_table[i].flag_table[j] = 0;
11354 li_config_table[i].coef_table[j] = 0;
11355 li_config_table[j].coef_table[i] = 0;
11356 }
11357 if (!a->li_pri)
11358 {
11359 li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET;
11360 if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
11361 {
11362 i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
11363 li_config_table[i].curchnl = 0;
11364 li_config_table[i].channel = 0;
11365 li_config_table[i].chflags = 0;
11366 for (j = 0; j < li_total_channels; j++)
11367 {
11368 li_config_table[i].flag_table[j] = 0;
11369 li_config_table[j].flag_table[i] = 0;
11370 li_config_table[i].coef_table[j] = 0;
11371 li_config_table[j].coef_table[i] = 0;
11372 }
11373 if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
11374 {
11375 i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
11376 li_config_table[i].curchnl = 0;
11377 li_config_table[i].channel = 0;
11378 li_config_table[i].chflags = 0;
11379 for (j = 0; j < li_total_channels; j++)
11380 {
11381 li_config_table[i].flag_table[j] = 0;
11382 li_config_table[j].flag_table[i] = 0;
11383 li_config_table[i].coef_table[j] = 0;
11384 li_config_table[j].coef_table[i] = 0;
11385 }
11386 }
11387 }
11388 }
11389 }
11390 }
11391
11392
11393 static void mixer_prepare_switch(dword Id, PLCI *plci)
11394 {
11395
11396 dbug(1, dprintf("[%06lx] %s,%d: mixer_prepare_switch",
11397 UnMapId(Id), (char *)(FILE_), __LINE__));
11398
11399 do
11400 {
11401 mixer_indication_coefs_set(Id, plci);
11402 } while (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos);
11403 }
11404
11405
11406 static word mixer_save_config(dword Id, PLCI *plci, byte Rc)
11407 {
11408 DIVA_CAPI_ADAPTER *a;
11409 word i, j;
11410
11411 dbug(1, dprintf("[%06lx] %s,%d: mixer_save_config %02x %d",
11412 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
11413
11414 a = plci->adapter;
11415 if ((plci->li_bchannel_id != 0)
11416 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11417 {
11418 i = a->li_base + (plci->li_bchannel_id - 1);
11419 for (j = 0; j < li_total_channels; j++)
11420 {
11421 li_config_table[i].coef_table[j] &= 0xf;
11422 li_config_table[j].coef_table[i] &= 0xf;
11423 }
11424 if (!a->li_pri)
11425 li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET;
11426 }
11427 return (GOOD);
11428 }
11429
11430
11431 static word mixer_restore_config(dword Id, PLCI *plci, byte Rc)
11432 {
11433 DIVA_CAPI_ADAPTER *a;
11434 word Info;
11435
11436 dbug(1, dprintf("[%06lx] %s,%d: mixer_restore_config %02x %d",
11437 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
11438
11439 Info = GOOD;
11440 a = plci->adapter;
11441 if ((plci->B1_facilities & B1_FACILITY_MIXER)
11442 && (plci->li_bchannel_id != 0)
11443 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
11444 {
11445 switch (plci->adjust_b_state)
11446 {
11447 case ADJUST_B_RESTORE_MIXER_1:
11448 if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
11449 {
11450 plci->internal_command = plci->adjust_b_command;
11451 if (plci_nl_busy(plci))
11452 {
11453 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_1;
11454 break;
11455 }
11456 xconnect_query_addresses(plci);
11457 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_2;
11458 break;
11459 }
11460 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5;
11461 Rc = OK;
11462 case ADJUST_B_RESTORE_MIXER_2:
11463 case ADJUST_B_RESTORE_MIXER_3:
11464 case ADJUST_B_RESTORE_MIXER_4:
11465 if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0))
11466 {
11467 dbug(1, dprintf("[%06lx] %s,%d: Adjust B query addresses failed %02x",
11468 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
11469 Info = _WRONG_STATE;
11470 break;
11471 }
11472 if (Rc == OK)
11473 {
11474 if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2)
11475 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_3;
11476 else if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_4)
11477 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5;
11478 }
11479 else if (Rc == 0)
11480 {
11481 if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2)
11482 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_4;
11483 else if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_3)
11484 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5;
11485 }
11486 if (plci->adjust_b_state != ADJUST_B_RESTORE_MIXER_5)
11487 {
11488 plci->internal_command = plci->adjust_b_command;
11489 break;
11490 }
11491 case ADJUST_B_RESTORE_MIXER_5:
11492 xconnect_write_coefs(plci, plci->adjust_b_command);
11493 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_6;
11494 Rc = OK;
11495 case ADJUST_B_RESTORE_MIXER_6:
11496 if (!xconnect_write_coefs_process(Id, plci, Rc))
11497 {
11498 dbug(1, dprintf("[%06lx] %s,%d: Write mixer coefs failed",
11499 UnMapId(Id), (char *)(FILE_), __LINE__));
11500 Info = _FACILITY_NOT_SUPPORTED;
11501 break;
11502 }
11503 if (plci->internal_command)
11504 break;
11505 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_7;
11506 case ADJUST_B_RESTORE_MIXER_7:
11507 break;
11508 }
11509 }
11510 return (Info);
11511 }
11512
11513
11514 static void mixer_command(dword Id, PLCI *plci, byte Rc)
11515 {
11516 DIVA_CAPI_ADAPTER *a;
11517 word i, internal_command;
11518
11519 dbug(1, dprintf("[%06lx] %s,%d: mixer_command %02x %04x %04x",
11520 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command,
11521 plci->li_cmd));
11522
11523 a = plci->adapter;
11524 internal_command = plci->internal_command;
11525 plci->internal_command = 0;
11526 switch (plci->li_cmd)
11527 {
11528 case LI_REQ_CONNECT:
11529 case LI_REQ_DISCONNECT:
11530 case LI_REQ_SILENT_UPDATE:
11531 switch (internal_command)
11532 {
11533 default:
11534 if (plci->li_channel_bits & LI_CHANNEL_INVOLVED)
11535 {
11536 adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities |
11537 B1_FACILITY_MIXER), MIXER_COMMAND_1);
11538 }
11539 case MIXER_COMMAND_1:
11540 if (plci->li_channel_bits & LI_CHANNEL_INVOLVED)
11541 {
11542 if (adjust_b_process(Id, plci, Rc) != GOOD)
11543 {
11544 dbug(1, dprintf("[%06lx] %s,%d: Load mixer failed",
11545 UnMapId(Id), (char *)(FILE_), __LINE__));
11546 break;
11547 }
11548 if (plci->internal_command)
11549 return;
11550 }
11551 plci->li_plci_b_req_pos = plci->li_plci_b_write_pos;
11552 if ((plci->li_channel_bits & LI_CHANNEL_INVOLVED)
11553 || ((get_b1_facilities(plci, plci->B1_resource) & B1_FACILITY_MIXER)
11554 && (add_b1_facilities(plci, plci->B1_resource, (word)(plci->B1_facilities &
11555 ~B1_FACILITY_MIXER)) == plci->B1_resource)))
11556 {
11557 xconnect_write_coefs(plci, MIXER_COMMAND_2);
11558 }
11559 else
11560 {
11561 do
11562 {
11563 mixer_indication_coefs_set(Id, plci);
11564 } while (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos);
11565 }
11566 case MIXER_COMMAND_2:
11567 if ((plci->li_channel_bits & LI_CHANNEL_INVOLVED)
11568 || ((get_b1_facilities(plci, plci->B1_resource) & B1_FACILITY_MIXER)
11569 && (add_b1_facilities(plci, plci->B1_resource, (word)(plci->B1_facilities &
11570 ~B1_FACILITY_MIXER)) == plci->B1_resource)))
11571 {
11572 if (!xconnect_write_coefs_process(Id, plci, Rc))
11573 {
11574 dbug(1, dprintf("[%06lx] %s,%d: Write mixer coefs failed",
11575 UnMapId(Id), (char *)(FILE_), __LINE__));
11576 if (plci->li_plci_b_write_pos != plci->li_plci_b_req_pos)
11577 {
11578 do
11579 {
11580 plci->li_plci_b_write_pos = (plci->li_plci_b_write_pos == 0) ?
11581 LI_PLCI_B_QUEUE_ENTRIES - 1 : plci->li_plci_b_write_pos - 1;
11582 i = (plci->li_plci_b_write_pos == 0) ?
11583 LI_PLCI_B_QUEUE_ENTRIES - 1 : plci->li_plci_b_write_pos - 1;
11584 } while ((plci->li_plci_b_write_pos != plci->li_plci_b_req_pos)
11585 && !(plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG));
11586 }
11587 break;
11588 }
11589 if (plci->internal_command)
11590 return;
11591 }
11592 if (!(plci->li_channel_bits & LI_CHANNEL_INVOLVED))
11593 {
11594 adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities &
11595 ~B1_FACILITY_MIXER), MIXER_COMMAND_3);
11596 }
11597 case MIXER_COMMAND_3:
11598 if (!(plci->li_channel_bits & LI_CHANNEL_INVOLVED))
11599 {
11600 if (adjust_b_process(Id, plci, Rc) != GOOD)
11601 {
11602 dbug(1, dprintf("[%06lx] %s,%d: Unload mixer failed",
11603 UnMapId(Id), (char *)(FILE_), __LINE__));
11604 break;
11605 }
11606 if (plci->internal_command)
11607 return;
11608 }
11609 break;
11610 }
11611 break;
11612 }
11613 if ((plci->li_bchannel_id == 0)
11614 || (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci))
11615 {
11616 dbug(1, dprintf("[%06x] %s,%d: Channel id wiped out %d",
11617 UnMapId(Id), (char *)(FILE_), __LINE__, (int)(plci->li_bchannel_id)));
11618 }
11619 else
11620 {
11621 i = a->li_base + (plci->li_bchannel_id - 1);
11622 li_config_table[i].curchnl = plci->li_channel_bits;
11623 if (!a->li_pri && (plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
11624 {
11625 i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
11626 li_config_table[i].curchnl = plci->li_channel_bits;
11627 if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
11628 {
11629 i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
11630 li_config_table[i].curchnl = plci->li_channel_bits;
11631 }
11632 }
11633 }
11634 }
11635
11636
11637 static void li_update_connect(dword Id, DIVA_CAPI_ADAPTER *a, PLCI *plci,
11638 dword plci_b_id, byte connect, dword li_flags)
11639 {
11640 word i, ch_a, ch_a_v, ch_a_s, ch_b, ch_b_v, ch_b_s;
11641 PLCI *plci_b;
11642 DIVA_CAPI_ADAPTER *a_b;
11643
11644 a_b = &(adapter[MapController((byte)(plci_b_id & 0x7f)) - 1]);
11645 plci_b = &(a_b->plci[((plci_b_id >> 8) & 0xff) - 1]);
11646 ch_a = a->li_base + (plci->li_bchannel_id - 1);
11647 if (!a->li_pri && (plci->tel == ADV_VOICE)
11648 && (plci == a->AdvSignalPLCI) && (Id & EXT_CONTROLLER))
11649 {
11650 ch_a_v = ch_a + MIXER_IC_CHANNEL_BASE;
11651 ch_a_s = (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11652 a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id) : ch_a_v;
11653 }
11654 else
11655 {
11656 ch_a_v = ch_a;
11657 ch_a_s = ch_a;
11658 }
11659 ch_b = a_b->li_base + (plci_b->li_bchannel_id - 1);
11660 if (!a_b->li_pri && (plci_b->tel == ADV_VOICE)
11661 && (plci_b == a_b->AdvSignalPLCI) && (plci_b_id & EXT_CONTROLLER))
11662 {
11663 ch_b_v = ch_b + MIXER_IC_CHANNEL_BASE;
11664 ch_b_s = (a_b->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11665 a_b->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci_b->li_bchannel_id) : ch_b_v;
11666 }
11667 else
11668 {
11669 ch_b_v = ch_b;
11670 ch_b_s = ch_b;
11671 }
11672 if (connect)
11673 {
11674 li_config_table[ch_a].flag_table[ch_a_v] &= ~LI_FLAG_MONITOR;
11675 li_config_table[ch_a].flag_table[ch_a_s] &= ~LI_FLAG_MONITOR;
11676 li_config_table[ch_a_v].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11677 li_config_table[ch_a_s].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11678 }
11679 li_config_table[ch_a].flag_table[ch_b_v] &= ~LI_FLAG_MONITOR;
11680 li_config_table[ch_a].flag_table[ch_b_s] &= ~LI_FLAG_MONITOR;
11681 li_config_table[ch_b_v].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11682 li_config_table[ch_b_s].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
11683 if (ch_a_v == ch_b_v)
11684 {
11685 li_config_table[ch_a_v].flag_table[ch_b_v] &= ~LI_FLAG_CONFERENCE;
11686 li_config_table[ch_a_s].flag_table[ch_b_s] &= ~LI_FLAG_CONFERENCE;
11687 }
11688 else
11689 {
11690 if (li_config_table[ch_a_v].flag_table[ch_b_v] & LI_FLAG_CONFERENCE)
11691 {
11692 for (i = 0; i < li_total_channels; i++)
11693 {
11694 if (i != ch_a_v)
11695 li_config_table[ch_a_v].flag_table[i] &= ~LI_FLAG_CONFERENCE;
11696 }
11697 }
11698 if (li_config_table[ch_a_s].flag_table[ch_b_v] & LI_FLAG_CONFERENCE)
11699 {
11700 for (i = 0; i < li_total_channels; i++)
11701 {
11702 if (i != ch_a_s)
11703 li_config_table[ch_a_s].flag_table[i] &= ~LI_FLAG_CONFERENCE;
11704 }
11705 }
11706 if (li_config_table[ch_b_v].flag_table[ch_a_v] & LI_FLAG_CONFERENCE)
11707 {
11708 for (i = 0; i < li_total_channels; i++)
11709 {
11710 if (i != ch_a_v)
11711 li_config_table[i].flag_table[ch_a_v] &= ~LI_FLAG_CONFERENCE;
11712 }
11713 }
11714 if (li_config_table[ch_b_v].flag_table[ch_a_s] & LI_FLAG_CONFERENCE)
11715 {
11716 for (i = 0; i < li_total_channels; i++)
11717 {
11718 if (i != ch_a_s)
11719 li_config_table[i].flag_table[ch_a_s] &= ~LI_FLAG_CONFERENCE;
11720 }
11721 }
11722 }
11723 if (li_flags & LI_FLAG_CONFERENCE_A_B)
11724 {
11725 li_config_table[ch_b_v].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11726 li_config_table[ch_b_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11727 li_config_table[ch_b_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11728 li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11729 }
11730 if (li_flags & LI_FLAG_CONFERENCE_B_A)
11731 {
11732 li_config_table[ch_a_v].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11733 li_config_table[ch_a_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11734 li_config_table[ch_a_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11735 li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11736 }
11737 if (li_flags & LI_FLAG_MONITOR_A)
11738 {
11739 li_config_table[ch_a].flag_table[ch_a_v] |= LI_FLAG_MONITOR;
11740 li_config_table[ch_a].flag_table[ch_a_s] |= LI_FLAG_MONITOR;
11741 }
11742 if (li_flags & LI_FLAG_MONITOR_B)
11743 {
11744 li_config_table[ch_a].flag_table[ch_b_v] |= LI_FLAG_MONITOR;
11745 li_config_table[ch_a].flag_table[ch_b_s] |= LI_FLAG_MONITOR;
11746 }
11747 if (li_flags & LI_FLAG_ANNOUNCEMENT_A)
11748 {
11749 li_config_table[ch_a_v].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11750 li_config_table[ch_a_s].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11751 }
11752 if (li_flags & LI_FLAG_ANNOUNCEMENT_B)
11753 {
11754 li_config_table[ch_b_v].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11755 li_config_table[ch_b_s].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
11756 }
11757 if (li_flags & LI_FLAG_MIX_A)
11758 {
11759 li_config_table[ch_a_v].flag_table[ch_a] |= LI_FLAG_MIX;
11760 li_config_table[ch_a_s].flag_table[ch_a] |= LI_FLAG_MIX;
11761 }
11762 if (li_flags & LI_FLAG_MIX_B)
11763 {
11764 li_config_table[ch_b_v].flag_table[ch_a] |= LI_FLAG_MIX;
11765 li_config_table[ch_b_s].flag_table[ch_a] |= LI_FLAG_MIX;
11766 }
11767 if (ch_a_v != ch_a_s)
11768 {
11769 li_config_table[ch_a_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11770 li_config_table[ch_a_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11771 }
11772 if (ch_b_v != ch_b_s)
11773 {
11774 li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11775 li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11776 }
11777 }
11778
11779
11780 static void li2_update_connect(dword Id, DIVA_CAPI_ADAPTER *a, PLCI *plci,
11781 dword plci_b_id, byte connect, dword li_flags)
11782 {
11783 word ch_a, ch_a_v, ch_a_s, ch_b, ch_b_v, ch_b_s;
11784 PLCI *plci_b;
11785 DIVA_CAPI_ADAPTER *a_b;
11786
11787 a_b = &(adapter[MapController((byte)(plci_b_id & 0x7f)) - 1]);
11788 plci_b = &(a_b->plci[((plci_b_id >> 8) & 0xff) - 1]);
11789 ch_a = a->li_base + (plci->li_bchannel_id - 1);
11790 if (!a->li_pri && (plci->tel == ADV_VOICE)
11791 && (plci == a->AdvSignalPLCI) && (Id & EXT_CONTROLLER))
11792 {
11793 ch_a_v = ch_a + MIXER_IC_CHANNEL_BASE;
11794 ch_a_s = (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11795 a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id) : ch_a_v;
11796 }
11797 else
11798 {
11799 ch_a_v = ch_a;
11800 ch_a_s = ch_a;
11801 }
11802 ch_b = a_b->li_base + (plci_b->li_bchannel_id - 1);
11803 if (!a_b->li_pri && (plci_b->tel == ADV_VOICE)
11804 && (plci_b == a_b->AdvSignalPLCI) && (plci_b_id & EXT_CONTROLLER))
11805 {
11806 ch_b_v = ch_b + MIXER_IC_CHANNEL_BASE;
11807 ch_b_s = (a_b->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
11808 a_b->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci_b->li_bchannel_id) : ch_b_v;
11809 }
11810 else
11811 {
11812 ch_b_v = ch_b;
11813 ch_b_s = ch_b;
11814 }
11815 if (connect)
11816 {
11817 li_config_table[ch_b].flag_table[ch_b_v] &= ~LI_FLAG_MONITOR;
11818 li_config_table[ch_b].flag_table[ch_b_s] &= ~LI_FLAG_MONITOR;
11819 li_config_table[ch_b_v].flag_table[ch_b] &= ~LI_FLAG_MIX;
11820 li_config_table[ch_b_s].flag_table[ch_b] &= ~LI_FLAG_MIX;
11821 li_config_table[ch_b].flag_table[ch_b] &= ~LI_FLAG_PCCONNECT;
11822 li_config_table[ch_b].chflags &= ~(LI_CHFLAG_MONITOR | LI_CHFLAG_MIX | LI_CHFLAG_LOOP);
11823 }
11824 li_config_table[ch_b_v].flag_table[ch_a_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11825 li_config_table[ch_b_s].flag_table[ch_a_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11826 li_config_table[ch_b_v].flag_table[ch_a_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11827 li_config_table[ch_b_s].flag_table[ch_a_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11828 li_config_table[ch_a_v].flag_table[ch_b_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11829 li_config_table[ch_a_v].flag_table[ch_b_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11830 li_config_table[ch_a_s].flag_table[ch_b_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11831 li_config_table[ch_a_s].flag_table[ch_b_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
11832 if (li_flags & LI2_FLAG_INTERCONNECT_A_B)
11833 {
11834 li_config_table[ch_b_v].flag_table[ch_a_v] |= LI_FLAG_INTERCONNECT;
11835 li_config_table[ch_b_s].flag_table[ch_a_v] |= LI_FLAG_INTERCONNECT;
11836 li_config_table[ch_b_v].flag_table[ch_a_s] |= LI_FLAG_INTERCONNECT;
11837 li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_INTERCONNECT;
11838 }
11839 if (li_flags & LI2_FLAG_INTERCONNECT_B_A)
11840 {
11841 li_config_table[ch_a_v].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11842 li_config_table[ch_a_v].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11843 li_config_table[ch_a_s].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11844 li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11845 }
11846 if (li_flags & LI2_FLAG_MONITOR_B)
11847 {
11848 li_config_table[ch_b].flag_table[ch_b_v] |= LI_FLAG_MONITOR;
11849 li_config_table[ch_b].flag_table[ch_b_s] |= LI_FLAG_MONITOR;
11850 }
11851 if (li_flags & LI2_FLAG_MIX_B)
11852 {
11853 li_config_table[ch_b_v].flag_table[ch_b] |= LI_FLAG_MIX;
11854 li_config_table[ch_b_s].flag_table[ch_b] |= LI_FLAG_MIX;
11855 }
11856 if (li_flags & LI2_FLAG_MONITOR_X)
11857 li_config_table[ch_b].chflags |= LI_CHFLAG_MONITOR;
11858 if (li_flags & LI2_FLAG_MIX_X)
11859 li_config_table[ch_b].chflags |= LI_CHFLAG_MIX;
11860 if (li_flags & LI2_FLAG_LOOP_B)
11861 {
11862 li_config_table[ch_b_v].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11863 li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
11864 li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11865 li_config_table[ch_b_s].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
11866 }
11867 if (li_flags & LI2_FLAG_LOOP_PC)
11868 li_config_table[ch_b].flag_table[ch_b] |= LI_FLAG_PCCONNECT;
11869 if (li_flags & LI2_FLAG_LOOP_X)
11870 li_config_table[ch_b].chflags |= LI_CHFLAG_LOOP;
11871 if (li_flags & LI2_FLAG_PCCONNECT_A_B)
11872 li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_PCCONNECT;
11873 if (li_flags & LI2_FLAG_PCCONNECT_B_A)
11874 li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_PCCONNECT;
11875 if (ch_a_v != ch_a_s)
11876 {
11877 li_config_table[ch_a_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
11878 li_config_table[ch_a_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
11879 }
11880 if (ch_b_v != ch_b_s)
11881 {
11882 li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
11883 li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
11884 }
11885 }
11886
11887
11888 static word li_check_main_plci(dword Id, PLCI *plci)
11889 {
11890 if (plci == NULL)
11891 {
11892 dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI",
11893 UnMapId(Id), (char *)(FILE_), __LINE__));
11894 return (_WRONG_IDENTIFIER);
11895 }
11896 if (!plci->State
11897 || !plci->NL.Id || plci->nl_remove_id
11898 || (plci->li_bchannel_id == 0))
11899 {
11900 dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
11901 UnMapId(Id), (char *)(FILE_), __LINE__));
11902 return (_WRONG_STATE);
11903 }
11904 li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci = plci;
11905 return (GOOD);
11906 }
11907
11908
11909 static PLCI *li_check_plci_b(dword Id, PLCI *plci,
11910 dword plci_b_id, word plci_b_write_pos, byte *p_result)
11911 {
11912 byte ctlr_b;
11913 PLCI *plci_b;
11914
11915 if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
11916 LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2)
11917 {
11918 dbug(1, dprintf("[%06lx] %s,%d: LI request overrun",
11919 UnMapId(Id), (char *)(FILE_), __LINE__));
11920 PUT_WORD(p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE);
11921 return (NULL);
11922 }
11923 ctlr_b = 0;
11924 if ((plci_b_id & 0x7f) != 0)
11925 {
11926 ctlr_b = MapController((byte)(plci_b_id & 0x7f));
11927 if ((ctlr_b > max_adapter) || ((ctlr_b != 0) && (adapter[ctlr_b - 1].request == NULL)))
11928 ctlr_b = 0;
11929 }
11930 if ((ctlr_b == 0)
11931 || (((plci_b_id >> 8) & 0xff) == 0)
11932 || (((plci_b_id >> 8) & 0xff) > adapter[ctlr_b - 1].max_plci))
11933 {
11934 dbug(1, dprintf("[%06lx] %s,%d: LI invalid second PLCI %08lx",
11935 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
11936 PUT_WORD(p_result, _WRONG_IDENTIFIER);
11937 return (NULL);
11938 }
11939 plci_b = &(adapter[ctlr_b - 1].plci[((plci_b_id >> 8) & 0xff) - 1]);
11940 if (!plci_b->State
11941 || !plci_b->NL.Id || plci_b->nl_remove_id
11942 || (plci_b->li_bchannel_id == 0))
11943 {
11944 dbug(1, dprintf("[%06lx] %s,%d: LI peer in wrong state %08lx",
11945 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
11946 PUT_WORD(p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE);
11947 return (NULL);
11948 }
11949 li_config_table[plci_b->adapter->li_base + (plci_b->li_bchannel_id - 1)].plci = plci_b;
11950 if (((byte)(plci_b_id & ~EXT_CONTROLLER)) !=
11951 ((byte)(UnMapController(plci->adapter->Id) & ~EXT_CONTROLLER))
11952 && (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
11953 || !(plci_b->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)))
11954 {
11955 dbug(1, dprintf("[%06lx] %s,%d: LI not on same ctrl %08lx",
11956 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
11957 PUT_WORD(p_result, _WRONG_IDENTIFIER);
11958 return (NULL);
11959 }
11960 if (!(get_b1_facilities(plci_b, add_b1_facilities(plci_b, plci_b->B1_resource,
11961 (word)(plci_b->B1_facilities | B1_FACILITY_MIXER))) & B1_FACILITY_MIXER))
11962 {
11963 dbug(1, dprintf("[%06lx] %s,%d: Interconnect peer cannot mix %d",
11964 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b->B1_resource));
11965 PUT_WORD(p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE);
11966 return (NULL);
11967 }
11968 return (plci_b);
11969 }
11970
11971
11972 static PLCI *li2_check_plci_b(dword Id, PLCI *plci,
11973 dword plci_b_id, word plci_b_write_pos, byte *p_result)
11974 {
11975 byte ctlr_b;
11976 PLCI *plci_b;
11977
11978 if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
11979 LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2)
11980 {
11981 dbug(1, dprintf("[%06lx] %s,%d: LI request overrun",
11982 UnMapId(Id), (char *)(FILE_), __LINE__));
11983 PUT_WORD(p_result, _WRONG_STATE);
11984 return (NULL);
11985 }
11986 ctlr_b = 0;
11987 if ((plci_b_id & 0x7f) != 0)
11988 {
11989 ctlr_b = MapController((byte)(plci_b_id & 0x7f));
11990 if ((ctlr_b > max_adapter) || ((ctlr_b != 0) && (adapter[ctlr_b - 1].request == NULL)))
11991 ctlr_b = 0;
11992 }
11993 if ((ctlr_b == 0)
11994 || (((plci_b_id >> 8) & 0xff) == 0)
11995 || (((plci_b_id >> 8) & 0xff) > adapter[ctlr_b - 1].max_plci))
11996 {
11997 dbug(1, dprintf("[%06lx] %s,%d: LI invalid second PLCI %08lx",
11998 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
11999 PUT_WORD(p_result, _WRONG_IDENTIFIER);
12000 return (NULL);
12001 }
12002 plci_b = &(adapter[ctlr_b - 1].plci[((plci_b_id >> 8) & 0xff) - 1]);
12003 if (!plci_b->State
12004 || !plci_b->NL.Id || plci_b->nl_remove_id
12005 || (plci_b->li_bchannel_id == 0)
12006 || (li_config_table[plci_b->adapter->li_base + (plci_b->li_bchannel_id - 1)].plci != plci_b))
12007 {
12008 dbug(1, dprintf("[%06lx] %s,%d: LI peer in wrong state %08lx",
12009 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
12010 PUT_WORD(p_result, _WRONG_STATE);
12011 return (NULL);
12012 }
12013 if (((byte)(plci_b_id & ~EXT_CONTROLLER)) !=
12014 ((byte)(UnMapController(plci->adapter->Id) & ~EXT_CONTROLLER))
12015 && (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12016 || !(plci_b->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)))
12017 {
12018 dbug(1, dprintf("[%06lx] %s,%d: LI not on same ctrl %08lx",
12019 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
12020 PUT_WORD(p_result, _WRONG_IDENTIFIER);
12021 return (NULL);
12022 }
12023 if (!(get_b1_facilities(plci_b, add_b1_facilities(plci_b, plci_b->B1_resource,
12024 (word)(plci_b->B1_facilities | B1_FACILITY_MIXER))) & B1_FACILITY_MIXER))
12025 {
12026 dbug(1, dprintf("[%06lx] %s,%d: Interconnect peer cannot mix %d",
12027 UnMapId(Id), (char *)(FILE_), __LINE__, plci_b->B1_resource));
12028 PUT_WORD(p_result, _WRONG_STATE);
12029 return (NULL);
12030 }
12031 return (plci_b);
12032 }
12033
12034
12035 static byte mixer_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg)
12036 {
12037 word Info;
12038 word i;
12039 dword d, li_flags, plci_b_id;
12040 PLCI *plci_b;
12041 API_PARSE li_parms[3];
12042 API_PARSE li_req_parms[3];
12043 API_PARSE li_participant_struct[2];
12044 API_PARSE li_participant_parms[3];
12045 word participant_parms_pos;
12046 byte result_buffer[32];
12047 byte *result;
12048 word result_pos;
12049 word plci_b_write_pos;
12050
12051 dbug(1, dprintf("[%06lx] %s,%d: mixer_request",
12052 UnMapId(Id), (char *)(FILE_), __LINE__));
12053
12054 Info = GOOD;
12055 result = result_buffer;
12056 result_buffer[0] = 0;
12057 if (!(a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED))
12058 {
12059 dbug(1, dprintf("[%06lx] %s,%d: Facility not supported",
12060 UnMapId(Id), (char *)(FILE_), __LINE__));
12061 Info = _FACILITY_NOT_SUPPORTED;
12062 }
12063 else if (api_parse(&msg[1].info[1], msg[1].length, "ws", li_parms))
12064 {
12065 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12066 UnMapId(Id), (char *)(FILE_), __LINE__));
12067 Info = _WRONG_MESSAGE_FORMAT;
12068 }
12069 else
12070 {
12071 result_buffer[0] = 3;
12072 PUT_WORD(&result_buffer[1], GET_WORD(li_parms[0].info));
12073 result_buffer[3] = 0;
12074 switch (GET_WORD(li_parms[0].info))
12075 {
12076 case LI_GET_SUPPORTED_SERVICES:
12077 if (appl->appl_flags & APPL_FLAG_OLD_LI_SPEC)
12078 {
12079 result_buffer[0] = 17;
12080 result_buffer[3] = 14;
12081 PUT_WORD(&result_buffer[4], GOOD);
12082 d = 0;
12083 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_CH)
12084 d |= LI_CONFERENCING_SUPPORTED;
12085 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_PC)
12086 d |= LI_MONITORING_SUPPORTED;
12087 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_CH)
12088 d |= LI_ANNOUNCEMENTS_SUPPORTED | LI_MIXING_SUPPORTED;
12089 if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12090 d |= LI_CROSS_CONTROLLER_SUPPORTED;
12091 PUT_DWORD(&result_buffer[6], d);
12092 if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12093 {
12094 d = 0;
12095 for (i = 0; i < li_total_channels; i++)
12096 {
12097 if ((li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12098 && (li_config_table[i].adapter->li_pri
12099 || (i < li_config_table[i].adapter->li_base + MIXER_BCHANNELS_BRI)))
12100 {
12101 d++;
12102 }
12103 }
12104 }
12105 else
12106 {
12107 d = a->li_pri ? a->li_channels : MIXER_BCHANNELS_BRI;
12108 }
12109 PUT_DWORD(&result_buffer[10], d / 2);
12110 PUT_DWORD(&result_buffer[14], d);
12111 }
12112 else
12113 {
12114 result_buffer[0] = 25;
12115 result_buffer[3] = 22;
12116 PUT_WORD(&result_buffer[4], GOOD);
12117 d = LI2_ASYMMETRIC_SUPPORTED | LI2_B_LOOPING_SUPPORTED | LI2_X_LOOPING_SUPPORTED;
12118 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_PC)
12119 d |= LI2_MONITORING_SUPPORTED | LI2_REMOTE_MONITORING_SUPPORTED;
12120 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_CH)
12121 d |= LI2_MIXING_SUPPORTED | LI2_REMOTE_MIXING_SUPPORTED;
12122 if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_PC)
12123 d |= LI2_PC_LOOPING_SUPPORTED;
12124 if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12125 d |= LI2_CROSS_CONTROLLER_SUPPORTED;
12126 PUT_DWORD(&result_buffer[6], d);
12127 d = a->li_pri ? a->li_channels : MIXER_BCHANNELS_BRI;
12128 PUT_DWORD(&result_buffer[10], d / 2);
12129 PUT_DWORD(&result_buffer[14], d - 1);
12130 if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12131 {
12132 d = 0;
12133 for (i = 0; i < li_total_channels; i++)
12134 {
12135 if ((li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
12136 && (li_config_table[i].adapter->li_pri
12137 || (i < li_config_table[i].adapter->li_base + MIXER_BCHANNELS_BRI)))
12138 {
12139 d++;
12140 }
12141 }
12142 }
12143 PUT_DWORD(&result_buffer[18], d / 2);
12144 PUT_DWORD(&result_buffer[22], d - 1);
12145 }
12146 break;
12147
12148 case LI_REQ_CONNECT:
12149 if (li_parms[1].length == 8)
12150 {
12151 appl->appl_flags |= APPL_FLAG_OLD_LI_SPEC;
12152 if (api_parse(&li_parms[1].info[1], li_parms[1].length, "dd", li_req_parms))
12153 {
12154 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12155 UnMapId(Id), (char *)(FILE_), __LINE__));
12156 Info = _WRONG_MESSAGE_FORMAT;
12157 break;
12158 }
12159 plci_b_id = GET_DWORD(li_req_parms[0].info) & 0xffff;
12160 li_flags = GET_DWORD(li_req_parms[1].info);
12161 Info = li_check_main_plci(Id, plci);
12162 result_buffer[0] = 9;
12163 result_buffer[3] = 6;
12164 PUT_DWORD(&result_buffer[4], plci_b_id);
12165 PUT_WORD(&result_buffer[8], GOOD);
12166 if (Info != GOOD)
12167 break;
12168 result = plci->saved_msg.info;
12169 for (i = 0; i <= result_buffer[0]; i++)
12170 result[i] = result_buffer[i];
12171 plci_b_write_pos = plci->li_plci_b_write_pos;
12172 plci_b = li_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[8]);
12173 if (plci_b == NULL)
12174 break;
12175 li_update_connect(Id, a, plci, plci_b_id, true, li_flags);
12176 plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_LAST_FLAG;
12177 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12178 plci->li_plci_b_write_pos = plci_b_write_pos;
12179 }
12180 else
12181 {
12182 appl->appl_flags &= ~APPL_FLAG_OLD_LI_SPEC;
12183 if (api_parse(&li_parms[1].info[1], li_parms[1].length, "ds", li_req_parms))
12184 {
12185 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12186 UnMapId(Id), (char *)(FILE_), __LINE__));
12187 Info = _WRONG_MESSAGE_FORMAT;
12188 break;
12189 }
12190 li_flags = GET_DWORD(li_req_parms[0].info) & ~(LI2_FLAG_INTERCONNECT_A_B | LI2_FLAG_INTERCONNECT_B_A);
12191 Info = li_check_main_plci(Id, plci);
12192 result_buffer[0] = 7;
12193 result_buffer[3] = 4;
12194 PUT_WORD(&result_buffer[4], Info);
12195 result_buffer[6] = 0;
12196 if (Info != GOOD)
12197 break;
12198 result = plci->saved_msg.info;
12199 for (i = 0; i <= result_buffer[0]; i++)
12200 result[i] = result_buffer[i];
12201 plci_b_write_pos = plci->li_plci_b_write_pos;
12202 participant_parms_pos = 0;
12203 result_pos = 7;
12204 li2_update_connect(Id, a, plci, UnMapId(Id), true, li_flags);
12205 while (participant_parms_pos < li_req_parms[1].length)
12206 {
12207 result[result_pos] = 6;
12208 result_pos += 7;
12209 PUT_DWORD(&result[result_pos - 6], 0);
12210 PUT_WORD(&result[result_pos - 2], GOOD);
12211 if (api_parse(&li_req_parms[1].info[1 + participant_parms_pos],
12212 (word)(li_parms[1].length - participant_parms_pos), "s", li_participant_struct))
12213 {
12214 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12215 UnMapId(Id), (char *)(FILE_), __LINE__));
12216 PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12217 break;
12218 }
12219 if (api_parse(&li_participant_struct[0].info[1],
12220 li_participant_struct[0].length, "dd", li_participant_parms))
12221 {
12222 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12223 UnMapId(Id), (char *)(FILE_), __LINE__));
12224 PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12225 break;
12226 }
12227 plci_b_id = GET_DWORD(li_participant_parms[0].info) & 0xffff;
12228 li_flags = GET_DWORD(li_participant_parms[1].info);
12229 PUT_DWORD(&result[result_pos - 6], plci_b_id);
12230 if (sizeof(result) - result_pos < 7)
12231 {
12232 dbug(1, dprintf("[%06lx] %s,%d: LI result overrun",
12233 UnMapId(Id), (char *)(FILE_), __LINE__));
12234 PUT_WORD(&result[result_pos - 2], _WRONG_STATE);
12235 break;
12236 }
12237 plci_b = li2_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[result_pos - 2]);
12238 if (plci_b != NULL)
12239 {
12240 li2_update_connect(Id, a, plci, plci_b_id, true, li_flags);
12241 plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id |
12242 ((li_flags & (LI2_FLAG_INTERCONNECT_A_B | LI2_FLAG_INTERCONNECT_B_A |
12243 LI2_FLAG_PCCONNECT_A_B | LI2_FLAG_PCCONNECT_B_A)) ? 0 : LI_PLCI_B_DISC_FLAG);
12244 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12245 }
12246 participant_parms_pos = (word)((&li_participant_struct[0].info[1 + li_participant_struct[0].length]) -
12247 (&li_req_parms[1].info[1]));
12248 }
12249 result[0] = (byte)(result_pos - 1);
12250 result[3] = (byte)(result_pos - 4);
12251 result[6] = (byte)(result_pos - 7);
12252 i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES - 1 : plci_b_write_pos - 1;
12253 if ((plci_b_write_pos == plci->li_plci_b_read_pos)
12254 || (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG))
12255 {
12256 plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_FLAG | LI_PLCI_B_LAST_FLAG;
12257 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12258 }
12259 else
12260 plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG;
12261 plci->li_plci_b_write_pos = plci_b_write_pos;
12262 }
12263 mixer_calculate_coefs(a);
12264 plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel;
12265 mixer_notify_update(plci, true);
12266 sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
12267 "wwS", Info, SELECTOR_LINE_INTERCONNECT, result);
12268 plci->command = 0;
12269 plci->li_cmd = GET_WORD(li_parms[0].info);
12270 start_internal_command(Id, plci, mixer_command);
12271 return (false);
12272
12273 case LI_REQ_DISCONNECT:
12274 if (li_parms[1].length == 4)
12275 {
12276 appl->appl_flags |= APPL_FLAG_OLD_LI_SPEC;
12277 if (api_parse(&li_parms[1].info[1], li_parms[1].length, "d", li_req_parms))
12278 {
12279 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12280 UnMapId(Id), (char *)(FILE_), __LINE__));
12281 Info = _WRONG_MESSAGE_FORMAT;
12282 break;
12283 }
12284 plci_b_id = GET_DWORD(li_req_parms[0].info) & 0xffff;
12285 Info = li_check_main_plci(Id, plci);
12286 result_buffer[0] = 9;
12287 result_buffer[3] = 6;
12288 PUT_DWORD(&result_buffer[4], GET_DWORD(li_req_parms[0].info));
12289 PUT_WORD(&result_buffer[8], GOOD);
12290 if (Info != GOOD)
12291 break;
12292 result = plci->saved_msg.info;
12293 for (i = 0; i <= result_buffer[0]; i++)
12294 result[i] = result_buffer[i];
12295 plci_b_write_pos = plci->li_plci_b_write_pos;
12296 plci_b = li_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[8]);
12297 if (plci_b == NULL)
12298 break;
12299 li_update_connect(Id, a, plci, plci_b_id, false, 0);
12300 plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG | LI_PLCI_B_LAST_FLAG;
12301 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12302 plci->li_plci_b_write_pos = plci_b_write_pos;
12303 }
12304 else
12305 {
12306 appl->appl_flags &= ~APPL_FLAG_OLD_LI_SPEC;
12307 if (api_parse(&li_parms[1].info[1], li_parms[1].length, "s", li_req_parms))
12308 {
12309 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12310 UnMapId(Id), (char *)(FILE_), __LINE__));
12311 Info = _WRONG_MESSAGE_FORMAT;
12312 break;
12313 }
12314 Info = li_check_main_plci(Id, plci);
12315 result_buffer[0] = 7;
12316 result_buffer[3] = 4;
12317 PUT_WORD(&result_buffer[4], Info);
12318 result_buffer[6] = 0;
12319 if (Info != GOOD)
12320 break;
12321 result = plci->saved_msg.info;
12322 for (i = 0; i <= result_buffer[0]; i++)
12323 result[i] = result_buffer[i];
12324 plci_b_write_pos = plci->li_plci_b_write_pos;
12325 participant_parms_pos = 0;
12326 result_pos = 7;
12327 while (participant_parms_pos < li_req_parms[0].length)
12328 {
12329 result[result_pos] = 6;
12330 result_pos += 7;
12331 PUT_DWORD(&result[result_pos - 6], 0);
12332 PUT_WORD(&result[result_pos - 2], GOOD);
12333 if (api_parse(&li_req_parms[0].info[1 + participant_parms_pos],
12334 (word)(li_parms[1].length - participant_parms_pos), "s", li_participant_struct))
12335 {
12336 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12337 UnMapId(Id), (char *)(FILE_), __LINE__));
12338 PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12339 break;
12340 }
12341 if (api_parse(&li_participant_struct[0].info[1],
12342 li_participant_struct[0].length, "d", li_participant_parms))
12343 {
12344 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12345 UnMapId(Id), (char *)(FILE_), __LINE__));
12346 PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
12347 break;
12348 }
12349 plci_b_id = GET_DWORD(li_participant_parms[0].info) & 0xffff;
12350 PUT_DWORD(&result[result_pos - 6], plci_b_id);
12351 if (sizeof(result) - result_pos < 7)
12352 {
12353 dbug(1, dprintf("[%06lx] %s,%d: LI result overrun",
12354 UnMapId(Id), (char *)(FILE_), __LINE__));
12355 PUT_WORD(&result[result_pos - 2], _WRONG_STATE);
12356 break;
12357 }
12358 plci_b = li2_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[result_pos - 2]);
12359 if (plci_b != NULL)
12360 {
12361 li2_update_connect(Id, a, plci, plci_b_id, false, 0);
12362 plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG;
12363 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12364 }
12365 participant_parms_pos = (word)((&li_participant_struct[0].info[1 + li_participant_struct[0].length]) -
12366 (&li_req_parms[0].info[1]));
12367 }
12368 result[0] = (byte)(result_pos - 1);
12369 result[3] = (byte)(result_pos - 4);
12370 result[6] = (byte)(result_pos - 7);
12371 i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES - 1 : plci_b_write_pos - 1;
12372 if ((plci_b_write_pos == plci->li_plci_b_read_pos)
12373 || (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG))
12374 {
12375 plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_FLAG | LI_PLCI_B_LAST_FLAG;
12376 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12377 }
12378 else
12379 plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG;
12380 plci->li_plci_b_write_pos = plci_b_write_pos;
12381 }
12382 mixer_calculate_coefs(a);
12383 plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel;
12384 mixer_notify_update(plci, true);
12385 sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
12386 "wwS", Info, SELECTOR_LINE_INTERCONNECT, result);
12387 plci->command = 0;
12388 plci->li_cmd = GET_WORD(li_parms[0].info);
12389 start_internal_command(Id, plci, mixer_command);
12390 return (false);
12391
12392 case LI_REQ_SILENT_UPDATE:
12393 if (!plci || !plci->State
12394 || !plci->NL.Id || plci->nl_remove_id
12395 || (plci->li_bchannel_id == 0)
12396 || (li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci != plci))
12397 {
12398 dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
12399 UnMapId(Id), (char *)(FILE_), __LINE__));
12400 return (false);
12401 }
12402 plci_b_write_pos = plci->li_plci_b_write_pos;
12403 if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
12404 LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2)
12405 {
12406 dbug(1, dprintf("[%06lx] %s,%d: LI request overrun",
12407 UnMapId(Id), (char *)(FILE_), __LINE__));
12408 return (false);
12409 }
12410 i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES - 1 : plci_b_write_pos - 1;
12411 if ((plci_b_write_pos == plci->li_plci_b_read_pos)
12412 || (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG))
12413 {
12414 plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_FLAG | LI_PLCI_B_LAST_FLAG;
12415 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12416 }
12417 else
12418 plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG;
12419 plci->li_plci_b_write_pos = plci_b_write_pos;
12420 plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel;
12421 plci->command = 0;
12422 plci->li_cmd = GET_WORD(li_parms[0].info);
12423 start_internal_command(Id, plci, mixer_command);
12424 return (false);
12425
12426 default:
12427 dbug(1, dprintf("[%06lx] %s,%d: LI unknown request %04x",
12428 UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(li_parms[0].info)));
12429 Info = _FACILITY_NOT_SUPPORTED;
12430 }
12431 }
12432 sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
12433 "wwS", Info, SELECTOR_LINE_INTERCONNECT, result);
12434 return (false);
12435 }
12436
12437
12438 static void mixer_indication_coefs_set(dword Id, PLCI *plci)
12439 {
12440 dword d;
12441 byte result[12];
12442
12443 dbug(1, dprintf("[%06lx] %s,%d: mixer_indication_coefs_set",
12444 UnMapId(Id), (char *)(FILE_), __LINE__));
12445
12446 if (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos)
12447 {
12448 do
12449 {
12450 d = plci->li_plci_b_queue[plci->li_plci_b_read_pos];
12451 if (!(d & LI_PLCI_B_SKIP_FLAG))
12452 {
12453 if (plci->appl->appl_flags & APPL_FLAG_OLD_LI_SPEC)
12454 {
12455 if (d & LI_PLCI_B_DISC_FLAG)
12456 {
12457 result[0] = 5;
12458 PUT_WORD(&result[1], LI_IND_DISCONNECT);
12459 result[3] = 2;
12460 PUT_WORD(&result[4], _LI_USER_INITIATED);
12461 }
12462 else
12463 {
12464 result[0] = 7;
12465 PUT_WORD(&result[1], LI_IND_CONNECT_ACTIVE);
12466 result[3] = 4;
12467 PUT_DWORD(&result[4], d & ~LI_PLCI_B_FLAG_MASK);
12468 }
12469 }
12470 else
12471 {
12472 if (d & LI_PLCI_B_DISC_FLAG)
12473 {
12474 result[0] = 9;
12475 PUT_WORD(&result[1], LI_IND_DISCONNECT);
12476 result[3] = 6;
12477 PUT_DWORD(&result[4], d & ~LI_PLCI_B_FLAG_MASK);
12478 PUT_WORD(&result[8], _LI_USER_INITIATED);
12479 }
12480 else
12481 {
12482 result[0] = 7;
12483 PUT_WORD(&result[1], LI_IND_CONNECT_ACTIVE);
12484 result[3] = 4;
12485 PUT_DWORD(&result[4], d & ~LI_PLCI_B_FLAG_MASK);
12486 }
12487 }
12488 sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0,
12489 "ws", SELECTOR_LINE_INTERCONNECT, result);
12490 }
12491 plci->li_plci_b_read_pos = (plci->li_plci_b_read_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ?
12492 0 : plci->li_plci_b_read_pos + 1;
12493 } while (!(d & LI_PLCI_B_LAST_FLAG) && (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos));
12494 }
12495 }
12496
12497
12498 static void mixer_indication_xconnect_from(dword Id, PLCI *plci, byte *msg, word length)
12499 {
12500 word i, j, ch;
12501 struct xconnect_transfer_address_s s, *p;
12502 DIVA_CAPI_ADAPTER *a;
12503
12504 dbug(1, dprintf("[%06lx] %s,%d: mixer_indication_xconnect_from %d",
12505 UnMapId(Id), (char *)(FILE_), __LINE__, (int)length));
12506
12507 a = plci->adapter;
12508 i = 1;
12509 for (i = 1; i < length; i += 16)
12510 {
12511 s.card_address.low = msg[i] | (msg[i + 1] << 8) | (((dword)(msg[i + 2])) << 16) | (((dword)(msg[i + 3])) << 24);
12512 s.card_address.high = msg[i + 4] | (msg[i + 5] << 8) | (((dword)(msg[i + 6])) << 16) | (((dword)(msg[i + 7])) << 24);
12513 s.offset = msg[i + 8] | (msg[i + 9] << 8) | (((dword)(msg[i + 10])) << 16) | (((dword)(msg[i + 11])) << 24);
12514 ch = msg[i + 12] | (msg[i + 13] << 8);
12515 j = ch & XCONNECT_CHANNEL_NUMBER_MASK;
12516 if (!a->li_pri && (plci->li_bchannel_id == 2))
12517 j = 1 - j;
12518 j += a->li_base;
12519 if (ch & XCONNECT_CHANNEL_PORT_PC)
12520 p = &(li_config_table[j].send_pc);
12521 else
12522 p = &(li_config_table[j].send_b);
12523 p->card_address.low = s.card_address.low;
12524 p->card_address.high = s.card_address.high;
12525 p->offset = s.offset;
12526 li_config_table[j].channel |= LI_CHANNEL_ADDRESSES_SET;
12527 }
12528 if (plci->internal_command_queue[0]
12529 && ((plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2)
12530 || (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_3)
12531 || (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_4)))
12532 {
12533 (*(plci->internal_command_queue[0]))(Id, plci, 0);
12534 if (!plci->internal_command)
12535 next_internal_command(Id, plci);
12536 }
12537 mixer_notify_update(plci, true);
12538 }
12539
12540
12541 static void mixer_indication_xconnect_to(dword Id, PLCI *plci, byte *msg, word length)
12542 {
12543
12544 dbug(1, dprintf("[%06lx] %s,%d: mixer_indication_xconnect_to %d",
12545 UnMapId(Id), (char *)(FILE_), __LINE__, (int) length));
12546
12547 }
12548
12549
12550 static byte mixer_notify_source_removed(PLCI *plci, dword plci_b_id)
12551 {
12552 word plci_b_write_pos;
12553
12554 plci_b_write_pos = plci->li_plci_b_write_pos;
12555 if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
12556 LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 1)
12557 {
12558 dbug(1, dprintf("[%06lx] %s,%d: LI request overrun",
12559 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
12560 (char *)(FILE_), __LINE__));
12561 return (false);
12562 }
12563 plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG;
12564 plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
12565 plci->li_plci_b_write_pos = plci_b_write_pos;
12566 return (true);
12567 }
12568
12569
12570 static void mixer_remove(PLCI *plci)
12571 {
12572 DIVA_CAPI_ADAPTER *a;
12573 PLCI *notify_plci;
12574 dword plci_b_id;
12575 word i, j;
12576
12577 dbug(1, dprintf("[%06lx] %s,%d: mixer_remove",
12578 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
12579 (char *)(FILE_), __LINE__));
12580
12581 a = plci->adapter;
12582 plci_b_id = (plci->Id << 8) | UnMapController(plci->adapter->Id);
12583 if (a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED)
12584 {
12585 if ((plci->li_bchannel_id != 0)
12586 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
12587 {
12588 i = a->li_base + (plci->li_bchannel_id - 1);
12589 if ((li_config_table[i].curchnl | li_config_table[i].channel) & LI_CHANNEL_INVOLVED)
12590 {
12591 for (j = 0; j < li_total_channels; j++)
12592 {
12593 if ((li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
12594 || (li_config_table[j].flag_table[i] & LI_FLAG_INTERCONNECT))
12595 {
12596 notify_plci = li_config_table[j].plci;
12597 if ((notify_plci != NULL)
12598 && (notify_plci != plci)
12599 && (notify_plci->appl != NULL)
12600 && !(notify_plci->appl->appl_flags & APPL_FLAG_OLD_LI_SPEC)
12601 && (notify_plci->State)
12602 && notify_plci->NL.Id && !notify_plci->nl_remove_id)
12603 {
12604 mixer_notify_source_removed(notify_plci, plci_b_id);
12605 }
12606 }
12607 }
12608 mixer_clear_config(plci);
12609 mixer_calculate_coefs(a);
12610 mixer_notify_update(plci, true);
12611 }
12612 li_config_table[i].plci = NULL;
12613 plci->li_bchannel_id = 0;
12614 }
12615 }
12616 }
12617
12618
12619 /*------------------------------------------------------------------*/
12620 /* Echo canceller facilities */
12621 /*------------------------------------------------------------------*/
12622
12623
12624 static void ec_write_parameters(PLCI *plci)
12625 {
12626 word w;
12627 byte parameter_buffer[6];
12628
12629 dbug(1, dprintf("[%06lx] %s,%d: ec_write_parameters",
12630 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
12631 (char *)(FILE_), __LINE__));
12632
12633 parameter_buffer[0] = 5;
12634 parameter_buffer[1] = DSP_CTRL_SET_LEC_PARAMETERS;
12635 PUT_WORD(&parameter_buffer[2], plci->ec_idi_options);
12636 plci->ec_idi_options &= ~LEC_RESET_COEFFICIENTS;
12637 w = (plci->ec_tail_length == 0) ? 128 : plci->ec_tail_length;
12638 PUT_WORD(&parameter_buffer[4], w);
12639 add_p(plci, FTY, parameter_buffer);
12640 sig_req(plci, TEL_CTRL, 0);
12641 send_req(plci);
12642 }
12643
12644
12645 static void ec_clear_config(PLCI *plci)
12646 {
12647
12648 dbug(1, dprintf("[%06lx] %s,%d: ec_clear_config",
12649 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
12650 (char *)(FILE_), __LINE__));
12651
12652 plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER |
12653 LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING;
12654 plci->ec_tail_length = 0;
12655 }
12656
12657
12658 static void ec_prepare_switch(dword Id, PLCI *plci)
12659 {
12660
12661 dbug(1, dprintf("[%06lx] %s,%d: ec_prepare_switch",
12662 UnMapId(Id), (char *)(FILE_), __LINE__));
12663
12664 }
12665
12666
12667 static word ec_save_config(dword Id, PLCI *plci, byte Rc)
12668 {
12669
12670 dbug(1, dprintf("[%06lx] %s,%d: ec_save_config %02x %d",
12671 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
12672
12673 return (GOOD);
12674 }
12675
12676
12677 static word ec_restore_config(dword Id, PLCI *plci, byte Rc)
12678 {
12679 word Info;
12680
12681 dbug(1, dprintf("[%06lx] %s,%d: ec_restore_config %02x %d",
12682 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
12683
12684 Info = GOOD;
12685 if (plci->B1_facilities & B1_FACILITY_EC)
12686 {
12687 switch (plci->adjust_b_state)
12688 {
12689 case ADJUST_B_RESTORE_EC_1:
12690 plci->internal_command = plci->adjust_b_command;
12691 if (plci->sig_req)
12692 {
12693 plci->adjust_b_state = ADJUST_B_RESTORE_EC_1;
12694 break;
12695 }
12696 ec_write_parameters(plci);
12697 plci->adjust_b_state = ADJUST_B_RESTORE_EC_2;
12698 break;
12699 case ADJUST_B_RESTORE_EC_2:
12700 if ((Rc != OK) && (Rc != OK_FC))
12701 {
12702 dbug(1, dprintf("[%06lx] %s,%d: Restore EC failed %02x",
12703 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
12704 Info = _WRONG_STATE;
12705 break;
12706 }
12707 break;
12708 }
12709 }
12710 return (Info);
12711 }
12712
12713
12714 static void ec_command(dword Id, PLCI *plci, byte Rc)
12715 {
12716 word internal_command, Info;
12717 byte result[8];
12718
12719 dbug(1, dprintf("[%06lx] %s,%d: ec_command %02x %04x %04x %04x %d",
12720 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command,
12721 plci->ec_cmd, plci->ec_idi_options, plci->ec_tail_length));
12722
12723 Info = GOOD;
12724 if (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC)
12725 {
12726 result[0] = 2;
12727 PUT_WORD(&result[1], EC_SUCCESS);
12728 }
12729 else
12730 {
12731 result[0] = 5;
12732 PUT_WORD(&result[1], plci->ec_cmd);
12733 result[3] = 2;
12734 PUT_WORD(&result[4], GOOD);
12735 }
12736 internal_command = plci->internal_command;
12737 plci->internal_command = 0;
12738 switch (plci->ec_cmd)
12739 {
12740 case EC_ENABLE_OPERATION:
12741 case EC_FREEZE_COEFFICIENTS:
12742 case EC_RESUME_COEFFICIENT_UPDATE:
12743 case EC_RESET_COEFFICIENTS:
12744 switch (internal_command)
12745 {
12746 default:
12747 adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities |
12748 B1_FACILITY_EC), EC_COMMAND_1);
12749 case EC_COMMAND_1:
12750 if (adjust_b_process(Id, plci, Rc) != GOOD)
12751 {
12752 dbug(1, dprintf("[%06lx] %s,%d: Load EC failed",
12753 UnMapId(Id), (char *)(FILE_), __LINE__));
12754 Info = _FACILITY_NOT_SUPPORTED;
12755 break;
12756 }
12757 if (plci->internal_command)
12758 return;
12759 case EC_COMMAND_2:
12760 if (plci->sig_req)
12761 {
12762 plci->internal_command = EC_COMMAND_2;
12763 return;
12764 }
12765 plci->internal_command = EC_COMMAND_3;
12766 ec_write_parameters(plci);
12767 return;
12768 case EC_COMMAND_3:
12769 if ((Rc != OK) && (Rc != OK_FC))
12770 {
12771 dbug(1, dprintf("[%06lx] %s,%d: Enable EC failed %02x",
12772 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
12773 Info = _FACILITY_NOT_SUPPORTED;
12774 break;
12775 }
12776 break;
12777 }
12778 break;
12779
12780 case EC_DISABLE_OPERATION:
12781 switch (internal_command)
12782 {
12783 default:
12784 case EC_COMMAND_1:
12785 if (plci->B1_facilities & B1_FACILITY_EC)
12786 {
12787 if (plci->sig_req)
12788 {
12789 plci->internal_command = EC_COMMAND_1;
12790 return;
12791 }
12792 plci->internal_command = EC_COMMAND_2;
12793 ec_write_parameters(plci);
12794 return;
12795 }
12796 Rc = OK;
12797 case EC_COMMAND_2:
12798 if ((Rc != OK) && (Rc != OK_FC))
12799 {
12800 dbug(1, dprintf("[%06lx] %s,%d: Disable EC failed %02x",
12801 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
12802 Info = _FACILITY_NOT_SUPPORTED;
12803 break;
12804 }
12805 adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities &
12806 ~B1_FACILITY_EC), EC_COMMAND_3);
12807 case EC_COMMAND_3:
12808 if (adjust_b_process(Id, plci, Rc) != GOOD)
12809 {
12810 dbug(1, dprintf("[%06lx] %s,%d: Unload EC failed",
12811 UnMapId(Id), (char *)(FILE_), __LINE__));
12812 Info = _FACILITY_NOT_SUPPORTED;
12813 break;
12814 }
12815 if (plci->internal_command)
12816 return;
12817 break;
12818 }
12819 break;
12820 }
12821 sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->number,
12822 "wws", Info, (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ?
12823 PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result);
12824 }
12825
12826
12827 static byte ec_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg)
12828 {
12829 word Info;
12830 word opt;
12831 API_PARSE ec_parms[3];
12832 byte result[16];
12833
12834 dbug(1, dprintf("[%06lx] %s,%d: ec_request",
12835 UnMapId(Id), (char *)(FILE_), __LINE__));
12836
12837 Info = GOOD;
12838 result[0] = 0;
12839 if (!(a->man_profile.private_options & (1L << PRIVATE_ECHO_CANCELLER)))
12840 {
12841 dbug(1, dprintf("[%06lx] %s,%d: Facility not supported",
12842 UnMapId(Id), (char *)(FILE_), __LINE__));
12843 Info = _FACILITY_NOT_SUPPORTED;
12844 }
12845 else
12846 {
12847 if (appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC)
12848 {
12849 if (api_parse(&msg[1].info[1], msg[1].length, "w", ec_parms))
12850 {
12851 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12852 UnMapId(Id), (char *)(FILE_), __LINE__));
12853 Info = _WRONG_MESSAGE_FORMAT;
12854 }
12855 else
12856 {
12857 if (plci == NULL)
12858 {
12859 dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI",
12860 UnMapId(Id), (char *)(FILE_), __LINE__));
12861 Info = _WRONG_IDENTIFIER;
12862 }
12863 else if (!plci->State || !plci->NL.Id || plci->nl_remove_id)
12864 {
12865 dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
12866 UnMapId(Id), (char *)(FILE_), __LINE__));
12867 Info = _WRONG_STATE;
12868 }
12869 else
12870 {
12871 plci->command = 0;
12872 plci->ec_cmd = GET_WORD(ec_parms[0].info);
12873 plci->ec_idi_options &= ~(LEC_MANUAL_DISABLE | LEC_RESET_COEFFICIENTS);
12874 result[0] = 2;
12875 PUT_WORD(&result[1], EC_SUCCESS);
12876 if (msg[1].length >= 4)
12877 {
12878 opt = GET_WORD(&ec_parms[0].info[2]);
12879 plci->ec_idi_options &= ~(LEC_ENABLE_NONLINEAR_PROCESSING |
12880 LEC_ENABLE_2100HZ_DETECTOR | LEC_REQUIRE_2100HZ_REVERSALS);
12881 if (!(opt & EC_DISABLE_NON_LINEAR_PROCESSING))
12882 plci->ec_idi_options |= LEC_ENABLE_NONLINEAR_PROCESSING;
12883 if (opt & EC_DETECT_DISABLE_TONE)
12884 plci->ec_idi_options |= LEC_ENABLE_2100HZ_DETECTOR;
12885 if (!(opt & EC_DO_NOT_REQUIRE_REVERSALS))
12886 plci->ec_idi_options |= LEC_REQUIRE_2100HZ_REVERSALS;
12887 if (msg[1].length >= 6)
12888 {
12889 plci->ec_tail_length = GET_WORD(&ec_parms[0].info[4]);
12890 }
12891 }
12892 switch (plci->ec_cmd)
12893 {
12894 case EC_ENABLE_OPERATION:
12895 plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS;
12896 start_internal_command(Id, plci, ec_command);
12897 return (false);
12898
12899 case EC_DISABLE_OPERATION:
12900 plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER |
12901 LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING |
12902 LEC_RESET_COEFFICIENTS;
12903 start_internal_command(Id, plci, ec_command);
12904 return (false);
12905
12906 case EC_FREEZE_COEFFICIENTS:
12907 plci->ec_idi_options |= LEC_FREEZE_COEFFICIENTS;
12908 start_internal_command(Id, plci, ec_command);
12909 return (false);
12910
12911 case EC_RESUME_COEFFICIENT_UPDATE:
12912 plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS;
12913 start_internal_command(Id, plci, ec_command);
12914 return (false);
12915
12916 case EC_RESET_COEFFICIENTS:
12917 plci->ec_idi_options |= LEC_RESET_COEFFICIENTS;
12918 start_internal_command(Id, plci, ec_command);
12919 return (false);
12920
12921 default:
12922 dbug(1, dprintf("[%06lx] %s,%d: EC unknown request %04x",
12923 UnMapId(Id), (char *)(FILE_), __LINE__, plci->ec_cmd));
12924 PUT_WORD(&result[1], EC_UNSUPPORTED_OPERATION);
12925 }
12926 }
12927 }
12928 }
12929 else
12930 {
12931 if (api_parse(&msg[1].info[1], msg[1].length, "ws", ec_parms))
12932 {
12933 dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
12934 UnMapId(Id), (char *)(FILE_), __LINE__));
12935 Info = _WRONG_MESSAGE_FORMAT;
12936 }
12937 else
12938 {
12939 if (GET_WORD(ec_parms[0].info) == EC_GET_SUPPORTED_SERVICES)
12940 {
12941 result[0] = 11;
12942 PUT_WORD(&result[1], EC_GET_SUPPORTED_SERVICES);
12943 result[3] = 8;
12944 PUT_WORD(&result[4], GOOD);
12945 PUT_WORD(&result[6], 0x0007);
12946 PUT_WORD(&result[8], LEC_MAX_SUPPORTED_TAIL_LENGTH);
12947 PUT_WORD(&result[10], 0);
12948 }
12949 else if (plci == NULL)
12950 {
12951 dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI",
12952 UnMapId(Id), (char *)(FILE_), __LINE__));
12953 Info = _WRONG_IDENTIFIER;
12954 }
12955 else if (!plci->State || !plci->NL.Id || plci->nl_remove_id)
12956 {
12957 dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
12958 UnMapId(Id), (char *)(FILE_), __LINE__));
12959 Info = _WRONG_STATE;
12960 }
12961 else
12962 {
12963 plci->command = 0;
12964 plci->ec_cmd = GET_WORD(ec_parms[0].info);
12965 plci->ec_idi_options &= ~(LEC_MANUAL_DISABLE | LEC_RESET_COEFFICIENTS);
12966 result[0] = 5;
12967 PUT_WORD(&result[1], plci->ec_cmd);
12968 result[3] = 2;
12969 PUT_WORD(&result[4], GOOD);
12970 plci->ec_idi_options &= ~(LEC_ENABLE_NONLINEAR_PROCESSING |
12971 LEC_ENABLE_2100HZ_DETECTOR | LEC_REQUIRE_2100HZ_REVERSALS);
12972 plci->ec_tail_length = 0;
12973 if (ec_parms[1].length >= 2)
12974 {
12975 opt = GET_WORD(&ec_parms[1].info[1]);
12976 if (opt & EC_ENABLE_NON_LINEAR_PROCESSING)
12977 plci->ec_idi_options |= LEC_ENABLE_NONLINEAR_PROCESSING;
12978 if (opt & EC_DETECT_DISABLE_TONE)
12979 plci->ec_idi_options |= LEC_ENABLE_2100HZ_DETECTOR;
12980 if (!(opt & EC_DO_NOT_REQUIRE_REVERSALS))
12981 plci->ec_idi_options |= LEC_REQUIRE_2100HZ_REVERSALS;
12982 if (ec_parms[1].length >= 4)
12983 {
12984 plci->ec_tail_length = GET_WORD(&ec_parms[1].info[3]);
12985 }
12986 }
12987 switch (plci->ec_cmd)
12988 {
12989 case EC_ENABLE_OPERATION:
12990 plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS;
12991 start_internal_command(Id, plci, ec_command);
12992 return (false);
12993
12994 case EC_DISABLE_OPERATION:
12995 plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER |
12996 LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING |
12997 LEC_RESET_COEFFICIENTS;
12998 start_internal_command(Id, plci, ec_command);
12999 return (false);
13000
13001 default:
13002 dbug(1, dprintf("[%06lx] %s,%d: EC unknown request %04x",
13003 UnMapId(Id), (char *)(FILE_), __LINE__, plci->ec_cmd));
13004 PUT_WORD(&result[4], _FACILITY_SPECIFIC_FUNCTION_NOT_SUPP);
13005 }
13006 }
13007 }
13008 }
13009 }
13010 sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
13011 "wws", Info, (appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ?
13012 PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result);
13013 return (false);
13014 }
13015
13016
13017 static void ec_indication(dword Id, PLCI *plci, byte *msg, word length)
13018 {
13019 byte result[8];
13020
13021 dbug(1, dprintf("[%06lx] %s,%d: ec_indication",
13022 UnMapId(Id), (char *)(FILE_), __LINE__));
13023
13024 if (!(plci->ec_idi_options & LEC_MANUAL_DISABLE))
13025 {
13026 if (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC)
13027 {
13028 result[0] = 2;
13029 PUT_WORD(&result[1], 0);
13030 switch (msg[1])
13031 {
13032 case LEC_DISABLE_TYPE_CONTIGNUOUS_2100HZ:
13033 PUT_WORD(&result[1], EC_BYPASS_DUE_TO_CONTINUOUS_2100HZ);
13034 break;
13035 case LEC_DISABLE_TYPE_REVERSED_2100HZ:
13036 PUT_WORD(&result[1], EC_BYPASS_DUE_TO_REVERSED_2100HZ);
13037 break;
13038 case LEC_DISABLE_RELEASED:
13039 PUT_WORD(&result[1], EC_BYPASS_RELEASED);
13040 break;
13041 }
13042 }
13043 else
13044 {
13045 result[0] = 5;
13046 PUT_WORD(&result[1], EC_BYPASS_INDICATION);
13047 result[3] = 2;
13048 PUT_WORD(&result[4], 0);
13049 switch (msg[1])
13050 {
13051 case LEC_DISABLE_TYPE_CONTIGNUOUS_2100HZ:
13052 PUT_WORD(&result[4], EC_BYPASS_DUE_TO_CONTINUOUS_2100HZ);
13053 break;
13054 case LEC_DISABLE_TYPE_REVERSED_2100HZ:
13055 PUT_WORD(&result[4], EC_BYPASS_DUE_TO_REVERSED_2100HZ);
13056 break;
13057 case LEC_DISABLE_RELEASED:
13058 PUT_WORD(&result[4], EC_BYPASS_RELEASED);
13059 break;
13060 }
13061 }
13062 sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ?
13063 PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result);
13064 }
13065 }
13066
13067
13068
13069 /*------------------------------------------------------------------*/
13070 /* Advanced voice */
13071 /*------------------------------------------------------------------*/
13072
13073 static void adv_voice_write_coefs(PLCI *plci, word write_command)
13074 {
13075 DIVA_CAPI_ADAPTER *a;
13076 word i;
13077 byte *p;
13078
13079 word w, n, j, k;
13080 byte ch_map[MIXER_CHANNELS_BRI];
13081
13082 byte coef_buffer[ADV_VOICE_COEF_BUFFER_SIZE + 2];
13083
13084 dbug(1, dprintf("[%06lx] %s,%d: adv_voice_write_coefs %d",
13085 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13086 (char *)(FILE_), __LINE__, write_command));
13087
13088 a = plci->adapter;
13089 p = coef_buffer + 1;
13090 *(p++) = DSP_CTRL_OLD_SET_MIXER_COEFFICIENTS;
13091 i = 0;
13092 while (i + sizeof(word) <= a->adv_voice_coef_length)
13093 {
13094 PUT_WORD(p, GET_WORD(a->adv_voice_coef_buffer + i));
13095 p += 2;
13096 i += 2;
13097 }
13098 while (i < ADV_VOICE_OLD_COEF_COUNT * sizeof(word))
13099 {
13100 PUT_WORD(p, 0x8000);
13101 p += 2;
13102 i += 2;
13103 }
13104
13105 if (!a->li_pri && (plci->li_bchannel_id == 0))
13106 {
13107 if ((li_config_table[a->li_base].plci == NULL) && (li_config_table[a->li_base + 1].plci != NULL))
13108 {
13109 plci->li_bchannel_id = 1;
13110 li_config_table[a->li_base].plci = plci;
13111 dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id %d",
13112 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13113 (char *)(FILE_), __LINE__, plci->li_bchannel_id));
13114 }
13115 else if ((li_config_table[a->li_base].plci != NULL) && (li_config_table[a->li_base + 1].plci == NULL))
13116 {
13117 plci->li_bchannel_id = 2;
13118 li_config_table[a->li_base + 1].plci = plci;
13119 dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id %d",
13120 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13121 (char *)(FILE_), __LINE__, plci->li_bchannel_id));
13122 }
13123 }
13124 if (!a->li_pri && (plci->li_bchannel_id != 0)
13125 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
13126 {
13127 i = a->li_base + (plci->li_bchannel_id - 1);
13128 switch (write_command)
13129 {
13130 case ADV_VOICE_WRITE_ACTIVATION:
13131 j = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
13132 k = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
13133 if (!(plci->B1_facilities & B1_FACILITY_MIXER))
13134 {
13135 li_config_table[j].flag_table[i] |= LI_FLAG_CONFERENCE | LI_FLAG_MIX;
13136 li_config_table[i].flag_table[j] |= LI_FLAG_CONFERENCE | LI_FLAG_MONITOR;
13137 }
13138 if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13139 {
13140 li_config_table[k].flag_table[i] |= LI_FLAG_CONFERENCE | LI_FLAG_MIX;
13141 li_config_table[i].flag_table[k] |= LI_FLAG_CONFERENCE | LI_FLAG_MONITOR;
13142 li_config_table[k].flag_table[j] |= LI_FLAG_CONFERENCE;
13143 li_config_table[j].flag_table[k] |= LI_FLAG_CONFERENCE;
13144 }
13145 mixer_calculate_coefs(a);
13146 li_config_table[i].curchnl = li_config_table[i].channel;
13147 li_config_table[j].curchnl = li_config_table[j].channel;
13148 if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13149 li_config_table[k].curchnl = li_config_table[k].channel;
13150 break;
13151
13152 case ADV_VOICE_WRITE_DEACTIVATION:
13153 for (j = 0; j < li_total_channels; j++)
13154 {
13155 li_config_table[i].flag_table[j] = 0;
13156 li_config_table[j].flag_table[i] = 0;
13157 }
13158 k = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
13159 for (j = 0; j < li_total_channels; j++)
13160 {
13161 li_config_table[k].flag_table[j] = 0;
13162 li_config_table[j].flag_table[k] = 0;
13163 }
13164 if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13165 {
13166 k = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
13167 for (j = 0; j < li_total_channels; j++)
13168 {
13169 li_config_table[k].flag_table[j] = 0;
13170 li_config_table[j].flag_table[k] = 0;
13171 }
13172 }
13173 mixer_calculate_coefs(a);
13174 break;
13175 }
13176 if (plci->B1_facilities & B1_FACILITY_MIXER)
13177 {
13178 w = 0;
13179 if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length)
13180 w = GET_WORD(a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE);
13181 if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
13182 w |= MIXER_FEATURE_ENABLE_TX_DATA;
13183 if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
13184 w |= MIXER_FEATURE_ENABLE_RX_DATA;
13185 *(p++) = (byte) w;
13186 *(p++) = (byte)(w >> 8);
13187 for (j = 0; j < sizeof(ch_map); j += 2)
13188 {
13189 ch_map[j] = (byte)(j + (plci->li_bchannel_id - 1));
13190 ch_map[j + 1] = (byte)(j + (2 - plci->li_bchannel_id));
13191 }
13192 for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++)
13193 {
13194 i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch];
13195 j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch];
13196 if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED)
13197 {
13198 *(p++) = ((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01);
13199 w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
13200 li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4;
13201 }
13202 else
13203 {
13204 *(p++) = (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + n < a->adv_voice_coef_length) ?
13205 a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + n] : 0x00;
13206 }
13207 }
13208 }
13209 else
13210 {
13211 for (i = ADV_VOICE_NEW_COEF_BASE; i < a->adv_voice_coef_length; i++)
13212 *(p++) = a->adv_voice_coef_buffer[i];
13213 }
13214 }
13215 else
13216
13217 {
13218 for (i = ADV_VOICE_NEW_COEF_BASE; i < a->adv_voice_coef_length; i++)
13219 *(p++) = a->adv_voice_coef_buffer[i];
13220 }
13221 coef_buffer[0] = (p - coef_buffer) - 1;
13222 add_p(plci, FTY, coef_buffer);
13223 sig_req(plci, TEL_CTRL, 0);
13224 send_req(plci);
13225 }
13226
13227
13228 static void adv_voice_clear_config(PLCI *plci)
13229 {
13230 DIVA_CAPI_ADAPTER *a;
13231
13232 word i, j;
13233
13234
13235 dbug(1, dprintf("[%06lx] %s,%d: adv_voice_clear_config",
13236 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13237 (char *)(FILE_), __LINE__));
13238
13239 a = plci->adapter;
13240 if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
13241 {
13242 a->adv_voice_coef_length = 0;
13243
13244 if (!a->li_pri && (plci->li_bchannel_id != 0)
13245 && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
13246 {
13247 i = a->li_base + (plci->li_bchannel_id - 1);
13248 li_config_table[i].curchnl = 0;
13249 li_config_table[i].channel = 0;
13250 li_config_table[i].chflags = 0;
13251 for (j = 0; j < li_total_channels; j++)
13252 {
13253 li_config_table[i].flag_table[j] = 0;
13254 li_config_table[j].flag_table[i] = 0;
13255 li_config_table[i].coef_table[j] = 0;
13256 li_config_table[j].coef_table[i] = 0;
13257 }
13258 li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET;
13259 i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
13260 li_config_table[i].curchnl = 0;
13261 li_config_table[i].channel = 0;
13262 li_config_table[i].chflags = 0;
13263 for (j = 0; j < li_total_channels; j++)
13264 {
13265 li_config_table[i].flag_table[j] = 0;
13266 li_config_table[j].flag_table[i] = 0;
13267 li_config_table[i].coef_table[j] = 0;
13268 li_config_table[j].coef_table[i] = 0;
13269 }
13270 if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
13271 {
13272 i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
13273 li_config_table[i].curchnl = 0;
13274 li_config_table[i].channel = 0;
13275 li_config_table[i].chflags = 0;
13276 for (j = 0; j < li_total_channels; j++)
13277 {
13278 li_config_table[i].flag_table[j] = 0;
13279 li_config_table[j].flag_table[i] = 0;
13280 li_config_table[i].coef_table[j] = 0;
13281 li_config_table[j].coef_table[i] = 0;
13282 }
13283 }
13284 }
13285
13286 }
13287 }
13288
13289
13290 static void adv_voice_prepare_switch(dword Id, PLCI *plci)
13291 {
13292
13293 dbug(1, dprintf("[%06lx] %s,%d: adv_voice_prepare_switch",
13294 UnMapId(Id), (char *)(FILE_), __LINE__));
13295
13296 }
13297
13298
13299 static word adv_voice_save_config(dword Id, PLCI *plci, byte Rc)
13300 {
13301
13302 dbug(1, dprintf("[%06lx] %s,%d: adv_voice_save_config %02x %d",
13303 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
13304
13305 return (GOOD);
13306 }
13307
13308
13309 static word adv_voice_restore_config(dword Id, PLCI *plci, byte Rc)
13310 {
13311 DIVA_CAPI_ADAPTER *a;
13312 word Info;
13313
13314 dbug(1, dprintf("[%06lx] %s,%d: adv_voice_restore_config %02x %d",
13315 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
13316
13317 Info = GOOD;
13318 a = plci->adapter;
13319 if ((plci->B1_facilities & B1_FACILITY_VOICE)
13320 && (plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
13321 {
13322 switch (plci->adjust_b_state)
13323 {
13324 case ADJUST_B_RESTORE_VOICE_1:
13325 plci->internal_command = plci->adjust_b_command;
13326 if (plci->sig_req)
13327 {
13328 plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_1;
13329 break;
13330 }
13331 adv_voice_write_coefs(plci, ADV_VOICE_WRITE_UPDATE);
13332 plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_2;
13333 break;
13334 case ADJUST_B_RESTORE_VOICE_2:
13335 if ((Rc != OK) && (Rc != OK_FC))
13336 {
13337 dbug(1, dprintf("[%06lx] %s,%d: Restore voice config failed %02x",
13338 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
13339 Info = _WRONG_STATE;
13340 break;
13341 }
13342 break;
13343 }
13344 }
13345 return (Info);
13346 }
13347
13348
13349
13350
13351 /*------------------------------------------------------------------*/
13352 /* B1 resource switching */
13353 /*------------------------------------------------------------------*/
13354
13355 static byte b1_facilities_table[] =
13356 {
13357 0x00, /* 0 No bchannel resources */
13358 0x00, /* 1 Codec (automatic law) */
13359 0x00, /* 2 Codec (A-law) */
13360 0x00, /* 3 Codec (y-law) */
13361 0x00, /* 4 HDLC for X.21 */
13362 0x00, /* 5 HDLC */
13363 0x00, /* 6 External Device 0 */
13364 0x00, /* 7 External Device 1 */
13365 0x00, /* 8 HDLC 56k */
13366 0x00, /* 9 Transparent */
13367 0x00, /* 10 Loopback to network */
13368 0x00, /* 11 Test pattern to net */
13369 0x00, /* 12 Rate adaptation sync */
13370 0x00, /* 13 Rate adaptation async */
13371 0x00, /* 14 R-Interface */
13372 0x00, /* 15 HDLC 128k leased line */
13373 0x00, /* 16 FAX */
13374 0x00, /* 17 Modem async */
13375 0x00, /* 18 Modem sync HDLC */
13376 0x00, /* 19 V.110 async HDLC */
13377 0x12, /* 20 Adv voice (Trans,mixer) */
13378 0x00, /* 21 Codec connected to IC */
13379 0x0c, /* 22 Trans,DTMF */
13380 0x1e, /* 23 Trans,DTMF+mixer */
13381 0x1f, /* 24 Trans,DTMF+mixer+local */
13382 0x13, /* 25 Trans,mixer+local */
13383 0x12, /* 26 HDLC,mixer */
13384 0x12, /* 27 HDLC 56k,mixer */
13385 0x2c, /* 28 Trans,LEC+DTMF */
13386 0x3e, /* 29 Trans,LEC+DTMF+mixer */
13387 0x3f, /* 30 Trans,LEC+DTMF+mixer+local */
13388 0x2c, /* 31 RTP,LEC+DTMF */
13389 0x3e, /* 32 RTP,LEC+DTMF+mixer */
13390 0x3f, /* 33 RTP,LEC+DTMF+mixer+local */
13391 0x00, /* 34 Signaling task */
13392 0x00, /* 35 PIAFS */
13393 0x0c, /* 36 Trans,DTMF+TONE */
13394 0x1e, /* 37 Trans,DTMF+TONE+mixer */
13395 0x1f /* 38 Trans,DTMF+TONE+mixer+local*/
13396 };
13397
13398
13399 static word get_b1_facilities(PLCI *plci, byte b1_resource)
13400 {
13401 word b1_facilities;
13402
13403 b1_facilities = b1_facilities_table[b1_resource];
13404 if ((b1_resource == 9) || (b1_resource == 20) || (b1_resource == 25))
13405 {
13406
13407 if (!(((plci->requested_options_conn | plci->requested_options) & (1L << PRIVATE_DTMF_TONE))
13408 || (plci->appl && (plci->adapter->requested_options_table[plci->appl->Id - 1] & (1L << PRIVATE_DTMF_TONE)))))
13409
13410 {
13411 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_SEND)
13412 b1_facilities |= B1_FACILITY_DTMFX;
13413 if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE)
13414 b1_facilities |= B1_FACILITY_DTMFR;
13415 }
13416 }
13417 if ((b1_resource == 17) || (b1_resource == 18))
13418 {
13419 if (plci->adapter->manufacturer_features & (MANUFACTURER_FEATURE_V18 | MANUFACTURER_FEATURE_VOWN))
13420 b1_facilities |= B1_FACILITY_DTMFX | B1_FACILITY_DTMFR;
13421 }
13422 /*
13423 dbug (1, dprintf("[%06lx] %s,%d: get_b1_facilities %d %04x",
13424 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13425 (char far *)(FILE_), __LINE__, b1_resource, b1_facilites));
13426 */
13427 return (b1_facilities);
13428 }
13429
13430
13431 static byte add_b1_facilities(PLCI *plci, byte b1_resource, word b1_facilities)
13432 {
13433 byte b;
13434
13435 switch (b1_resource)
13436 {
13437 case 5:
13438 case 26:
13439 if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13440 b = 26;
13441 else
13442 b = 5;
13443 break;
13444
13445 case 8:
13446 case 27:
13447 if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13448 b = 27;
13449 else
13450 b = 8;
13451 break;
13452
13453 case 9:
13454 case 20:
13455 case 22:
13456 case 23:
13457 case 24:
13458 case 25:
13459 case 28:
13460 case 29:
13461 case 30:
13462 case 36:
13463 case 37:
13464 case 38:
13465 if (b1_facilities & B1_FACILITY_EC)
13466 {
13467 if (b1_facilities & B1_FACILITY_LOCAL)
13468 b = 30;
13469 else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13470 b = 29;
13471 else
13472 b = 28;
13473 }
13474
13475 else if ((b1_facilities & (B1_FACILITY_DTMFX | B1_FACILITY_DTMFR | B1_FACILITY_MIXER))
13476 && (((plci->requested_options_conn | plci->requested_options) & (1L << PRIVATE_DTMF_TONE))
13477 || (plci->appl && (plci->adapter->requested_options_table[plci->appl->Id - 1] & (1L << PRIVATE_DTMF_TONE)))))
13478 {
13479 if (b1_facilities & B1_FACILITY_LOCAL)
13480 b = 38;
13481 else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13482 b = 37;
13483 else
13484 b = 36;
13485 }
13486
13487 else if (((plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_HARDDTMF)
13488 && !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE))
13489 || ((b1_facilities & B1_FACILITY_DTMFR)
13490 && ((b1_facilities & B1_FACILITY_MIXER)
13491 || !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE)))
13492 || ((b1_facilities & B1_FACILITY_DTMFX)
13493 && ((b1_facilities & B1_FACILITY_MIXER)
13494 || !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_SEND))))
13495 {
13496 if (b1_facilities & B1_FACILITY_LOCAL)
13497 b = 24;
13498 else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13499 b = 23;
13500 else
13501 b = 22;
13502 }
13503 else
13504 {
13505 if (b1_facilities & B1_FACILITY_LOCAL)
13506 b = 25;
13507 else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13508 b = 20;
13509 else
13510 b = 9;
13511 }
13512 break;
13513
13514 case 31:
13515 case 32:
13516 case 33:
13517 if (b1_facilities & B1_FACILITY_LOCAL)
13518 b = 33;
13519 else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
13520 b = 32;
13521 else
13522 b = 31;
13523 break;
13524
13525 default:
13526 b = b1_resource;
13527 }
13528 dbug(1, dprintf("[%06lx] %s,%d: add_b1_facilities %d %04x %d %04x",
13529 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13530 (char *)(FILE_), __LINE__,
13531 b1_resource, b1_facilities, b, get_b1_facilities(plci, b)));
13532 return (b);
13533 }
13534
13535
13536 static void adjust_b1_facilities(PLCI *plci, byte new_b1_resource, word new_b1_facilities)
13537 {
13538 word removed_facilities;
13539
13540 dbug(1, dprintf("[%06lx] %s,%d: adjust_b1_facilities %d %04x %04x",
13541 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13542 (char *)(FILE_), __LINE__, new_b1_resource, new_b1_facilities,
13543 new_b1_facilities & get_b1_facilities(plci, new_b1_resource)));
13544
13545 new_b1_facilities &= get_b1_facilities(plci, new_b1_resource);
13546 removed_facilities = plci->B1_facilities & ~new_b1_facilities;
13547
13548 if (removed_facilities & B1_FACILITY_EC)
13549 ec_clear_config(plci);
13550
13551
13552 if (removed_facilities & B1_FACILITY_DTMFR)
13553 {
13554 dtmf_rec_clear_config(plci);
13555 dtmf_parameter_clear_config(plci);
13556 }
13557 if (removed_facilities & B1_FACILITY_DTMFX)
13558 dtmf_send_clear_config(plci);
13559
13560
13561 if (removed_facilities & B1_FACILITY_MIXER)
13562 mixer_clear_config(plci);
13563
13564 if (removed_facilities & B1_FACILITY_VOICE)
13565 adv_voice_clear_config(plci);
13566 plci->B1_facilities = new_b1_facilities;
13567 }
13568
13569
13570 static void adjust_b_clear(PLCI *plci)
13571 {
13572
13573 dbug(1, dprintf("[%06lx] %s,%d: adjust_b_clear",
13574 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
13575 (char *)(FILE_), __LINE__));
13576
13577 plci->adjust_b_restore = false;
13578 }
13579
13580
13581 static word adjust_b_process(dword Id, PLCI *plci, byte Rc)
13582 {
13583 word Info;
13584 byte b1_resource;
13585 NCCI *ncci_ptr;
13586 API_PARSE bp[2];
13587
13588 dbug(1, dprintf("[%06lx] %s,%d: adjust_b_process %02x %d",
13589 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
13590
13591 Info = GOOD;
13592 switch (plci->adjust_b_state)
13593 {
13594 case ADJUST_B_START:
13595 if ((plci->adjust_b_parms_msg == NULL)
13596 && (plci->adjust_b_mode & ADJUST_B_MODE_SWITCH_L1)
13597 && ((plci->adjust_b_mode & ~(ADJUST_B_MODE_SAVE | ADJUST_B_MODE_SWITCH_L1 |
13598 ADJUST_B_MODE_NO_RESOURCE | ADJUST_B_MODE_RESTORE)) == 0))
13599 {
13600 b1_resource = (plci->adjust_b_mode == ADJUST_B_MODE_NO_RESOURCE) ?
13601 0 : add_b1_facilities(plci, plci->B1_resource, plci->adjust_b_facilities);
13602 if (b1_resource == plci->B1_resource)
13603 {
13604 adjust_b1_facilities(plci, b1_resource, plci->adjust_b_facilities);
13605 break;
13606 }
13607 if (plci->adjust_b_facilities & ~get_b1_facilities(plci, b1_resource))
13608 {
13609 dbug(1, dprintf("[%06lx] %s,%d: Adjust B nonsupported facilities %d %d %04x",
13610 UnMapId(Id), (char *)(FILE_), __LINE__,
13611 plci->B1_resource, b1_resource, plci->adjust_b_facilities));
13612 Info = _WRONG_STATE;
13613 break;
13614 }
13615 }
13616 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13617 {
13618
13619 mixer_prepare_switch(Id, plci);
13620
13621
13622 dtmf_prepare_switch(Id, plci);
13623 dtmf_parameter_prepare_switch(Id, plci);
13624
13625
13626 ec_prepare_switch(Id, plci);
13627
13628 adv_voice_prepare_switch(Id, plci);
13629 }
13630 plci->adjust_b_state = ADJUST_B_SAVE_MIXER_1;
13631 Rc = OK;
13632 case ADJUST_B_SAVE_MIXER_1:
13633 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13634 {
13635
13636 Info = mixer_save_config(Id, plci, Rc);
13637 if ((Info != GOOD) || plci->internal_command)
13638 break;
13639
13640 }
13641 plci->adjust_b_state = ADJUST_B_SAVE_DTMF_1;
13642 Rc = OK;
13643 case ADJUST_B_SAVE_DTMF_1:
13644 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13645 {
13646
13647 Info = dtmf_save_config(Id, plci, Rc);
13648 if ((Info != GOOD) || plci->internal_command)
13649 break;
13650
13651 }
13652 plci->adjust_b_state = ADJUST_B_REMOVE_L23_1;
13653 case ADJUST_B_REMOVE_L23_1:
13654 if ((plci->adjust_b_mode & ADJUST_B_MODE_REMOVE_L23)
13655 && plci->NL.Id && !plci->nl_remove_id)
13656 {
13657 plci->internal_command = plci->adjust_b_command;
13658 if (plci->adjust_b_ncci != 0)
13659 {
13660 ncci_ptr = &(plci->adapter->ncci[plci->adjust_b_ncci]);
13661 while (ncci_ptr->data_pending)
13662 {
13663 plci->data_sent_ptr = ncci_ptr->DBuffer[ncci_ptr->data_out].P;
13664 data_rc(plci, plci->adapter->ncci_ch[plci->adjust_b_ncci]);
13665 }
13666 while (ncci_ptr->data_ack_pending)
13667 data_ack(plci, plci->adapter->ncci_ch[plci->adjust_b_ncci]);
13668 }
13669 nl_req_ncci(plci, REMOVE,
13670 (byte)((plci->adjust_b_mode & ADJUST_B_MODE_CONNECT) ? plci->adjust_b_ncci : 0));
13671 send_req(plci);
13672 plci->adjust_b_state = ADJUST_B_REMOVE_L23_2;
13673 break;
13674 }
13675 plci->adjust_b_state = ADJUST_B_REMOVE_L23_2;
13676 Rc = OK;
13677 case ADJUST_B_REMOVE_L23_2:
13678 if ((Rc != OK) && (Rc != OK_FC))
13679 {
13680 dbug(1, dprintf("[%06lx] %s,%d: Adjust B remove failed %02x",
13681 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
13682 Info = _WRONG_STATE;
13683 break;
13684 }
13685 if (plci->adjust_b_mode & ADJUST_B_MODE_REMOVE_L23)
13686 {
13687 if (plci_nl_busy(plci))
13688 {
13689 plci->internal_command = plci->adjust_b_command;
13690 break;
13691 }
13692 }
13693 plci->adjust_b_state = ADJUST_B_SAVE_EC_1;
13694 Rc = OK;
13695 case ADJUST_B_SAVE_EC_1:
13696 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13697 {
13698
13699 Info = ec_save_config(Id, plci, Rc);
13700 if ((Info != GOOD) || plci->internal_command)
13701 break;
13702
13703 }
13704 plci->adjust_b_state = ADJUST_B_SAVE_DTMF_PARAMETER_1;
13705 Rc = OK;
13706 case ADJUST_B_SAVE_DTMF_PARAMETER_1:
13707 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13708 {
13709
13710 Info = dtmf_parameter_save_config(Id, plci, Rc);
13711 if ((Info != GOOD) || plci->internal_command)
13712 break;
13713
13714 }
13715 plci->adjust_b_state = ADJUST_B_SAVE_VOICE_1;
13716 Rc = OK;
13717 case ADJUST_B_SAVE_VOICE_1:
13718 if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
13719 {
13720 Info = adv_voice_save_config(Id, plci, Rc);
13721 if ((Info != GOOD) || plci->internal_command)
13722 break;
13723 }
13724 plci->adjust_b_state = ADJUST_B_SWITCH_L1_1;
13725 case ADJUST_B_SWITCH_L1_1:
13726 if (plci->adjust_b_mode & ADJUST_B_MODE_SWITCH_L1)
13727 {
13728 if (plci->sig_req)
13729 {
13730 plci->internal_command = plci->adjust_b_command;
13731 break;
13732 }
13733 if (plci->adjust_b_parms_msg != NULL)
13734 api_load_msg(plci->adjust_b_parms_msg, bp);
13735 else
13736 api_load_msg(&plci->B_protocol, bp);
13737 Info = add_b1(plci, bp,
13738 (word)((plci->adjust_b_mode & ADJUST_B_MODE_NO_RESOURCE) ? 2 : 0),
13739 plci->adjust_b_facilities);
13740 if (Info != GOOD)
13741 {
13742 dbug(1, dprintf("[%06lx] %s,%d: Adjust B invalid L1 parameters %d %04x",
13743 UnMapId(Id), (char *)(FILE_), __LINE__,
13744 plci->B1_resource, plci->adjust_b_facilities));
13745 break;
13746 }
13747 plci->internal_command = plci->adjust_b_command;
13748 sig_req(plci, RESOURCES, 0);
13749 send_req(plci);
13750 plci->adjust_b_state = ADJUST_B_SWITCH_L1_2;
13751 break;
13752 }
13753 plci->adjust_b_state = ADJUST_B_SWITCH_L1_2;
13754 Rc = OK;
13755 case ADJUST_B_SWITCH_L1_2:
13756 if ((Rc != OK) && (Rc != OK_FC))
13757 {
13758 dbug(1, dprintf("[%06lx] %s,%d: Adjust B switch failed %02x %d %04x",
13759 UnMapId(Id), (char *)(FILE_), __LINE__,
13760 Rc, plci->B1_resource, plci->adjust_b_facilities));
13761 Info = _WRONG_STATE;
13762 break;
13763 }
13764 plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_1;
13765 Rc = OK;
13766 case ADJUST_B_RESTORE_VOICE_1:
13767 case ADJUST_B_RESTORE_VOICE_2:
13768 if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13769 {
13770 Info = adv_voice_restore_config(Id, plci, Rc);
13771 if ((Info != GOOD) || plci->internal_command)
13772 break;
13773 }
13774 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_1;
13775 Rc = OK;
13776 case ADJUST_B_RESTORE_DTMF_PARAMETER_1:
13777 case ADJUST_B_RESTORE_DTMF_PARAMETER_2:
13778 if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13779 {
13780
13781 Info = dtmf_parameter_restore_config(Id, plci, Rc);
13782 if ((Info != GOOD) || plci->internal_command)
13783 break;
13784
13785 }
13786 plci->adjust_b_state = ADJUST_B_RESTORE_EC_1;
13787 Rc = OK;
13788 case ADJUST_B_RESTORE_EC_1:
13789 case ADJUST_B_RESTORE_EC_2:
13790 if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13791 {
13792
13793 Info = ec_restore_config(Id, plci, Rc);
13794 if ((Info != GOOD) || plci->internal_command)
13795 break;
13796
13797 }
13798 plci->adjust_b_state = ADJUST_B_ASSIGN_L23_1;
13799 case ADJUST_B_ASSIGN_L23_1:
13800 if (plci->adjust_b_mode & ADJUST_B_MODE_ASSIGN_L23)
13801 {
13802 if (plci_nl_busy(plci))
13803 {
13804 plci->internal_command = plci->adjust_b_command;
13805 break;
13806 }
13807 if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT)
13808 plci->call_dir |= CALL_DIR_FORCE_OUTG_NL;
13809 if (plci->adjust_b_parms_msg != NULL)
13810 api_load_msg(plci->adjust_b_parms_msg, bp);
13811 else
13812 api_load_msg(&plci->B_protocol, bp);
13813 Info = add_b23(plci, bp);
13814 if (Info != GOOD)
13815 {
13816 dbug(1, dprintf("[%06lx] %s,%d: Adjust B invalid L23 parameters %04x",
13817 UnMapId(Id), (char *)(FILE_), __LINE__, Info));
13818 break;
13819 }
13820 plci->internal_command = plci->adjust_b_command;
13821 nl_req_ncci(plci, ASSIGN, 0);
13822 send_req(plci);
13823 plci->adjust_b_state = ADJUST_B_ASSIGN_L23_2;
13824 break;
13825 }
13826 plci->adjust_b_state = ADJUST_B_ASSIGN_L23_2;
13827 Rc = ASSIGN_OK;
13828 case ADJUST_B_ASSIGN_L23_2:
13829 if ((Rc != OK) && (Rc != OK_FC) && (Rc != ASSIGN_OK))
13830 {
13831 dbug(1, dprintf("[%06lx] %s,%d: Adjust B assign failed %02x",
13832 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
13833 Info = _WRONG_STATE;
13834 break;
13835 }
13836 if (plci->adjust_b_mode & ADJUST_B_MODE_ASSIGN_L23)
13837 {
13838 if (Rc != ASSIGN_OK)
13839 {
13840 plci->internal_command = plci->adjust_b_command;
13841 break;
13842 }
13843 }
13844 if (plci->adjust_b_mode & ADJUST_B_MODE_USER_CONNECT)
13845 {
13846 plci->adjust_b_restore = true;
13847 break;
13848 }
13849 plci->adjust_b_state = ADJUST_B_CONNECT_1;
13850 case ADJUST_B_CONNECT_1:
13851 if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT)
13852 {
13853 plci->internal_command = plci->adjust_b_command;
13854 if (plci_nl_busy(plci))
13855 break;
13856 nl_req_ncci(plci, N_CONNECT, 0);
13857 send_req(plci);
13858 plci->adjust_b_state = ADJUST_B_CONNECT_2;
13859 break;
13860 }
13861 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
13862 Rc = OK;
13863 case ADJUST_B_CONNECT_2:
13864 case ADJUST_B_CONNECT_3:
13865 case ADJUST_B_CONNECT_4:
13866 if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0))
13867 {
13868 dbug(1, dprintf("[%06lx] %s,%d: Adjust B connect failed %02x",
13869 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
13870 Info = _WRONG_STATE;
13871 break;
13872 }
13873 if (Rc == OK)
13874 {
13875 if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT)
13876 {
13877 get_ncci(plci, (byte)(Id >> 16), plci->adjust_b_ncci);
13878 Id = (Id & 0xffff) | (((dword)(plci->adjust_b_ncci)) << 16);
13879 }
13880 if (plci->adjust_b_state == ADJUST_B_CONNECT_2)
13881 plci->adjust_b_state = ADJUST_B_CONNECT_3;
13882 else if (plci->adjust_b_state == ADJUST_B_CONNECT_4)
13883 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
13884 }
13885 else if (Rc == 0)
13886 {
13887 if (plci->adjust_b_state == ADJUST_B_CONNECT_2)
13888 plci->adjust_b_state = ADJUST_B_CONNECT_4;
13889 else if (plci->adjust_b_state == ADJUST_B_CONNECT_3)
13890 plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
13891 }
13892 if (plci->adjust_b_state != ADJUST_B_RESTORE_DTMF_1)
13893 {
13894 plci->internal_command = plci->adjust_b_command;
13895 break;
13896 }
13897 Rc = OK;
13898 case ADJUST_B_RESTORE_DTMF_1:
13899 case ADJUST_B_RESTORE_DTMF_2:
13900 if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13901 {
13902
13903 Info = dtmf_restore_config(Id, plci, Rc);
13904 if ((Info != GOOD) || plci->internal_command)
13905 break;
13906
13907 }
13908 plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_1;
13909 Rc = OK;
13910 case ADJUST_B_RESTORE_MIXER_1:
13911 case ADJUST_B_RESTORE_MIXER_2:
13912 case ADJUST_B_RESTORE_MIXER_3:
13913 case ADJUST_B_RESTORE_MIXER_4:
13914 case ADJUST_B_RESTORE_MIXER_5:
13915 case ADJUST_B_RESTORE_MIXER_6:
13916 case ADJUST_B_RESTORE_MIXER_7:
13917 if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
13918 {
13919
13920 Info = mixer_restore_config(Id, plci, Rc);
13921 if ((Info != GOOD) || plci->internal_command)
13922 break;
13923
13924 }
13925 plci->adjust_b_state = ADJUST_B_END;
13926 case ADJUST_B_END:
13927 break;
13928 }
13929 return (Info);
13930 }
13931
13932
13933 static void adjust_b1_resource(dword Id, PLCI *plci, API_SAVE *bp_msg, word b1_facilities, word internal_command)
13934 {
13935
13936 dbug(1, dprintf("[%06lx] %s,%d: adjust_b1_resource %d %04x",
13937 UnMapId(Id), (char *)(FILE_), __LINE__,
13938 plci->B1_resource, b1_facilities));
13939
13940 plci->adjust_b_parms_msg = bp_msg;
13941 plci->adjust_b_facilities = b1_facilities;
13942 plci->adjust_b_command = internal_command;
13943 plci->adjust_b_ncci = (word)(Id >> 16);
13944 if ((bp_msg == NULL) && (plci->B1_resource == 0))
13945 plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_NO_RESOURCE | ADJUST_B_MODE_SWITCH_L1;
13946 else
13947 plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_SWITCH_L1 | ADJUST_B_MODE_RESTORE;
13948 plci->adjust_b_state = ADJUST_B_START;
13949 dbug(1, dprintf("[%06lx] %s,%d: Adjust B1 resource %d %04x...",
13950 UnMapId(Id), (char *)(FILE_), __LINE__,
13951 plci->B1_resource, b1_facilities));
13952 }
13953
13954
13955 static void adjust_b_restore(dword Id, PLCI *plci, byte Rc)
13956 {
13957 word internal_command;
13958
13959 dbug(1, dprintf("[%06lx] %s,%d: adjust_b_restore %02x %04x",
13960 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
13961
13962 internal_command = plci->internal_command;
13963 plci->internal_command = 0;
13964 switch (internal_command)
13965 {
13966 default:
13967 plci->command = 0;
13968 if (plci->req_in != 0)
13969 {
13970 plci->internal_command = ADJUST_B_RESTORE_1;
13971 break;
13972 }
13973 Rc = OK;
13974 case ADJUST_B_RESTORE_1:
13975 if ((Rc != OK) && (Rc != OK_FC))
13976 {
13977 dbug(1, dprintf("[%06lx] %s,%d: Adjust B enqueued failed %02x",
13978 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
13979 }
13980 plci->adjust_b_parms_msg = NULL;
13981 plci->adjust_b_facilities = plci->B1_facilities;
13982 plci->adjust_b_command = ADJUST_B_RESTORE_2;
13983 plci->adjust_b_ncci = (word)(Id >> 16);
13984 plci->adjust_b_mode = ADJUST_B_MODE_RESTORE;
13985 plci->adjust_b_state = ADJUST_B_START;
13986 dbug(1, dprintf("[%06lx] %s,%d: Adjust B restore...",
13987 UnMapId(Id), (char *)(FILE_), __LINE__));
13988 case ADJUST_B_RESTORE_2:
13989 if (adjust_b_process(Id, plci, Rc) != GOOD)
13990 {
13991 dbug(1, dprintf("[%06lx] %s,%d: Adjust B restore failed",
13992 UnMapId(Id), (char *)(FILE_), __LINE__));
13993 }
13994 if (plci->internal_command)
13995 break;
13996 break;
13997 }
13998 }
13999
14000
14001 static void reset_b3_command(dword Id, PLCI *plci, byte Rc)
14002 {
14003 word Info;
14004 word internal_command;
14005
14006 dbug(1, dprintf("[%06lx] %s,%d: reset_b3_command %02x %04x",
14007 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14008
14009 Info = GOOD;
14010 internal_command = plci->internal_command;
14011 plci->internal_command = 0;
14012 switch (internal_command)
14013 {
14014 default:
14015 plci->command = 0;
14016 plci->adjust_b_parms_msg = NULL;
14017 plci->adjust_b_facilities = plci->B1_facilities;
14018 plci->adjust_b_command = RESET_B3_COMMAND_1;
14019 plci->adjust_b_ncci = (word)(Id >> 16);
14020 plci->adjust_b_mode = ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_CONNECT;
14021 plci->adjust_b_state = ADJUST_B_START;
14022 dbug(1, dprintf("[%06lx] %s,%d: Reset B3...",
14023 UnMapId(Id), (char *)(FILE_), __LINE__));
14024 case RESET_B3_COMMAND_1:
14025 Info = adjust_b_process(Id, plci, Rc);
14026 if (Info != GOOD)
14027 {
14028 dbug(1, dprintf("[%06lx] %s,%d: Reset failed",
14029 UnMapId(Id), (char *)(FILE_), __LINE__));
14030 break;
14031 }
14032 if (plci->internal_command)
14033 return;
14034 break;
14035 }
14036 /* sendf (plci->appl, _RESET_B3_R | CONFIRM, Id, plci->number, "w", Info);*/
14037 sendf(plci->appl, _RESET_B3_I, Id, 0, "s", "");
14038 }
14039
14040
14041 static void select_b_command(dword Id, PLCI *plci, byte Rc)
14042 {
14043 word Info;
14044 word internal_command;
14045 byte esc_chi[3];
14046
14047 dbug(1, dprintf("[%06lx] %s,%d: select_b_command %02x %04x",
14048 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14049
14050 Info = GOOD;
14051 internal_command = plci->internal_command;
14052 plci->internal_command = 0;
14053 switch (internal_command)
14054 {
14055 default:
14056 plci->command = 0;
14057 plci->adjust_b_parms_msg = &plci->saved_msg;
14058 if ((plci->tel == ADV_VOICE) && (plci == plci->adapter->AdvSignalPLCI))
14059 plci->adjust_b_facilities = plci->B1_facilities | B1_FACILITY_VOICE;
14060 else
14061 plci->adjust_b_facilities = plci->B1_facilities & ~B1_FACILITY_VOICE;
14062 plci->adjust_b_command = SELECT_B_COMMAND_1;
14063 plci->adjust_b_ncci = (word)(Id >> 16);
14064 if (plci->saved_msg.parms[0].length == 0)
14065 {
14066 plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_SWITCH_L1 |
14067 ADJUST_B_MODE_NO_RESOURCE;
14068 }
14069 else
14070 {
14071 plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_SWITCH_L1 |
14072 ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_USER_CONNECT | ADJUST_B_MODE_RESTORE;
14073 }
14074 plci->adjust_b_state = ADJUST_B_START;
14075 dbug(1, dprintf("[%06lx] %s,%d: Select B protocol...",
14076 UnMapId(Id), (char *)(FILE_), __LINE__));
14077 case SELECT_B_COMMAND_1:
14078 Info = adjust_b_process(Id, plci, Rc);
14079 if (Info != GOOD)
14080 {
14081 dbug(1, dprintf("[%06lx] %s,%d: Select B protocol failed",
14082 UnMapId(Id), (char *)(FILE_), __LINE__));
14083 break;
14084 }
14085 if (plci->internal_command)
14086 return;
14087 if (plci->tel == ADV_VOICE)
14088 {
14089 esc_chi[0] = 0x02;
14090 esc_chi[1] = 0x18;
14091 esc_chi[2] = plci->b_channel;
14092 SetVoiceChannel(plci->adapter->AdvCodecPLCI, esc_chi, plci->adapter);
14093 }
14094 break;
14095 }
14096 sendf(plci->appl, _SELECT_B_REQ | CONFIRM, Id, plci->number, "w", Info);
14097 }
14098
14099
14100 static void fax_connect_ack_command(dword Id, PLCI *plci, byte Rc)
14101 {
14102 word internal_command;
14103
14104 dbug(1, dprintf("[%06lx] %s,%d: fax_connect_ack_command %02x %04x",
14105 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14106
14107 internal_command = plci->internal_command;
14108 plci->internal_command = 0;
14109 switch (internal_command)
14110 {
14111 default:
14112 plci->command = 0;
14113 case FAX_CONNECT_ACK_COMMAND_1:
14114 if (plci_nl_busy(plci))
14115 {
14116 plci->internal_command = FAX_CONNECT_ACK_COMMAND_1;
14117 return;
14118 }
14119 plci->internal_command = FAX_CONNECT_ACK_COMMAND_2;
14120 plci->NData[0].P = plci->fax_connect_info_buffer;
14121 plci->NData[0].PLength = plci->fax_connect_info_length;
14122 plci->NL.X = plci->NData;
14123 plci->NL.ReqCh = 0;
14124 plci->NL.Req = plci->nl_req = (byte) N_CONNECT_ACK;
14125 plci->adapter->request(&plci->NL);
14126 return;
14127 case FAX_CONNECT_ACK_COMMAND_2:
14128 if ((Rc != OK) && (Rc != OK_FC))
14129 {
14130 dbug(1, dprintf("[%06lx] %s,%d: FAX issue CONNECT ACK failed %02x",
14131 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14132 break;
14133 }
14134 }
14135 if ((plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
14136 && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
14137 {
14138 if (plci->B3_prot == 4)
14139 sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
14140 else
14141 sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
14142 plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
14143 }
14144 }
14145
14146
14147 static void fax_edata_ack_command(dword Id, PLCI *plci, byte Rc)
14148 {
14149 word internal_command;
14150
14151 dbug(1, dprintf("[%06lx] %s,%d: fax_edata_ack_command %02x %04x",
14152 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14153
14154 internal_command = plci->internal_command;
14155 plci->internal_command = 0;
14156 switch (internal_command)
14157 {
14158 default:
14159 plci->command = 0;
14160 case FAX_EDATA_ACK_COMMAND_1:
14161 if (plci_nl_busy(plci))
14162 {
14163 plci->internal_command = FAX_EDATA_ACK_COMMAND_1;
14164 return;
14165 }
14166 plci->internal_command = FAX_EDATA_ACK_COMMAND_2;
14167 plci->NData[0].P = plci->fax_connect_info_buffer;
14168 plci->NData[0].PLength = plci->fax_edata_ack_length;
14169 plci->NL.X = plci->NData;
14170 plci->NL.ReqCh = 0;
14171 plci->NL.Req = plci->nl_req = (byte) N_EDATA;
14172 plci->adapter->request(&plci->NL);
14173 return;
14174 case FAX_EDATA_ACK_COMMAND_2:
14175 if ((Rc != OK) && (Rc != OK_FC))
14176 {
14177 dbug(1, dprintf("[%06lx] %s,%d: FAX issue EDATA ACK failed %02x",
14178 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14179 break;
14180 }
14181 }
14182 }
14183
14184
14185 static void fax_connect_info_command(dword Id, PLCI *plci, byte Rc)
14186 {
14187 word Info;
14188 word internal_command;
14189
14190 dbug(1, dprintf("[%06lx] %s,%d: fax_connect_info_command %02x %04x",
14191 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14192
14193 Info = GOOD;
14194 internal_command = plci->internal_command;
14195 plci->internal_command = 0;
14196 switch (internal_command)
14197 {
14198 default:
14199 plci->command = 0;
14200 case FAX_CONNECT_INFO_COMMAND_1:
14201 if (plci_nl_busy(plci))
14202 {
14203 plci->internal_command = FAX_CONNECT_INFO_COMMAND_1;
14204 return;
14205 }
14206 plci->internal_command = FAX_CONNECT_INFO_COMMAND_2;
14207 plci->NData[0].P = plci->fax_connect_info_buffer;
14208 plci->NData[0].PLength = plci->fax_connect_info_length;
14209 plci->NL.X = plci->NData;
14210 plci->NL.ReqCh = 0;
14211 plci->NL.Req = plci->nl_req = (byte) N_EDATA;
14212 plci->adapter->request(&plci->NL);
14213 return;
14214 case FAX_CONNECT_INFO_COMMAND_2:
14215 if ((Rc != OK) && (Rc != OK_FC))
14216 {
14217 dbug(1, dprintf("[%06lx] %s,%d: FAX setting connect info failed %02x",
14218 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14219 Info = _WRONG_STATE;
14220 break;
14221 }
14222 if (plci_nl_busy(plci))
14223 {
14224 plci->internal_command = FAX_CONNECT_INFO_COMMAND_2;
14225 return;
14226 }
14227 plci->command = _CONNECT_B3_R;
14228 nl_req_ncci(plci, N_CONNECT, 0);
14229 send_req(plci);
14230 return;
14231 }
14232 sendf(plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info);
14233 }
14234
14235
14236 static void fax_adjust_b23_command(dword Id, PLCI *plci, byte Rc)
14237 {
14238 word Info;
14239 word internal_command;
14240
14241 dbug(1, dprintf("[%06lx] %s,%d: fax_adjust_b23_command %02x %04x",
14242 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14243
14244 Info = GOOD;
14245 internal_command = plci->internal_command;
14246 plci->internal_command = 0;
14247 switch (internal_command)
14248 {
14249 default:
14250 plci->command = 0;
14251 plci->adjust_b_parms_msg = NULL;
14252 plci->adjust_b_facilities = plci->B1_facilities;
14253 plci->adjust_b_command = FAX_ADJUST_B23_COMMAND_1;
14254 plci->adjust_b_ncci = (word)(Id >> 16);
14255 plci->adjust_b_mode = ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_ASSIGN_L23;
14256 plci->adjust_b_state = ADJUST_B_START;
14257 dbug(1, dprintf("[%06lx] %s,%d: FAX adjust B23...",
14258 UnMapId(Id), (char *)(FILE_), __LINE__));
14259 case FAX_ADJUST_B23_COMMAND_1:
14260 Info = adjust_b_process(Id, plci, Rc);
14261 if (Info != GOOD)
14262 {
14263 dbug(1, dprintf("[%06lx] %s,%d: FAX adjust failed",
14264 UnMapId(Id), (char *)(FILE_), __LINE__));
14265 break;
14266 }
14267 if (plci->internal_command)
14268 return;
14269 case FAX_ADJUST_B23_COMMAND_2:
14270 if (plci_nl_busy(plci))
14271 {
14272 plci->internal_command = FAX_ADJUST_B23_COMMAND_2;
14273 return;
14274 }
14275 plci->command = _CONNECT_B3_R;
14276 nl_req_ncci(plci, N_CONNECT, 0);
14277 send_req(plci);
14278 return;
14279 }
14280 sendf(plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info);
14281 }
14282
14283
14284 static void fax_disconnect_command(dword Id, PLCI *plci, byte Rc)
14285 {
14286 word internal_command;
14287
14288 dbug(1, dprintf("[%06lx] %s,%d: fax_disconnect_command %02x %04x",
14289 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14290
14291 internal_command = plci->internal_command;
14292 plci->internal_command = 0;
14293 switch (internal_command)
14294 {
14295 default:
14296 plci->command = 0;
14297 plci->internal_command = FAX_DISCONNECT_COMMAND_1;
14298 return;
14299 case FAX_DISCONNECT_COMMAND_1:
14300 case FAX_DISCONNECT_COMMAND_2:
14301 case FAX_DISCONNECT_COMMAND_3:
14302 if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0))
14303 {
14304 dbug(1, dprintf("[%06lx] %s,%d: FAX disconnect EDATA failed %02x",
14305 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14306 break;
14307 }
14308 if (Rc == OK)
14309 {
14310 if ((internal_command == FAX_DISCONNECT_COMMAND_1)
14311 || (internal_command == FAX_DISCONNECT_COMMAND_2))
14312 {
14313 plci->internal_command = FAX_DISCONNECT_COMMAND_2;
14314 }
14315 }
14316 else if (Rc == 0)
14317 {
14318 if (internal_command == FAX_DISCONNECT_COMMAND_1)
14319 plci->internal_command = FAX_DISCONNECT_COMMAND_3;
14320 }
14321 return;
14322 }
14323 }
14324
14325
14326
14327 static void rtp_connect_b3_req_command(dword Id, PLCI *plci, byte Rc)
14328 {
14329 word Info;
14330 word internal_command;
14331
14332 dbug(1, dprintf("[%06lx] %s,%d: rtp_connect_b3_req_command %02x %04x",
14333 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14334
14335 Info = GOOD;
14336 internal_command = plci->internal_command;
14337 plci->internal_command = 0;
14338 switch (internal_command)
14339 {
14340 default:
14341 plci->command = 0;
14342 case RTP_CONNECT_B3_REQ_COMMAND_1:
14343 if (plci_nl_busy(plci))
14344 {
14345 plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_1;
14346 return;
14347 }
14348 plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_2;
14349 nl_req_ncci(plci, N_CONNECT, 0);
14350 send_req(plci);
14351 return;
14352 case RTP_CONNECT_B3_REQ_COMMAND_2:
14353 if ((Rc != OK) && (Rc != OK_FC))
14354 {
14355 dbug(1, dprintf("[%06lx] %s,%d: RTP setting connect info failed %02x",
14356 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14357 Info = _WRONG_STATE;
14358 break;
14359 }
14360 if (plci_nl_busy(plci))
14361 {
14362 plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_2;
14363 return;
14364 }
14365 plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_3;
14366 plci->NData[0].PLength = plci->internal_req_buffer[0];
14367 plci->NData[0].P = plci->internal_req_buffer + 1;
14368 plci->NL.X = plci->NData;
14369 plci->NL.ReqCh = 0;
14370 plci->NL.Req = plci->nl_req = (byte) N_UDATA;
14371 plci->adapter->request(&plci->NL);
14372 break;
14373 case RTP_CONNECT_B3_REQ_COMMAND_3:
14374 return;
14375 }
14376 sendf(plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info);
14377 }
14378
14379
14380 static void rtp_connect_b3_res_command(dword Id, PLCI *plci, byte Rc)
14381 {
14382 word internal_command;
14383
14384 dbug(1, dprintf("[%06lx] %s,%d: rtp_connect_b3_res_command %02x %04x",
14385 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14386
14387 internal_command = plci->internal_command;
14388 plci->internal_command = 0;
14389 switch (internal_command)
14390 {
14391 default:
14392 plci->command = 0;
14393 case RTP_CONNECT_B3_RES_COMMAND_1:
14394 if (plci_nl_busy(plci))
14395 {
14396 plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_1;
14397 return;
14398 }
14399 plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_2;
14400 nl_req_ncci(plci, N_CONNECT_ACK, (byte)(Id >> 16));
14401 send_req(plci);
14402 return;
14403 case RTP_CONNECT_B3_RES_COMMAND_2:
14404 if ((Rc != OK) && (Rc != OK_FC))
14405 {
14406 dbug(1, dprintf("[%06lx] %s,%d: RTP setting connect resp info failed %02x",
14407 UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
14408 break;
14409 }
14410 if (plci_nl_busy(plci))
14411 {
14412 plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_2;
14413 return;
14414 }
14415 sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
14416 plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_3;
14417 plci->NData[0].PLength = plci->internal_req_buffer[0];
14418 plci->NData[0].P = plci->internal_req_buffer + 1;
14419 plci->NL.X = plci->NData;
14420 plci->NL.ReqCh = 0;
14421 plci->NL.Req = plci->nl_req = (byte) N_UDATA;
14422 plci->adapter->request(&plci->NL);
14423 return;
14424 case RTP_CONNECT_B3_RES_COMMAND_3:
14425 return;
14426 }
14427 }
14428
14429
14430
14431 static void hold_save_command(dword Id, PLCI *plci, byte Rc)
14432 {
14433 byte SS_Ind[] = "\x05\x02\x00\x02\x00\x00"; /* Hold_Ind struct*/
14434 word Info;
14435 word internal_command;
14436
14437 dbug(1, dprintf("[%06lx] %s,%d: hold_save_command %02x %04x",
14438 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14439
14440 Info = GOOD;
14441 internal_command = plci->internal_command;
14442 plci->internal_command = 0;
14443 switch (internal_command)
14444 {
14445 default:
14446 if (!plci->NL.Id)
14447 break;
14448 plci->command = 0;
14449 plci->adjust_b_parms_msg = NULL;
14450 plci->adjust_b_facilities = plci->B1_facilities;
14451 plci->adjust_b_command = HOLD_SAVE_COMMAND_1;
14452 plci->adjust_b_ncci = (word)(Id >> 16);
14453 plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23;
14454 plci->adjust_b_state = ADJUST_B_START;
14455 dbug(1, dprintf("[%06lx] %s,%d: HOLD save...",
14456 UnMapId(Id), (char *)(FILE_), __LINE__));
14457 case HOLD_SAVE_COMMAND_1:
14458 Info = adjust_b_process(Id, plci, Rc);
14459 if (Info != GOOD)
14460 {
14461 dbug(1, dprintf("[%06lx] %s,%d: HOLD save failed",
14462 UnMapId(Id), (char *)(FILE_), __LINE__));
14463 break;
14464 }
14465 if (plci->internal_command)
14466 return;
14467 }
14468 sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", 3, SS_Ind);
14469 }
14470
14471
14472 static void retrieve_restore_command(dword Id, PLCI *plci, byte Rc)
14473 {
14474 byte SS_Ind[] = "\x05\x03\x00\x02\x00\x00"; /* Retrieve_Ind struct*/
14475 word Info;
14476 word internal_command;
14477
14478 dbug(1, dprintf("[%06lx] %s,%d: retrieve_restore_command %02x %04x",
14479 UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
14480
14481 Info = GOOD;
14482 internal_command = plci->internal_command;
14483 plci->internal_command = 0;
14484 switch (internal_command)
14485 {
14486 default:
14487 plci->command = 0;
14488 plci->adjust_b_parms_msg = NULL;
14489 plci->adjust_b_facilities = plci->B1_facilities;
14490 plci->adjust_b_command = RETRIEVE_RESTORE_COMMAND_1;
14491 plci->adjust_b_ncci = (word)(Id >> 16);
14492 plci->adjust_b_mode = ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_USER_CONNECT | ADJUST_B_MODE_RESTORE;
14493 plci->adjust_b_state = ADJUST_B_START;
14494 dbug(1, dprintf("[%06lx] %s,%d: RETRIEVE restore...",
14495 UnMapId(Id), (char *)(FILE_), __LINE__));
14496 case RETRIEVE_RESTORE_COMMAND_1:
14497 Info = adjust_b_process(Id, plci, Rc);
14498 if (Info != GOOD)
14499 {
14500 dbug(1, dprintf("[%06lx] %s,%d: RETRIEVE restore failed",
14501 UnMapId(Id), (char *)(FILE_), __LINE__));
14502 break;
14503 }
14504 if (plci->internal_command)
14505 return;
14506 }
14507 sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", 3, SS_Ind);
14508 }
14509
14510
14511 static void init_b1_config(PLCI *plci)
14512 {
14513
14514 dbug(1, dprintf("[%06lx] %s,%d: init_b1_config",
14515 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
14516 (char *)(FILE_), __LINE__));
14517
14518 plci->B1_resource = 0;
14519 plci->B1_facilities = 0;
14520
14521 plci->li_bchannel_id = 0;
14522 mixer_clear_config(plci);
14523
14524
14525 ec_clear_config(plci);
14526
14527
14528 dtmf_rec_clear_config(plci);
14529 dtmf_send_clear_config(plci);
14530 dtmf_parameter_clear_config(plci);
14531
14532 adv_voice_clear_config(plci);
14533 adjust_b_clear(plci);
14534 }
14535
14536
14537 static void clear_b1_config(PLCI *plci)
14538 {
14539
14540 dbug(1, dprintf("[%06lx] %s,%d: clear_b1_config",
14541 (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
14542 (char *)(FILE_), __LINE__));
14543
14544 adv_voice_clear_config(plci);
14545 adjust_b_clear(plci);
14546
14547 ec_clear_config(plci);
14548
14549
14550 dtmf_rec_clear_config(plci);
14551 dtmf_send_clear_config(plci);
14552 dtmf_parameter_clear_config(plci);
14553
14554
14555 if ((plci->li_bchannel_id != 0)
14556 && (li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci == plci))
14557 {
14558 mixer_clear_config(plci);
14559 li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci = NULL;
14560 plci->li_bchannel_id = 0;
14561 }
14562
14563 plci->B1_resource = 0;
14564 plci->B1_facilities = 0;
14565 }
14566
14567
14568 /* -----------------------------------------------------------------
14569 XON protocol local helpers
14570 ----------------------------------------------------------------- */
14571 static void channel_flow_control_remove(PLCI *plci) {
14572 DIVA_CAPI_ADAPTER *a = plci->adapter;
14573 word i;
14574 for (i = 1; i < MAX_NL_CHANNEL + 1; i++) {
14575 if (a->ch_flow_plci[i] == plci->Id) {
14576 a->ch_flow_plci[i] = 0;
14577 a->ch_flow_control[i] = 0;
14578 }
14579 }
14580 }
14581
14582 static void channel_x_on(PLCI *plci, byte ch) {
14583 DIVA_CAPI_ADAPTER *a = plci->adapter;
14584 if (a->ch_flow_control[ch] & N_XON_SENT) {
14585 a->ch_flow_control[ch] &= ~N_XON_SENT;
14586 }
14587 }
14588
14589 static void channel_x_off(PLCI *plci, byte ch, byte flag) {
14590 DIVA_CAPI_ADAPTER *a = plci->adapter;
14591 if ((a->ch_flow_control[ch] & N_RX_FLOW_CONTROL_MASK) == 0) {
14592 a->ch_flow_control[ch] |= (N_CH_XOFF | flag);
14593 a->ch_flow_plci[ch] = plci->Id;
14594 a->ch_flow_control_pending++;
14595 }
14596 }
14597
14598 static void channel_request_xon(PLCI *plci, byte ch) {
14599 DIVA_CAPI_ADAPTER *a = plci->adapter;
14600
14601 if (a->ch_flow_control[ch] & N_CH_XOFF) {
14602 a->ch_flow_control[ch] |= N_XON_REQ;
14603 a->ch_flow_control[ch] &= ~N_CH_XOFF;
14604 a->ch_flow_control[ch] &= ~N_XON_CONNECT_IND;
14605 }
14606 }
14607
14608 static void channel_xmit_extended_xon(PLCI *plci) {
14609 DIVA_CAPI_ADAPTER *a;
14610 int max_ch = ARRAY_SIZE(a->ch_flow_control);
14611 int i, one_requested = 0;
14612
14613 if ((!plci) || (!plci->Id) || ((a = plci->adapter) == NULL)) {
14614 return;
14615 }
14616
14617 for (i = 0; i < max_ch; i++) {
14618 if ((a->ch_flow_control[i] & N_CH_XOFF) &&
14619 (a->ch_flow_control[i] & N_XON_CONNECT_IND) &&
14620 (plci->Id == a->ch_flow_plci[i])) {
14621 channel_request_xon(plci, (byte)i);
14622 one_requested = 1;
14623 }
14624 }
14625
14626 if (one_requested) {
14627 channel_xmit_xon(plci);
14628 }
14629 }
14630
14631 /*
14632 Try to xmit next X_ON
14633 */
14634 static int find_channel_with_pending_x_on(DIVA_CAPI_ADAPTER *a, PLCI *plci) {
14635 int max_ch = ARRAY_SIZE(a->ch_flow_control);
14636 int i;
14637
14638 if (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL)) {
14639 return (0);
14640 }
14641
14642 if (a->last_flow_control_ch >= max_ch) {
14643 a->last_flow_control_ch = 1;
14644 }
14645 for (i = a->last_flow_control_ch; i < max_ch; i++) {
14646 if ((a->ch_flow_control[i] & N_XON_REQ) &&
14647 (plci->Id == a->ch_flow_plci[i])) {
14648 a->last_flow_control_ch = i + 1;
14649 return (i);
14650 }
14651 }
14652
14653 for (i = 1; i < a->last_flow_control_ch; i++) {
14654 if ((a->ch_flow_control[i] & N_XON_REQ) &&
14655 (plci->Id == a->ch_flow_plci[i])) {
14656 a->last_flow_control_ch = i + 1;
14657 return (i);
14658 }
14659 }
14660
14661 return (0);
14662 }
14663
14664 static void channel_xmit_xon(PLCI *plci) {
14665 DIVA_CAPI_ADAPTER *a = plci->adapter;
14666 byte ch;
14667
14668 if (plci->nl_req || !plci->NL.Id || plci->nl_remove_id) {
14669 return;
14670 }
14671 if ((ch = (byte)find_channel_with_pending_x_on(a, plci)) == 0) {
14672 return;
14673 }
14674 a->ch_flow_control[ch] &= ~N_XON_REQ;
14675 a->ch_flow_control[ch] |= N_XON_SENT;
14676
14677 plci->NL.Req = plci->nl_req = (byte)N_XON;
14678 plci->NL.ReqCh = ch;
14679 plci->NL.X = plci->NData;
14680 plci->NL.XNum = 1;
14681 plci->NData[0].P = &plci->RBuffer[0];
14682 plci->NData[0].PLength = 0;
14683
14684 plci->adapter->request(&plci->NL);
14685 }
14686
14687 static int channel_can_xon(PLCI *plci, byte ch) {
14688 APPL *APPLptr;
14689 DIVA_CAPI_ADAPTER *a;
14690 word NCCIcode;
14691 dword count;
14692 word Num;
14693 word i;
14694
14695 APPLptr = plci->appl;
14696 a = plci->adapter;
14697
14698 if (!APPLptr)
14699 return (0);
14700
14701 NCCIcode = a->ch_ncci[ch] | (((word) a->Id) << 8);
14702
14703 /* count all buffers within the Application pool */
14704 /* belonging to the same NCCI. XON if a first is */
14705 /* used. */
14706 count = 0;
14707 Num = 0xffff;
14708 for (i = 0; i < APPLptr->MaxBuffer; i++) {
14709 if (NCCIcode == APPLptr->DataNCCI[i]) count++;
14710 if (!APPLptr->DataNCCI[i] && Num == 0xffff) Num = i;
14711 }
14712 if ((count > 2) || (Num == 0xffff)) {
14713 return (0);
14714 }
14715 return (1);
14716 }
14717
14718
14719 /*------------------------------------------------------------------*/
14720
14721 static word CPN_filter_ok(byte *cpn, DIVA_CAPI_ADAPTER *a, word offset)
14722 {
14723 return 1;
14724 }
14725
14726
14727
14728 /**********************************************************************************/
14729 /* function groups the listening applications according to the CIP mask and the */
14730 /* Info_Mask. Each group gets just one Connect_Ind. Some application manufacturer */
14731 /* are not multi-instance capable, so they start e.g. 30 applications what causes */
14732 /* big problems on application level (one call, 30 Connect_Ind, ect). The */
14733 /* function must be enabled by setting "a->group_optimization_enabled" from the */
14734 /* OS specific part (per adapter). */
14735 /**********************************************************************************/
14736 static void group_optimization(DIVA_CAPI_ADAPTER *a, PLCI *plci)
14737 {
14738 word i, j, k, busy, group_found;
14739 dword info_mask_group[MAX_CIP_TYPES];
14740 dword cip_mask_group[MAX_CIP_TYPES];
14741 word appl_number_group_type[MAX_APPL];
14742 PLCI *auxplci;
14743
14744 set_group_ind_mask(plci); /* all APPLs within this inc. call are allowed to dial in */
14745
14746 if (!a->group_optimization_enabled)
14747 {
14748 dbug(1, dprintf("No group optimization"));
14749 return;
14750 }
14751
14752 dbug(1, dprintf("Group optimization = 0x%x...", a->group_optimization_enabled));
14753
14754 for (i = 0; i < MAX_CIP_TYPES; i++)
14755 {
14756 info_mask_group[i] = 0;
14757 cip_mask_group[i] = 0;
14758 }
14759 for (i = 0; i < MAX_APPL; i++)
14760 {
14761 appl_number_group_type[i] = 0;
14762 }
14763 for (i = 0; i < max_appl; i++) /* check if any multi instance capable application is present */
14764 { /* group_optimization set to 1 means not to optimize multi-instance capable applications (default) */
14765 if (application[i].Id && (application[i].MaxNCCI) > 1 && (a->CIP_Mask[i]) && (a->group_optimization_enabled == 1))
14766 {
14767 dbug(1, dprintf("Multi-Instance capable, no optimization required"));
14768 return; /* allow good application unfiltered access */
14769 }
14770 }
14771 for (i = 0; i < max_appl; i++) /* Build CIP Groups */
14772 {
14773 if (application[i].Id && a->CIP_Mask[i])
14774 {
14775 for (k = 0, busy = false; k < a->max_plci; k++)
14776 {
14777 if (a->plci[k].Id)
14778 {
14779 auxplci = &a->plci[k];
14780 if (auxplci->appl == &application[i]) /* application has a busy PLCI */
14781 {
14782 busy = true;
14783 dbug(1, dprintf("Appl 0x%x is busy", i + 1));
14784 }
14785 else if (test_c_ind_mask_bit(auxplci, i)) /* application has an incoming call pending */
14786 {
14787 busy = true;
14788 dbug(1, dprintf("Appl 0x%x has inc. call pending", i + 1));
14789 }
14790 }
14791 }
14792
14793 for (j = 0, group_found = 0; j <= (MAX_CIP_TYPES) && !busy && !group_found; j++) /* build groups with free applications only */
14794 {
14795 if (j == MAX_CIP_TYPES) /* all groups are in use but group still not found */
14796 { /* the MAX_CIP_TYPES group enables all calls because of field overflow */
14797 appl_number_group_type[i] = MAX_CIP_TYPES;
14798 group_found = true;
14799 dbug(1, dprintf("Field overflow appl 0x%x", i + 1));
14800 }
14801 else if ((info_mask_group[j] == a->CIP_Mask[i]) && (cip_mask_group[j] == a->Info_Mask[i]))
14802 { /* is group already present ? */
14803 appl_number_group_type[i] = j | 0x80; /* store the group number for each application */
14804 group_found = true;
14805 dbug(1, dprintf("Group 0x%x found with appl 0x%x, CIP=0x%lx", appl_number_group_type[i], i + 1, info_mask_group[j]));
14806 }
14807 else if (!info_mask_group[j])
14808 { /* establish a new group */
14809 appl_number_group_type[i] = j | 0x80; /* store the group number for each application */
14810 info_mask_group[j] = a->CIP_Mask[i]; /* store the new CIP mask for the new group */
14811 cip_mask_group[j] = a->Info_Mask[i]; /* store the new Info_Mask for this new group */
14812 group_found = true;
14813 dbug(1, dprintf("New Group 0x%x established with appl 0x%x, CIP=0x%lx", appl_number_group_type[i], i + 1, info_mask_group[j]));
14814 }
14815 }
14816 }
14817 }
14818
14819 for (i = 0; i < max_appl; i++) /* Build group_optimization_mask_table */
14820 {
14821 if (appl_number_group_type[i]) /* application is free, has listens and is member of a group */
14822 {
14823 if (appl_number_group_type[i] == MAX_CIP_TYPES)
14824 {
14825 dbug(1, dprintf("OverflowGroup 0x%x, valid appl = 0x%x, call enabled", appl_number_group_type[i], i + 1));
14826 }
14827 else
14828 {
14829 dbug(1, dprintf("Group 0x%x, valid appl = 0x%x", appl_number_group_type[i], i + 1));
14830 for (j = i + 1; j < max_appl; j++) /* search other group members and mark them as busy */
14831 {
14832 if (appl_number_group_type[i] == appl_number_group_type[j])
14833 {
14834 dbug(1, dprintf("Appl 0x%x is member of group 0x%x, no call", j + 1, appl_number_group_type[j]));
14835 clear_group_ind_mask_bit(plci, j); /* disable call on other group members */
14836 appl_number_group_type[j] = 0; /* remove disabled group member from group list */
14837 }
14838 }
14839 }
14840 }
14841 else /* application should not get a call */
14842 {
14843 clear_group_ind_mask_bit(plci, i);
14844 }
14845 }
14846
14847 }
14848
14849
14850
14851 /* OS notifies the driver about a application Capi_Register */
14852 word CapiRegister(word id)
14853 {
14854 word i, j, appls_found;
14855
14856 PLCI *plci;
14857 DIVA_CAPI_ADAPTER *a;
14858
14859 for (i = 0, appls_found = 0; i < max_appl; i++)
14860 {
14861 if (application[i].Id && (application[i].Id != id))
14862 {
14863 appls_found++; /* an application has been found */
14864 }
14865 }
14866
14867 if (appls_found) return true;
14868 for (i = 0; i < max_adapter; i++) /* scan all adapters... */
14869 {
14870 a = &adapter[i];
14871 if (a->request)
14872 {
14873 if (a->flag_dynamic_l1_down) /* remove adapter from L1 tristate (Huntgroup) */
14874 {
14875 if (!appls_found) /* first application does a capi register */
14876 {
14877 if ((j = get_plci(a))) /* activate L1 of all adapters */
14878 {
14879 plci = &a->plci[j - 1];
14880 plci->command = 0;
14881 add_p(plci, OAD, "\x01\xfd");
14882 add_p(plci, CAI, "\x01\x80");
14883 add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
14884 add_p(plci, SHIFT | 6, NULL);
14885 add_p(plci, SIN, "\x02\x00\x00");
14886 plci->internal_command = START_L1_SIG_ASSIGN_PEND;
14887 sig_req(plci, ASSIGN, DSIG_ID);
14888 add_p(plci, FTY, "\x02\xff\x07"); /* l1 start */
14889 sig_req(plci, SIG_CTRL, 0);
14890 send_req(plci);
14891 }
14892 }
14893 }
14894 }
14895 }
14896 return false;
14897 }
14898
14899 /*------------------------------------------------------------------*/
14900
14901 /* Functions for virtual Switching e.g. Transfer by join, Conference */
14902
14903 static void VSwitchReqInd(PLCI *plci, dword Id, byte **parms)
14904 {
14905 word i;
14906 /* Format of vswitch_t:
14907 0 byte length
14908 1 byte VSWITCHIE
14909 2 byte VSWITCH_REQ/VSWITCH_IND
14910 3 byte reserved
14911 4 word VSwitchcommand
14912 6 word returnerror
14913 8... Params
14914 */
14915 if (!plci ||
14916 !plci->appl ||
14917 !plci->State ||
14918 plci->Sig.Ind == NCR_FACILITY
14919 )
14920 return;
14921
14922 for (i = 0; i < MAX_MULTI_IE; i++)
14923 {
14924 if (!parms[i][0]) continue;
14925 if (parms[i][0] < 7)
14926 {
14927 parms[i][0] = 0; /* kill it */
14928 continue;
14929 }
14930 dbug(1, dprintf("VSwitchReqInd(%d)", parms[i][4]));
14931 switch (parms[i][4])
14932 {
14933 case VSJOIN:
14934 if (!plci->relatedPTYPLCI ||
14935 (plci->ptyState != S_ECT && plci->relatedPTYPLCI->ptyState != S_ECT))
14936 { /* Error */
14937 break;
14938 }
14939 /* remember all necessary informations */
14940 if (parms[i][0] != 11 || parms[i][8] != 3) /* Length Test */
14941 {
14942 break;
14943 }
14944 if (parms[i][2] == VSWITCH_IND && parms[i][9] == 1)
14945 { /* first indication after ECT-Request on Consultation Call */
14946 plci->vswitchstate = parms[i][9];
14947 parms[i][9] = 2; /* State */
14948 /* now ask first Call to join */
14949 }
14950 else if (parms[i][2] == VSWITCH_REQ && parms[i][9] == 3)
14951 { /* Answer of VSWITCH_REQ from first Call */
14952 plci->vswitchstate = parms[i][9];
14953 /* tell consultation call to join
14954 and the protocol capabilities of the first call */
14955 }
14956 else
14957 { /* Error */
14958 break;
14959 }
14960 plci->vsprot = parms[i][10]; /* protocol */
14961 plci->vsprotdialect = parms[i][11]; /* protocoldialect */
14962 /* send join request to related PLCI */
14963 parms[i][1] = VSWITCHIE;
14964 parms[i][2] = VSWITCH_REQ;
14965
14966 plci->relatedPTYPLCI->command = 0;
14967 plci->relatedPTYPLCI->internal_command = VSWITCH_REQ_PEND;
14968 add_p(plci->relatedPTYPLCI, ESC, &parms[i][0]);
14969 sig_req(plci->relatedPTYPLCI, VSWITCH_REQ, 0);
14970 send_req(plci->relatedPTYPLCI);
14971 break;
14972 case VSTRANSPORT:
14973 default:
14974 if (plci->relatedPTYPLCI &&
14975 plci->vswitchstate == 3 &&
14976 plci->relatedPTYPLCI->vswitchstate == 3)
14977 {
14978 add_p(plci->relatedPTYPLCI, ESC, &parms[i][0]);
14979 sig_req(plci->relatedPTYPLCI, VSWITCH_REQ, 0);
14980 send_req(plci->relatedPTYPLCI);
14981 }
14982 break;
14983 }
14984 parms[i][0] = 0; /* kill it */
14985 }
14986 }
14987
14988
14989 /*------------------------------------------------------------------*/
14990
14991 static int diva_get_dma_descriptor(PLCI *plci, dword *dma_magic) {
14992 ENTITY e;
14993 IDI_SYNC_REQ *pReq = (IDI_SYNC_REQ *)&e;
14994
14995 if (!(diva_xdi_extended_features & DIVA_CAPI_XDI_PROVIDES_RX_DMA)) {
14996 return (-1);
14997 }
14998
14999 pReq->xdi_dma_descriptor_operation.Req = 0;
15000 pReq->xdi_dma_descriptor_operation.Rc = IDI_SYNC_REQ_DMA_DESCRIPTOR_OPERATION;
15001
15002 pReq->xdi_dma_descriptor_operation.info.operation = IDI_SYNC_REQ_DMA_DESCRIPTOR_ALLOC;
15003 pReq->xdi_dma_descriptor_operation.info.descriptor_number = -1;
15004 pReq->xdi_dma_descriptor_operation.info.descriptor_address = NULL;
15005 pReq->xdi_dma_descriptor_operation.info.descriptor_magic = 0;
15006
15007 e.user[0] = plci->adapter->Id - 1;
15008 plci->adapter->request((ENTITY *)pReq);
15009
15010 if (!pReq->xdi_dma_descriptor_operation.info.operation &&
15011 (pReq->xdi_dma_descriptor_operation.info.descriptor_number >= 0) &&
15012 pReq->xdi_dma_descriptor_operation.info.descriptor_magic) {
15013 *dma_magic = pReq->xdi_dma_descriptor_operation.info.descriptor_magic;
15014 dbug(3, dprintf("dma_alloc, a:%d (%d-%08x)",
15015 plci->adapter->Id,
15016 pReq->xdi_dma_descriptor_operation.info.descriptor_number,
15017 *dma_magic));
15018 return (pReq->xdi_dma_descriptor_operation.info.descriptor_number);
15019 } else {
15020 dbug(1, dprintf("dma_alloc failed"));
15021 return (-1);
15022 }
15023 }
15024
15025 static void diva_free_dma_descriptor(PLCI *plci, int nr) {
15026 ENTITY e;
15027 IDI_SYNC_REQ *pReq = (IDI_SYNC_REQ *)&e;
15028
15029 if (nr < 0) {
15030 return;
15031 }
15032
15033 pReq->xdi_dma_descriptor_operation.Req = 0;
15034 pReq->xdi_dma_descriptor_operation.Rc = IDI_SYNC_REQ_DMA_DESCRIPTOR_OPERATION;
15035
15036 pReq->xdi_dma_descriptor_operation.info.operation = IDI_SYNC_REQ_DMA_DESCRIPTOR_FREE;
15037 pReq->xdi_dma_descriptor_operation.info.descriptor_number = nr;
15038 pReq->xdi_dma_descriptor_operation.info.descriptor_address = NULL;
15039 pReq->xdi_dma_descriptor_operation.info.descriptor_magic = 0;
15040
15041 e.user[0] = plci->adapter->Id - 1;
15042 plci->adapter->request((ENTITY *)pReq);
15043
15044 if (!pReq->xdi_dma_descriptor_operation.info.operation) {
15045 dbug(1, dprintf("dma_free(%d)", nr));
15046 } else {
15047 dbug(1, dprintf("dma_free failed (%d)", nr));
15048 }
15049 }
15050
15051 /*------------------------------------------------------------------*/
Linux with added FPC-III support