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*******************************************************************************/ 77int 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*******************************************************************************/ 208int 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*******************************************************************************/ 244int 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*******************************************************************************/ 291int 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 324int 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*******************************************************************************/ 352int 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*******************************************************************************/ 388int 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*******************************************************************************/ 424int 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*******************************************************************************/ 461int 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*******************************************************************************/ 505BOOLEAN 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*******************************************************************************/ 563int 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*******************************************************************************/ 612int 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*******************************************************************************/ 656int 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*******************************************************************************/ 696int 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*******************************************************************************/ 783int 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 862int 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*******************************************************************************/ 942int 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*******************************************************************************/ 982int 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*******************************************************************************/ 1021int 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*******************************************************************************/ 1060int 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*******************************************************************************/ 1109int 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*******************************************************************************/ 1187int 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*******************************************************************************/ 1293int 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*******************************************************************************/ 1351static 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*******************************************************************************/ 1415int 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*******************************************************************************/ 1480int 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*******************************************************************************/ 1641int 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*******************************************************************************/ 1764int 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*******************************************************************************/ 1811void 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*******************************************************************************/ 1836UINT8 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