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