1 /******************************************************************************
2 *
3 * Copyright (C) 1999-2012 Broadcom Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18
19 /******************************************************************************
20 *
21 * This module contains functions for port emulation entity and RFCOMM
22 * communications
23 *
24 ******************************************************************************/
25 #include <string.h>
26
27 #include "bt_target.h"
28 #include "gki.h"
29 #include "rfcdefs.h"
30 #include "port_api.h"
31 #include "btm_int.h"
32 #include "btm_api.h"
33 #include "port_int.h"
34 #include "rfc_int.h"
35 #include "bt_utils.h"
36
37 /*
38 ** Local function definitions
39 */
40 UINT32 port_rfc_send_tx_data (tPORT *p_port);
41 void port_rfc_closed (tPORT *p_port, UINT8 res);
42 void port_get_credits (tPORT *p_port, UINT8 k);
43
44
45 /*******************************************************************************
46 **
47 ** Function port_open_continue
48 **
49 ** Description This function is called after security manager completes
50 ** required security checks.
51 **
52 ** Returns void
53 **
54 *******************************************************************************/
port_open_continue(tPORT * p_port)55 int port_open_continue (tPORT *p_port)
56 {
57 tRFC_MCB *p_mcb;
58
59 RFCOMM_TRACE_EVENT ("port_open_continue, p_port:%p", p_port);
60
61 /* Check if multiplexer channel has already been established */
62 if ((p_mcb = rfc_alloc_multiplexer_channel (p_port->bd_addr, TRUE)) == NULL)
63 {
64 RFCOMM_TRACE_WARNING ("port_open_continue no mx channel");
65 port_release_port (p_port);
66 return (PORT_NO_RESOURCES);
67 }
68
69 p_port->rfc.p_mcb = p_mcb;
70
71 p_mcb->port_inx[p_port->dlci] = p_port->inx;
72
73 /* Connection is up and we know local and remote features, select MTU */
74 port_select_mtu (p_port);
75
76 if (p_mcb->state == RFC_MX_STATE_CONNECTED)
77 {
78 RFCOMM_ParNegReq (p_mcb, p_port->dlci, p_port->mtu);
79 }
80 else if ((p_mcb->state == RFC_MX_STATE_IDLE)
81 ||(p_mcb->state == RFC_MX_STATE_DISC_WAIT_UA))
82 {
83 /* In RFC_MX_STATE_IDLE state, MX state machine will create connection */
84 /* In RFC_MX_STATE_DISC_WAIT_UA state, MX state machine will recreate connection */
85 /* after disconnecting is completed */
86 RFCOMM_StartReq (p_mcb);
87 }
88 else
89 {
90 /* MX state machine ignores RFC_MX_EVENT_START_REQ in these states */
91 /* When it enters RFC_MX_STATE_CONNECTED, it will check any openning ports */
92 RFCOMM_TRACE_DEBUG ("port_open_continue: mx state(%d) mx channel is openning", p_mcb->state);
93 }
94 return (PORT_SUCCESS);
95 }
96
97
98 /*******************************************************************************
99 **
100 ** Function port_start_control
101 **
102 ** Description This function is called in the BTU_TASK context to
103 ** send control information
104 **
105 ** Returns void
106 **
107 *******************************************************************************/
port_start_control(tPORT * p_port)108 void port_start_control (tPORT *p_port)
109 {
110 tRFC_MCB *p_mcb = p_port->rfc.p_mcb;
111
112 if (p_mcb == NULL)
113 return;
114
115 RFCOMM_ControlReq (p_mcb, p_port->dlci, &p_port->local_ctrl);
116 }
117
118
119 /*******************************************************************************
120 **
121 ** Function port_start_par_neg
122 **
123 ** Description This function is called in the BTU_TASK context to
124 ** send configuration information
125 **
126 ** Returns void
127 **
128 *******************************************************************************/
port_start_par_neg(tPORT * p_port)129 void port_start_par_neg (tPORT *p_port)
130 {
131 tRFC_MCB *p_mcb = p_port->rfc.p_mcb;
132
133 if (p_mcb == NULL)
134 return;
135
136 RFCOMM_PortNegReq (p_mcb, p_port->dlci, &p_port->user_port_pars);
137 }
138
139
140 /*******************************************************************************
141 **
142 ** Function port_start_close
143 **
144 ** Description This function is called in the BTU_TASK context to
145 ** release DLC
146 **
147 ** Returns void
148 **
149 *******************************************************************************/
port_start_close(tPORT * p_port)150 void port_start_close (tPORT *p_port)
151 {
152 tRFC_MCB *p_mcb = p_port->rfc.p_mcb;
153 UINT8 old_signals;
154 UINT32 events = 0;
155
156 /* At first indicate to the user that signals on the connection were dropped */
157 p_port->line_status |= LINE_STATUS_FAILED;
158 old_signals = p_port->peer_ctrl.modem_signal;
159
160 p_port->peer_ctrl.modem_signal &= ~(PORT_DTRDSR_ON | PORT_CTSRTS_ON | PORT_DCD_ON);
161
162 events |= port_get_signal_changes (p_port, old_signals, p_port->peer_ctrl.modem_signal);
163
164 if(p_port->ev_mask & PORT_EV_CONNECT_ERR)
165 events |= PORT_EV_CONNECT_ERR;
166
167 if(p_port->ev_mask & PORT_EV_ERR)
168 events |= PORT_EV_ERR;
169
170 if ((p_port->p_callback != NULL) && events)
171 p_port->p_callback (events, p_port->inx);
172
173
174 /* Check if RFCOMM side has been closed while the message was queued */
175 if ((p_mcb == NULL) || (p_port->rfc.state == RFC_STATE_CLOSED))
176 {
177 /* Call management callback function before calling port_release_port() to clear tPort */
178 if (p_port->p_mgmt_callback)
179 p_port->p_mgmt_callback (PORT_CLOSED, p_port->inx);
180
181 port_release_port (p_port);
182 }
183 else
184 {
185 RFCOMM_DlcReleaseReq (p_mcb, p_port->dlci);
186 }
187 }
188
189
190 /*******************************************************************************
191 **
192 ** Function PORT_StartCnf
193 **
194 ** Description This function is called from the RFCOMM layer when
195 ** establishing of the multiplexer channel is completed.
196 ** Continue establishing of the connection for all ports that
197 ** are in the OPENING state
198 **
199 *******************************************************************************/
PORT_StartCnf(tRFC_MCB * p_mcb,UINT16 result)200 void PORT_StartCnf (tRFC_MCB *p_mcb, UINT16 result)
201 {
202 tPORT *p_port;
203 int i;
204 BOOLEAN no_ports_up = TRUE;
205
206 RFCOMM_TRACE_EVENT ("PORT_StartCnf result:%d", result);
207
208 p_port = &rfc_cb.port.port[0];
209 for (i = 0; i < MAX_RFC_PORTS; i++, p_port++)
210 {
211 if (p_port->rfc.p_mcb == p_mcb)
212 {
213 no_ports_up = FALSE;
214
215 if (result == RFCOMM_SUCCESS)
216 RFCOMM_ParNegReq (p_mcb, p_port->dlci, p_port->mtu);
217 else
218 {
219 RFCOMM_TRACE_WARNING ("PORT_StartCnf failed result:%d", result);
220
221 /* Warning: result is also set to 4 when l2cap connection
222 fails due to l2cap connect cnf (no_resources) */
223 if( result == HCI_ERR_PAGE_TIMEOUT )
224 p_port->error = PORT_PAGE_TIMEOUT;
225 else
226 p_port->error = PORT_START_FAILED;
227
228 rfc_release_multiplexer_channel (p_mcb);
229 p_port->rfc.p_mcb = NULL;
230
231 /* Send event to the application */
232 if (p_port->p_callback && (p_port->ev_mask & PORT_EV_CONNECT_ERR))
233 (p_port->p_callback)(PORT_EV_CONNECT_ERR, p_port->inx);
234
235 if (p_port->p_mgmt_callback)
236 p_port->p_mgmt_callback (PORT_START_FAILED, p_port->inx);
237
238 port_release_port (p_port);
239 }
240 }
241 }
242
243 /* There can be a situation when after starting connection, user closes the */
244 /* port, we can catch it here to close multiplexor channel */
245 if (no_ports_up)
246 {
247 rfc_check_mcb_active (p_mcb);
248 }
249 }
250
251
252 /*******************************************************************************
253 **
254 ** Function PORT_StartInd
255 **
256 ** Description This function is called from the RFCOMM layer when
257 ** some peer device wants to establish a multiplexer
258 ** connection. Check if there are any ports open with this
259 ** or not assigned multiplexer.
260 **
261 *******************************************************************************/
PORT_StartInd(tRFC_MCB * p_mcb)262 void PORT_StartInd (tRFC_MCB *p_mcb)
263 {
264 tPORT *p_port;
265 int i;
266
267 RFCOMM_TRACE_EVENT ("PORT_StartInd");
268
269 p_port = &rfc_cb.port.port[0];
270 for (i = 0; i < MAX_RFC_PORTS; i++, p_port++)
271 {
272 if ((p_port->rfc.p_mcb == NULL)
273 || (p_port->rfc.p_mcb == p_mcb))
274 {
275 RFCOMM_TRACE_DEBUG("PORT_StartInd, RFCOMM_StartRsp RFCOMM_SUCCESS: p_mcb:%p", p_mcb);
276 RFCOMM_StartRsp (p_mcb, RFCOMM_SUCCESS);
277 return;
278 }
279 }
280 RFCOMM_StartRsp (p_mcb, RFCOMM_ERROR);
281 }
282
283
284 /*******************************************************************************
285 **
286 ** Function PORT_ParNegInd
287 **
288 ** Description This function is called from the RFCOMM layer to change
289 ** DLCI parameters (currently only MTU is negotiated).
290 ** If can not find the port do not accept the request.
291 ** Otherwise save the MTU size supported by the peer.
292 **
293 *******************************************************************************/
PORT_ParNegInd(tRFC_MCB * p_mcb,UINT8 dlci,UINT16 mtu,UINT8 cl,UINT8 k)294 void PORT_ParNegInd (tRFC_MCB *p_mcb, UINT8 dlci, UINT16 mtu, UINT8 cl, UINT8 k)
295 {
296 tPORT *p_port = port_find_mcb_dlci_port (p_mcb, dlci);
297 UINT8 our_cl;
298 UINT8 our_k;
299
300 RFCOMM_TRACE_EVENT ("PORT_ParNegInd dlci:%d mtu:%d", dlci, mtu);
301
302 if (!p_port)
303 {
304 /* This can be a first request for this port */
305 p_port = port_find_dlci_port (dlci);
306 if (!p_port)
307 {
308 /* If the port cannot be opened, send a DM. Per Errata 1205 */
309 rfc_send_dm(p_mcb, dlci, FALSE);
310 /* check if this is the last port open, some headsets have
311 problem, they don't disconnect if we send DM */
312 rfc_check_mcb_active( p_mcb );
313 RFCOMM_TRACE_EVENT( "PORT_ParNegInd: port not found" );
314 return;
315 }
316 p_mcb->port_inx[dlci] = p_port->inx;
317 }
318
319 memcpy (p_port->bd_addr, p_mcb->bd_addr, BD_ADDR_LEN);
320
321 /* Connection is up and we know local and remote features, select MTU */
322 port_select_mtu (p_port);
323
324 p_port->rfc.p_mcb = p_mcb;
325 p_port->mtu = (p_port->mtu < mtu) ? p_port->mtu : mtu;
326 p_port->peer_mtu = p_port->mtu;
327
328 /* Negotiate the flow control mechanism. If flow control mechanism for */
329 /* mux has not been set yet, set it now. If either we or peer wants TS 07.10, */
330 /* use that. Otherwise both must want credit based, so use that. If flow is */
331 /* already defined for this mux, we respond with that value. */
332 if (p_mcb->flow == PORT_FC_UNDEFINED)
333 {
334 if ((PORT_FC_DEFAULT == PORT_FC_TS710) || (cl == RFCOMM_PN_CONV_LAYER_TYPE_1))
335 {
336 p_mcb->flow = PORT_FC_TS710;
337 }
338 else
339 {
340 p_mcb->flow = PORT_FC_CREDIT;
341 }
342 }
343
344 /* Regardless of our flow control mechanism, if the PN cl is zero, we must */
345 /* respond with zero. "A responding implementation must set this field to 14 */
346 /* if (and only if) the PN request was 15." This could happen if a PN is sent */
347 /* after the DLCI is already established-- the PN in that case must have cl = 0. */
348 /* See RFCOMM spec 5.5.3 */
349 if (cl == RFCOMM_PN_CONV_LAYER_TYPE_1)
350 {
351 our_cl = RFCOMM_PN_CONV_LAYER_TYPE_1;
352 our_k = 0;
353 }
354 else if (p_mcb->flow == PORT_FC_CREDIT)
355 {
356 /* get credits */
357 port_get_credits (p_port, k);
358
359 /* Set convergence layer and number of credits (k) */
360 our_cl = RFCOMM_PN_CONV_LAYER_CBFC_R;
361 our_k = (p_port->credit_rx_max < RFCOMM_K_MAX) ? p_port->credit_rx_max : RFCOMM_K_MAX;
362 p_port->credit_rx = our_k;
363 }
364 else
365 {
366 /* must not be using credit based flow control; use TS 7.10 */
367 our_cl = RFCOMM_PN_CONV_LAYER_TYPE_1;
368 our_k = 0;
369 }
370 RFCOMM_ParNegRsp (p_mcb, dlci, p_port->mtu, our_cl, our_k);
371 }
372
373
374 /*******************************************************************************
375 **
376 ** Function PORT_ParNegCnf
377 **
378 ** Description This function is called from the RFCOMM layer to change
379 ** DLCI parameters (currently only MTU is negotiated).
380 ** Save the MTU size supported by the peer.
381 ** If the confirmation is received during the port opening
382 ** procedure send EstablishRequest to continue.
383 **
384 *******************************************************************************/
PORT_ParNegCnf(tRFC_MCB * p_mcb,UINT8 dlci,UINT16 mtu,UINT8 cl,UINT8 k)385 void PORT_ParNegCnf (tRFC_MCB *p_mcb, UINT8 dlci, UINT16 mtu, UINT8 cl, UINT8 k)
386 {
387 tPORT *p_port = port_find_mcb_dlci_port (p_mcb, dlci);
388
389 RFCOMM_TRACE_EVENT ("PORT_ParNegCnf dlci:%d mtu:%d cl: %d k: %d", dlci, mtu, cl, k);
390
391 if (!p_port)
392 return;
393
394 /* Flow control mechanism not set yet. Negotiate flow control mechanism. */
395 if (p_mcb->flow == PORT_FC_UNDEFINED)
396 {
397 /* Our stack is configured for TS07.10 and they responded with credit-based. */
398 /* This is illegal-- negotiation fails. */
399 if ((PORT_FC_DEFAULT == PORT_FC_TS710) && (cl == RFCOMM_PN_CONV_LAYER_CBFC_R))
400 {
401 rfc_send_disc (p_mcb, p_port->dlci);
402 rfc_port_closed (p_port);
403 return;
404 }
405 /* Our stack is configured for credit-based and they responded with credit-based. */
406 else if (cl == RFCOMM_PN_CONV_LAYER_CBFC_R)
407 {
408 p_mcb->flow = PORT_FC_CREDIT;
409 }
410 /* They responded with any other value. Treat this as negotiation to TS07.10. */
411 else
412 {
413 p_mcb->flow = PORT_FC_TS710;
414 }
415 }
416 /* If mux flow control mechanism set, we honor that setting regardless of */
417 /* the CL value in their response. This allows us to gracefully accept any */
418 /* illegal PN negotiation scenarios. */
419
420 p_port->mtu = (p_port->mtu < mtu) ? p_port->mtu : mtu;
421 p_port->peer_mtu = p_port->mtu;
422
423 if (p_mcb->flow == PORT_FC_CREDIT)
424 {
425 port_get_credits (p_port, k);
426 }
427
428 if (p_port->state == PORT_STATE_OPENING)
429 RFCOMM_DlcEstablishReq (p_mcb, p_port->dlci, p_port->mtu);
430 }
431
432
433 /*******************************************************************************
434 **
435 ** Function PORT_DlcEstablishInd
436 **
437 ** Description This function is called from the RFCOMM layer when peer
438 ** device wants to establish a new DLC. If this is not the
439 ** first message in the establishment procedure port_handle
440 ** has a handle to the port control block otherwise the control
441 ** block should be found based on the muliplexer channel and
442 ** dlci. The block should be allocated allocated before
443 ** meaning that application already made open.
444 **
445 *******************************************************************************/
PORT_DlcEstablishInd(tRFC_MCB * p_mcb,UINT8 dlci,UINT16 mtu)446 void PORT_DlcEstablishInd (tRFC_MCB *p_mcb, UINT8 dlci, UINT16 mtu)
447 {
448 tPORT *p_port = port_find_mcb_dlci_port (p_mcb, dlci);
449
450 RFCOMM_TRACE_DEBUG ("PORT_DlcEstablishInd p_mcb:%p, dlci:%d mtu:%di, p_port:%p", p_mcb, dlci, mtu, p_port);
451 RFCOMM_TRACE_DEBUG ("PORT_DlcEstablishInd p_mcb addr:%02x:%02x:%02x:%02x:%02x:%02x",
452 p_mcb->bd_addr[0], p_mcb->bd_addr[1], p_mcb->bd_addr[2],
453 p_mcb->bd_addr[3], p_mcb->bd_addr[4], p_mcb->bd_addr[5]);
454
455 if (!p_port)
456 {
457 /* This can be a first request for this port */
458 p_port = port_find_dlci_port (dlci);
459 if (!p_port)
460 {
461 RFCOMM_DlcEstablishRsp (p_mcb, dlci, 0, RFCOMM_ERROR);
462 return;
463 }
464 p_mcb->port_inx[dlci] = p_port->inx;
465 }
466
467 /* If L2CAP's mtu less then RFCOMM's take it */
468 if (mtu && (mtu < p_port->peer_mtu))
469 p_port->peer_mtu = mtu;
470
471 /* If there was an inactivity timer running for MCB stop it */
472 rfc_timer_stop (p_mcb);
473
474 RFCOMM_DlcEstablishRsp (p_mcb, dlci, p_port->mtu, RFCOMM_SUCCESS);
475
476 /* This is the server side. If application wants to know when connection */
477 /* is established, thats the place */
478 if (p_port->p_callback && (p_port->ev_mask & PORT_EV_CONNECTED))
479 (p_port->p_callback)(PORT_EV_CONNECTED, p_port->inx);
480
481 if (p_port->p_mgmt_callback)
482 p_port->p_mgmt_callback (PORT_SUCCESS, p_port->inx);
483
484 p_port->state = PORT_STATE_OPENED;
485 }
486
487
488 /*******************************************************************************
489 **
490 ** Function PORT_DlcEstablishCnf
491 **
492 ** Description This function is called from the RFCOMM layer when peer
493 ** acknowledges establish procedure (SABME/UA). Send reply
494 ** to the user and set state to OPENED if result was
495 ** successfull.
496 **
497 *******************************************************************************/
PORT_DlcEstablishCnf(tRFC_MCB * p_mcb,UINT8 dlci,UINT16 mtu,UINT16 result)498 void PORT_DlcEstablishCnf (tRFC_MCB *p_mcb, UINT8 dlci, UINT16 mtu, UINT16 result)
499 {
500 tPORT *p_port = port_find_mcb_dlci_port (p_mcb, dlci);
501
502 RFCOMM_TRACE_EVENT ("PORT_DlcEstablishCnf dlci:%d mtu:%d result:%d", dlci, mtu, result);
503
504 if (!p_port)
505 return;
506
507 if (result != RFCOMM_SUCCESS)
508 {
509 p_port->error = PORT_START_FAILED;
510 port_rfc_closed (p_port, PORT_START_FAILED);
511 return;
512 }
513
514 /* If L2CAP's mtu less then RFCOMM's take it */
515 if (mtu && (mtu < p_port->peer_mtu))
516 p_port->peer_mtu = mtu;
517
518 /* If there was an inactivity timer running for MCB stop it */
519 rfc_timer_stop (p_mcb);
520
521 if (p_port->p_callback && (p_port->ev_mask & PORT_EV_CONNECTED))
522 (p_port->p_callback)(PORT_EV_CONNECTED, p_port->inx);
523
524 if (p_port->p_mgmt_callback)
525 p_port->p_mgmt_callback (PORT_SUCCESS, p_port->inx);
526
527 p_port->state = PORT_STATE_OPENED;
528
529 /* RPN is required only if we want to tell DTE how the port should be opened */
530 if ((p_port->uuid == UUID_SERVCLASS_DIALUP_NETWORKING)
531 || (p_port->uuid == UUID_SERVCLASS_FAX))
532 RFCOMM_PortNegReq (p_port->rfc.p_mcb, p_port->dlci, NULL);
533 else
534 RFCOMM_ControlReq (p_port->rfc.p_mcb, p_port->dlci, &p_port->local_ctrl);
535 }
536
537
538 /*******************************************************************************
539 **
540 ** Function PORT_PortNegInd
541 **
542 ** Description This function is called from the RFCOMM layer when peer
543 ** device wants to set parameters of the port. As per the spec
544 ** this message has to be sent before the first data packet
545 ** and can be sent before establish. The block should be
546 ** allocated before meaning that application already made open.
547 **
548 *******************************************************************************/
PORT_PortNegInd(tRFC_MCB * p_mcb,UINT8 dlci,tPORT_STATE * p_pars,UINT16 param_mask)549 void PORT_PortNegInd (tRFC_MCB *p_mcb, UINT8 dlci, tPORT_STATE *p_pars,
550 UINT16 param_mask)
551 {
552 tPORT *p_port = port_find_mcb_dlci_port (p_mcb, dlci);
553
554 RFCOMM_TRACE_EVENT ("PORT_PortNegInd");
555
556 if (!p_port)
557 {
558 /* This can be a first request for this port */
559 p_port = port_find_dlci_port (dlci);
560 if (!p_port)
561 {
562 RFCOMM_PortNegRsp (p_mcb, dlci, p_pars, 0);
563 return;
564 }
565 p_mcb->port_inx[dlci] = p_port->inx;
566 }
567
568 /* Check if the flow control is acceptable on local side */
569 p_port->peer_port_pars = *p_pars;
570 RFCOMM_PortNegRsp (p_mcb, dlci, p_pars, param_mask);
571 }
572
573
574 /*******************************************************************************
575 **
576 ** Function PORT_PortNegCnf
577 **
578 ** Description This function is called from the RFCOMM layer to change
579 ** state for the port. Propagate change to the user.
580 **
581 *******************************************************************************/
PORT_PortNegCnf(tRFC_MCB * p_mcb,UINT8 dlci,tPORT_STATE * p_pars,UINT16 result)582 void PORT_PortNegCnf (tRFC_MCB *p_mcb, UINT8 dlci, tPORT_STATE *p_pars, UINT16 result)
583 {
584 tPORT *p_port = port_find_mcb_dlci_port (p_mcb, dlci);
585 UNUSED(p_pars);
586
587 RFCOMM_TRACE_EVENT ("PORT_PortNegCnf");
588
589 if (!p_port)
590 {
591 RFCOMM_TRACE_WARNING ("PORT_PortNegCnf no port");
592 return;
593 }
594 /* Port negotiation failed. Drop the connection */
595 if (result != RFCOMM_SUCCESS)
596 {
597 p_port->error = PORT_PORT_NEG_FAILED;
598
599 RFCOMM_DlcReleaseReq (p_mcb, p_port->dlci);
600
601 port_rfc_closed (p_port, PORT_PORT_NEG_FAILED);
602 return;
603 }
604
605 if (!(p_port->port_ctrl & PORT_CTRL_REQ_SENT))
606 {
607 RFCOMM_ControlReq (p_port->rfc.p_mcb, p_port->dlci, &p_port->local_ctrl);
608 }
609 else
610 {
611 RFCOMM_TRACE_WARNING ("PORT_PortNegCnf Control Already sent");
612 }
613 }
614
615
616 /*******************************************************************************
617 **
618 ** Function PORT_ControlInd
619 **
620 ** Description This function is called from the RFCOMM layer on the modem
621 ** signal change. Propagate change to the user.
622 **
623 *******************************************************************************/
PORT_ControlInd(tRFC_MCB * p_mcb,UINT8 dlci,tPORT_CTRL * p_pars)624 void PORT_ControlInd (tRFC_MCB *p_mcb, UINT8 dlci, tPORT_CTRL *p_pars)
625 {
626 tPORT *p_port = port_find_mcb_dlci_port (p_mcb, dlci);
627 UINT32 event;
628 UINT8 old_signals;
629
630 RFCOMM_TRACE_EVENT ("PORT_ControlInd");
631
632 if (!p_port)
633 return;
634
635 old_signals = p_port->peer_ctrl.modem_signal;
636
637 event = port_get_signal_changes (p_port, old_signals, p_pars->modem_signal);
638
639 p_port->peer_ctrl = *p_pars;
640
641 if (!(p_port->port_ctrl & PORT_CTRL_REQ_SENT))
642 RFCOMM_ControlReq (p_port->rfc.p_mcb, p_port->dlci, &p_port->local_ctrl);
643 else
644 {
645 /* If this is the first time we received control RFCOMM is connected */
646 if (!(p_port->port_ctrl & PORT_CTRL_IND_RECEIVED))
647 {
648 event |= (PORT_EV_CONNECTED & p_port->ev_mask);
649 }
650
651 if (p_port->port_ctrl & PORT_CTRL_REQ_CONFIRMED)
652 {
653 event |= port_rfc_send_tx_data(p_port);
654 }
655 }
656
657 p_port->port_ctrl |= (PORT_CTRL_IND_RECEIVED | PORT_CTRL_IND_RESPONDED);
658
659 if (p_pars->break_signal)
660 event |= (PORT_EV_BREAK & p_port->ev_mask);
661
662 /* execute call back function only if the application is registered for events */
663 if (event && p_port->p_callback)
664 (p_port->p_callback)(event, p_port->inx);
665
666 RFCOMM_TRACE_EVENT ("PORT_ControlInd DTR_DSR : %d, RTS_CTS : %d, RI : %d, DCD : %d",
667 ((p_port->peer_ctrl.modem_signal & MODEM_SIGNAL_DTRDSR) ? 1 : 0),
668 ((p_port->peer_ctrl.modem_signal & MODEM_SIGNAL_RTSCTS) ? 1 : 0),
669 ((p_port->peer_ctrl.modem_signal & MODEM_SIGNAL_RI) ? 1 : 0),
670 ((p_port->peer_ctrl.modem_signal & MODEM_SIGNAL_DCD) ? 1 : 0));
671
672 }
673
674
675 /*******************************************************************************
676 **
677 ** Function PORT_ControlCnf
678 **
679 ** Description This function is called from the RFCOMM layer when
680 ** peer acknowleges change of the modem signals.
681 **
682 *******************************************************************************/
PORT_ControlCnf(tRFC_MCB * p_mcb,UINT8 dlci,tPORT_CTRL * p_pars)683 void PORT_ControlCnf (tRFC_MCB *p_mcb, UINT8 dlci, tPORT_CTRL *p_pars)
684 {
685 tPORT *p_port = port_find_mcb_dlci_port (p_mcb, dlci);
686 UINT32 event = 0;
687 UNUSED(p_pars);
688
689 RFCOMM_TRACE_EVENT ("PORT_ControlCnf");
690
691 if (!p_port)
692 return;
693
694 if (!(p_port->port_ctrl & PORT_CTRL_REQ_CONFIRMED))
695 {
696 p_port->port_ctrl |= PORT_CTRL_REQ_CONFIRMED;
697
698 if (p_port->port_ctrl & PORT_CTRL_IND_RECEIVED)
699 event = (p_port->ev_mask & PORT_EV_CONNECTED);
700 }
701
702 if (p_port->port_ctrl & PORT_CTRL_IND_RECEIVED)
703 {
704 event |= port_rfc_send_tx_data(p_port);
705 }
706
707 /* execute call back function only if the application is registered for events */
708 if (event && p_port->p_callback)
709 (p_port->p_callback)(event, p_port->inx);
710 }
711
712
713 /*******************************************************************************
714 **
715 ** Function PORT_LineStatusInd
716 **
717 ** Description This function is called from the RFCOMM layer when
718 ** peer indicates change in the line status
719 **
720 *******************************************************************************/
PORT_LineStatusInd(tRFC_MCB * p_mcb,UINT8 dlci,UINT8 line_status)721 void PORT_LineStatusInd (tRFC_MCB *p_mcb, UINT8 dlci, UINT8 line_status)
722 {
723 tPORT *p_port = port_find_mcb_dlci_port (p_mcb, dlci);
724 UINT32 event = 0;
725
726 RFCOMM_TRACE_EVENT ("PORT_LineStatusInd");
727
728 if (!p_port)
729 return;
730
731 p_port->line_status |= line_status;
732
733 if (line_status & PORT_ERR_OVERRUN)
734 event |= PORT_EV_OVERRUN;
735
736 if (line_status & PORT_ERR_BREAK)
737 event |= PORT_EV_BREAK;
738
739 if (line_status & ~(PORT_ERR_OVERRUN | PORT_ERR_BREAK))
740 event |= PORT_EV_ERR;
741
742 if ((p_port->p_callback != NULL) && (p_port->ev_mask & event))
743 p_port->p_callback ((p_port->ev_mask & event), p_port->inx);
744 }
745
746
747 /*******************************************************************************
748 **
749 ** Function PORT_DlcReleaseInd
750 **
751 ** Description This function is called from the RFCOMM layer when
752 ** DLC connection is released.
753 **
754 *******************************************************************************/
PORT_DlcReleaseInd(tRFC_MCB * p_mcb,UINT8 dlci)755 void PORT_DlcReleaseInd (tRFC_MCB *p_mcb, UINT8 dlci)
756 {
757 tPORT *p_port = port_find_mcb_dlci_port (p_mcb, dlci);
758
759 RFCOMM_TRACE_EVENT ("PORT_DlcReleaseInd");
760
761 if (!p_port)
762 return;
763
764 port_rfc_closed (p_port, PORT_CLOSED);
765 }
766
767
768 /*******************************************************************************
769 **
770 ** Function PORT_CloseInd
771 **
772 ** Description This function is called from the RFCOMM layer when
773 ** multiplexer connection is released.
774 **
775 *******************************************************************************/
PORT_CloseInd(tRFC_MCB * p_mcb)776 void PORT_CloseInd (tRFC_MCB *p_mcb)
777 {
778 tPORT *p_port;
779 int i;
780
781 RFCOMM_TRACE_EVENT ("PORT_CloseInd");
782
783 p_port = &rfc_cb.port.port[0];
784 for (i = 0; i < MAX_RFC_PORTS; i++, p_port++)
785 {
786 if (p_port->rfc.p_mcb == p_mcb)
787 {
788 port_rfc_closed (p_port, PORT_PEER_CONNECTION_FAILED);
789 }
790 }
791 rfc_release_multiplexer_channel (p_mcb);
792 }
793
794 /*******************************************************************************
795 **
796 ** Function Port_TimeOutCloseMux
797 **
798 ** Description This function is called when RFCOMM timesout on a command
799 ** as a result multiplexer connection is closed.
800 **
801 *******************************************************************************/
Port_TimeOutCloseMux(tRFC_MCB * p_mcb)802 void Port_TimeOutCloseMux (tRFC_MCB *p_mcb)
803 {
804 tPORT *p_port;
805 int i;
806
807 RFCOMM_TRACE_EVENT ("Port_TimeOutCloseMux");
808
809 p_port = &rfc_cb.port.port[0];
810 for (i = 0; i < MAX_RFC_PORTS; i++, p_port++)
811 {
812 if (p_port->rfc.p_mcb == p_mcb)
813 {
814 port_rfc_closed (p_port, PORT_PEER_TIMEOUT);
815 }
816 }
817 }
818
819
820 /*******************************************************************************
821 **
822 ** Function PORT_DataInd
823 **
824 ** Description This function is called from the RFCOMM layer when data
825 ** buffer is received from the peer.
826 **
827 *******************************************************************************/
PORT_DataInd(tRFC_MCB * p_mcb,UINT8 dlci,BT_HDR * p_buf)828 void PORT_DataInd (tRFC_MCB *p_mcb, UINT8 dlci, BT_HDR *p_buf)
829 {
830 tPORT *p_port = port_find_mcb_dlci_port (p_mcb, dlci);
831 UINT8 rx_char1;
832 UINT32 events = 0;
833 UINT8 *p;
834 int i;
835
836 RFCOMM_TRACE_EVENT("PORT_DataInd with data length %d, p_mcb:%p,p_port:%p,dlci:%d",
837 p_buf->len, p_mcb, p_port, dlci);
838 if (!p_port)
839 {
840 GKI_freebuf (p_buf);
841 return;
842 }
843 /* If client registered callout callback with flow control we can just deliver receive data */
844 if (p_port->p_data_co_callback)
845 {
846 /* Another packet is delivered to user. Send credits to peer if required */
847
848 if(p_port->p_data_co_callback(p_port->inx, (UINT8*)p_buf, -1, DATA_CO_CALLBACK_TYPE_INCOMING))
849 port_flow_control_peer(p_port, TRUE, 1);
850 else port_flow_control_peer(p_port, FALSE, 0);
851 //GKI_freebuf (p_buf);
852 return;
853 }
854 else RFCOMM_TRACE_ERROR("PORT_DataInd, p_port:%p, p_data_co_callback is null", p_port);
855 /* If client registered callback we can just deliver receive data */
856 if (p_port->p_data_callback)
857 {
858 /* Another packet is delivered to user. Send credits to peer if required */
859 port_flow_control_peer(p_port, TRUE, 1);
860
861 p_port->p_data_callback (p_port->inx, (UINT8 *)(p_buf + 1) + p_buf->offset, p_buf->len);
862 GKI_freebuf (p_buf);
863 return;
864 }
865
866 /* Check if rx queue exceeds the limit */
867 if ((p_port->rx.queue_size + p_buf->len > PORT_RX_CRITICAL_WM)
868 || (GKI_queue_length(&p_port->rx.queue) + 1 > p_port->rx_buf_critical))
869 {
870 RFCOMM_TRACE_EVENT ("PORT_DataInd. Buffer over run. Dropping the buffer");
871 GKI_freebuf (p_buf);
872
873 RFCOMM_LineStatusReq (p_mcb, dlci, LINE_STATUS_OVERRUN);
874 return;
875 }
876
877 /* If user registered to receive notification when a particular byte is */
878 /* received we mast check all received bytes */
879 if (((rx_char1 = p_port->user_port_pars.rx_char1) != 0)
880 && (p_port->ev_mask & PORT_EV_RXFLAG))
881 {
882 for (i = 0, p = (UINT8 *)(p_buf + 1) + p_buf->offset; i < p_buf->len; i++)
883 {
884 if (*p++ == rx_char1)
885 {
886 events |= PORT_EV_RXFLAG;
887 break;
888 }
889 }
890 }
891
892 PORT_SCHEDULE_LOCK;
893
894 GKI_enqueue (&p_port->rx.queue, p_buf);
895 p_port->rx.queue_size += p_buf->len;
896
897 PORT_SCHEDULE_UNLOCK;
898
899 /* perform flow control procedures if necessary */
900 port_flow_control_peer(p_port, FALSE, 0);
901
902 /* If user indicated flow control can not deliver any notifications to him */
903 if (p_port->rx.user_fc)
904 {
905 if (events & PORT_EV_RXFLAG)
906 p_port->rx_flag_ev_pending = TRUE;
907
908 return;
909 }
910
911 events |= PORT_EV_RXCHAR;
912
913 /* Mask out all events that are not of interest to user */
914 events &= p_port->ev_mask;
915
916 if (p_port->p_callback && events)
917 p_port->p_callback (events, p_port->inx);
918 }
919
920
921 /*******************************************************************************
922 **
923 ** Function PORT_FlowInd
924 **
925 ** Description This function is called from the RFCOMM layer on the flow
926 ** control signal change. Propagate change to the user.
927 **
928 *******************************************************************************/
PORT_FlowInd(tRFC_MCB * p_mcb,UINT8 dlci,BOOLEAN enable_data)929 void PORT_FlowInd (tRFC_MCB *p_mcb, UINT8 dlci, BOOLEAN enable_data)
930 {
931 tPORT *p_port = (tPORT *)NULL;
932 UINT32 events = 0;
933 int i;
934
935 RFCOMM_TRACE_EVENT ("PORT_FlowInd fc:%d", enable_data);
936
937 if (dlci == 0)
938 {
939 p_mcb->peer_ready = enable_data;
940 }
941 else
942 {
943 if ((p_port = port_find_mcb_dlci_port (p_mcb, dlci)) == NULL)
944 return;
945
946 p_port->tx.peer_fc = !enable_data;
947 }
948
949 for (i = 0; i < MAX_RFC_PORTS; i++)
950 {
951 /* If DLCI is 0 event applies to all ports */
952 if (dlci == 0)
953 {
954 p_port = &rfc_cb.port.port[i];
955 if (!p_port->in_use
956 || (p_port->rfc.p_mcb != p_mcb)
957 || (p_port->rfc.state != RFC_STATE_OPENED))
958 continue;
959 }
960 events = 0;
961
962 /* Check if flow of data is still enabled */
963 events |= port_flow_control_user (p_port);
964
965 /* Check if data can be sent and send it */
966 events |= port_rfc_send_tx_data (p_port);
967
968 /* Mask out all events that are not of interest to user */
969 events &= p_port->ev_mask;
970
971 /* Send event to the application */
972 if (p_port->p_callback && events)
973 (p_port->p_callback)(events, p_port->inx);
974
975 /* If DLCI is not 0 event applies to one port only */
976 if (dlci != 0)
977 break;
978 }
979 }
980
981
982 /*******************************************************************************
983 **
984 ** Function port_rfc_send_tx_data
985 **
986 ** Description This function is when forward data can be sent to the peer
987 **
988 *******************************************************************************/
port_rfc_send_tx_data(tPORT * p_port)989 UINT32 port_rfc_send_tx_data (tPORT *p_port)
990 {
991 UINT32 events = 0;
992 BT_HDR *p_buf;
993
994 /* if there is data to be sent */
995 if (p_port->tx.queue_size > 0)
996 {
997 /* while the rfcomm peer is not flow controlling us, and peer is ready */
998 while (!p_port->tx.peer_fc && p_port->rfc.p_mcb && p_port->rfc.p_mcb->peer_ready)
999 {
1000 /* get data from tx queue and send it */
1001 PORT_SCHEDULE_LOCK;
1002
1003 if ((p_buf = (BT_HDR *)GKI_dequeue (&p_port->tx.queue)) != NULL)
1004 {
1005 p_port->tx.queue_size -= p_buf->len;
1006
1007 PORT_SCHEDULE_UNLOCK;
1008
1009 RFCOMM_TRACE_DEBUG ("Sending RFCOMM_DataReq tx.queue_size=%d", p_port->tx.queue_size);
1010
1011 RFCOMM_DataReq (p_port->rfc.p_mcb, p_port->dlci, p_buf);
1012
1013 events |= PORT_EV_TXCHAR;
1014
1015 if (p_port->tx.queue_size == 0)
1016 {
1017 events |= PORT_EV_TXEMPTY;
1018 break;
1019 }
1020 }
1021 /* queue is empty-- all data sent */
1022 else
1023 {
1024 PORT_SCHEDULE_UNLOCK;
1025
1026 events |= PORT_EV_TXEMPTY;
1027 break;
1028 }
1029 }
1030 /* If we flow controlled user based on the queue size enable data again */
1031 events |= port_flow_control_user (p_port);
1032 }
1033 return (events & p_port->ev_mask);
1034 }
1035
1036
1037 /*******************************************************************************
1038 **
1039 ** Function port_rfc_closed
1040 **
1041 ** Description This function when RFCOMM side of port is closed
1042 **
1043 *******************************************************************************/
port_rfc_closed(tPORT * p_port,UINT8 res)1044 void port_rfc_closed (tPORT *p_port, UINT8 res)
1045 {
1046 UINT8 old_signals;
1047 UINT32 events = 0;
1048 tRFC_MCB *p_mcb = p_port->rfc.p_mcb;
1049
1050 if ((p_port->state == PORT_STATE_OPENING) && (p_port->is_server))
1051 {
1052 /* The servr side has not been informed that connection is up, ignore */
1053 RFCOMM_TRACE_EVENT ("port_rfc_closed in OPENING state ignored");
1054
1055 rfc_port_timer_stop (p_port);
1056 p_port->rfc.state = RFC_STATE_CLOSED;
1057
1058 if (p_mcb)
1059 {
1060 p_mcb->port_inx[p_port->dlci] = 0;
1061
1062 /* If there are no more ports opened on this MCB release it */
1063 rfc_check_mcb_active (p_mcb);
1064 p_port->rfc.p_mcb = NULL;
1065 }
1066
1067 /* Need to restore DLCI to listening state
1068 * if the server was on the initiating RFC
1069 */
1070 p_port->dlci &= 0xfe;
1071
1072 return;
1073 }
1074
1075 if ((p_port->state != PORT_STATE_CLOSING) && (p_port->state != PORT_STATE_CLOSED))
1076 {
1077 p_port->line_status |= LINE_STATUS_FAILED;
1078
1079 old_signals = p_port->peer_ctrl.modem_signal;
1080
1081 p_port->peer_ctrl.modem_signal &= ~(PORT_DTRDSR_ON | PORT_CTSRTS_ON | PORT_DCD_ON);
1082
1083 events |= port_get_signal_changes (p_port, old_signals, p_port->peer_ctrl.modem_signal);
1084
1085 if(p_port->ev_mask & PORT_EV_CONNECT_ERR)
1086 events |= PORT_EV_CONNECT_ERR;
1087 }
1088 RFCOMM_TRACE_EVENT ("port_rfc_closed state:%d sending events:%x", p_port->state, events);
1089
1090 if ((p_port->p_callback != NULL) && events)
1091 p_port->p_callback (events, p_port->inx);
1092
1093 if (p_port->p_mgmt_callback)
1094 p_port->p_mgmt_callback (res, p_port->inx);
1095
1096 p_port->rfc.state = RFC_STATE_CLOSED;
1097
1098 RFCOMM_TRACE_WARNING ("%s RFCOMM connection in state %d closed: %s (res: %d)",
1099 __func__, p_port->state, PORT_GetResultString(res), res);
1100
1101 port_release_port (p_port);
1102 }
1103
1104
1105 /*******************************************************************************
1106 **
1107 ** Function port_get_credits
1108 **
1109 ** Description Set initial values for credits.
1110 ** Adjust max number of rx credits based on negotiated MTU.
1111 ** Check max allowed num of bytes, max allowed num buffers,
1112 ** should be less then 255
1113 **
1114 *******************************************************************************/
port_get_credits(tPORT * p_port,UINT8 k)1115 void port_get_credits (tPORT *p_port, UINT8 k)
1116 {
1117 p_port->credit_tx = k;
1118 if (p_port->credit_tx == 0)
1119 p_port->tx.peer_fc = TRUE;
1120 }
1121