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 file contains the Serial Port API code
22 *
23 ******************************************************************************/
24
25 #include <string.h>
26 #include "bt_target.h"
27 #include "gki.h"
28 #include "rfcdefs.h"
29 #include "port_api.h"
30 #include "port_int.h"
31 #include "btm_int.h"
32 #include "btm_api.h"
33 #include "rfc_int.h"
34 #include "l2c_api.h"
35 #include "sdp_api.h"
36
37 /* duration of break in 200ms units */
38 #define PORT_BREAK_DURATION 1
39
40 #include <cutils/log.h>
41 #define info(fmt, ...) ALOGI ("%s: " fmt,__FUNCTION__, ## __VA_ARGS__)
42 #define debug(fmt, ...) ALOGD ("%s: " fmt,__FUNCTION__, ## __VA_ARGS__)
43 #define error(fmt, ...) ALOGE ("## ERROR : %s: " fmt "##",__FUNCTION__, ## __VA_ARGS__)
44 #define asrt(s) if(!(s)) ALOGE ("## %s assert %s failed at line:%d ##",__FUNCTION__, #s, __LINE__)
45
46 /*******************************************************************************
47 **
48 ** Function RFCOMM_CreateConnection
49 **
50 ** Description RFCOMM_CreateConnection function is used from the application
51 ** to establish serial port connection to the peer device,
52 ** or allow RFCOMM to accept a connection from the peer
53 ** application.
54 **
55 ** Parameters: scn - Service Channel Number as registered with
56 ** the SDP (server) or obtained using SDP from
57 ** the peer device (client).
58 ** is_server - TRUE if requesting application is a server
59 ** mtu - Maximum frame size the application can accept
60 ** bd_addr - BD_ADDR of the peer (client)
61 ** mask - specifies events to be enabled. A value
62 ** of zero disables all events.
63 ** p_handle - OUT pointer to the handle.
64 ** p_mgmt_cb - pointer to callback function to receive
65 ** connection up/down events.
66 ** Notes:
67 **
68 ** Server can call this function with the same scn parameter multiple times if
69 ** it is ready to accept multiple simulteneous connections.
70 **
71 ** DLCI for the connection is (scn * 2 + 1) if client originates connection on
72 ** existing none initiator multiplexer channel. Otherwise it is (scn * 2).
73 ** For the server DLCI can be changed later if client will be calling it using
74 ** (scn * 2 + 1) dlci.
75 **
76 *******************************************************************************/
RFCOMM_CreateConnection(UINT16 uuid,UINT8 scn,BOOLEAN is_server,UINT16 mtu,BD_ADDR bd_addr,UINT16 * p_handle,tPORT_CALLBACK * p_mgmt_cb)77 int RFCOMM_CreateConnection (UINT16 uuid, UINT8 scn, BOOLEAN is_server,
78 UINT16 mtu, BD_ADDR bd_addr, UINT16 *p_handle,
79 tPORT_CALLBACK *p_mgmt_cb)
80 {
81 tPORT *p_port;
82 int i;
83 UINT8 dlci;
84 tRFC_MCB *p_mcb = port_find_mcb (bd_addr);
85 UINT16 rfcomm_mtu;
86
87 RFCOMM_TRACE_API ("RFCOMM_CreateConnection() BDA: %02x-%02x-%02x-%02x-%02x-%02x",
88 bd_addr[0], bd_addr[1], bd_addr[2], bd_addr[3], bd_addr[4], bd_addr[5]);
89
90 *p_handle = 0;
91
92 if (( scn == 0 )||(scn >= PORT_MAX_RFC_PORTS ))
93 {
94 /* Server Channel Number(SCN) should be in range 1...30 */
95 RFCOMM_TRACE_ERROR ("RFCOMM_CreateConnection - invalid SCN");
96 return (PORT_INVALID_SCN);
97 }
98
99 /* For client that originate connection on the existing none initiator */
100 /* multiplexer channel DLCI should be odd */
101 if (p_mcb && !p_mcb->is_initiator && !is_server)
102 dlci = (scn << 1) + 1;
103 else
104 dlci = (scn << 1);
105 RFCOMM_TRACE_API("RFCOMM_CreateConnection(): scn:%d, dlci:%d, is_server:%d mtu:%d, p_mcb:%p",
106 scn, dlci, is_server, mtu, p_mcb);
107
108 /* For the server side always allocate a new port. On the client side */
109 /* do not allow the same (dlci, bd_addr) to be opened twice by application */
110 if (!is_server && ((p_port = port_find_port (dlci, bd_addr)) != NULL))
111 {
112 /* if existing port is also a client port */
113 if (p_port->is_server == FALSE)
114 {
115 RFCOMM_TRACE_ERROR ("RFCOMM_CreateConnection - already opened state:%d, RFC state:%d, MCB state:%d",
116 p_port->state, p_port->rfc.state, p_port->rfc.p_mcb ? p_port->rfc.p_mcb->state : 0);
117 return (PORT_ALREADY_OPENED);
118 }
119 }
120
121 if ((p_port = port_allocate_port (dlci, bd_addr)) == NULL)
122 {
123 RFCOMM_TRACE_WARNING ("RFCOMM_CreateConnection - no resources");
124 return (PORT_NO_RESOURCES);
125 }
126 RFCOMM_TRACE_API("RFCOMM_CreateConnection(): scn:%d, dlci:%d, is_server:%d mtu:%d, p_mcb:%p, p_port:%p",
127 scn, dlci, is_server, mtu, p_mcb, p_port);
128
129 p_port->default_signal_state = (PORT_DTRDSR_ON | PORT_CTSRTS_ON | PORT_DCD_ON);
130
131 switch (uuid)
132 {
133 case UUID_PROTOCOL_OBEX:
134 p_port->default_signal_state = PORT_OBEX_DEFAULT_SIGNAL_STATE;
135 break;
136 case UUID_SERVCLASS_SERIAL_PORT:
137 p_port->default_signal_state = PORT_SPP_DEFAULT_SIGNAL_STATE;
138 break;
139 case UUID_SERVCLASS_LAN_ACCESS_USING_PPP:
140 p_port->default_signal_state = PORT_PPP_DEFAULT_SIGNAL_STATE;
141 break;
142 case UUID_SERVCLASS_DIALUP_NETWORKING:
143 case UUID_SERVCLASS_FAX:
144 p_port->default_signal_state = PORT_DUN_DEFAULT_SIGNAL_STATE;
145 break;
146 }
147
148 RFCOMM_TRACE_EVENT ("RFCOMM_CreateConnection dlci:%d signal state:0x%x", dlci, p_port->default_signal_state);
149
150 *p_handle = p_port->inx;
151
152 p_port->state = PORT_STATE_OPENING;
153 p_port->uuid = uuid;
154 p_port->is_server = is_server;
155 p_port->scn = scn;
156 p_port->ev_mask = 0;
157
158 /* If the MTU is not specified (0), keep MTU decision until the
159 * PN frame has to be send
160 * at that time connection should be established and we
161 * will know for sure our prefered MTU
162 */
163
164 rfcomm_mtu = L2CAP_MTU_SIZE - RFCOMM_DATA_OVERHEAD;
165
166 if (mtu)
167 p_port->mtu = (mtu < rfcomm_mtu) ? mtu : rfcomm_mtu;
168 else
169 p_port->mtu = rfcomm_mtu;
170
171 /* server doesn't need to release port when closing */
172 if( is_server )
173 {
174 p_port->keep_port_handle = TRUE;
175
176 /* keep mtu that user asked, p_port->mtu could be updated during param negotiation */
177 p_port->keep_mtu = p_port->mtu;
178 }
179
180 p_port->local_ctrl.modem_signal = p_port->default_signal_state;
181 p_port->local_ctrl.fc = FALSE;
182
183 p_port->p_mgmt_callback = p_mgmt_cb;
184
185 for (i = 0; i < BD_ADDR_LEN; i++)
186 p_port->bd_addr[i] = bd_addr[i];
187
188 /* If this is not initiator of the connection need to just wait */
189 if (p_port->is_server)
190 {
191 return (PORT_SUCCESS);
192 }
193
194 /* Open will be continued after security checks are passed */
195 return port_open_continue (p_port);
196 }
197
198
199 /*******************************************************************************
200 **
201 ** Function RFCOMM_RemoveConnection
202 **
203 ** Description This function is called to close the specified connection.
204 **
205 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
206 **
207 *******************************************************************************/
RFCOMM_RemoveConnection(UINT16 handle)208 int RFCOMM_RemoveConnection (UINT16 handle)
209 {
210 tPORT *p_port;
211
212 RFCOMM_TRACE_API ("RFCOMM_RemoveConnection() handle:%d", handle);
213
214 /* Check if handle is valid to avoid crashing */
215 if ((handle == 0) || (handle > MAX_RFC_PORTS))
216 {
217 RFCOMM_TRACE_ERROR ("RFCOMM_RemoveConnection() BAD handle:%d", handle);
218 return (PORT_BAD_HANDLE);
219 }
220 p_port = &rfc_cb.port.port[handle - 1];
221
222 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
223 {
224 RFCOMM_TRACE_EVENT ("RFCOMM_RemoveConnection() Not opened:%d", handle);
225 return (PORT_SUCCESS);
226 }
227
228 p_port->state = PORT_STATE_CLOSING;
229
230 port_start_close (p_port);
231
232 return (PORT_SUCCESS);
233 }
234
235 /*******************************************************************************
236 **
237 ** Function RFCOMM_RemoveServer
238 **
239 ** Description This function is called to close the server port.
240 **
241 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
242 **
243 *******************************************************************************/
RFCOMM_RemoveServer(UINT16 handle)244 int RFCOMM_RemoveServer (UINT16 handle)
245 {
246 tPORT *p_port;
247
248 RFCOMM_TRACE_API ("RFCOMM_RemoveServer() handle:%d", handle);
249
250 /* Check if handle is valid to avoid crashing */
251 if ((handle == 0) || (handle > MAX_RFC_PORTS))
252 {
253 RFCOMM_TRACE_ERROR ("RFCOMM_RemoveServer() BAD handle:%d", handle);
254 return (PORT_BAD_HANDLE);
255 }
256 p_port = &rfc_cb.port.port[handle - 1];
257
258 /* Do not report any events to the client any more. */
259 p_port->p_mgmt_callback = NULL;
260
261 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
262 {
263 RFCOMM_TRACE_EVENT ("RFCOMM_RemoveServer() Not opened:%d", handle);
264 return (PORT_SUCCESS);
265 }
266
267 /* this port will be deallocated after closing */
268 p_port->keep_port_handle = FALSE;
269 p_port->state = PORT_STATE_CLOSING;
270
271 port_start_close (p_port);
272
273 return (PORT_SUCCESS);
274 }
275
276 /*******************************************************************************
277 **
278 ** Function PORT_SetEventCallback
279 **
280 ** Description This function is called to provide an address of the
281 ** function which will be called when one of the events
282 ** specified in the mask occures.
283 **
284 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
285 ** p_callback - address of the callback function which should
286 ** be called from the RFCOMM when an event
287 ** specified in the mask occures.
288 **
289 **
290 *******************************************************************************/
PORT_SetEventCallback(UINT16 port_handle,tPORT_CALLBACK * p_port_cb)291 int PORT_SetEventCallback (UINT16 port_handle, tPORT_CALLBACK *p_port_cb)
292 {
293 tPORT *p_port;
294
295 /* Check if handle is valid to avoid crashing */
296 if ((port_handle == 0) || (port_handle > MAX_RFC_PORTS))
297 {
298 return (PORT_BAD_HANDLE);
299 }
300
301 p_port = &rfc_cb.port.port[port_handle - 1];
302
303 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
304 {
305 return (PORT_NOT_OPENED);
306 }
307
308 RFCOMM_TRACE_API ("PORT_SetEventCallback() handle:%d", port_handle);
309
310 p_port->p_callback = p_port_cb;
311
312 return (PORT_SUCCESS);
313 }
314 /*******************************************************************************
315 **
316 ** Function PORT_ClearKeepHandleFlag
317 **
318 ** Description This function is called to clear the keep handle flag
319 ** which will cause not to keep the port handle open when closed
320 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
321 **
322 *******************************************************************************/
323
PORT_ClearKeepHandleFlag(UINT16 port_handle)324 int PORT_ClearKeepHandleFlag (UINT16 port_handle)
325 {
326 tPORT *p_port;
327
328 /* Check if handle is valid to avoid crashing */
329 if ((port_handle == 0) || (port_handle > MAX_RFC_PORTS))
330 {
331 return (PORT_BAD_HANDLE);
332 }
333
334 p_port = &rfc_cb.port.port[port_handle - 1];
335 p_port->keep_port_handle = 0;
336 return (PORT_SUCCESS);
337 }
338
339 /*******************************************************************************
340 **
341 ** Function PORT_SetDataCallback
342 **
343 ** Description This function is when a data packet is received
344 **
345 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
346 ** p_callback - address of the callback function which should
347 ** be called from the RFCOMM when data packet
348 ** is received.
349 **
350 **
351 *******************************************************************************/
PORT_SetDataCallback(UINT16 port_handle,tPORT_DATA_CALLBACK * p_port_cb)352 int PORT_SetDataCallback (UINT16 port_handle, tPORT_DATA_CALLBACK *p_port_cb)
353 {
354 tPORT *p_port;
355
356 RFCOMM_TRACE_API ("PORT_SetDataCallback() handle:%d cb 0x%x", port_handle, p_port_cb);
357
358 /* Check if handle is valid to avoid crashing */
359 if ((port_handle == 0) || (port_handle > MAX_RFC_PORTS))
360 {
361 return (PORT_BAD_HANDLE);
362 }
363
364 p_port = &rfc_cb.port.port[port_handle - 1];
365
366 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
367 {
368 return (PORT_NOT_OPENED);
369 }
370
371 p_port->p_data_callback = p_port_cb;
372
373 return (PORT_SUCCESS);
374 }
375 /*******************************************************************************
376 **
377 ** Function PORT_SetCODataCallback
378 **
379 ** Description This function is when a data packet is received
380 **
381 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
382 ** p_callback - address of the callback function which should
383 ** be called from the RFCOMM when data packet
384 ** is received.
385 **
386 **
387 *******************************************************************************/
PORT_SetDataCOCallback(UINT16 port_handle,tPORT_DATA_CO_CALLBACK * p_port_cb)388 int PORT_SetDataCOCallback (UINT16 port_handle, tPORT_DATA_CO_CALLBACK *p_port_cb)
389 {
390 tPORT *p_port;
391
392 RFCOMM_TRACE_API ("PORT_SetDataCOCallback() handle:%d cb 0x%x", port_handle, p_port_cb);
393
394 /* Check if handle is valid to avoid crashing */
395 if ((port_handle == 0) || (port_handle > MAX_RFC_PORTS))
396 {
397 return (PORT_BAD_HANDLE);
398 }
399
400 p_port = &rfc_cb.port.port[port_handle - 1];
401
402 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
403 {
404 return (PORT_NOT_OPENED);
405 }
406
407 p_port->p_data_co_callback = p_port_cb;
408
409 return (PORT_SUCCESS);
410 }
411
412
413
414 /*******************************************************************************
415 **
416 ** Function PORT_SetEventMask
417 **
418 ** Description This function is called to close the specified connection.
419 **
420 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
421 ** mask - Bitmask of the events the host is interested in
422 **
423 *******************************************************************************/
PORT_SetEventMask(UINT16 port_handle,UINT32 mask)424 int PORT_SetEventMask (UINT16 port_handle, UINT32 mask)
425 {
426 tPORT *p_port;
427
428 RFCOMM_TRACE_API ("PORT_SetEventMask() handle:%d mask:0x%x", port_handle, mask);
429
430 /* Check if handle is valid to avoid crashing */
431 if ((port_handle == 0) || (port_handle > MAX_RFC_PORTS))
432 {
433 return (PORT_BAD_HANDLE);
434 }
435
436 p_port = &rfc_cb.port.port[port_handle - 1];
437
438 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
439 {
440 return (PORT_NOT_OPENED);
441 }
442
443 p_port->ev_mask = mask;
444
445 return (PORT_SUCCESS);
446 }
447
448
449 /*******************************************************************************
450 **
451 ** Function PORT_CheckConnection
452 **
453 ** Description This function returns PORT_SUCCESS if connection referenced
454 ** by handle is up and running
455 **
456 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
457 ** bd_addr - OUT bd_addr of the peer
458 ** p_lcid - OUT L2CAP's LCID
459 **
460 *******************************************************************************/
PORT_CheckConnection(UINT16 handle,BD_ADDR bd_addr,UINT16 * p_lcid)461 int PORT_CheckConnection (UINT16 handle, BD_ADDR bd_addr, UINT16 *p_lcid)
462 {
463 tPORT *p_port;
464
465 RFCOMM_TRACE_API ("PORT_CheckConnection() handle:%d", handle);
466
467 /* Check if handle is valid to avoid crashing */
468 if ((handle == 0) || (handle > MAX_RFC_PORTS))
469 {
470 return (PORT_BAD_HANDLE);
471 }
472
473 p_port = &rfc_cb.port.port[handle - 1];
474
475 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
476 {
477 return (PORT_NOT_OPENED);
478 }
479
480 if (!p_port->rfc.p_mcb
481 || !p_port->rfc.p_mcb->peer_ready
482 || (p_port->rfc.state != RFC_STATE_OPENED))
483 {
484 return (PORT_LINE_ERR);
485 }
486
487 memcpy (bd_addr, p_port->rfc.p_mcb->bd_addr, BD_ADDR_LEN);
488 if (p_lcid)
489 *p_lcid = p_port->rfc.p_mcb->lcid;
490
491 return (PORT_SUCCESS);
492 }
493
494 /*******************************************************************************
495 **
496 ** Function PORT_IsOpening
497 **
498 ** Description This function returns TRUE if there is any RFCOMM connection
499 ** opening in process.
500 **
501 ** Parameters: TRUE if any connection opening is found
502 ** bd_addr - bd_addr of the peer
503 **
504 *******************************************************************************/
PORT_IsOpening(BD_ADDR bd_addr)505 BOOLEAN PORT_IsOpening (BD_ADDR bd_addr)
506 {
507 UINT8 xx, yy;
508 tRFC_MCB *p_mcb = NULL;
509 tPORT *p_port;
510 BOOLEAN found_port;
511
512 /* Check for any rfc_mcb which is in the middle of opening. */
513 for (xx = 0; xx < MAX_BD_CONNECTIONS; xx++)
514 {
515 if ((rfc_cb.port.rfc_mcb[xx].state > RFC_MX_STATE_IDLE) &&
516 (rfc_cb.port.rfc_mcb[xx].state < RFC_MX_STATE_CONNECTED))
517 {
518 memcpy (bd_addr, rfc_cb.port.rfc_mcb[xx].bd_addr, BD_ADDR_LEN);
519 return TRUE;
520 }
521
522 if (rfc_cb.port.rfc_mcb[xx].state == RFC_MX_STATE_CONNECTED)
523 {
524 found_port = FALSE;
525 p_mcb = &rfc_cb.port.rfc_mcb[xx];
526 p_port = &rfc_cb.port.port[0];
527
528 for (yy = 0; yy < MAX_RFC_PORTS; yy++, p_port++)
529 {
530 if (p_port->rfc.p_mcb == p_mcb)
531 {
532 found_port = TRUE;
533 break;
534 }
535 }
536
537 if ((!found_port) ||
538 (found_port && (p_port->rfc.state < RFC_STATE_OPENED)))
539 {
540 /* Port is not established yet. */
541 memcpy (bd_addr, rfc_cb.port.rfc_mcb[xx].bd_addr, BD_ADDR_LEN);
542 return TRUE;
543 }
544 }
545 }
546
547 return FALSE;
548 }
549
550 /*******************************************************************************
551 **
552 ** Function PORT_SetState
553 **
554 ** Description This function configures connection according to the
555 ** specifications in the tPORT_STATE structure.
556 **
557 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
558 ** p_settings - Pointer to a tPORT_STATE structure containing
559 ** configuration information for the connection.
560 **
561 **
562 *******************************************************************************/
PORT_SetState(UINT16 handle,tPORT_STATE * p_settings)563 int PORT_SetState (UINT16 handle, tPORT_STATE *p_settings)
564 {
565 tPORT *p_port;
566 UINT8 baud_rate;
567
568 RFCOMM_TRACE_API ("PORT_SetState() handle:%d", handle);
569
570 /* Check if handle is valid to avoid crashing */
571 if ((handle == 0) || (handle > MAX_RFC_PORTS))
572 {
573 return (PORT_BAD_HANDLE);
574 }
575
576 p_port = &rfc_cb.port.port[handle - 1];
577
578 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
579 {
580 return (PORT_NOT_OPENED);
581 }
582
583 if (p_port->line_status)
584 {
585 return (PORT_LINE_ERR);
586 }
587
588 RFCOMM_TRACE_API ("PORT_SetState() handle:%d FC_TYPE:0x%x", handle,
589 p_settings->fc_type);
590
591 baud_rate = p_port->user_port_pars.baud_rate;
592 p_port->user_port_pars = *p_settings;
593
594 /* for now we've been asked to pass only baud rate */
595 if (baud_rate != p_settings->baud_rate)
596 {
597 port_start_par_neg (p_port);
598 }
599 return (PORT_SUCCESS);
600 }
601
602 /*******************************************************************************
603 **
604 ** Function PORT_GetRxQueueCnt
605 **
606 ** Description This function return number of buffers on the rx queue.
607 **
608 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
609 ** p_rx_queue_count - Pointer to return queue count in.
610 **
611 *******************************************************************************/
PORT_GetRxQueueCnt(UINT16 handle,UINT16 * p_rx_queue_count)612 int PORT_GetRxQueueCnt (UINT16 handle, UINT16 *p_rx_queue_count)
613 {
614 tPORT *p_port;
615
616 RFCOMM_TRACE_API ("PORT_GetRxQueueCnt() handle:%d", handle);
617
618 /* Check if handle is valid to avoid crashing */
619 if ((handle == 0) || (handle > MAX_RFC_PORTS))
620 {
621 return (PORT_BAD_HANDLE);
622 }
623
624 p_port = &rfc_cb.port.port[handle - 1];
625
626 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
627 {
628 return (PORT_NOT_OPENED);
629 }
630
631 if (p_port->line_status)
632 {
633 return (PORT_LINE_ERR);
634 }
635
636 *p_rx_queue_count = p_port->rx.queue_size;
637
638 RFCOMM_TRACE_API ("PORT_GetRxQueueCnt() p_rx_queue_count:%d, p_port->rx.queue.count = %d",
639 *p_rx_queue_count, p_port->rx.queue_size);
640
641 return (PORT_SUCCESS);
642 }
643
644 /*******************************************************************************
645 **
646 ** Function PORT_GetState
647 **
648 ** Description This function is called to fill tPORT_STATE structure
649 ** with the curremt control settings for the port
650 **
651 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
652 ** p_settings - Pointer to a tPORT_STATE structure in which
653 ** configuration information is returned.
654 **
655 *******************************************************************************/
PORT_GetState(UINT16 handle,tPORT_STATE * p_settings)656 int PORT_GetState (UINT16 handle, tPORT_STATE *p_settings)
657 {
658 tPORT *p_port;
659
660 RFCOMM_TRACE_API ("PORT_GetState() handle:%d", handle);
661
662 /* Check if handle is valid to avoid crashing */
663 if ((handle == 0) || (handle > MAX_RFC_PORTS))
664 {
665 return (PORT_BAD_HANDLE);
666 }
667
668 p_port = &rfc_cb.port.port[handle - 1];
669
670 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
671 {
672 return (PORT_NOT_OPENED);
673 }
674
675 if (p_port->line_status)
676 {
677 return (PORT_LINE_ERR);
678 }
679
680 *p_settings = p_port->user_port_pars;
681 return (PORT_SUCCESS);
682 }
683
684
685 /*******************************************************************************
686 **
687 ** Function PORT_Control
688 **
689 ** Description This function directs a specified connection to pass control
690 ** control information to the peer device.
691 **
692 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
693 ** signal = specify the function to be passed
694 **
695 *******************************************************************************/
PORT_Control(UINT16 handle,UINT8 signal)696 int PORT_Control (UINT16 handle, UINT8 signal)
697 {
698 tPORT *p_port;
699 UINT8 old_modem_signal;
700
701 RFCOMM_TRACE_API ("PORT_Control() handle:%d signal:0x%x", handle, signal);
702
703 /* Check if handle is valid to avoid crashing */
704 if ((handle == 0) || (handle > MAX_RFC_PORTS))
705 {
706 return (PORT_BAD_HANDLE);
707 }
708
709 p_port = &rfc_cb.port.port[handle - 1];
710
711 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
712 {
713 return (PORT_NOT_OPENED);
714 }
715
716 old_modem_signal = p_port->local_ctrl.modem_signal;
717 p_port->local_ctrl.break_signal = 0;
718
719 switch (signal)
720 {
721 case PORT_SET_CTSRTS:
722 p_port->local_ctrl.modem_signal |= PORT_CTSRTS_ON;
723 break;
724
725 case PORT_CLR_CTSRTS:
726 p_port->local_ctrl.modem_signal &= ~PORT_CTSRTS_ON;
727 break;
728
729 case PORT_SET_DTRDSR:
730 p_port->local_ctrl.modem_signal |= PORT_DTRDSR_ON;
731 break;
732
733 case PORT_CLR_DTRDSR:
734 p_port->local_ctrl.modem_signal &= ~PORT_DTRDSR_ON;
735 break;
736
737 case PORT_SET_RI:
738 p_port->local_ctrl.modem_signal |= PORT_RING_ON;
739 break;
740
741 case PORT_CLR_RI:
742 p_port->local_ctrl.modem_signal &= ~PORT_RING_ON;
743 break;
744
745 case PORT_SET_DCD:
746 p_port->local_ctrl.modem_signal |= PORT_DCD_ON;
747 break;
748
749 case PORT_CLR_DCD:
750 p_port->local_ctrl.modem_signal &= ~PORT_DCD_ON;
751 break;
752 }
753
754 if (signal == PORT_BREAK)
755 p_port->local_ctrl.break_signal = PORT_BREAK_DURATION;
756 else if (p_port->local_ctrl.modem_signal == old_modem_signal)
757 return (PORT_SUCCESS);
758
759 port_start_control (p_port);
760
761 RFCOMM_TRACE_EVENT ("PORT_Control DTR_DSR : %d, RTS_CTS : %d, RI : %d, DCD : %d",
762 ((p_port->local_ctrl.modem_signal & MODEM_SIGNAL_DTRDSR) ? 1 : 0),
763 ((p_port->local_ctrl.modem_signal & MODEM_SIGNAL_RTSCTS) ? 1 : 0),
764 ((p_port->local_ctrl.modem_signal & MODEM_SIGNAL_RI) ? 1 : 0),
765 ((p_port->local_ctrl.modem_signal & MODEM_SIGNAL_DCD) ? 1 : 0));
766
767 return (PORT_SUCCESS);
768 }
769
770
771 /*******************************************************************************
772 **
773 ** Function PORT_FlowControl
774 **
775 ** Description This function directs a specified connection to pass
776 ** flow control message to the peer device. Enable flag passed
777 ** shows if port can accept more data.
778 **
779 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
780 ** enable - enables data flow
781 **
782 *******************************************************************************/
PORT_FlowControl(UINT16 handle,BOOLEAN enable)783 int PORT_FlowControl (UINT16 handle, BOOLEAN enable)
784 {
785 tPORT *p_port;
786 BOOLEAN old_fc;
787 UINT32 events;
788
789 RFCOMM_TRACE_API ("PORT_FlowControl() handle:%d enable: %d", handle, enable);
790
791 /* Check if handle is valid to avoid crashing */
792 if ((handle == 0) || (handle > MAX_RFC_PORTS))
793 {
794 return (PORT_BAD_HANDLE);
795 }
796
797 p_port = &rfc_cb.port.port[handle - 1];
798
799 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
800 {
801 return (PORT_NOT_OPENED);
802 }
803
804 if (!p_port->rfc.p_mcb)
805 {
806 return (PORT_NOT_OPENED);
807 }
808
809 p_port->rx.user_fc = !enable;
810
811 if (p_port->rfc.p_mcb->flow == PORT_FC_CREDIT)
812 {
813 if (!p_port->rx.user_fc)
814 {
815 port_flow_control_peer(p_port, TRUE, 0);
816 }
817 }
818 else
819 {
820 old_fc = p_port->local_ctrl.fc;
821
822 /* FC is set if user is set or peer is set */
823 p_port->local_ctrl.fc = (p_port->rx.user_fc | p_port->rx.peer_fc);
824
825 if (p_port->local_ctrl.fc != old_fc)
826 port_start_control (p_port);
827 }
828
829 /* Need to take care of the case when we could not deliver events */
830 /* to the application because we were flow controlled */
831 if (enable && (p_port->rx.queue_size != 0))
832 {
833 events = PORT_EV_RXCHAR;
834 if (p_port->rx_flag_ev_pending)
835 {
836 p_port->rx_flag_ev_pending = FALSE;
837 events |= PORT_EV_RXFLAG;
838 }
839
840 events &= p_port->ev_mask;
841 if (p_port->p_callback && events)
842 {
843 p_port->p_callback (events, p_port->inx);
844 }
845 }
846 return (PORT_SUCCESS);
847 }
848 /*******************************************************************************
849 **
850 ** Function PORT_FlowControl_MaxCredit
851 **
852 ** Description This function directs a specified connection to pass
853 ** flow control message to the peer device. Enable flag passed
854 ** shows if port can accept more data. It also sends max credit
855 ** when data flow enabled
856 **
857 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
858 ** enable - enables data flow
859 **
860 *******************************************************************************/
861
PORT_FlowControl_MaxCredit(UINT16 handle,BOOLEAN enable)862 int PORT_FlowControl_MaxCredit (UINT16 handle, BOOLEAN enable)
863 {
864 tPORT *p_port;
865 BOOLEAN old_fc;
866 UINT32 events;
867
868 RFCOMM_TRACE_API ("PORT_FlowControl() handle:%d enable: %d", handle, enable);
869
870 /* Check if handle is valid to avoid crashing */
871 if ((handle == 0) || (handle > MAX_RFC_PORTS))
872 {
873 return (PORT_BAD_HANDLE);
874 }
875
876 p_port = &rfc_cb.port.port[handle - 1];
877
878 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
879 {
880 return (PORT_NOT_OPENED);
881 }
882
883 if (!p_port->rfc.p_mcb)
884 {
885 return (PORT_NOT_OPENED);
886 }
887
888 p_port->rx.user_fc = !enable;
889
890 if (p_port->rfc.p_mcb->flow == PORT_FC_CREDIT)
891 {
892 if (!p_port->rx.user_fc)
893 {
894 port_flow_control_peer(p_port, TRUE, p_port->credit_rx);
895 }
896 }
897 else
898 {
899 old_fc = p_port->local_ctrl.fc;
900
901 /* FC is set if user is set or peer is set */
902 p_port->local_ctrl.fc = (p_port->rx.user_fc | p_port->rx.peer_fc);
903
904 if (p_port->local_ctrl.fc != old_fc)
905 port_start_control (p_port);
906 }
907
908 /* Need to take care of the case when we could not deliver events */
909 /* to the application because we were flow controlled */
910 if (enable && (p_port->rx.queue_size != 0))
911 {
912 events = PORT_EV_RXCHAR;
913 if (p_port->rx_flag_ev_pending)
914 {
915 p_port->rx_flag_ev_pending = FALSE;
916 events |= PORT_EV_RXFLAG;
917 }
918
919 events &= p_port->ev_mask;
920 if (p_port->p_callback && events)
921 {
922 p_port->p_callback (events, p_port->inx);
923 }
924 }
925 return (PORT_SUCCESS);
926 }
927
928
929 /*******************************************************************************
930 **
931 ** Function PORT_GetModemStatus
932 **
933 ** Description This function retrieves modem control signals. Normally
934 ** application will call this function after a callback
935 ** function is called with notification that one of signals
936 ** has been changed.
937 **
938 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
939 ** p_signal - specify the pointer to control signals info
940 **
941 *******************************************************************************/
PORT_GetModemStatus(UINT16 handle,UINT8 * p_signal)942 int PORT_GetModemStatus (UINT16 handle, UINT8 *p_signal)
943 {
944 tPORT *p_port;
945
946 if ((handle == 0) || (handle > MAX_RFC_PORTS))
947 {
948 return (PORT_BAD_HANDLE);
949 }
950
951 p_port = &rfc_cb.port.port[handle - 1];
952
953 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
954 {
955 return (PORT_NOT_OPENED);
956 }
957
958 *p_signal = p_port->peer_ctrl.modem_signal;
959
960 RFCOMM_TRACE_API ("PORT_GetModemStatus() handle:%d signal:%x", handle, *p_signal);
961
962 return (PORT_SUCCESS);
963 }
964
965
966 /*******************************************************************************
967 **
968 ** Function PORT_ClearError
969 **
970 ** Description This function retreives information about a communications
971 ** error and reports current status of a connection. The
972 ** function should be called when an error occures to clear
973 ** the connection error flag and to enable additional read
974 ** and write operations.
975 **
976 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
977 ** p_errors - pointer of the variable to receive error codes
978 ** p_status - pointer to the tPORT_STATUS structur to receive
979 ** connection status
980 **
981 *******************************************************************************/
PORT_ClearError(UINT16 handle,UINT16 * p_errors,tPORT_STATUS * p_status)982 int PORT_ClearError (UINT16 handle, UINT16 *p_errors, tPORT_STATUS *p_status)
983 {
984 tPORT *p_port;
985
986 RFCOMM_TRACE_API ("PORT_ClearError() handle:%d", handle);
987
988 if ((handle == 0) || (handle > MAX_RFC_PORTS))
989 {
990 return (PORT_BAD_HANDLE);
991 }
992
993 p_port = &rfc_cb.port.port[handle - 1];
994
995 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
996 {
997 return (PORT_NOT_OPENED);
998 }
999
1000 *p_errors = p_port->line_status;
1001
1002 /* This is the only call to clear error status. We can not clear */
1003 /* connection failed status. To clean it port should be closed and reopened */
1004 p_port->line_status = (p_port->line_status & LINE_STATUS_FAILED);
1005
1006 PORT_GetQueueStatus (handle, p_status);
1007 return (PORT_SUCCESS);
1008 }
1009
1010
1011 /*******************************************************************************
1012 **
1013 ** Function PORT_SendError
1014 **
1015 ** Description This function send a communications error to the peer device
1016 **
1017 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
1018 ** errors - receive error codes
1019 **
1020 *******************************************************************************/
PORT_SendError(UINT16 handle,UINT8 errors)1021 int PORT_SendError (UINT16 handle, UINT8 errors)
1022 {
1023 tPORT *p_port;
1024
1025 RFCOMM_TRACE_API ("PORT_SendError() handle:%d errors:0x%x", handle, errors);
1026
1027 if ((handle == 0) || (handle > MAX_RFC_PORTS))
1028 {
1029 return (PORT_BAD_HANDLE);
1030 }
1031
1032 p_port = &rfc_cb.port.port[handle - 1];
1033
1034 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
1035 {
1036 return (PORT_NOT_OPENED);
1037 }
1038
1039 if (!p_port->rfc.p_mcb)
1040 {
1041 return (PORT_NOT_OPENED);
1042 }
1043
1044 RFCOMM_LineStatusReq (p_port->rfc.p_mcb, p_port->dlci, errors);
1045 return (PORT_SUCCESS);
1046 }
1047
1048
1049 /*******************************************************************************
1050 **
1051 ** Function PORT_GetQueueStatus
1052 **
1053 ** Description This function reports current status of a connection.
1054 **
1055 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
1056 ** p_status - pointer to the tPORT_STATUS structur to receive
1057 ** connection status
1058 **
1059 *******************************************************************************/
PORT_GetQueueStatus(UINT16 handle,tPORT_STATUS * p_status)1060 int PORT_GetQueueStatus (UINT16 handle, tPORT_STATUS *p_status)
1061 {
1062 tPORT *p_port;
1063
1064 /* RFCOMM_TRACE_API ("PORT_GetQueueStatus() handle:%d", handle); */
1065
1066 if ((handle == 0) || (handle > MAX_RFC_PORTS))
1067 {
1068 return (PORT_BAD_HANDLE);
1069 }
1070
1071 p_port = &rfc_cb.port.port[handle - 1];
1072
1073 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
1074 {
1075 return (PORT_NOT_OPENED);
1076 }
1077
1078 p_status->in_queue_size = (UINT16) p_port->rx.queue_size;
1079 p_status->out_queue_size = (UINT16) p_port->tx.queue_size;
1080
1081 p_status->mtu_size = (UINT16) p_port->peer_mtu;
1082
1083 p_status->flags = 0;
1084
1085 if (!(p_port->peer_ctrl.modem_signal & PORT_CTSRTS_ON))
1086 p_status->flags |= PORT_FLAG_CTS_HOLD;
1087
1088 if (!(p_port->peer_ctrl.modem_signal & PORT_DTRDSR_ON))
1089 p_status->flags |= PORT_FLAG_DSR_HOLD;
1090
1091 if (!(p_port->peer_ctrl.modem_signal & PORT_DCD_ON))
1092 p_status->flags |= PORT_FLAG_RLSD_HOLD;
1093
1094 return (PORT_SUCCESS);
1095 }
1096
1097
1098 /*******************************************************************************
1099 **
1100 ** Function PORT_Purge
1101 **
1102 ** Description This function discards all the data from the output or
1103 ** input queues of the specified connection.
1104 **
1105 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
1106 ** purge_flags - specify the action to take.
1107 **
1108 *******************************************************************************/
PORT_Purge(UINT16 handle,UINT8 purge_flags)1109 int PORT_Purge (UINT16 handle, UINT8 purge_flags)
1110 {
1111 tPORT *p_port;
1112 BT_HDR *p_buf;
1113 UINT16 count;
1114 UINT32 events;
1115
1116 RFCOMM_TRACE_API ("PORT_Purge() handle:%d flags:0x%x", handle, purge_flags);
1117
1118 /* Check if handle is valid to avoid crashing */
1119 if ((handle == 0) || (handle > MAX_RFC_PORTS))
1120 {
1121 return (PORT_BAD_HANDLE);
1122 }
1123
1124 p_port = &rfc_cb.port.port[handle - 1];
1125
1126 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
1127 {
1128 return (PORT_NOT_OPENED);
1129 }
1130
1131 if (purge_flags & PORT_PURGE_RXCLEAR)
1132 {
1133 PORT_SCHEDULE_LOCK; /* to prevent missing credit */
1134
1135 count = p_port->rx.queue.count;
1136
1137 while ((p_buf = (BT_HDR *)GKI_dequeue (&p_port->rx.queue)) != NULL)
1138 GKI_freebuf (p_buf);
1139
1140 p_port->rx.queue_size = 0;
1141
1142 PORT_SCHEDULE_UNLOCK;
1143
1144 /* If we flowed controlled peer based on rx_queue size enable data again */
1145 if (count)
1146 port_flow_control_peer (p_port, TRUE, count);
1147 }
1148
1149 if (purge_flags & PORT_PURGE_TXCLEAR)
1150 {
1151 PORT_SCHEDULE_LOCK; /* to prevent tx.queue_size from being negative */
1152
1153 while ((p_buf = (BT_HDR *)GKI_dequeue (&p_port->tx.queue)) != NULL)
1154 GKI_freebuf (p_buf);
1155
1156 p_port->tx.queue_size = 0;
1157
1158 PORT_SCHEDULE_UNLOCK;
1159
1160 events = PORT_EV_TXEMPTY;
1161
1162 events |= port_flow_control_user (p_port);
1163
1164 events &= p_port->ev_mask;
1165
1166 if ((p_port->p_callback != NULL) && events)
1167 (p_port->p_callback)(events, p_port->inx);
1168 }
1169
1170 return (PORT_SUCCESS);
1171 }
1172
1173
1174 /*******************************************************************************
1175 **
1176 ** Function PORT_ReadData
1177 **
1178 ** Description Normally not GKI aware application will call this function
1179 ** after receiving PORT_EV_RXCHAR event.
1180 **
1181 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
1182 ** p_data - Data area
1183 ** max_len - Byte count requested
1184 ** p_len - Byte count received
1185 **
1186 *******************************************************************************/
PORT_ReadData(UINT16 handle,char * p_data,UINT16 max_len,UINT16 * p_len)1187 int PORT_ReadData (UINT16 handle, char *p_data, UINT16 max_len, UINT16 *p_len)
1188 {
1189 tPORT *p_port;
1190 BT_HDR *p_buf;
1191 UINT16 count;
1192
1193 RFCOMM_TRACE_API ("PORT_ReadData() handle:%d max_len:%d", handle, max_len);
1194
1195 /* Initialize this in case of an error */
1196 *p_len = 0;
1197
1198 /* Check if handle is valid to avoid crashing */
1199 if ((handle == 0) || (handle > MAX_RFC_PORTS))
1200 {
1201 return (PORT_BAD_HANDLE);
1202 }
1203
1204 p_port = &rfc_cb.port.port[handle - 1];
1205
1206 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
1207 {
1208 return (PORT_NOT_OPENED);
1209 }
1210
1211 if (p_port->line_status)
1212 {
1213 return (PORT_LINE_ERR);
1214 }
1215
1216 p_buf = (BT_HDR *)GKI_getfirst (&p_port->rx.queue);
1217 if (!p_buf)
1218 return (PORT_SUCCESS);
1219
1220 count = 0;
1221
1222 while (max_len && p_buf)
1223 {
1224 if (p_buf->len > max_len)
1225 {
1226 memcpy (p_data, (UINT8 *)(p_buf + 1) + p_buf->offset, max_len);
1227 p_buf->offset += max_len;
1228 p_buf->len -= max_len;
1229
1230 *p_len += max_len;
1231
1232 PORT_SCHEDULE_LOCK;
1233
1234 p_port->rx.queue_size -= max_len;
1235
1236 PORT_SCHEDULE_UNLOCK;
1237
1238 break;
1239 }
1240 else
1241 {
1242 memcpy (p_data, (UINT8 *)(p_buf + 1) + p_buf->offset, p_buf->len);
1243
1244 *p_len += p_buf->len;
1245 max_len -= p_buf->len;
1246
1247 PORT_SCHEDULE_LOCK;
1248
1249 p_port->rx.queue_size -= p_buf->len;
1250
1251 if (max_len)
1252 {
1253 p_data += p_buf->len;
1254 p_buf = (BT_HDR *)GKI_getnext (p_buf);
1255 }
1256
1257 GKI_freebuf (GKI_dequeue (&p_port->rx.queue));
1258
1259 PORT_SCHEDULE_UNLOCK;
1260
1261 count++;
1262 }
1263 }
1264
1265 if (*p_len == 1)
1266 {
1267 RFCOMM_TRACE_EVENT ("PORT_ReadData queue:%d returned:%d %x", p_port->rx.queue_size, *p_len, (p_data[0]));
1268 }
1269 else
1270 {
1271 RFCOMM_TRACE_EVENT ("PORT_ReadData queue:%d returned:%d", p_port->rx.queue_size, *p_len);
1272 }
1273
1274 /* If rfcomm suspended traffic from the peer based on the rx_queue_size */
1275 /* check if it can be resumed now */
1276 port_flow_control_peer (p_port, TRUE, count);
1277
1278 return (PORT_SUCCESS);
1279 }
1280
1281
1282 /*******************************************************************************
1283 **
1284 ** Function PORT_Read
1285 **
1286 ** Description Normally application will call this function after receiving
1287 ** PORT_EV_RXCHAR event.
1288 **
1289 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
1290 ** pp_buf - pointer to address of buffer with data,
1291 **
1292 *******************************************************************************/
PORT_Read(UINT16 handle,BT_HDR ** pp_buf)1293 int PORT_Read (UINT16 handle, BT_HDR **pp_buf)
1294 {
1295 tPORT *p_port;
1296 BT_HDR *p_buf;
1297
1298 RFCOMM_TRACE_API ("PORT_Read() handle:%d", handle);
1299
1300 /* Check if handle is valid to avoid crashing */
1301 if ((handle == 0) || (handle > MAX_RFC_PORTS))
1302 {
1303 return (PORT_BAD_HANDLE);
1304 }
1305 p_port = &rfc_cb.port.port[handle - 1];
1306
1307 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
1308 {
1309 return (PORT_NOT_OPENED);
1310 }
1311
1312 if (p_port->line_status)
1313 {
1314 return (PORT_LINE_ERR);
1315 }
1316
1317 PORT_SCHEDULE_LOCK;
1318
1319 p_buf = (BT_HDR *)GKI_dequeue (&p_port->rx.queue);
1320 if (p_buf)
1321 {
1322 p_port->rx.queue_size -= p_buf->len;
1323
1324 PORT_SCHEDULE_UNLOCK;
1325
1326 /* If rfcomm suspended traffic from the peer based on the rx_queue_size */
1327 /* check if it can be resumed now */
1328 port_flow_control_peer (p_port, TRUE, 1);
1329 }
1330 else
1331 {
1332 PORT_SCHEDULE_UNLOCK;
1333 }
1334
1335 *pp_buf = p_buf;
1336 return (PORT_SUCCESS);
1337 }
1338
1339
1340 /*******************************************************************************
1341 **
1342 ** Function port_write
1343 **
1344 ** Description This function when a data packet is received from the apper
1345 ** layer task.
1346 **
1347 ** Parameters: p_port - pointer to address of port control block
1348 ** p_buf - pointer to address of buffer with data,
1349 **
1350 *******************************************************************************/
port_write(tPORT * p_port,BT_HDR * p_buf)1351 static int port_write (tPORT *p_port, BT_HDR *p_buf)
1352 {
1353 /* We should not allow to write data in to server port when connection is not opened */
1354 if (p_port->is_server && (p_port->rfc.state != RFC_STATE_OPENED))
1355 {
1356 GKI_freebuf (p_buf);
1357 return (PORT_CLOSED);
1358 }
1359
1360 /* Keep the data in pending queue if peer does not allow data, or */
1361 /* Peer is not ready or Port is not yet opened or initial port control */
1362 /* command has not been sent */
1363 if (p_port->tx.peer_fc
1364 || !p_port->rfc.p_mcb
1365 || !p_port->rfc.p_mcb->peer_ready
1366 || (p_port->rfc.state != RFC_STATE_OPENED)
1367 || ((p_port->port_ctrl & (PORT_CTRL_REQ_SENT | PORT_CTRL_IND_RECEIVED)) !=
1368 (PORT_CTRL_REQ_SENT | PORT_CTRL_IND_RECEIVED)))
1369 {
1370 if ((p_port->tx.queue_size > PORT_TX_CRITICAL_WM)
1371 || (p_port->tx.queue.count > PORT_TX_BUF_CRITICAL_WM))
1372 {
1373 RFCOMM_TRACE_WARNING ("PORT_Write: Queue size: %d",
1374 p_port->tx.queue_size);
1375
1376 GKI_freebuf (p_buf);
1377
1378 if ((p_port->p_callback != NULL) && (p_port->ev_mask & PORT_EV_ERR))
1379 p_port->p_callback (PORT_EV_ERR, p_port->inx);
1380
1381 return (PORT_TX_FULL);
1382 }
1383
1384 RFCOMM_TRACE_EVENT ("PORT_Write : Data is enqued. flow disabled %d peer_ready %d state %d ctrl_state %x",
1385 p_port->tx.peer_fc,
1386 (p_port->rfc.p_mcb && p_port->rfc.p_mcb->peer_ready),
1387 p_port->rfc.state,
1388 p_port->port_ctrl);
1389
1390 GKI_enqueue (&p_port->tx.queue, p_buf);
1391 p_port->tx.queue_size += p_buf->len;
1392
1393 return (PORT_CMD_PENDING);
1394 }
1395 else
1396 {
1397 RFCOMM_TRACE_EVENT ("PORT_Write : Data is being sent");
1398
1399 RFCOMM_DataReq (p_port->rfc.p_mcb, p_port->dlci, p_buf);
1400 return (PORT_SUCCESS);
1401 }
1402 }
1403
1404 /*******************************************************************************
1405 **
1406 ** Function PORT_Write
1407 **
1408 ** Description This function when a data packet is received from the apper
1409 ** layer task.
1410 **
1411 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
1412 ** pp_buf - pointer to address of buffer with data,
1413 **
1414 *******************************************************************************/
PORT_Write(UINT16 handle,BT_HDR * p_buf)1415 int PORT_Write (UINT16 handle, BT_HDR *p_buf)
1416 {
1417 tPORT *p_port;
1418 UINT32 event = 0;
1419 int rc;
1420
1421 RFCOMM_TRACE_API ("PORT_Write() handle:%d", handle);
1422
1423 /* Check if handle is valid to avoid crashing */
1424 if ((handle == 0) || (handle > MAX_RFC_PORTS))
1425 {
1426 GKI_freebuf (p_buf);
1427 return (PORT_BAD_HANDLE);
1428 }
1429
1430 p_port = &rfc_cb.port.port[handle - 1];
1431
1432 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
1433 {
1434 GKI_freebuf (p_buf);
1435 return (PORT_NOT_OPENED);
1436 }
1437
1438 if (p_port->line_status)
1439 {
1440 RFCOMM_TRACE_WARNING ("PORT_Write: Data dropped line_status:0x%x",
1441 p_port->line_status);
1442 GKI_freebuf (p_buf);
1443 return (PORT_LINE_ERR);
1444 }
1445
1446 rc = port_write (p_port, p_buf);
1447 event |= port_flow_control_user (p_port);
1448
1449 switch (rc)
1450 {
1451 case PORT_TX_FULL:
1452 event |= PORT_EV_ERR;
1453 break;
1454
1455 case PORT_SUCCESS:
1456 event |= (PORT_EV_TXCHAR | PORT_EV_TXEMPTY);
1457 break;
1458 }
1459 /* Mask out all events that are not of interest to user */
1460 event &= p_port->ev_mask;
1461
1462 /* Send event to the application */
1463 if (p_port->p_callback && event)
1464 (p_port->p_callback)(event, p_port->inx);
1465
1466 return (PORT_SUCCESS);
1467 }
1468 /*******************************************************************************
1469 **
1470 ** Function PORT_WriteDataCO
1471 **
1472 ** Description Normally not GKI aware application will call this function
1473 ** to send data to the port by callout functions
1474 **
1475 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
1476 ** fd - socket fd
1477 ** p_len - Byte count returned
1478 **
1479 *******************************************************************************/
PORT_WriteDataCO(UINT16 handle,int * p_len)1480 int PORT_WriteDataCO (UINT16 handle, int* p_len)
1481 {
1482
1483 tPORT *p_port;
1484 BT_HDR *p_buf;
1485 UINT32 event = 0;
1486 int rc = 0;
1487 UINT16 length;
1488
1489 RFCOMM_TRACE_API ("PORT_WriteDataCO() handle:%d", handle);
1490 int written;
1491 *p_len = 0;
1492
1493 /* Check if handle is valid to avoid crashing */
1494 if ((handle == 0) || (handle > MAX_RFC_PORTS))
1495 {
1496 return (PORT_BAD_HANDLE);
1497 }
1498 p_port = &rfc_cb.port.port[handle - 1];
1499
1500 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
1501 {
1502 RFCOMM_TRACE_WARNING ("PORT_WriteDataByFd() no port state:%d", p_port->state);
1503 return (PORT_NOT_OPENED);
1504 }
1505
1506 if (!p_port->peer_mtu)
1507 {
1508 RFCOMM_TRACE_ERROR ("PORT_WriteDataByFd() peer_mtu:%d", p_port->peer_mtu);
1509 return (PORT_UNKNOWN_ERROR);
1510 }
1511 int available = 0;
1512 //if(ioctl(fd, FIONREAD, &available) < 0)
1513 if(p_port->p_data_co_callback(handle, (UINT8*)&available, sizeof(available),
1514 DATA_CO_CALLBACK_TYPE_OUTGOING_SIZE) == FALSE)
1515 {
1516 RFCOMM_TRACE_ERROR("p_data_co_callback DATA_CO_CALLBACK_TYPE_INCOMING_SIZE failed, available:%d", available);
1517 return (PORT_UNKNOWN_ERROR);
1518 }
1519 if(available == 0)
1520 return PORT_SUCCESS;
1521 /* Length for each buffer is the smaller of GKI buffer, peer MTU, or max_len */
1522 length = RFCOMM_DATA_POOL_BUF_SIZE -
1523 (UINT16)(sizeof(BT_HDR) + L2CAP_MIN_OFFSET + RFCOMM_DATA_OVERHEAD);
1524
1525 /* If there are buffers scheduled for transmission check if requested */
1526 /* data fits into the end of the queue */
1527 PORT_SCHEDULE_LOCK;
1528
1529 if (((p_buf = (BT_HDR *)p_port->tx.queue.p_last) != NULL)
1530 && (((int)p_buf->len + available) <= (int)p_port->peer_mtu)
1531 && (((int)p_buf->len + available) <= (int)length))
1532 {
1533 //if(recv(fd, (UINT8 *)(p_buf + 1) + p_buf->offset + p_buf->len, available, 0) != available)
1534 if(p_port->p_data_co_callback(handle, (UINT8 *)(p_buf + 1) + p_buf->offset + p_buf->len,
1535 available, DATA_CO_CALLBACK_TYPE_OUTGOING) == FALSE)
1536
1537 {
1538 error("p_data_co_callback DATA_CO_CALLBACK_TYPE_OUTGOING failed, available:%d", available);
1539 PORT_SCHEDULE_UNLOCK;
1540 return (PORT_UNKNOWN_ERROR);
1541 }
1542 //memcpy ((UINT8 *)(p_buf + 1) + p_buf->offset + p_buf->len, p_data, max_len);
1543 p_port->tx.queue_size += (UINT16)available;
1544
1545 *p_len = available;
1546 p_buf->len += (UINT16)available;
1547
1548 PORT_SCHEDULE_UNLOCK;
1549
1550 return (PORT_SUCCESS);
1551 }
1552
1553 PORT_SCHEDULE_UNLOCK;
1554
1555 //int max_read = length < p_port->peer_mtu ? length : p_port->peer_mtu;
1556
1557 //max_read = available < max_read ? available : max_read;
1558
1559 while (available)
1560 {
1561 /* if we're over buffer high water mark, we're done */
1562 if ((p_port->tx.queue_size > PORT_TX_HIGH_WM)
1563 || (p_port->tx.queue.count > PORT_TX_BUF_HIGH_WM))
1564 {
1565 port_flow_control_user(p_port);
1566 event |= PORT_EV_FC;
1567 debug("tx queue is full,tx.queue_size:%d,tx.queue.count:%d,available:%d",
1568 p_port->tx.queue_size, p_port->tx.queue.count, available);
1569 break;
1570 }
1571
1572 /* continue with rfcomm data write */
1573 p_buf = (BT_HDR *)GKI_getpoolbuf (RFCOMM_DATA_POOL_ID);
1574 if (!p_buf)
1575 break;
1576
1577 p_buf->offset = L2CAP_MIN_OFFSET + RFCOMM_MIN_OFFSET;
1578 p_buf->layer_specific = handle;
1579
1580 if (p_port->peer_mtu < length)
1581 length = p_port->peer_mtu;
1582 if (available < (int)length)
1583 length = (UINT16)available;
1584 p_buf->len = length;
1585 p_buf->event = BT_EVT_TO_BTU_SP_DATA;
1586
1587 //memcpy ((UINT8 *)(p_buf + 1) + p_buf->offset, p_data, length);
1588 //if(recv(fd, (UINT8 *)(p_buf + 1) + p_buf->offset, (int)length, 0) != (int)length)
1589 if(p_port->p_data_co_callback(handle, (UINT8 *)(p_buf + 1) + p_buf->offset, length,
1590 DATA_CO_CALLBACK_TYPE_OUTGOING) == FALSE)
1591 {
1592 error("p_data_co_callback DATA_CO_CALLBACK_TYPE_OUTGOING failed, length:%d", length);
1593 return (PORT_UNKNOWN_ERROR);
1594 }
1595
1596
1597 RFCOMM_TRACE_EVENT ("PORT_WriteData %d bytes", length);
1598
1599 rc = port_write (p_port, p_buf);
1600
1601 /* If queue went below the threashold need to send flow control */
1602 event |= port_flow_control_user (p_port);
1603
1604 if (rc == PORT_SUCCESS)
1605 event |= PORT_EV_TXCHAR;
1606
1607 if ((rc != PORT_SUCCESS) && (rc != PORT_CMD_PENDING))
1608 break;
1609
1610 *p_len += length;
1611 available -= (int)length;
1612 }
1613 if (!available && (rc != PORT_CMD_PENDING) && (rc != PORT_TX_QUEUE_DISABLED))
1614 event |= PORT_EV_TXEMPTY;
1615
1616 /* Mask out all events that are not of interest to user */
1617 event &= p_port->ev_mask;
1618
1619 /* Send event to the application */
1620 if (p_port->p_callback && event)
1621 (p_port->p_callback)(event, p_port->inx);
1622
1623 return (PORT_SUCCESS);
1624 }
1625
1626
1627
1628 /*******************************************************************************
1629 **
1630 ** Function PORT_WriteData
1631 **
1632 ** Description Normally not GKI aware application will call this function
1633 ** to send data to the port.
1634 **
1635 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
1636 ** p_data - Data area
1637 ** max_len - Byte count requested
1638 ** p_len - Byte count received
1639 **
1640 *******************************************************************************/
PORT_WriteData(UINT16 handle,char * p_data,UINT16 max_len,UINT16 * p_len)1641 int PORT_WriteData (UINT16 handle, char *p_data, UINT16 max_len, UINT16 *p_len)
1642 {
1643 tPORT *p_port;
1644 BT_HDR *p_buf;
1645 UINT32 event = 0;
1646 int rc = 0;
1647 UINT16 length;
1648
1649 RFCOMM_TRACE_API ("PORT_WriteData() max_len:%d", max_len);
1650
1651 *p_len = 0;
1652
1653 /* Check if handle is valid to avoid crashing */
1654 if ((handle == 0) || (handle > MAX_RFC_PORTS))
1655 {
1656 return (PORT_BAD_HANDLE);
1657 }
1658 p_port = &rfc_cb.port.port[handle - 1];
1659
1660 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
1661 {
1662 RFCOMM_TRACE_WARNING ("PORT_WriteData() no port state:%d", p_port->state);
1663 return (PORT_NOT_OPENED);
1664 }
1665
1666 if (!max_len || !p_port->peer_mtu)
1667 {
1668 RFCOMM_TRACE_ERROR ("PORT_WriteData() peer_mtu:%d", p_port->peer_mtu);
1669 return (PORT_UNKNOWN_ERROR);
1670 }
1671
1672 /* Length for each buffer is the smaller of GKI buffer, peer MTU, or max_len */
1673 length = RFCOMM_DATA_POOL_BUF_SIZE -
1674 (UINT16)(sizeof(BT_HDR) + L2CAP_MIN_OFFSET + RFCOMM_DATA_OVERHEAD);
1675
1676 /* If there are buffers scheduled for transmission check if requested */
1677 /* data fits into the end of the queue */
1678 PORT_SCHEDULE_LOCK;
1679
1680 if (((p_buf = (BT_HDR *)p_port->tx.queue.p_last) != NULL)
1681 && ((p_buf->len + max_len) <= p_port->peer_mtu)
1682 && ((p_buf->len + max_len) <= length))
1683 {
1684 memcpy ((UINT8 *)(p_buf + 1) + p_buf->offset + p_buf->len, p_data, max_len);
1685 p_port->tx.queue_size += max_len;
1686
1687 *p_len = max_len;
1688 p_buf->len += max_len;
1689
1690 PORT_SCHEDULE_UNLOCK;
1691
1692 return (PORT_SUCCESS);
1693 }
1694
1695 PORT_SCHEDULE_UNLOCK;
1696
1697 while (max_len)
1698 {
1699 /* if we're over buffer high water mark, we're done */
1700 if ((p_port->tx.queue_size > PORT_TX_HIGH_WM)
1701 || (p_port->tx.queue.count > PORT_TX_BUF_HIGH_WM))
1702 break;
1703
1704 /* continue with rfcomm data write */
1705 p_buf = (BT_HDR *)GKI_getpoolbuf (RFCOMM_DATA_POOL_ID);
1706 if (!p_buf)
1707 break;
1708
1709 p_buf->offset = L2CAP_MIN_OFFSET + RFCOMM_MIN_OFFSET;
1710 p_buf->layer_specific = handle;
1711
1712 if (p_port->peer_mtu < length)
1713 length = p_port->peer_mtu;
1714 if (max_len < length)
1715 length = max_len;
1716 p_buf->len = length;
1717 p_buf->event = BT_EVT_TO_BTU_SP_DATA;
1718
1719 memcpy ((UINT8 *)(p_buf + 1) + p_buf->offset, p_data, length);
1720
1721 RFCOMM_TRACE_EVENT ("PORT_WriteData %d bytes", length);
1722
1723 rc = port_write (p_port, p_buf);
1724
1725 /* If queue went below the threashold need to send flow control */
1726 event |= port_flow_control_user (p_port);
1727
1728 if (rc == PORT_SUCCESS)
1729 event |= PORT_EV_TXCHAR;
1730
1731 if ((rc != PORT_SUCCESS) && (rc != PORT_CMD_PENDING))
1732 break;
1733
1734 *p_len += length;
1735 max_len -= length;
1736 p_data += length;
1737
1738 }
1739 if (!max_len && (rc != PORT_CMD_PENDING) && (rc != PORT_TX_QUEUE_DISABLED))
1740 event |= PORT_EV_TXEMPTY;
1741
1742 /* Mask out all events that are not of interest to user */
1743 event &= p_port->ev_mask;
1744
1745 /* Send event to the application */
1746 if (p_port->p_callback && event)
1747 (p_port->p_callback)(event, p_port->inx);
1748
1749 return (PORT_SUCCESS);
1750 }
1751
1752
1753 /*******************************************************************************
1754 **
1755 ** Function PORT_Test
1756 **
1757 ** Description Application can call this function to send RFCOMM Test frame
1758 **
1759 ** Parameters: handle - Handle returned in the RFCOMM_CreateConnection
1760 ** p_data - Data area
1761 ** max_len - Byte count requested
1762 **
1763 *******************************************************************************/
PORT_Test(UINT16 handle,UINT8 * p_data,UINT16 len)1764 int PORT_Test (UINT16 handle, UINT8 *p_data, UINT16 len)
1765 {
1766 BT_HDR *p_buf;
1767 tPORT *p_port;
1768
1769 RFCOMM_TRACE_API ("PORT_Test() len:%d", len);
1770
1771 if ((handle == 0) || (handle > MAX_RFC_PORTS))
1772 {
1773 return (PORT_BAD_HANDLE);
1774 }
1775 p_port = &rfc_cb.port.port[handle - 1];
1776
1777 if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED))
1778 {
1779 return (PORT_NOT_OPENED);
1780 }
1781
1782 if (len > ((p_port->mtu == 0) ? RFCOMM_DEFAULT_MTU : p_port->mtu))
1783 {
1784 return (PORT_UNKNOWN_ERROR);
1785 }
1786
1787 if ((p_buf = (BT_HDR *)GKI_getpoolbuf (RFCOMM_CMD_POOL_ID)) != NULL)
1788 {
1789
1790 p_buf->offset = L2CAP_MIN_OFFSET + RFCOMM_MIN_OFFSET + 2;
1791 p_buf->len = len;
1792
1793 memcpy ((UINT8 *)(p_buf + 1) + p_buf->offset, p_data, p_buf->len);
1794
1795 rfc_send_test (p_port->rfc.p_mcb, TRUE, p_buf);
1796 return (PORT_SUCCESS);
1797 }
1798 else
1799 {
1800 return (PORT_NO_MEM);
1801 }
1802 }
1803
1804 /*******************************************************************************
1805 **
1806 ** Function RFCOMM_Init
1807 **
1808 ** Description This function is called to initialize RFCOMM layer
1809 **
1810 *******************************************************************************/
RFCOMM_Init(void)1811 void RFCOMM_Init (void)
1812 {
1813 memset (&rfc_cb, 0, sizeof (tRFC_CB)); /* Init RFCOMM control block */
1814
1815 rfc_cb.rfc.last_mux = MAX_BD_CONNECTIONS;
1816
1817 #if defined(RFCOMM_INITIAL_TRACE_LEVEL)
1818 rfc_cb.trace_level = RFCOMM_INITIAL_TRACE_LEVEL;
1819 #else
1820 rfc_cb.trace_level = BT_TRACE_LEVEL_NONE; /* No traces */
1821 #endif
1822
1823 rfcomm_l2cap_if_init ();
1824 }
1825
1826 /*******************************************************************************
1827 **
1828 ** Function PORT_SetTraceLevel
1829 **
1830 ** Description This function sets the trace level for RFCOMM. If called with
1831 ** a value of 0xFF, it simply reads the current trace level.
1832 **
1833 ** Returns the new (current) trace level
1834 **
1835 *******************************************************************************/
PORT_SetTraceLevel(UINT8 new_level)1836 UINT8 PORT_SetTraceLevel (UINT8 new_level)
1837 {
1838 if (new_level != 0xFF)
1839 rfc_cb.trace_level = new_level;
1840
1841 return (rfc_cb.trace_level);
1842 }
1843
1844