FreeCalypso > hg > freecalypso-citrine

comparison g23m-aci/uart/uart_kerp.c @ 0:75a11d740a02

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
initial import of gsm-fw from freecalypso-sw rev 1033:5ab737ac3ad7
author Mychaela Falconia <falcon@freecalypso.org>
date Thu, 09 Jun 2016 00:02:41 +0000
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:75a11d740a02
1 /*
2 +-----------------------------------------------------------------------------
3 | Project :
4 | Modul :
5 +-----------------------------------------------------------------------------
6 | Copyright 2002 Texas Instruments Berlin, AG
7 | All rights reserved.
8 |
9 | This file is confidential and a trade secret of Texas
10 | Instruments Berlin, AG
11 | The receipt of or possession of this file does not convey
12 | any rights to reproduce or disclose its contents or to
13 | manufacture, use, or sell anything it may describe, in
14 | whole, or in part, without the specific written consent of
15 | Texas Instruments Berlin, AG.
16 +-----------------------------------------------------------------------------
17 | Purpose : This modul is part of the entity UART and implements all
18 | functions to handles the incoming primitives as described in
19 | the SDL-documentation (KER-statemachine)
20 +-----------------------------------------------------------------------------
21 */
22
23 #ifndef UART_KERP_C
24 #define UART_KERP_C
25 #endif /* !UART_KERP_C */
26
27 #include "config.h"
28 #include "fixedconf.h"
29 #include "condat-features.h"
30
31 #define ENTITY_UART
32
33 /*==== INCLUDES =============================================================*/
34
35 #ifdef WIN32
36 #include "nucleus.h"
37 #endif /* WIN32 */
38 #include "typedefs.h" /* to get Condat data types */
39 #include "vsi.h" /* to get a lot of macros */
40 #include "macdef.h" /* to get a lot of macros */
41 #include "custom.h"
42 #include "gsm.h" /* to get a lot of macros */
43 #include "cnf_uart.h" /* to get cnf-definitions */
44 #include "mon_uart.h" /* to get mon-definitions */
45 #include "prim.h" /* to get the definitions of used SAP and directions */
46 #ifdef DTILIB
47 #include "dti.h" /* to get dti lib */
48 #endif /* DTILIB */
49 #include "pei.h" /* to get PEI interface */
50 #ifdef FF_MULTI_PORT
51 #include "gsi.h" /* to get definitions of serial driver */
52 #else /* FF_MULTI_PORT */
53 #ifdef _TARGET_
54 #include "../../serial/serialswitch.h"
55 #include "../../serial/traceswitch.h"
56 #else /* _TARGET_ */
57 #include "serial_dat.h" /* to get definitions of serial driver */
58 #endif /* _TARGET_ */
59 #endif /* FF_MULTI_PORT */
60 #include "uart.h" /* to get the global entity definitions */
61
62 #include "uart_kerf.h" /* to get ker functions */
63 #include "uart_kers.h" /* to get ker signals */
64 #include "uart_drxs.h" /* to get drx signals */
65 #include "uart_dtxs.h" /* to get dtx signals */
66 #include "uart_rts.h" /* to get rt signals */
67 #ifdef FF_MULTI_PORT
68 #include "uart_prxs.h" /* to get rx signals */
69 #include "uart_ptxs.h" /* to get tx signals */
70 #else /* FF_MULTI_PORT */
71 #include "uart_rxs.h" /* to get rx signals */
72 #include "uart_txs.h" /* to get tx signals */
73 #endif /* FF_MULTI_PORT */
74
75 /*==== CONST ================================================================*/
76
77 /*==== LOCAL VARS ===========================================================*/
78
79 /*==== PRIVATE FUNCTIONS ====================================================*/
80
81 /*==== PUBLIC FUNCTIONS =====================================================*/
82
83
84
85 /*
86 +------------------------------------------------------------------------------
87 | Function : ker_uart_parameters_req
88 +------------------------------------------------------------------------------
89 | Description : Handles the primitive UART_PARAMETERS_REQ
90 |
91 | Parameters : *uart_parameters_req - Ptr to primitive payload
92 |
93 +------------------------------------------------------------------------------
94 */
95 GLOBAL void ker_uart_parameters_req (
96 T_UART_PARAMETERS_REQ *uart_parameters_req)
97 {
98 UBYTE i;
99 T_DLC* dlc;
100
101 TRACE_FUNCTION( "ker_uart_parameters_req" );
102
103 #ifdef UART_RANGE_CHECK
104 if(uart_parameters_req EQ NULL)
105 {
106 TRACE_EVENT("ERROR: uart_parameters_req is NULL");
107 }
108 else if((*((ULONG*)((UBYTE*)uart_parameters_req - sizeof(T_PRIM_HEADER) - 8))) NEQ 0)
109 {
110 TRACE_EVENT_P1("ERROR: uart_parameters_req=%08x is not allocated",
111 uart_parameters_req);
112 }
113 else if(uart_parameters_req->device >= UART_INSTANCES)
114 {
115 TRACE_EVENT_P2("ERROR: device=%d is greater than UART_INSTANCES=%d",
116 uart_parameters_req->device,
117 UART_INSTANCES);
118 }
119 #endif /* UART_RANGE_CHECK */
120
121 /*
122 * set UART instance
123 */
124 uart_data = &uart_data_base[uart_parameters_req->device];
125
126 #ifdef FF_MULTI_PORT
127 /*
128 * set new baud rate
129 */
130 switch (uart_parameters_req->comPar.speed)
131 {
132 case UART_IO_SPEED_AUTO:
133 uart_data->ker.act_dcb.Baud = GSI_BAUD_AUTO;
134 break;
135 case UART_IO_SPEED_75:
136 uart_data->ker.act_dcb.Baud = GSI_BAUD_75;
137 break;
138 case UART_IO_SPEED_150:
139 uart_data->ker.act_dcb.Baud = GSI_BAUD_150;
140 break;
141 case UART_IO_SPEED_300:
142 uart_data->ker.act_dcb.Baud = GSI_BAUD_300;
143 break;
144 case UART_IO_SPEED_600:
145 uart_data->ker.act_dcb.Baud = GSI_BAUD_600;
146 break;
147 case UART_IO_SPEED_1200:
148 uart_data->ker.act_dcb.Baud = GSI_BAUD_1200;
149 break;
150 case UART_IO_SPEED_2400:
151 uart_data->ker.act_dcb.Baud = GSI_BAUD_2400;
152 break;
153 case UART_IO_SPEED_4800:
154 uart_data->ker.act_dcb.Baud = GSI_BAUD_4800;
155 break;
156 case UART_IO_SPEED_7200:
157 uart_data->ker.act_dcb.Baud = GSI_BAUD_7200;
158 break;
159 case UART_IO_SPEED_9600:
160 uart_data->ker.act_dcb.Baud = GSI_BAUD_9600;
161 break;
162 case UART_IO_SPEED_14400:
163 uart_data->ker.act_dcb.Baud = GSI_BAUD_14400;
164 break;
165 case UART_IO_SPEED_19200:
166 uart_data->ker.act_dcb.Baud = GSI_BAUD_19200;
167 break;
168 case UART_IO_SPEED_28800:
169 uart_data->ker.act_dcb.Baud = GSI_BAUD_28800;
170 break;
171 case UART_IO_SPEED_33900:
172 uart_data->ker.act_dcb.Baud = GSI_BAUD_33900;
173 break;
174 case UART_IO_SPEED_38400:
175 uart_data->ker.act_dcb.Baud = GSI_BAUD_38400;
176 break;
177 case UART_IO_SPEED_57600:
178 uart_data->ker.act_dcb.Baud = GSI_BAUD_57600;
179 break;
180 case UART_IO_SPEED_115200:
181 uart_data->ker.act_dcb.Baud = GSI_BAUD_115200;
182 break;
183 case UART_IO_SPEED_203125:
184 uart_data->ker.act_dcb.Baud = GSI_BAUD_203125;
185 break;
186 case UART_IO_SPEED_406250:
187 uart_data->ker.act_dcb.Baud = GSI_BAUD_406250;
188 break;
189 case UART_IO_SPEED_812500:
190 uart_data->ker.act_dcb.Baud = GSI_BAUD_812500;
191 break;
192 case UART_IO_SPEED_UNDEF: /* unchanged */
193 break;
194 default:
195 TRACE_ERROR( "UART_PARAMETERS_REQ: baudrate unexpected" );
196 break;
197 }
198
199 /*
200 * set new bits per character
201 */
202 switch (uart_parameters_req->comPar.bpc)
203 {
204 case UART_IO_BPC_7:
205 uart_data->ker.act_dcb.DataBits = GSI_CHAR7;
206 break;
207 case UART_IO_BPC_8:
208 uart_data->ker.act_dcb.DataBits = GSI_CHAR8;
209 break;
210 case UART_IO_BPC_UNDEF: /* unchanged */
211 break;
212 default:
213 TRACE_ERROR( "UART_PARAMETERS_REQ: bpc unexpected" );
214 break;
215 }
216
217 /*
218 * set new stop bit
219 */
220 switch (uart_parameters_req->comPar.nsb)
221 {
222 case UART_IO_SB_1:
223 uart_data->ker.act_dcb.StopBits = GSI_STOP1;
224 break;
225 case UART_IO_SB_2:
226 uart_data->ker.act_dcb.StopBits = GSI_STOP2;
227 break;
228 case UART_IO_SB_UNDEF: /* unchanged */
229 break;
230 default:
231 TRACE_ERROR( "UART_PARAMETERS_REQ: stop bits unexpected" );
232 break;
233 }
234
235 /*
236 * set new parity
237 */
238 switch (uart_parameters_req->comPar.parity)
239 {
240 case UART_IO_PA_NONE:
241 uart_data->ker.act_dcb.Parity = GSI_PARITYNO;
242 break;
243 case UART_IO_PA_EVEN:
244 uart_data->ker.act_dcb.Parity = GSI_PARITYEVEN;
245 break;
246 case UART_IO_PA_ODD:
247 uart_data->ker.act_dcb.Parity = GSI_PARITYODD;
248 break;
249 case UART_IO_PA_SPACE:
250 uart_data->ker.act_dcb.Parity = GSI_PARITYSPACE;
251 break;
252 case UART_IO_PA_UNDEF: /* unchanged */
253 break;
254 default:
255 TRACE_ERROR( "UART_PARAMETERS_REQ: parity unexpected" );
256 break;
257 }
258
259 /*
260 * set new RX flow control
261 */
262 switch (uart_parameters_req->comPar.flow_rx)
263 {
264 case UART_IO_FC_RX_NONE:
265 uart_data->ker.act_dcb.RxFlowControl = GSI_FLOWNO;
266 break;
267 case UART_IO_FC_RX_RTS:
268 uart_data->ker.act_dcb.RxFlowControl = GSI_FLOWHW;
269 break;
270 case UART_IO_FC_RX_XOFF:
271 uart_data->ker.act_dcb.RxFlowControl = GSI_FLOWSW;
272 break;
273 case UART_IO_FC_RX_UNDEF: /* unchanged */
274 break;
275 default:
276 TRACE_ERROR( "UART_PARAMETERS_REQ: RX flow control unexpected" );
277 break;
278 }
279
280 /*
281 * set new TX flow control
282 */
283 switch (uart_parameters_req->comPar.flow_tx)
284 {
285 case UART_IO_FC_TX_NONE:
286 uart_data->ker.act_dcb.TxFlowControl = GSI_FLOWNO;
287 break;
288 case UART_IO_FC_TX_RTS:
289 uart_data->ker.act_dcb.TxFlowControl = GSI_FLOWHW;
290 break;
291 case UART_IO_FC_TX_XOFF:
292 uart_data->ker.act_dcb.TxFlowControl = GSI_FLOWSW;
293 break;
294 case UART_IO_FC_TX_UNDEF: /* unchanged */
295 break;
296 default:
297 TRACE_ERROR( "UART_PARAMETERS_REQ: TX flow control unexpected" );
298 break;
299 }
300
301 /*
302 * set new XON / XOFF values
303 */
304 if(uart_parameters_req->comPar.xon_valid EQ UART_IO_XON_VALID)
305 uart_data->ker.act_dcb.XON = uart_parameters_req->comPar.xon;
306 if(uart_parameters_req->comPar.xoff_valid EQ UART_IO_XOFF_VALID)
307 uart_data->ker.act_dcb.XOFF = uart_parameters_req->comPar.xoff;
308 #else /* FF_MULTI_PORT */
309 /*
310 * set new baud rate
311 */
312 switch (uart_parameters_req->comPar.speed)
313 {
314 case UART_IO_SPEED_AUTO:
315 uart_data->ker.act_br = UF_BAUD_AUTO;
316 break;
317 case UART_IO_SPEED_75:
318 uart_data->ker.act_br = UF_BAUD_75;
319 break;
320 case UART_IO_SPEED_150:
321 uart_data->ker.act_br = UF_BAUD_150;
322 break;
323 case UART_IO_SPEED_300:
324 uart_data->ker.act_br = UF_BAUD_300;
325 break;
326 case UART_IO_SPEED_600:
327 uart_data->ker.act_br = UF_BAUD_600;
328 break;
329 case UART_IO_SPEED_1200:
330 uart_data->ker.act_br = UF_BAUD_1200;
331 break;
332 case UART_IO_SPEED_2400:
333 uart_data->ker.act_br = UF_BAUD_2400;
334 break;
335 case UART_IO_SPEED_4800:
336 uart_data->ker.act_br = UF_BAUD_4800;
337 break;
338 case UART_IO_SPEED_7200:
339 uart_data->ker.act_br = UF_BAUD_7200;
340 break;
341 case UART_IO_SPEED_9600:
342 uart_data->ker.act_br = UF_BAUD_9600;
343 break;
344 case UART_IO_SPEED_14400:
345 uart_data->ker.act_br = UF_BAUD_14400;
346 break;
347 case UART_IO_SPEED_19200:
348 uart_data->ker.act_br = UF_BAUD_19200;
349 break;
350 case UART_IO_SPEED_28800:
351 uart_data->ker.act_br = UF_BAUD_28800;
352 break;
353 case UART_IO_SPEED_33900:
354 uart_data->ker.act_br = UF_BAUD_33900;
355 break;
356 case UART_IO_SPEED_38400:
357 uart_data->ker.act_br = UF_BAUD_38400;
358 break;
359 case UART_IO_SPEED_57600:
360 uart_data->ker.act_br = UF_BAUD_57600;
361 break;
362 case UART_IO_SPEED_115200:
363 uart_data->ker.act_br = UF_BAUD_115200;
364 break;
365 case UART_IO_SPEED_203125:
366 uart_data->ker.act_br = UF_BAUD_203125;
367 break;
368 case UART_IO_SPEED_406250:
369 uart_data->ker.act_br = UF_BAUD_406250;
370 break;
371 case UART_IO_SPEED_812500:
372 uart_data->ker.act_br = UF_BAUD_812500;
373 break;
374 case UART_IO_SPEED_UNDEF: /* unchanged */
375 break;
376 default:
377 TRACE_ERROR( "UART_PARAMETERS_REQ: baudrate unexpected" );
378 break;
379 }
380
381 /*
382 * set new RX flow control
383 */
384 switch (uart_parameters_req->comPar.flow_rx)
385 {
386 case UART_IO_FC_RX_NONE:
387 uart_data->ker.act_fc_rx = fc_none;
388 break;
389 case UART_IO_FC_RX_RTS:
390 uart_data->ker.act_fc_rx = fc_rts;
391 break;
392 case UART_IO_FC_RX_XOFF:
393 uart_data->ker.act_fc_rx = fc_xoff;
394 break;
395 case UART_IO_FC_RX_UNDEF: /* unchanged */
396 break;
397 default:
398 TRACE_ERROR( "UART_PARAMETERS_REQ: RX flow control unexpected" );
399 break;
400 }
401
402 /*
403 * set new TX flow control
404 */
405 switch (uart_parameters_req->comPar.flow_tx)
406 {
407 case UART_IO_FC_TX_NONE:
408 uart_data->ker.act_fc_tx = fc_none;
409 break;
410 case UART_IO_FC_TX_RTS:
411 uart_data->ker.act_fc_tx = fc_rts;
412 break;
413 case UART_IO_FC_TX_XOFF:
414 uart_data->ker.act_fc_tx = fc_xoff;
415 break;
416 case UART_IO_FC_TX_UNDEF: /* unchanged */
417 break;
418 default:
419 TRACE_ERROR( "UART_PARAMETERS_REQ: TX flow control unexpected" );
420 break;
421 }
422
423 /*
424 * set new bits per character
425 */
426 switch (uart_parameters_req->comPar.bpc)
427 {
428 case UART_IO_BPC_7:
429 uart_data->ker.act_bpc = bpc_7;
430 break;
431 case UART_IO_BPC_8:
432 uart_data->ker.act_bpc = bpc_8;
433 break;
434 case UART_IO_BPC_UNDEF: /* unchanged */
435 break;
436 default:
437 TRACE_ERROR( "UART_PARAMETERS_REQ: bpc unexpected" );
438 break;
439 }
440
441 /*
442 * set new stop bit
443 */
444 switch (uart_parameters_req->comPar.nsb)
445 {
446 case UART_IO_SB_1:
447 uart_data->ker.act_sb = sb_1;
448 break;
449 case UART_IO_SB_2:
450 uart_data->ker.act_sb = sb_2;
451 break;
452 case UART_IO_SB_UNDEF: /* unchanged */
453 break;
454 default:
455 TRACE_ERROR( "UART_PARAMETERS_REQ: stop bits unexpected" );
456 break;
457 }
458
459 /*
460 * set new parity
461 */
462 switch (uart_parameters_req->comPar.parity)
463 {
464 case UART_IO_PA_NONE:
465 uart_data->ker.act_par = pa_none;
466 break;
467 case UART_IO_PA_EVEN:
468 uart_data->ker.act_par = pa_even;
469 break;
470 case UART_IO_PA_ODD:
471 uart_data->ker.act_par = pa_odd;
472 break;
473 case UART_IO_PA_SPACE:
474 uart_data->ker.act_par = pa_space;
475 break;
476 case UART_IO_PA_UNDEF: /* unchanged */
477 break;
478 default:
479 TRACE_ERROR( "UART_PARAMETERS_REQ: parity unexpected" );
480 break;
481 }
482
483 /*
484 * set new XON / XOFF values
485 */
486 if(uart_parameters_req->comPar.xon_valid EQ UART_IO_XON_VALID)
487 uart_data->ker.act_xon = uart_parameters_req->comPar.xon;
488 if(uart_parameters_req->comPar.xoff_valid EQ UART_IO_XOFF_VALID)
489 uart_data->ker.act_xoff = uart_parameters_req->comPar.xoff;
490 #endif /* FF_MULTI_PORT */
491
492 /*
493 * set new escape detection values
494 */
495 if(uart_parameters_req->comPar.esc_valid EQ UART_IO_ESC_VALID)
496 {
497 #ifdef FF_MULTI_PORT
498 uart_data->ker.act_dcb.EscChar = uart_parameters_req->comPar.esc_char;
499 uart_data->ker.act_dcb.GuardPeriod = uart_parameters_req->comPar.esc_gp;
500 #else /* FF_MULTI_PORT */
501 uart_data->ker.act_ec = uart_parameters_req->comPar.esc_char;
502 uart_data->ker.act_gp = uart_parameters_req->comPar.esc_gp;
503 #endif /* FF_MULTI_PORT */
504 }
505
506 /*
507 * free the received primitive
508 */
509 PFREE(uart_parameters_req);
510
511 switch( GET_STATE( UART_SERVICE_KER ) )
512 {
513 case KER_READY:
514 /*
515 * flush all still to send data
516 */
517 uart_data->ker.received_prim|= UART_PARAMETERS_REQ_MASK;
518 uart_data->ker.flush_state = UART_KER_DRX_FLUSH;
519 dlc = &uart_data->dlc_table[UART_CONTROL_INSTANCE];
520 dlc->flushed = FALSE;
521 uart_data->drx = dlc->drx;
522 sig_ker_drx_flush_req();
523 break;
524
525 case KER_MUX:
526 case KER_MUX_ESTABLISH:
527 case KER_MUX_DLC_CLOSING:
528 case KER_MUX_CLOSING:
529 case KER_MUX_CLOSED:
530 /*
531 * flush all still to send data
532 */
533 uart_data->ker.received_prim|= UART_PARAMETERS_REQ_MASK;
534 uart_data->ker.flush_state = UART_KER_DRX_FLUSH;
535 /*
536 * mark all to flush DLCs
537 */
538 for(i = 0; i < UART_MAX_NUMBER_OF_CHANNELS; i++)
539 {
540 dlc = &uart_data->dlc_table[i];
541 if((i EQ UART_CONTROL_INSTANCE) ||
542 (dlc->connection_state EQ UART_CONNECTION_OPEN))
543 {
544 dlc->flushed = FALSE;
545 }
546 }
547 /*
548 * initiate flush in all to flushed DLCs
549 */
550 for(i = 0; i < UART_MAX_NUMBER_OF_CHANNELS; i++)
551 {
552 dlc = &uart_data->dlc_table[i];
553 if(dlc->flushed NEQ TRUE)
554 {
555 if(i EQ UART_CONTROL_INSTANCE)
556 {
557 if(uart_data->ker.tx_data_desc EQ NULL)
558 sig_any_ker_flushed_ind(UART_CONTROL_INSTANCE);
559 }
560 else
561 {
562 uart_data->drx = dlc->drx;
563 sig_ker_drx_flush_req();
564 }
565 }
566 }
567 break;
568
569 case KER_DEAD:
570 /*
571 * set new UART parameters
572 */
573 ker_setupUart();
574
575 #ifdef FF_MULTI_PORT
576 uart_data->ker.act_ec = uart_data->ker.act_dcb.EscChar;
577 uart_data->ker.act_gp = uart_data->ker.act_dcb.GuardPeriod;
578 #endif /* FF_MULTI_PORT */
579
580 /*
581 * send confirm primitive
582 */
583 {
584 PALLOC (uart_parameters_cnf, UART_PARAMETERS_CNF);
585 uart_parameters_cnf->device = uart_data->device;
586 PSEND (hCommMMI, uart_parameters_cnf);
587 }
588 break;
589
590 default:
591 TRACE_ERROR( "UART_PARAMETERS_REQ unexpected" );
592 break;
593 }
594 } /* ker_uart_parameters_req() */
595
596
597
598 /*
599 +------------------------------------------------------------------------------
600 | Function : ker_uart_dti_req
601 +------------------------------------------------------------------------------
602 | Description : Handles the primitive UART_DTI_REQ
603 |
604 | Parameters : *uart_dti_req - Ptr to primitive payload
605 |
606 +------------------------------------------------------------------------------
607 */
608 GLOBAL void ker_uart_dti_req ( T_UART_DTI_REQ *uart_dti_req )
609 {
610 T_DLC* dlc;
611 UBYTE dlc_instance; /* dlc_instance is used as the channel number for dtilib */
612 #ifdef DTILIB
613 U8 isOK;
614 #else /* DTILIB */
615 T_HANDLE hCommUPLINK;
616 #endif /* DTILIB */
617
618 TRACE_FUNCTION( "ker_uart_dti_req" );
619
620 #ifdef UART_RANGE_CHECK
621 if(uart_dti_req EQ NULL)
622 {
623 TRACE_EVENT("ERROR: uart_dti_req is NULL");
624 }
625 else if((*((ULONG*)((UBYTE*)uart_dti_req - sizeof(T_PRIM_HEADER) - 8))) NEQ 0)
626 {
627 TRACE_EVENT_P1("ERROR: uart_dti_req=%08x is not allocated",
628 uart_dti_req);
629 }
630 else if(uart_dti_req->device >= UART_INSTANCES)
631 {
632 TRACE_EVENT_P2("ERROR: device=%d is greater than UART_INSTANCES=%d",
633 uart_dti_req->device,
634 UART_INSTANCES);
635 }
636 #endif /* UART_RANGE_CHECK */
637
638 /*
639 * set UART instance
640 */
641 uart_data = &uart_data_base[uart_dti_req->device];
642
643 switch( GET_STATE( UART_SERVICE_KER ) )
644 {
645 case KER_MUX:
646 case KER_MUX_DLC_CLOSING:
647 dlc_instance = uart_data->dlc_instance[uart_dti_req->dlci];
648 break;
649
650 default:
651 dlc_instance = UART_CONTROL_INSTANCE;
652 break;
653 }
654
655 dlc = &uart_data->dlc_table[dlc_instance];
656 /*
657 * close communication channel
658 * if it is already closed, silently discard primitive
659 */
660 if(dlc->dti_state NEQ DTI_CLOSED)
661 {
662 dti_close(
663 uart_hDTI,
664 uart_data->device,
665 UART_DTI_UP_INTERFACE,
666 dlc_instance,
667 FALSE
668 );
669 dlc->dti_state = DTI_CLOSED;
670
671 /*
672 * no reopen
673 */
674 if (uart_dti_req->dti_conn EQ UART_DISCONNECT_DTI)
675 {
676 PALLOC (uart_dti_cnf, UART_DTI_CNF);
677 uart_data->drx = dlc->drx;
678 uart_data->dtx = dlc->dtx;
679 sig_ker_drx_disconnected_mode_req();
680 sig_ker_dtx_disconnected_mode_req();
681
682 /*
683 * send confirm primitive
684 */
685 uart_dti_cnf->device = uart_data->device;
686 uart_dti_cnf->dlci = uart_data->dlc_table[dlc_instance].dlci; /* EQ dlci */
687 uart_dti_cnf->dti_conn = UART_DISCONNECT_DTI;
688 PSEND (hCommMMI, uart_dti_cnf);
689
690 return;
691 }
692 }
693
694 #ifdef DTILIB
695 if( GET_STATE( UART_SERVICE_KER ) EQ KER_DEAD )
696 {
697 /*
698 * set dlc values - this has to happen before
699 * the call of dti_open, because within that call
700 * a callback-function may be called which makes
701 * use of them..
702 */
703 dlc = &uart_data->dlc_table[UART_CONTROL_INSTANCE];
704 dlc->drx = &uart_data->drx_base[0];
705 dlc->dtx = &uart_data->dtx_base[0];
706 dlc->dlci = 0;
707 uart_data->dlc_instance[0] = UART_CONTROL_INSTANCE;
708 dlc->priority = 0;
709 dlc->lines = 0;
710 }
711
712 /*
713 * set DTI connection
714 */
715 dlc->dti_state = DTI_SETUP;
716
717 uart_data->drx = dlc->drx;
718 uart_data->dtx = dlc->dtx;
719 #endif /* DTILIB */
720
721 #ifdef _SIMULATION_
722 /*
723 * !!! Problem with entity_name which is a pointer in new SAP
724 * !!! therefore we set the peer entity simply to "MMI".
725 * !!! This should be corrected in order to allow test case simulations
726 * !!! with other peer entities.
727 */
728
729 #ifdef DTILIB
730 isOK = dti_open(
731 uart_hDTI,
732 uart_data->device,
733 UART_DTI_UP_INTERFACE,
734 dlc_instance,
735 UART_UPLINK_QUEUE_SIZE,
736 uart_dti_req->direction,
737 DTI_QUEUE_UNUSED,
738 DTI_VERSION_10,
739 "MMI",
740 uart_dti_req->link_id
741 );
742 #else /* DTILIB */
743 hCommUPLINK = vsi_c_open (VSI_CALLER "MMI");
744 #endif /* DTILIB */
745 #else /* _SIMULATION_ */
746 /*
747 * open new communication channel
748 */
749 #ifdef DTILIB
750 isOK = dti_open(
751 uart_hDTI,
752 uart_data->device,
753 UART_DTI_UP_INTERFACE,
754 dlc_instance,
755 UART_UPLINK_QUEUE_SIZE,
756 uart_dti_req->direction,
757 DTI_QUEUE_UNUSED,
758 DTI_VERSION_10,
759 (U8*)(uart_dti_req->entity_name),
760 uart_dti_req->link_id
761 );
762 #else /* DTILIB */
763 hCommUPLINK = vsi_c_open (VSI_CALLER
764 (char *)(uart_dti_req->entity_name));
765 #endif /* DTILIB */
766 #endif /* _SIMULATION_ */
767
768
769 #ifdef DTILIB
770 if(!isOK)
771 /* error?! */
772 /*
773 * NOTE: internal initialization of the new communication channel
774 * is done in sig_dti_ker_connection_opened() when using DTILIB
775 *
776 * when debugging the below code, please also have a look there!!
777 */
778 #else /* DTILIB */
779 uart_data->tui_uart = uart_dti_req->tui_uart;
780 if(hCommUPLINK >= VSI_OK)
781 {
782 PALLOC (uart_dti_cnf, UART_DTI_CNF);
783 /*
784 * send confirm primitive
785 */
786 uart_dti_cnf->device = uart_data->device;
787 uart_dti_cnf->dlci = uart_dti_req->dlci;
788 uart_dti_cnf->dti_conn = UART_CONNECT_DTI;
789 PSEND (hCommMMI, uart_dti_cnf);
790 /*
791 * initialize new communication channel
792 */
793 switch( GET_STATE( UART_SERVICE_KER ) )
794 {
795 case KER_DEAD:
796 SET_STATE( UART_SERVICE_KER, KER_READY );
797 /*
798 * enable UART
799 */
800 #ifdef _SIMULATION_
801 {
802 /*
803 * send DTI_GETDATA_REQ
804 */
805 PALLOC (dti_getdata_req, DTI2_GETDATA_REQ);
806 dti_getdata_req->tui = 2; /* for enable */
807 dti_getdata_req->c_id = 0;
808 dti_getdata_req->op_ack = 0;
809 PSEND (hCommMMI, dti_getdata_req);
810 }
811 #else /* _SIMULATION_ */
812 #ifndef FF_MULTI_PORT
813 if((ret=UF_Enable (uart_data->device, TRUE)) NEQ UF_OK)
814 {
815 TRACE_ERROR_P2("UF Driver: Can't enable UART, [%d], uart_kerp.c(%d)",
816 ret,__LINE__);
817 }
818 #endif /* !FF_MULTI_PORT */
819 #endif /* _SIMULATION */
820 /*
821 * set dlc values
822 */
823 dlc = &uart_data->dlc_table[UART_CONTROL_INSTANCE];
824 dlc->drx = &uart_data->drx_base[0];
825 dlc->dtx = &uart_data->dtx_base[0];
826 dlc->dlci = 0;
827 dlc->priority = 0;
828 dlc->lines = 0;
829 /*
830 * set RX and TX in ready mode
831 */
832 sig_ker_rx_ready_mode_req();
833 sig_ker_tx_ready_mode_req();
834 /*
835 * set DTI connection
836 */
837 dlc->hCommUPLINK = hCommUPLINK;
838 uart_data->drx = dlc->drx;
839 uart_data->dtx = dlc->dtx;
840 sig_ker_drx_ready_mode_req(UART_CONTROL_INSTANCE);
841 sig_ker_dtx_ready_mode_req(UART_CONTROL_INSTANCE);
842 sig_ker_drx_set_dti_peer_req(uart_dti_req->tui_peer,
843 hCommUPLINK,
844 uart_dti_req->c_id);
845 sig_ker_dtx_set_dti_peer_req(uart_dti_req->tui_peer,
846 hCommUPLINK,
847 uart_dti_req->c_id);
848
849 break;
850
851 case KER_READY:
852 case KER_MUX:
853 dlc->hCommUPLINK = hCommUPLINK;
854 uart_data->drx = dlc->drx;
855 uart_data->dtx = dlc->dtx;
856 sig_ker_drx_set_dti_peer_req(uart_dti_req->tui_peer,
857 hCommUPLINK,
858 uart_dti_req->c_id);
859 sig_ker_dtx_set_dti_peer_req(uart_dti_req->tui_peer,
860 hCommUPLINK,
861 uart_dti_req->c_id);
862 break;
863
864 default:
865 TRACE_ERROR( "UART_DTI_REQ unexpected" );
866 break;
867 }
868 }
869 else /* UPLINK OK */
870 #endif /* DTILIB */
871 {
872 /*
873 * send error primitive if communication channel is not opened
874 */
875 PALLOC (uart_error_ind, UART_ERROR_IND);
876 uart_error_ind->device = uart_data->device;
877 uart_error_ind->dlci = uart_dti_req->dlci;
878 uart_error_ind->error = UART_ERROR_NO_CHANNEL;
879 PSEND (hCommMMI, uart_error_ind);
880 }
881
882 /*
883 * free the received primitive
884 */
885 PFREE(uart_dti_req);
886 } /* ker_uart_dti_req() */
887
888
889 /*
890 +------------------------------------------------------------------------------
891 | Function : ker_uart_disable_req
892 +------------------------------------------------------------------------------
893 | Description : Handles the primitive UART_DISABLE_REQ
894 |
895 | Parameters : *uart_disable_req - Ptr to primitive payload
896 |
897 +------------------------------------------------------------------------------
898 */
899 GLOBAL void ker_uart_disable_req ( T_UART_DISABLE_REQ *uart_disable_req )
900 {
901 UBYTE i;
902 T_DLC* dlc;
903
904 TRACE_FUNCTION( "ker_uart_disable_req" );
905
906 #ifdef UART_RANGE_CHECK
907 if(uart_disable_req EQ NULL)
908 {
909 TRACE_EVENT("ERROR: uart_disable_req is NULL");
910 }
911 else if((*((ULONG*)((UBYTE*)uart_disable_req - sizeof(T_PRIM_HEADER) - 8))) NEQ 0)
912 {
913 TRACE_EVENT_P1("ERROR: uart_disable_req=%08x is not allocated",
914 uart_disable_req);
915 }
916 else if(uart_disable_req->device >= UART_INSTANCES)
917 {
918 TRACE_EVENT_P2("ERROR: device=%d is greater than UART_INSTANCES=%d",
919 uart_disable_req->device,
920 UART_INSTANCES);
921 }
922 #endif /* UART_RANGE_CHECK */
923
924 /*
925 * set UART instance
926 */
927 uart_data = &uart_data_base[uart_disable_req->device];
928
929 /*
930 * free the received primitive
931 */
932 PFREE(uart_disable_req);
933
934 switch( GET_STATE( UART_SERVICE_KER ) )
935 {
936 case KER_READY:
937 /*
938 * flush all still to send data
939 */
940 uart_data->ker.received_prim|= UART_DISABLE_REQ_MASK;
941 uart_data->ker.flush_state = UART_KER_DRX_FLUSH;
942 dlc = &uart_data->dlc_table[UART_CONTROL_INSTANCE];
943 dlc->flushed = FALSE;
944 uart_data->drx = dlc->drx;
945 sig_ker_drx_flush_req();
946 break;
947
948 case KER_MUX:
949 case KER_MUX_ESTABLISH:
950 case KER_MUX_DLC_CLOSING:
951 case KER_MUX_CLOSING:
952 case KER_MUX_CLOSED:
953 /*
954 * flush all still to send data
955 */
956 uart_data->ker.received_prim|= UART_DISABLE_REQ_MASK;
957 uart_data->ker.flush_state = UART_KER_DRX_FLUSH;
958 /*
959 * mark all to flush DLCs
960 */
961 for(i = 0; i < UART_MAX_NUMBER_OF_CHANNELS; i++)
962 {
963 dlc = &uart_data->dlc_table[i];
964 if((i EQ UART_CONTROL_INSTANCE) ||
965 (dlc->connection_state EQ UART_CONNECTION_OPEN))
966 {
967 dlc->flushed = FALSE;
968 }
969 }
970 /*
971 * initiate flush in all to flushed DLCs
972 */
973 for(i = 0; i < UART_MAX_NUMBER_OF_CHANNELS; i++)
974 {
975 dlc = &uart_data->dlc_table[i];
976 if(dlc->flushed NEQ TRUE)
977 {
978 if(i EQ UART_CONTROL_INSTANCE)
979 {
980 if(uart_data->ker.tx_data_desc EQ NULL)
981 sig_any_ker_flushed_ind(UART_CONTROL_INSTANCE);
982 }
983 else
984 {
985 uart_data->drx = dlc->drx;
986 sig_ker_drx_flush_req();
987 }
988 }
989 }
990 break;
991
992 case KER_DEAD:
993 /*
994 * send confirm primitive
995 */
996 {
997 PALLOC (uart_disable_cnf, UART_DISABLE_CNF);
998 uart_disable_cnf->device = uart_data->device;
999 PSEND (hCommMMI, uart_disable_cnf);
1000 }
1001 break;
1002
1003 default:
1004 TRACE_ERROR( "UART_DISABLE_REQ unexpected" );
1005 break;
1006 }
1007 } /* ker_uart_disable_req() */
1008
1009
1010
1011 /*
1012 +------------------------------------------------------------------------------
1013 | Function : ker_uart_ring_req
1014 +------------------------------------------------------------------------------
1015 | Description : Handles the primitive UART_RING_REQ
1016 |
1017 | Parameters : *uart_ring_req - Ptr to primitive payload
1018 |
1019 +------------------------------------------------------------------------------
1020 */
1021 GLOBAL void ker_uart_ring_req ( T_UART_RING_REQ *uart_ring_req )
1022 {
1023 T_DLC* dlc;
1024
1025 TRACE_FUNCTION( "ker_uart_ring_req" );
1026
1027 #ifdef UART_RANGE_CHECK
1028 if(uart_ring_req EQ NULL)
1029 {
1030 TRACE_EVENT("ERROR: uart_ring_req is NULL");
1031 }
1032 else if((*((ULONG*)((UBYTE*)uart_ring_req - sizeof(T_PRIM_HEADER) - 8))) NEQ 0)
1033 {
1034 TRACE_EVENT_P1("ERROR: uart_ring_req=%08x is not allocated",
1035 uart_ring_req);
1036 }
1037 else if(uart_ring_req->device >= UART_INSTANCES)
1038 {
1039 TRACE_EVENT_P2("ERROR: device=%d is greater than UART_INSTANCES=%d",
1040 uart_ring_req->device,
1041 UART_INSTANCES);
1042 }
1043 #endif /* UART_RANGE_CHECK */
1044
1045 /*
1046 * set UART instance
1047 */
1048 uart_data = &uart_data_base[uart_ring_req->device];
1049
1050 /*
1051 * set DLC instance
1052 */
1053 if((GET_STATE( UART_SERVICE_KER )) EQ KER_READY)
1054 dlc = &uart_data->dlc_table[UART_CONTROL_INSTANCE];
1055 else
1056 dlc = &uart_data->dlc_table[uart_data->
1057 dlc_instance[uart_ring_req->dlci]];
1058
1059 /*
1060 * store new line states
1061 */
1062 if(uart_ring_req->line_state EQ UART_LINE_ON)
1063 {
1064 TRACE_EVENT_P1("RING: on - DLCI=%d", uart_ring_req->dlci);
1065 dlc->lines|= UART_RI_MASK;
1066 }
1067 else
1068 {
1069 TRACE_EVENT_P1("RING: off - DLCI=%d", uart_ring_req->dlci);
1070 dlc->lines&= ~(UART_RI_MASK);
1071 }
1072
1073 /*
1074 * free the received primitive
1075 */
1076 PFREE(uart_ring_req);
1077
1078 switch( GET_STATE( UART_SERVICE_KER ) )
1079 {
1080 case KER_READY:
1081 case KER_MUX:
1082 /*
1083 * flush all still to send data
1084 */
1085 dlc->received_prim |= UART_RING_REQ_MASK;
1086 uart_data->ker.flush_state = UART_KER_DRX_FLUSH;
1087 dlc->flushed = FALSE;
1088 uart_data->drx = dlc->drx;
1089 sig_ker_drx_flush_req();
1090 break;
1091
1092 default:
1093 TRACE_ERROR( "UART_RING_REQ unexpected" );
1094 break;
1095 }
1096 } /* ker_uart_ring_req() */
1097
1098
1099
1100 /*
1101 +------------------------------------------------------------------------------
1102 | Function : ker_uart_dcd_req
1103 +------------------------------------------------------------------------------
1104 | Description : Handles the primitive UART_DCD_REQ
1105 |
1106 | Parameters : *uart_dcd_req - Ptr to primitive payload
1107 |
1108 +------------------------------------------------------------------------------
1109 */
1110 GLOBAL void ker_uart_dcd_req ( T_UART_DCD_REQ *uart_dcd_req )
1111 {
1112 T_DLC* dlc;
1113
1114 TRACE_FUNCTION( "ker_uart_dcd_req" );
1115
1116 #ifdef UART_RANGE_CHECK
1117 if(uart_dcd_req EQ NULL)
1118 {
1119 TRACE_EVENT("ERROR: uart_dcd_req is NULL");
1120 }
1121 else if((*((ULONG*)((UBYTE*)uart_dcd_req - sizeof(T_PRIM_HEADER) - 8))) NEQ 0)
1122 {
1123 TRACE_EVENT_P1("ERROR: uart_dcd_req=%08x is not allocated",
1124 uart_dcd_req);
1125 }
1126 else if(uart_dcd_req->device >= UART_INSTANCES)
1127 {
1128 TRACE_EVENT_P2("ERROR: device=%d is greater than UART_INSTANCES=%d",
1129 uart_dcd_req->device,
1130 UART_INSTANCES);
1131 }
1132 #endif /* UART_RANGE_CHECK */
1133
1134 /*
1135 * set UART instance
1136 */
1137 uart_data = &uart_data_base[uart_dcd_req->device];
1138
1139 /*
1140 * set DLC instance
1141 */
1142 if((GET_STATE( UART_SERVICE_KER )) EQ KER_READY)
1143 dlc = &uart_data->dlc_table[UART_CONTROL_INSTANCE];
1144 else
1145 dlc = &uart_data->dlc_table[uart_data->
1146 dlc_instance[uart_dcd_req->dlci]];
1147
1148 /*
1149 * store new line states
1150 */
1151 if(uart_dcd_req->line_state EQ UART_LINE_ON)
1152 {
1153 TRACE_EVENT_P1("DCD: on - DLCI=%d", uart_dcd_req->dlci);
1154 dlc->lines&= ~(UART_DCD_MASK);
1155 }
1156 else
1157 {
1158 TRACE_EVENT_P1("DCD: off - DLCI=%d", uart_dcd_req->dlci);
1159 dlc->lines|= UART_DCD_MASK;
1160 }
1161
1162 /*
1163 * free the received primitive
1164 */
1165 PFREE(uart_dcd_req);
1166
1167 switch( GET_STATE( UART_SERVICE_KER ) )
1168 {
1169 case KER_READY:
1170 case KER_MUX:
1171 /*
1172 * flush all still to send data
1173 */
1174 dlc->received_prim |= UART_DCD_REQ_MASK;
1175 uart_data->ker.flush_state = UART_KER_DRX_FLUSH;
1176 dlc->flushed = FALSE;
1177 uart_data->drx = dlc->drx;
1178 sig_ker_drx_flush_req();
1179 break;
1180
1181 default:
1182 TRACE_ERROR( "UART_DCD_REQ unexpected" );
1183 break;
1184 }
1185 } /* ker_uart_dcd_req() */
1186
1187
1188
1189 /*
1190 +------------------------------------------------------------------------------
1191 | Function : ker_uart_escape_req
1192 +------------------------------------------------------------------------------
1193 | Description : Handles the primitive UART_ESCAPE_REQ
1194 |
1195 | Parameters : *uart_escape_req - Ptr to primitive payload
1196 |
1197 +------------------------------------------------------------------------------
1198 */
1199 GLOBAL void ker_uart_escape_req ( T_UART_ESCAPE_REQ *uart_escape_req )
1200 {
1201
1202 TRACE_FUNCTION( "ker_uart_escape_req" );
1203
1204 #ifdef UART_RANGE_CHECK
1205 if(uart_escape_req EQ NULL)
1206 {
1207 TRACE_EVENT("ERROR: uart_escape_req is NULL");
1208 }
1209 else if((*((ULONG*)((UBYTE*)uart_escape_req - sizeof(T_PRIM_HEADER) - 8))) NEQ 0)
1210 {
1211 TRACE_EVENT_P1("ERROR: uart_escape_req=%08x is not allocated",
1212 uart_escape_req);
1213 }
1214 else if(uart_escape_req->device >= UART_INSTANCES)
1215 {
1216 TRACE_EVENT_P2("ERROR: device=%d is greater than UART_INSTANCES=%d",
1217 uart_escape_req->device,
1218 UART_INSTANCES);
1219 }
1220 #endif /* UART_RANGE_CHECK */
1221
1222 /*
1223 * set UART instance
1224 */
1225 uart_data = &uart_data_base[uart_escape_req->device];
1226
1227 /*
1228 * set DLC instance
1229 */
1230 /* Following part of code is not required so put under comment ,but may be used
1231 * in future
1232 */
1233 /*
1234 if((GET_STATE( UART_SERVICE_KER )) EQ KER_READY)
1235 dlc = &uart_data->dlc_table[UART_CONTROL_INSTANCE];
1236 else
1237 dlc = &uart_data->dlc_table[uart_data->
1238 dlc_instance[uart_escape_req->dlci]];
1239 */
1240 /*
1241 * Send confirmation to ACI
1242 */
1243 {
1244 PALLOC (uart_escape_cnf, UART_ESCAPE_CNF);
1245
1246 uart_escape_cnf->device = uart_escape_req->device;
1247 uart_escape_cnf->dlci = uart_escape_req->dlci;
1248
1249 PSEND (hCommMMI, uart_escape_cnf);
1250 }
1251
1252 /*
1253 * TODO: Set escape on/off parameter in dtx,
1254 * Call UF_SetEscape and handle/stop ongoing
1255 * escape sequence detection if required
1256 */
1257
1258 /*
1259 * free the received primitive
1260 */
1261 PFREE(uart_escape_req);
1262
1263 switch( GET_STATE( UART_SERVICE_KER ) )
1264 {
1265 case KER_READY:
1266 case KER_MUX:
1267 break;
1268
1269 default:
1270 TRACE_ERROR( "UART_ESCAPE_REQ unexpected" );
1271 break;
1272 }
1273 } /* ker_uart_escape_req() */
1274
1275
1276
1277 /*
1278 +------------------------------------------------------------------------------
1279 | Function : ker_uart_mux_start_req
1280 +------------------------------------------------------------------------------
1281 | Description : Handles the primitive UART_MUX_START_REQ
1282 |
1283 | Parameters : *uart_mux_start_req - Ptr to primitive payload
1284 |
1285 +------------------------------------------------------------------------------
1286 */
1287 GLOBAL void ker_uart_mux_start_req ( T_UART_MUX_START_REQ *uart_mux_start_req )
1288 {
1289 T_DLC* dlc;
1290 #ifndef _SIMULATION_
1291 USHORT ret;
1292 #endif
1293 TRACE_FUNCTION( "ker_uart_mux_start_req" );
1294
1295 #ifdef UART_RANGE_CHECK
1296 if(uart_mux_start_req EQ NULL)
1297 {
1298 TRACE_EVENT("ERROR: uart_mux_start_req is NULL");
1299 }
1300 else if((*((ULONG*)((UBYTE*)uart_mux_start_req - sizeof(T_PRIM_HEADER) - 8))) NEQ 0)
1301 {
1302 TRACE_EVENT_P1("ERROR: uart_mux_start_req=%08x is not allocated",
1303 uart_mux_start_req);
1304 }
1305 else if(uart_mux_start_req->device >= UART_INSTANCES)
1306 {
1307 TRACE_EVENT_P2("ERROR: device=%d is greater than UART_INSTANCES=%d",
1308 uart_mux_start_req->device,
1309 UART_INSTANCES);
1310 }
1311 #endif /* UART_RANGE_CHECK */
1312
1313 /*
1314 * set UART instance
1315 */
1316 uart_data = &uart_data_base[uart_mux_start_req->device];
1317
1318 /*
1319 * set parameters
1320 */
1321 uart_data->n1 = uart_mux_start_req->n1;
1322 uart_data->ker.n2 = uart_mux_start_req->n2;
1323 sig_ker_rt_parameters_req(uart_mux_start_req->t1,
1324 uart_mux_start_req->t2,
1325 uart_mux_start_req->t3);
1326
1327 /*
1328 * free the received primitive
1329 */
1330 PFREE(uart_mux_start_req);
1331
1332 switch( GET_STATE( UART_SERVICE_KER ) )
1333 {
1334 case KER_READY:
1335 /*
1336 * flush all still to send data
1337 */
1338 uart_data->ker.received_prim|= UART_MUX_START_REQ_MASK;
1339 uart_data->ker.flush_state = UART_KER_DRX_FLUSH;
1340 dlc = &uart_data->dlc_table[UART_CONTROL_INSTANCE];
1341 dlc->flushed = FALSE;
1342 uart_data->drx = dlc->drx;
1343 sig_ker_drx_flush_req();
1344 break;
1345
1346 case KER_DEAD:
1347 SET_STATE( UART_SERVICE_KER, KER_MUX_ESTABLISH );
1348 #ifdef _SIMULATION_
1349 {
1350 /*
1351 * send DTI_GETDATA_REQ
1352 */
1353 PALLOC (dti_getdata_req, DTI2_GETDATA_REQ);
1354 #ifdef DTI2
1355 dti_getdata_req->link_id = LINK_ENABLE_PORT_1; /* for enable */
1356 #else /* DTI2 */
1357 dti_getdata_req->tui = 2; /* for enable */
1358 dti_getdata_req->c_id = 0;
1359 dti_getdata_req->op_ack = 0;
1360 #endif /* DTI2 */
1361 PSEND (hCommMMI, dti_getdata_req);
1362 }
1363 #else /* _SIMULATION_ */
1364 #ifndef FF_MULTI_PORT
1365 if((ret = UF_Enable (uart_data->device, TRUE)) NEQ UF_OK)
1366 {
1367 TRACE_ERROR_P2("UF Driver: Can't enable UART, [%d], uart_kerp.c(%d)",
1368 ret,__LINE__);
1369 }
1370 #endif /* !FF_MULTI_PORT */
1371 #endif /* _SIMULATION */
1372
1373 /*
1374 * set RX and TX service in mux mode
1375 */
1376 sig_ker_rx_mux_mode_req();
1377 sig_ker_tx_mux_mode_req();
1378 /*
1379 * start reception
1380 */
1381 MALLOC(uart_data->ker.rx_data_desc, (USHORT)(sizeof(T_desc2) -
1382 1 +
1383 uart_data->n1 +
1384 2));
1385 uart_data->ker.rx_data_desc->next = (ULONG)NULL;
1386 uart_data->ker.rx_data_desc->len = 0;
1387 sig_ker_rx_ready_to_receive_req(uart_data->ker.rx_data_desc,
1388 0,
1389 (USHORT)(uart_data->n1 + 2));
1390 /*
1391 * start timer
1392 */
1393 sig_ker_rt_start_t3_req();
1394
1395 /*
1396 * send confirm primitive
1397 */
1398 {
1399 PALLOC (uart_mux_start_cnf, UART_MUX_START_CNF);
1400 uart_mux_start_cnf->device = uart_data->device;
1401 PSEND (hCommMMI, uart_mux_start_cnf);
1402 }
1403 break;
1404
1405 default:
1406 TRACE_ERROR( "UART_MUX_START_REQ unexpected" );
1407 break;
1408 }
1409 } /* ker_uart_mux_start_req() */
1410
1411
1412
1413 /*
1414 +------------------------------------------------------------------------------
1415 | Function : ker_uart_mux_dlc_establish_res
1416 +------------------------------------------------------------------------------
1417 | Description : Handles the primitive UART_MUX_DLC_ESTABLISH_RES
1418 |
1419 | Parameters : *uart_mux_dlc_establish_res - Ptr to primitive payload
1420 |
1421 +------------------------------------------------------------------------------
1422 */
1423 GLOBAL void ker_uart_mux_dlc_establish_res (
1424 T_UART_MUX_DLC_ESTABLISH_RES *uart_mux_dlc_establish_res )
1425 {
1426 T_desc2* temp_desc;
1427 T_DLC* dlc;
1428
1429 TRACE_FUNCTION( "uart_mux_dlc_establish_res" );
1430
1431 #ifdef UART_RANGE_CHECK
1432 if(uart_mux_dlc_establish_res EQ NULL)
1433 {
1434 TRACE_EVENT("ERROR: uart_mux_dlc_establish_res is NULL");
1435 }
1436 else if((*((ULONG*)((UBYTE*)uart_mux_dlc_establish_res
1437 - sizeof(T_PRIM_HEADER) - 8))) NEQ 0)
1438 {
1439 TRACE_EVENT_P1("ERROR: uart_mux_dlc_establish_res=%08x is not allocated",
1440 uart_mux_dlc_establish_res);
1441 }
1442 else if(uart_mux_dlc_establish_res->device >= UART_INSTANCES)
1443 {
1444 TRACE_EVENT_P2("ERROR: device=%d is greater than UART_INSTANCES=%d",
1445 uart_mux_dlc_establish_res->device,
1446 UART_INSTANCES);
1447 }
1448 #endif /* UART_RANGE_CHECK */
1449
1450 /*
1451 * set UART instance
1452 */
1453 uart_data = &uart_data_base[uart_mux_dlc_establish_res->device];
1454
1455 switch( GET_STATE( UART_SERVICE_KER ) )
1456 {
1457 case KER_MUX:
1458 dlc = &uart_data->dlc_table[uart_data->
1459 dlc_instance[uart_mux_dlc_establish_res->dlci]];
1460 dlc->connection_state = UART_CONNECTION_OPEN;
1461 /*
1462 * send UA response
1463 */
1464 temp_desc = dlc->next_command;
1465 dlc->next_command = NULL;
1466 ker_mux_send_frame(temp_desc);
1467 /*
1468 * start Data services
1469 */
1470 uart_data->drx = dlc->drx;
1471 uart_data->dtx = dlc->dtx;
1472 sig_ker_drx_ready_mode_req(uart_data->
1473 dlc_instance[uart_mux_dlc_establish_res->dlci]);
1474 sig_ker_dtx_ready_mode_req(uart_data->
1475 dlc_instance[uart_mux_dlc_establish_res->dlci]);
1476 break;
1477
1478 default:
1479 TRACE_ERROR( "UART_MUX_DLC_ESTABLISH_RES unexpected" );
1480 break;
1481 }
1482 /*
1483 * free the received primitive
1484 */
1485 PFREE(uart_mux_dlc_establish_res);
1486 } /* uart_mux_dlc_establish_res() */
1487
1488
1489
1490 /*
1491 +------------------------------------------------------------------------------
1492 | Function : ker_uart_mux_dlc_release_req
1493 +------------------------------------------------------------------------------
1494 | Description : Handles the primitive UART_MUX_DLC_RELEASE_REQ
1495 |
1496 | Parameters : *ker_uart_mux_dlc_release_req - Ptr to primitive payload
1497 |
1498 +------------------------------------------------------------------------------
1499 */
1500 GLOBAL void ker_uart_mux_dlc_release_req (
1501 T_UART_MUX_DLC_RELEASE_REQ *uart_mux_dlc_release_req )
1502 {
1503 T_desc2* temp_desc;
1504 T_DLC* dlc;
1505 UBYTE dlc_instance; /* channel */
1506
1507 TRACE_FUNCTION( "ker_uart_mux_dlc_release_req" );
1508
1509 #ifdef UART_RANGE_CHECK
1510 if(uart_mux_dlc_release_req EQ NULL)
1511 {
1512 TRACE_EVENT("ERROR: uart_mux_dlc_release_req is NULL");
1513 }
1514 else if((*((ULONG*)((UBYTE*)uart_mux_dlc_release_req
1515 - sizeof(T_PRIM_HEADER) - 8))) NEQ 0)
1516 {
1517 TRACE_EVENT_P1("ERROR: uart_mux_dlc_release_req=%08x is not allocated",
1518 uart_mux_dlc_release_req);
1519 }
1520 else if(uart_mux_dlc_release_req->device >= UART_INSTANCES)
1521 {
1522 TRACE_EVENT_P2("ERROR: device=%d is greater than UART_INSTANCES=%d",
1523 uart_mux_dlc_release_req->device,
1524 UART_INSTANCES);
1525 }
1526 #endif /* UART_RANGE_CHECK */
1527
1528 /*
1529 * set UART instance
1530 */
1531 uart_data = &uart_data_base[uart_mux_dlc_release_req->device];
1532
1533 switch( GET_STATE( UART_SERVICE_KER ) )
1534 {
1535 case KER_MUX:
1536 dlc_instance = uart_data->dlc_instance[uart_mux_dlc_release_req->dlci];
1537 dlc = &uart_data->dlc_table[dlc_instance];
1538 /*
1539 * close DTI connection
1540 */
1541 uart_data->drx = dlc->drx;
1542 uart_data->dtx = dlc->dtx;
1543 sig_ker_drx_dead_mode_req();
1544 sig_ker_dtx_dead_mode_req();
1545 #ifdef DTILIB
1546 if(dlc->dti_state NEQ DTI_CLOSED)
1547 {
1548 dti_close(
1549 uart_hDTI,
1550 uart_data->device,
1551 UART_DTI_UP_INTERFACE,
1552 dlc_instance,
1553 FALSE
1554 );
1555 dlc->dti_state = DTI_CLOSED;
1556 }
1557 #else /* DTILIB */
1558 if(dlc->hCommUPLINK NEQ VSI_ERROR)
1559 {
1560 vsi_c_close (VSI_CALLER dlc->hCommUPLINK);
1561 dlc->hCommUPLINK = VSI_ERROR;
1562 }
1563 #endif /* DTILIB */
1564 switch(dlc->connection_state)
1565 {
1566 case UART_CONNECTION_SABM_RCVD:
1567 /*
1568 * negative response for an UART_MUX_DLC_ESTABLISH_IND
1569 * send DM response
1570 */
1571 temp_desc = dlc->next_command;
1572 dlc->next_command = NULL;
1573 temp_desc->buffer[UART_OFFSET_CONTROL] = UART_DM_CONTROL_FRAME
1574 ;/*lint !e415 access of out-of-bounds pointer*/
1575 ker_mux_send_frame(temp_desc);
1576 ker_mux_dlc_release(dlc_instance);
1577 break;
1578
1579 case UART_CONNECTION_OPEN:
1580 dlc->connection_state = UART_CONNECTION_DISC_SENT;
1581 ker_send_disc_frame(uart_mux_dlc_release_req->dlci);
1582 break;
1583 case UART_CONNECTION_DEAD:
1584 break;
1585
1586 default:
1587 TRACE_EVENT_P3("Warning: Unexpected DLC connection state: %d - \
1588 %s(%d)", dlc->connection_state, __FILE__, __LINE__);
1589 break;
1590 }
1591 break;
1592
1593 default:
1594 TRACE_ERROR( "UART_MUX_DLC_RELEASE_REQ unexpected" );
1595 break;
1596 }
1597 /*
1598 * free the received primitive
1599 */
1600 PFREE(uart_mux_dlc_release_req);
1601 } /* ker_uart_mux_dlc_release_req() */
1602
1603
1604
1605 /*
1606 +------------------------------------------------------------------------------
1607 | Function : ker_uart_mux_sleep_req
1608 +------------------------------------------------------------------------------
1609 | Description : Handles the primitive UART_MUX_SLEEP_REQ
1610 |
1611 | Parameters : *uart_mux_sleep_req - Ptr to primitive payload
1612 |
1613 +------------------------------------------------------------------------------
1614 */
1615 GLOBAL void ker_uart_mux_sleep_req (
1616 T_UART_MUX_SLEEP_REQ *uart_mux_sleep_req )
1617 {
1618 TRACE_FUNCTION( "uart_mux_sleep_req" );
1619
1620 #ifdef UART_RANGE_CHECK
1621 if(uart_mux_sleep_req EQ NULL)
1622 {
1623 TRACE_EVENT("ERROR: uart_mux_sleep_req is NULL");
1624 }
1625 else if((*((ULONG*)((UBYTE*)uart_mux_sleep_req
1626 - sizeof(T_PRIM_HEADER) - 8))) NEQ 0)
1627 {
1628 TRACE_EVENT_P1("ERROR: uart_mux_sleep_req=%08x is not allocated",
1629 uart_mux_sleep_req);
1630 }
1631 else if(uart_mux_sleep_req->device >= UART_INSTANCES)
1632 {
1633 TRACE_EVENT_P2("ERROR: device=%d is greater than UART_INSTANCES=%d",
1634 uart_mux_sleep_req->device,
1635 UART_INSTANCES);
1636 }
1637 #endif /* UART_RANGE_CHECK */
1638
1639 /*
1640 * set UART instance
1641 */
1642 uart_data = &uart_data_base[uart_mux_sleep_req->device];
1643
1644 /*
1645 * Primitive UART_MUX_SLEEP_REQ is not supported
1646 */
1647 TRACE_ERROR( "UART_MUX_SLEEP_REQ unexpected" );
1648
1649 /*
1650 * free the received primitive
1651 */
1652 PFREE(uart_mux_sleep_req);
1653 } /* ker_uart_mux_sleep_req() */
1654
1655
1656
1657 /*
1658 +------------------------------------------------------------------------------
1659 | Function : ker_uart_mux_wakeup_req
1660 +------------------------------------------------------------------------------
1661 | Description : Handles the primitive UART_MUX_WAKEUP_REQ
1662 |
1663 | Parameters : *uart_mux_wakeup_req - Ptr to primitive payload
1664 |
1665 +------------------------------------------------------------------------------
1666 */
1667 GLOBAL void ker_uart_mux_wakeup_req (
1668 T_UART_MUX_WAKEUP_REQ *uart_mux_wakeup_req )
1669 {
1670 TRACE_FUNCTION( "ker_uart_mux_wakeup_req" );
1671
1672 #ifdef UART_RANGE_CHECK
1673 if(uart_mux_wakeup_req EQ NULL)
1674 {
1675 TRACE_EVENT("ERROR: uart_mux_wakeup_req is NULL");
1676 }
1677 else if((*((ULONG*)((UBYTE*)uart_mux_wakeup_req - sizeof(T_PRIM_HEADER) - 8))) NEQ 0)
1678 {
1679 TRACE_EVENT_P1("ERROR: uart_mux_wakeup_req=%08x is not allocated",
1680 uart_mux_wakeup_req);
1681 }
1682 else if(uart_mux_wakeup_req->device >= UART_INSTANCES)
1683 {
1684 TRACE_EVENT_P2("ERROR: device=%d is greater than UART_INSTANCES=%d",
1685 uart_mux_wakeup_req->device,
1686 UART_INSTANCES);
1687 }
1688 #endif /* UART_RANGE_CHECK */
1689
1690 /*
1691 * set UART instance
1692 */
1693 uart_data = &uart_data_base[uart_mux_wakeup_req->device];
1694 /*
1695 * Primitive UART_MUX_WAKEUP_REQ is not supported
1696 */
1697 TRACE_ERROR( "UART_MUX_WAKEUP_REQ unexpected" );
1698 /*
1699 * free the received primitive
1700 */
1701 PFREE(uart_mux_wakeup_req);
1702 } /* ker_uart_mux_wakeup_req() */
1703
1704
1705
1706 /*
1707 +------------------------------------------------------------------------------
1708 | Function : ker_uart_mux_close_req
1709 +------------------------------------------------------------------------------
1710 | Description : Handles the primitive UART_MUX_CLOSE_REQ
1711 |
1712 | Parameters : *uart_mux_close_req - Ptr to primitive payload
1713 |
1714 +------------------------------------------------------------------------------
1715 */
1716 GLOBAL void ker_uart_mux_close_req (
1717 T_UART_MUX_CLOSE_REQ *uart_mux_close_req )
1718 {
1719 UBYTE i;
1720 T_DLC* dlc;
1721 T_desc2* temp_desc;
1722 BOOL continuous;
1723
1724
1725 TRACE_FUNCTION( "ker_uart_mux_close_req" );
1726
1727 #ifdef UART_RANGE_CHECK
1728 if(uart_mux_close_req EQ NULL)
1729 {
1730 TRACE_EVENT("ERROR: uart_mux_close_req is NULL");
1731 }
1732 else if((*((ULONG*)((UBYTE*)uart_mux_close_req - sizeof(T_PRIM_HEADER) - 8))) NEQ 0)
1733 {
1734 TRACE_EVENT_P1("ERROR: uart_mux_close_req=%08x is not allocated",
1735 uart_mux_close_req);
1736 }
1737 else if(uart_mux_close_req->device >= UART_INSTANCES)
1738 {
1739 TRACE_EVENT_P2("ERROR: device=%d is greater than UART_INSTANCES=%d",
1740 uart_mux_close_req->device,
1741 UART_INSTANCES);
1742 }
1743 #endif /* UART_RANGE_CHECK */
1744
1745 /*
1746 * set UART instance
1747 */
1748 uart_data = &uart_data_base[uart_mux_close_req->device];
1749
1750 switch( GET_STATE( UART_SERVICE_KER ) )
1751 {
1752 case KER_MUX_ESTABLISH:
1753 SET_STATE( UART_SERVICE_KER, KER_MUX_CLOSED );
1754 /*
1755 * stop timers and
1756 * remove all DLC instances
1757 */
1758 ker_mux_close_down();
1759 if(uart_data->ker.tx_data_desc EQ NULL)
1760 {
1761 uart_data->ker.received_prim|= UART_MUX_CLOSE_REQ_MASK;
1762
1763 if(uart_data->ker.flush_state EQ UART_KER_NOT_FLUSHING)
1764 {
1765 uart_data->ker.flush_state = UART_KER_TX_FLUSH;
1766 sig_ker_tx_flush_req();
1767 }
1768 }
1769 break;
1770
1771 case KER_MUX:
1772 SET_STATE( UART_SERVICE_KER, KER_MUX_DLC_CLOSING );
1773 /*
1774 * close all VSI channels and Data services
1775 */
1776 continuous = TRUE;
1777 for(i = 0; i <= UART_MAX_NUMBER_OF_CHANNELS; i++)
1778 {
1779 dlc = &uart_data->dlc_table[i];
1780 /*
1781 * close all DLC channels except Control channel
1782 */
1783 if(i NEQ UART_CONTROL_INSTANCE)
1784 {
1785 switch(dlc->connection_state)
1786 {
1787 case UART_CONNECTION_SABM_RCVD:
1788 /*
1789 * send DM response
1790 */
1791 temp_desc = dlc->next_command;
1792 dlc->next_command = NULL;
1793 temp_desc->buffer[UART_OFFSET_CONTROL] = UART_DM_CONTROL_FRAME
1794 ;/*lint !e415 access of out-of-bounds pointer*/
1795 ker_mux_send_frame(temp_desc);
1796 ker_mux_dlc_release(i);
1797 break;
1798
1799 case UART_CONNECTION_OPEN:
1800 dlc->connection_state = UART_CONNECTION_DISC_SENT;
1801 ker_send_disc_frame(dlc->dlci);
1802 continuous = FALSE;
1803 break;
1804
1805 case UART_CONNECTION_DISC_SENT:
1806 continuous = FALSE;
1807 break;
1808
1809 case UART_CONNECTION_DEAD:
1810 break;
1811
1812 default:
1813 TRACE_EVENT_P3("Warning: Unexpected DLC connection state: %d - \
1814 %s(%d)",dlc->connection_state,__FILE__, __LINE__);
1815 break;
1816 }
1817 }
1818 }
1819 if(continuous EQ TRUE)
1820 {
1821 SET_STATE( UART_SERVICE_KER, KER_MUX_CLOSING );
1822 /*
1823 * build and send CLD command frame:
1824 */
1825 ker_mux_send_close_down();
1826 /*
1827 * start timer
1828 */
1829 sig_ker_rt_start_t3_req();
1830 }
1831 break;
1832
1833 case KER_MUX_DLC_CLOSING:
1834 case KER_MUX_CLOSING:
1835 case KER_MUX_CLOSED:
1836 break;
1837
1838 default:
1839 TRACE_ERROR( "UART_MUX_CLOSE_REQ unexpected" );
1840 break;
1841 }
1842
1843 /*
1844 * free the received primitive
1845 */
1846 PFREE(uart_mux_close_req);
1847
1848 } /* ker_uart_mux_close_req() */
1849
1850
1851
1852 #ifdef DTILIB
1853 /*
1854 +------------------------------------------------------------------------------
1855 | Function : sig_dti_ker_connection_opened_ind
1856 +------------------------------------------------------------------------------
1857 | Description : Handles the DTILIB callback call DTI_REASON_CONNECTION_OPENED
1858 |
1859 | This signal means that a dti connection has been successfully opened.
1860 |
1861 | Parameter : dlc_instance
1862 |
1863 +------------------------------------------------------------------------------
1864 */
1865 GLOBAL void sig_dti_ker_connection_opened_ind (UBYTE dlc_instance)
1866 {
1867 #ifndef _SIMULATION_
1868 USHORT ret;
1869 #endif
1870 PALLOC (uart_dti_cnf, UART_DTI_CNF);
1871
1872 TRACE_FUNCTION( "sig_dti_ker_connection_opened_ind" );
1873
1874 /*
1875 * send confirm primitive
1876 */
1877 uart_dti_cnf->device = uart_data->device;
1878 uart_dti_cnf->dlci = uart_data->dlc_table[dlc_instance].dlci; /* EQ dlci */
1879 uart_dti_cnf->dti_conn = UART_CONNECT_DTI;
1880 PSEND (hCommMMI, uart_dti_cnf);
1881
1882 /*
1883 * initialize new communication channel
1884 */
1885 switch( GET_STATE( UART_SERVICE_KER ) )
1886 {
1887 case KER_DEAD:
1888 SET_STATE( UART_SERVICE_KER, KER_READY );
1889 /*
1890 * enable UART
1891 */
1892 #ifdef _SIMULATION_
1893 {
1894 /*
1895 * send DTI_GETDATA_REQ
1896 */
1897 PALLOC (dti_getdata_req, DTI2_GETDATA_REQ);
1898 #ifdef DTI2
1899 dti_getdata_req->link_id = LINK_ENABLE_PORT_1; /* for enable */
1900 #else /* DTI2 */
1901 dti_getdata_req->tui = 2; /* for enable */
1902 dti_getdata_req->c_id = 0;
1903 dti_getdata_req->op_ack = 0;
1904 #endif /* DTI2 */
1905 PSEND (hCommMMI, dti_getdata_req);
1906 }
1907 #else /* _SIMULATION_ */
1908 if((ret = UF_Enable (uart_data->device, TRUE)) NEQ UF_OK)
1909 {
1910 TRACE_ERROR_P2("UF Driver: Can't enable UART, [%d], uart_kerp.c(%d)",
1911 ret,__LINE__);
1912 }
1913 #endif /* _SIMULATION */
1914
1915 /*
1916 * set RX and TX in ready mode
1917 */
1918 sig_ker_rx_ready_mode_req();
1919 sig_ker_tx_ready_mode_req();
1920
1921 /*
1922 * set DTI connection
1923 */
1924 sig_ker_drx_ready_mode_req(UART_CONTROL_INSTANCE);
1925 sig_ker_dtx_ready_mode_req(UART_CONTROL_INSTANCE);
1926 sig_ker_drx_set_dtilib_peer_req();
1927 sig_ker_dtx_set_dtilib_peer_req();
1928 break;
1929
1930 case KER_READY:
1931 case KER_MUX:
1932 sig_ker_drx_set_dtilib_peer_req();
1933 sig_ker_dtx_set_dtilib_peer_req();
1934 break;
1935
1936 default:
1937 TRACE_ERROR( "UART_DTI_REQ unexpected" );
1938 break;
1939 }
1940 } /* sig_dti_ker_connection_opened_ind */
1941
1942
1943
1944 /*
1945 +------------------------------------------------------------------------------
1946 | Function : sig_dti_ker_connection_closed_ind
1947 +------------------------------------------------------------------------------
1948 | Description : Handles the DTILIB callback call DTI_REASON_CONNECTION_CLOSED
1949 |
1950 | This signal means that a dti connection has been closed by
1951 | the neighbour entity.
1952 |
1953 | Parameters : dlc_instance - affected dlc instance
1954 |
1955 +------------------------------------------------------------------------------
1956 */
1957 GLOBAL void sig_dti_ker_connection_closed_ind (U8 dlc_instance)
1958 {
1959 T_DLC *dlc;
1960
1961 TRACE_FUNCTION( "sig_dti_ker_connection_closed_ind" );
1962
1963 /*
1964 * set DLC
1965 */
1966 dlc = &uart_data->dlc_table[dlc_instance];
1967 uart_data->drx = dlc->drx;
1968 uart_data->dtx = dlc->dtx;
1969 /*
1970 * set DTI connection to closed state
1971 * if it is already closed, do nothing
1972 */
1973 if(dlc->dti_state NEQ DTI_CLOSED)
1974 {
1975 dlc->dti_state = DTI_CLOSED;
1976 sig_ker_drx_disconnected_mode_req();
1977 sig_ker_dtx_disconnected_mode_req();
1978 /*
1979 * inform MMI
1980 */
1981 {
1982 PALLOC (uart_dti_ind, UART_DTI_IND);
1983 uart_dti_ind->device = uart_data->device;
1984 uart_dti_ind->dlci = dlc->dlci;
1985 uart_dti_ind->dti_conn = UART_DISCONNECT_DTI;
1986 PSEND (hCommMMI, uart_dti_ind);
1987 }
1988 }
1989 } /* sig_dti_ker_connection_closed_ind */
1990 #endif /* DTILIB */