1 /****************************************************************************** 2 * 3 * Copyright (C) 2009-2013 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 #include <string.h> 20 21 #include "bt_target.h" 22 #include "bt_utils.h" 23 #include "gap_int.h" 24 #include "btm_int.h" 25 #include "gki.h" 26 #include "btu.h" 27 28 /******************************************************************************* 29 ** 30 ** Function GAP_SetDiscoverableMode 31 ** 32 ** Description This function is called to allow or disallow a service to 33 ** discovered (Inquiry Scans). 34 ** 35 ** Parameters: mode - GAP_NON_DISCOVERABLE, GAP_LIMITED_DISCOVERABLE, 36 ** or GAP_GENERAL_DISCOVERABLE 37 ** 38 ** duration - Amount of time for the duration of an inquiry scan. 39 ** The step size is in 0.625 msec intervals. 40 ** Range: 0x0012 - 0x1000 (11.25 - 2560 msecs) 41 ** 42 ** If a value of '0' is entered the default of 43 ** 0x0012 (11.25 msecs) will be used. 44 ** Note: The duration must be less than or equal to 45 ** the interval. 46 ** 47 ** interval - Amount of time between the start of two inquiry scans. 48 ** The step size is in 0.625 msec intervals. 49 ** Range: 0x0012 - 0x1000 (11.25 - 2560 msecs) 50 ** If a value of '0' is entered the default of 51 ** 0x800 (1.28 secs) will be used. 52 ** 53 ** 54 ** Returns BT_PASS (0) if successful, 55 ** GAP_ERR_ILL_PARM if a bad parameter is detected, 56 ** GAP_DEVICE_NOT_UP if the device is not active, 57 ** GAP_ERR_PROCESSING if not enough resources to carry out request 58 ** 59 *******************************************************************************/ 60 UINT16 GAP_SetDiscoverableMode (UINT16 mode, UINT16 duration, UINT16 interval) 61 { 62 tBTM_STATUS status; 63 64 status = BTM_SetDiscoverability(mode, duration, interval); 65 66 return (gap_convert_btm_status (status)); 67 } 68 69 70 /******************************************************************************* 71 ** 72 ** Function GAP_ReadDiscoverableMode 73 ** 74 ** Description This function is called to retrieve the current discoverable mode 75 ** for the local device. 76 ** 77 ** Parameters: duration - pointer to the amount of time of an inquiry scan. 78 ** The step size is in 0.625 msec intervals. 79 ** Range: 0x0012 - 0x1000 (11.25 - 2560 msecs) 80 ** 81 ** interval - pointer to the amount of time between the start of 82 ** two inquiry scans. 83 ** The step size is in 0.625 msec intervals. 84 ** Range: 0x0012 - 0x1000 (11.25 - 2560 msecs) 85 ** 86 ** 87 ** Returns GAP_NON_DISCOVERABLE, GAP_LIMITED_DISCOVERABLE, or 88 ** GAP_GENERAL_DISCOVERABLE 89 ** 90 *******************************************************************************/ 91 UINT16 GAP_ReadDiscoverableMode (UINT16 *duration, UINT16 *interval) 92 { 93 return (BTM_ReadDiscoverability(duration, interval)); 94 } 95 96 97 /******************************************************************************* 98 ** 99 ** Function GAP_SetConnectableMode 100 ** 101 ** Description This function is called to allow or disallow a 102 ** connections on the local device. 103 ** 104 ** Parameters: mode - GAP_NON_CONNECTABLE, GAP_CONNECTABLE, 105 ** 106 ** duration - Amount of time for the duration of a page scan. 107 ** The step size is in 0.625 msec intervals. 108 ** Range: 0x0012 - 0x1000 (11.25 - 2560 msecs) 109 ** 110 ** If a value of '0' is entered the default of 111 ** 0x0012 (11.25 msecs) will be used. 112 ** Note: The duration must be less than or equal to 113 ** the interval. 114 ** 115 ** interval - Amount of time between the start of two page scans. 116 ** The step size is in 0.625 msec intervals. 117 ** Range: 0x0012 - 0x1000 (11.25 - 2560 msecs) 118 ** If a value of '0' is entered the default of 119 ** 0x800 (1.28 secs) will be used. 120 ** 121 ** 122 ** Returns BT_PASS (0) if successful, 123 ** GAP_ERR_ILL_PARM if a bad parameter is detected, 124 ** GAP_DEVICE_NOT_UP if the device is not active, 125 ** GAP_ERR_PROCESSING if not enough resources to carry out request 126 ** 127 *******************************************************************************/ 128 UINT16 GAP_SetConnectableMode (UINT16 mode, UINT16 duration, UINT16 interval) 129 { 130 tBTM_STATUS status; 131 132 status = BTM_SetConnectability(mode, duration, interval); 133 134 return (gap_convert_btm_status (status)); 135 } 136 137 138 /******************************************************************************* 139 ** 140 ** Function GAP_FindAddrByName 141 ** 142 ** Description This function is called to retrieve a device address given 143 ** a device name. It first looks in the current local inquiry 144 ** database for the device with the specified name. If not found 145 ** it initiates a general inquiry. Upon completion, it retrieves 146 ** the name for each device until a match is found or all devices 147 ** have been checked. Note: This process can take a while to 148 ** complete. 149 ** 150 ** Parameters: devname - 151 ** 152 ** inqparms - pointer to the inquiry information 153 ** mode - GAP_GENERAL_INQUIRY or GAP_LIMITED_INQUIRY inquiry 154 ** duration - length in 1.28 sec intervals 155 ** max_resps - maximum amount of devices to search for before ending the inquiry 156 ** filter_cond_type - GAP_CLR_INQUIRY_FILTER, GAP_FILTER_COND_DEVICE_CLASS, or 157 ** GAP_FILTER_COND_BD_ADDR 158 ** filter_cond - value for the filter (based on filter_cond_type) 159 ** 160 ** 161 ** Returns BT_PASS if the name was immediately available. (BD_ADDR is returned) 162 ** GAP_CMD_INITIATED if an inquiry has been initiated 163 ** 164 *******************************************************************************/ 165 UINT16 GAP_FindAddrByName (BD_NAME devname, tGAP_INQ_PARMS *p_inq_parms, tGAP_CALLBACK *p_addr_cb, 166 BD_ADDR bd_addr) 167 { 168 UINT16 status; 169 tBTM_STATUS btm_status; 170 171 172 /* If the remote name is retrieved automatically during an inquiry search the local db first */ 173 if ((status = gap_find_local_addr_by_name (devname, bd_addr)) != BT_PASS) 174 { 175 /* If this code is used, the name wasn't in the current inquiry database */ 176 /* A general inquiry must now be initiated */ 177 if (gap_cb.findaddr_cb.in_use == FALSE) 178 { 179 gap_cb.findaddr_cb.p_cback = p_addr_cb; 180 gap_cb.findaddr_cb.p_cur_inq = (tBTM_INQ_INFO *) NULL; /* Reset to the beginning of the database */ 181 BCM_STRNCPY_S ((char *)gap_cb.findaddr_cb.results.devname, sizeof(gap_cb.findaddr_cb.results.devname), (char *)devname, BTM_MAX_REM_BD_NAME_LEN); 182 183 /* make sure we have an end of string char */ 184 gap_cb.findaddr_cb.results.devname[BTM_MAX_REM_BD_NAME_LEN] = 0; 185 186 btm_status = BTM_StartInquiry (p_inq_parms, (tBTM_INQ_RESULTS_CB *) NULL, 187 (tBTM_CMPL_CB *) gap_find_addr_inq_cb); 188 gap_cb.findaddr_cb.in_use = TRUE; 189 190 /* convert the error code into a GAP code and check the results for any errors */ 191 if ((status = gap_convert_btm_status (btm_status)) == GAP_CMD_INITIATED) 192 gap_cb.findaddr_cb.in_use = TRUE; 193 } 194 else 195 status = GAP_ERR_BUSY; 196 } 197 198 return (status); 199 } 200 201 202 /******************************************************************************* 203 ** 204 ** Function GAP_ReadConnectableMode 205 ** 206 ** Description This function is called to retrieve the current connectability 207 ** mode for the local device. 208 ** 209 ** Parameters: duration - pointer to the amount of time of an page scan. 210 ** The step size is in 0.625 msec intervals. 211 ** Range: 0x0012 - 0x1000 (11.25 - 2560 msecs) 212 ** 213 ** interval - pointer to the amount of time between the start of 214 ** two page scans. 215 ** The step size is in 0.625 msec intervals. 216 ** Range: 0x0012 - 0x1000 (11.25 - 2560 msecs) 217 ** 218 ** 219 ** Returns GAP_NON_CONNECTABLE, GAP_CONNECTABLE 220 ** 221 *******************************************************************************/ 222 223 UINT16 GAP_ReadConnectableMode (UINT16 *duration, UINT16 *interval) 224 { 225 return (BTM_ReadConnectability(duration, interval)); 226 } 227 228 229 /******************************************************************************* 230 ** 231 ** Function GAP_SetSecurityMode 232 ** 233 ** Description Set security mode for the device 234 ** 235 ** Returns void 236 ** 237 *******************************************************************************/ 238 void GAP_SetSecurityMode (UINT8 sec_mode) 239 { 240 BTM_SetSecurityMode (sec_mode); 241 } 242 243 244 /******************************************************************************* 245 ** 246 ** Function GAP_Bond 247 ** 248 ** Description This function is called to perform bonding with peer device 249 ** 250 ** Parameters: bd_addr - Address of the device to bond 251 ** pin_len - length in bytes of the PIN Code 252 ** p_pin - pointer to array with the PIN Code 253 ** trusted_mask - bitwise OR of trusted services (array of UINT32) 254 ** 255 *******************************************************************************/ 256 UINT8 GAP_Bond (BD_ADDR bd_addr, UINT8 pin_len, UINT8 *p_pin, UINT32 trusted_mask[]) 257 { 258 return ((UINT8) BTM_SecBond (bd_addr, pin_len, p_pin, trusted_mask)); 259 } 260 261 262 /******************************************************************************* 263 ** 264 ** Function GAP_SecRegister 265 ** 266 ** Description Application manager calls this function to register for 267 ** security services. There can be one and only one application 268 ** saving link keys. BTM allows only first registration. 269 ** 270 ** Returns TRUE if registered OK, else FALSE 271 ** 272 *******************************************************************************/ 273 BOOLEAN GAP_SecRegister (tBTM_APPL_INFO *p_cb_info) 274 { 275 return (BTM_SecRegister (p_cb_info)); 276 } 277 278 279 /******************************************************************************* 280 ** 281 ** Function GAP_PinRsp 282 ** 283 ** Description This function is called from UI after Security Manager submitted 284 ** PIN code request. 285 ** 286 ** Parameters: bd_addr - Address of the device for which PIN was requested 287 ** res - result of the operation BTM_SUCCESS if success 288 ** pin_len - length in bytes of the PIN Code 289 ** p_pin - pointer to array with the PIN Code 290 ** trusted_mask - bitwise OR of trusted services (array of UINT32) 291 ** 292 *******************************************************************************/ 293 void GAP_PinRsp (BD_ADDR bd_addr, UINT8 res, UINT8 pin_len, UINT8 *p_pin, UINT32 trusted_mask[]) 294 { 295 BTM_PINCodeReply (bd_addr, res, pin_len, p_pin, trusted_mask); 296 } 297 298 299 /******************************************************************************* 300 ** 301 ** Function GAP_AuthorizeRsp 302 ** 303 ** Description This function is called from UI after Security Manager submitted 304 ** authorization request 305 ** 306 ** Parameters: bd_addr - Address of the device for which PIN was requested 307 ** res - result of the operation BTM_SUCCESS if success 308 ** trusted_mask - bitwise OR of trusted services (array of UINT32) 309 ** 310 *******************************************************************************/ 311 void GAP_AuthorizeRsp (BD_ADDR bd_addr, UINT8 res, UINT32 trusted_mask[]) 312 { 313 BTM_DeviceAuthorized (bd_addr, res, trusted_mask); 314 } 315 316 317 /******************************************************************************* 318 ** 319 ** Function GAP_SetPairableMode 320 ** 321 ** Description This function is called to allow or disallow pairing 322 ** on the local device. 323 ** 324 ** Parameters: mode - GAP_ALLOW_PAIRING, GAP_DISALLOW_PAIRING 325 ** connect_only_pairable - TRUE or FALSE connect only to paired devices 326 ** 327 ** callback - The callback is called when a pin number is requested. 328 ** 329 ** Returns BT_PASS (0) if successful, or a non-zero error code 330 ** 331 *******************************************************************************/ 332 333 UINT16 GAP_SetPairableMode (UINT16 mode, BOOLEAN connect_only_paired) 334 { 335 tBTM_STATUS btm_status; 336 UINT16 status = BT_PASS; 337 338 if (mode == GAP_ALLOW_PAIRING) 339 { 340 btm_status = BTM_SetConnectability(BTM_CONNECTABLE, 0, 0); 341 342 if ((status = gap_convert_btm_status (btm_status)) == BT_PASS) 343 BTM_SetPairableMode (TRUE, connect_only_paired); 344 } 345 else if (mode == GAP_DISALLOW_PAIRING) 346 { 347 BTM_SetPairableMode (FALSE, connect_only_paired); 348 } 349 else 350 { 351 GAP_TRACE_ERROR ("GAP_SetPairableMode: illegal mode %d", mode); 352 status = GAP_ERR_ILL_MODE; 353 } 354 return (status); 355 } 356 357 358 /******************************************************************************* 359 ** 360 ** Function GAP_StartInquiry 361 ** 362 ** Description This function initiates a single inquiry. 363 ** 364 ** Parameters: p_inqparms - pointer to the inquiry information 365 ** mode - GAP_GENERAL_INQUIRY or GAP_LIMITED_INQUIRY inquiry 366 ** duration - length in 1.28 sec intervals 367 ** max_resps - maximum amount of devices to search for before ending the inquiry 368 ** filter_cond_type - GAP_CLR_INQUIRY_FILTER, GAP_FILTER_COND_DEVICE_CLASS, or 369 ** GAP_FILTER_COND_BD_ADDR 370 ** filter_cond - value for the filter (based on filter_cond_type) 371 ** 372 ** p_results_cb - Pointer to the callback routine which gets called 373 ** upon receipt of an inquiry result. If this field is 374 ** NULL, the application is not notified. 375 ** 376 ** p_cmpl_cb - Pointer to the callback routine which gets called 377 ** upon completion. If this field is NULL, the 378 ** application is not notified when completed. 379 ** 380 ** 381 ** Returns BT_PASS (0) if successful, 382 ** GAP_ERR_ILL_MODE if a bad mode parameter was passed 383 ** GAP_ERR_ILL_INQ_TIME if a bad interval or duration was passed 384 ** GAP_ERR_NO_CTRL_BLK if out of control blocks 385 ** GAP_ERR_ILL_PARM if a bad parameter was detected in BTM 386 ** GAP_ERR_BUSY if the device already has an iquiry active 387 ** GAP_DEVICE_NOT_UP if the device is not initialized yet 388 ** GAP_ERR_PROCESSING if any other BTM error was returned 389 ** 390 *******************************************************************************/ 391 UINT16 GAP_StartInquiry (tGAP_INQ_PARMS *p_inq_parms, tGAP_CALLBACK *p_results_cb, tGAP_CALLBACK *p_cmpl_cb) 392 { 393 tGAP_INFO *p_cb; 394 tBTM_STATUS btm_status; 395 UINT16 retval; 396 397 /*** Make sure the parameters are valid before continuing ***/ 398 if (p_inq_parms->mode != GAP_GENERAL_INQUIRY && p_inq_parms->mode != GAP_LIMITED_INQUIRY) 399 return (GAP_ERR_ILL_MODE); 400 401 if (p_inq_parms->duration < GAP_MIN_INQUIRY_LEN || 402 p_inq_parms->duration > GAP_MAX_INQUIRY_LENGTH) 403 return (GAP_ERR_ILL_INQ_TIME); 404 405 /*** get a control block for this operation ***/ 406 if ((p_cb = gap_allocate_cb()) != NULL) 407 { 408 p_cb->gap_cback = p_cmpl_cb; 409 p_cb->gap_inq_rslt_cback = p_results_cb; 410 p_cb->event = GAP_EVT_INQUIRY_COMPLETE; /* Return event expected */ 411 412 btm_status = BTM_StartInquiry(p_inq_parms, gap_inq_results_cb, 413 (tBTM_CMPL_CB *) gap_cb.btm_cback[p_cb->index]); 414 415 /* convert the error code into a GAP code and check the results for any errors */ 416 if ((retval = gap_convert_btm_status (btm_status)) != GAP_CMD_INITIATED) 417 gap_free_cb(p_cb); /* Error starting the inquiry */ 418 } 419 else 420 retval = GAP_ERR_NO_CTRL_BLK; 421 422 return (retval); 423 } 424 425 426 /******************************************************************************* 427 ** 428 ** Function GAP_StartPeriodicInquiry 429 ** 430 ** Description This function initiates a periodic inquiry. 431 ** 432 ** Parameters: p_inqparms - pointer to the inquiry information 433 ** mode - GAP_GENERAL_INQUIRY or GAP_LIMITED_INQUIRY inquiry 434 ** duration - length in 1.28 sec intervals 435 ** max_resps - maximum amount of devices to search for before ending the inquiry 436 ** filter_cond_type - GAP_CLR_INQUIRY_FILTER, GAP_FILTER_COND_DEVICE_CLASS, or 437 ** GAP_FILTER_COND_BD_ADDR 438 ** filter_cond - value for the filter (based on filter_cond_type) 439 ** 440 ** min_time - Minimum amount of time between consecutive inquiries. 441 ** The value is in 1.28 second intervals. 442 ** Range: 0x0002 - 0xFFFE (2.56 - 83883.52 seconds) 443 ** 444 ** max_time - Maximum amount of time between consecutive inquiries. 445 ** The value is in 1.28 sec intervals. 446 ** Range: 0x0003 - 0xFFFF (3.84 - 83884.8 seconds) 447 ** 448 ** p_results_cb - Pointer to the callback routine which gets called 449 ** upon receipt of an inquiry result. If this field is 450 ** NULL, the application is not notified. 451 ** 452 ** 453 ** Returns BT_PASS (0) if successful, 454 ** GAP_ERR_ILL_MODE if a bad mode parameter was passed 455 ** GAP_ERR_ILL_INQ_TIME if a bad interval or duration was passed 456 ** GAP_ERR_NO_CTRL_BLK if out of control blocks 457 ** GAP_ERR_ILL_PARM if a bad parameter was detected in BTM 458 ** GAP_ERR_BUSY if the device already has an iquiry active 459 ** GAP_DEVICE_NOT_UP if the device is not initialized yet 460 ** GAP_ERR_PROCESSING if any other BTM error was returned 461 ** 462 *******************************************************************************/ 463 464 UINT16 GAP_StartPeriodicInquiry (tGAP_INQ_PARMS *p_inq_parms, UINT16 min_time, 465 UINT16 max_time, tGAP_CALLBACK *p_results_cb) 466 { 467 tGAP_INFO *p_cb; 468 tBTM_STATUS btm_status; 469 UINT16 retval = BT_PASS; 470 471 /*** Make sure the parameters are valid before continuing ***/ 472 if (p_inq_parms->mode != GAP_GENERAL_INQUIRY && p_inq_parms->mode != GAP_LIMITED_INQUIRY) 473 return (GAP_ERR_ILL_MODE); 474 475 if (p_inq_parms->duration < GAP_MIN_INQUIRY_LEN || 476 p_inq_parms->duration > GAP_MAX_INQUIRY_LENGTH || 477 min_time <= p_inq_parms->duration || 478 min_time < GAP_PER_INQ_MIN_MIN_PERIOD || 479 min_time > GAP_PER_INQ_MAX_MIN_PERIOD || 480 max_time <= min_time || 481 max_time < GAP_PER_INQ_MIN_MAX_PERIOD) 482 { 483 return (GAP_ERR_ILL_INQ_TIME); 484 } 485 486 /*** get a control block for this operation ***/ 487 if ((p_cb = gap_allocate_cb()) != NULL) 488 { 489 p_cb->gap_inq_rslt_cback = p_results_cb; 490 p_cb->event = GAP_EVT_INQUIRY_COMPLETE; /* mark the inquiry event active */ 491 492 btm_status = BTM_SetPeriodicInquiryMode(p_inq_parms, max_time, min_time, 493 gap_inq_results_cb); 494 495 /* convert the error code into a GAP code and check the results for any errors */ 496 if ((retval = gap_convert_btm_status (btm_status)) != GAP_CMD_INITIATED) 497 gap_free_cb(p_cb); /* Error starting the inquiry */ 498 } 499 else 500 retval = GAP_ERR_NO_CTRL_BLK; 501 502 return (retval); 503 } 504 505 506 /******************************************************************************* 507 ** 508 ** Function GAP_CancelInquiry 509 ** 510 ** Description This function cancels a single inquiry (if in progress) 511 ** 512 ** Parameters: None 513 ** 514 ** Returns BOOLEAN (TRUE if successful, otherwise FALSE) 515 ** 516 *******************************************************************************/ 517 UINT16 GAP_CancelInquiry(void) 518 { 519 tGAP_INFO *p_cb = &gap_cb.blk[0]; 520 UINT8 x; 521 tBTM_STATUS btm_status; 522 UINT16 status; 523 524 btm_status = BTM_CancelInquiry(); 525 if ((status = gap_convert_btm_status (btm_status)) == BT_PASS) 526 { 527 /* Free the control block that is waiting for the inquiry complete event */ 528 for (x = 0; x < GAP_MAX_BLOCKS; x++, p_cb++) 529 { 530 if (p_cb->in_use && p_cb->event == GAP_EVT_INQUIRY_COMPLETE) 531 { 532 gap_free_cb(p_cb); 533 return (BT_PASS); 534 } 535 } 536 537 /* If here the control block was not found */ 538 status = GAP_ERR_NO_CTRL_BLK; 539 } 540 541 return (status); 542 } 543 544 545 /******************************************************************************* 546 ** 547 ** Function GAP_CancelPeriodicInquiry 548 ** 549 ** Description This function cancels a periodic inquiry (if in progress) 550 ** 551 ** Parameters: None 552 ** 553 ** Returns BOOLEAN: (TRUE if successful, otherwise FALSE) 554 ** 555 *******************************************************************************/ 556 UINT16 GAP_CancelPeriodicInquiry(void) 557 { 558 tGAP_INFO *p_cb = &gap_cb.blk[0]; 559 UINT8 x; 560 tBTM_STATUS btm_status; 561 UINT16 status; 562 563 btm_status = BTM_CancelPeriodicInquiry(); 564 if ((status = gap_convert_btm_status (btm_status)) == BT_PASS) 565 { 566 /* Free the control block that is waiting for the inquiry complete event */ 567 for (x = 0; x < GAP_MAX_BLOCKS; x++, p_cb++) 568 { 569 if (p_cb->in_use && p_cb->event == GAP_EVT_INQUIRY_COMPLETE) 570 { 571 gap_free_cb(p_cb); 572 return (BT_PASS); 573 } 574 } 575 576 /* If here the control block was not found */ 577 status = GAP_ERR_NO_CTRL_BLK; 578 } 579 580 return (status); 581 } 582 583 584 /******************************************************************************* 585 ** 586 ** Function GAP_GetFirstInquiryResult 587 ** 588 ** Description This function retrieves the first valid inquiry result. 589 ** 590 ** Parameters: p_results - pointer to the inquiry results 591 ** 592 ** Returns BT_PASS (0) if successful, or a non-zero error code 593 ** GAP_EOINQDB if no more entries in the database. 594 ** 595 *******************************************************************************/ 596 UINT16 GAP_GetFirstInquiryResult(tGAP_INQ_RESULTS *p_results) 597 { 598 UINT8 *ptr; 599 600 gap_cb.cur_inqptr = BTM_InqFirstResult(); 601 602 if (gap_cb.cur_inqptr != NULL) 603 { 604 memcpy(p_results, &gap_cb.cur_inqptr->results, sizeof(tBTM_INQ_RESULTS)); 605 606 ptr = (UINT8 *)gap_cb.cur_inqptr->results.remote_bd_addr; 607 GAP_TRACE_EVENT("GAP_GetFirstInqResult %02x%02x%02x%02x%02x%02x", 608 ptr[0],ptr[1],ptr[2],ptr[3],ptr[4],ptr[5]); 609 return(BT_PASS); 610 } 611 else 612 { 613 GAP_TRACE_EVENT("GAP_FirstInqResults: No BD_ADDRs Found"); 614 memset(p_results, 0, sizeof(tBTM_INQ_RESULTS)); 615 return(GAP_EOINQDB); 616 } 617 } 618 619 620 /******************************************************************************* 621 ** 622 ** Function GAP_GetNextInquiryResult 623 ** 624 ** Description This function retrieves the next valid inquiry result. 625 ** 626 ** Parameters: p_results - pointer to the inquiry results 627 ** 628 ** Returns BT_PASS (0) if successful, or a non-zero status code 629 ** GAP_EOINQDB if no more entries in the database. 630 ** 631 *******************************************************************************/ 632 UINT16 GAP_GetNextInquiryResult(tGAP_INQ_RESULTS *p_results) 633 { 634 UINT8 *ptr; 635 636 /*** if the current inquiry db pointer is NULL then call the first entry ***/ 637 if (gap_cb.cur_inqptr) 638 { 639 gap_cb.cur_inqptr = BTM_InqNextResult(gap_cb.cur_inqptr); 640 if (gap_cb.cur_inqptr != NULL) 641 { 642 memcpy(p_results, &gap_cb.cur_inqptr->results, 643 sizeof(tGAP_INQ_RESULTS)); 644 645 ptr = (UINT8 *)gap_cb.cur_inqptr->results.remote_bd_addr; 646 GAP_TRACE_EVENT("GAP_GetNextInqResult %02x%02x%02x%02x%02x%02x", 647 ptr[0],ptr[1],ptr[2],ptr[3],ptr[4],ptr[5]); 648 649 return(BT_PASS); 650 } 651 else 652 { 653 GAP_TRACE_EVENT("GAP_NextInqResults: No BD_ADDRs Found"); 654 memset(p_results, 0, sizeof(tBTM_INQ_RESULTS)); 655 return(GAP_EOINQDB); 656 } 657 } 658 else 659 return (GAP_GetFirstInquiryResult(p_results)); 660 } 661 662 663 /******************************************************************************* 664 ** 665 ** Function GAP_ReadLocalDeviceInfo 666 ** 667 ** Description This function retrieves local device information to the caller. 668 ** 669 ** Parameters: name - (output) pointer to the UTF-8 encoded string representing 670 ** the device name. 671 ** 672 ** addr - (output) pointer to the Bluetooth device address (BD_ADDR). 673 ** 674 ** verinfo - (output) pointer to the LMP version information. 675 ** 676 ** features - (output) pointer to the LMP features for the device. 677 ** 678 ** NOTE: Return parameters that are set to NULL are not retrieved. 679 ** 680 ** Returns BT_PASS (0) if successful, or a non-zero error code 681 ** 682 *******************************************************************************/ 683 684 UINT16 GAP_ReadLocalDeviceInfo(UINT8 *name, BD_ADDR *addr, tGAP_LMP_VERSION *verinfo, 685 tGAP_LMP_FEATURES *features) 686 { 687 UNUSED(name); 688 UNUSED(addr); 689 UNUSED(verinfo); 690 UNUSED(features); 691 return (GAP_UNSUPPORTED); 692 } 693 694 695 696 /******************************************************************************* 697 ** 698 ** Function GAP_GetRemoteDeviceName 699 ** 700 ** Description The remote name is retrieved from the specified remote device. If 701 ** GAP_CMD_INITIATED is returned by the function, the command was 702 ** successfully sent to the controller. The GAP_EVT_NAME_RESP event 703 ** is passed in the callback when the remote device name has been retrieved. 704 ** 705 ** Parameters: addr - The Bluetooth device address (BD_ADDR) of the remote 706 ** device. 707 ** 708 ** callback - pointer to the callback which is called after the 709 ** remote device has been retrieved. 710 ** p_data in the callback points to the structure containing the 711 ** status, device name length, and the UTF-8 encoded 712 ** device name. (type tBTM_REMOTE_DEV_NAME) 713 ** The event field in the callback is set to GAP_EVT_REM_NAME_COMPLETE. 714 ** The callback is not called unless (GAP_CMD_INITIATED) is returned. 715 ** 716 ** 717 ** Returns 718 ** GAP_CMD_INITIATED if remote search successfully initiated 719 ** GAP_ERR_BUSY if a remote name request is already in progress, 720 ** GAP_ERR_NO_CTRL_BLK if out of control blocks (too many commands pending) 721 ** GAP_BAD_BD_ADDR if the device address is bad, 722 ** GAP_DEVICE_NOT_UP if the device has not been initialized yet 723 ** GAP_ERR_PROCESSING if any other BTM error has been returned 724 ** 725 *******************************************************************************/ 726 UINT16 GAP_GetRemoteDeviceName (BD_ADDR addr, tGAP_CALLBACK *callback) 727 { 728 tGAP_INFO *p_cb; 729 UINT16 retval; 730 tBTM_STATUS btm_status; 731 732 if ((p_cb = gap_allocate_cb()) != NULL) 733 { 734 p_cb->gap_cback = callback; 735 p_cb->event = GAP_EVT_REM_NAME_COMPLETE; /* Return event expected */ 736 737 btm_status = BTM_ReadRemoteDeviceName (addr, gap_cb.btm_cback[p_cb->index], BT_TRANSPORT_BR_EDR); 738 739 /* If the name was not returned immediately, or if an error occurred, release the control block */ 740 if ((retval = gap_convert_btm_status (btm_status)) != GAP_CMD_INITIATED) 741 gap_free_cb (p_cb); 742 } 743 else 744 retval = GAP_ERR_NO_CTRL_BLK; 745 746 return (retval); 747 } 748 749 /******************************************************************************* 750 ** 751 ** Function GAP_SetDeviceClass 752 ** 753 ** Description This function updates the local Device Class. 754 ** 755 ** Parameters: 756 ** p_cod - Pointer to the device class to set to 757 ** 758 ** cmd - the fields of the device class to update. 759 ** GAP_SET_COD_MAJOR_MINOR, - overwrite major, minor class 760 ** GAP_SET_COD_SERVICE_CLASS - set the bits in the input 761 ** GAP_CLR_COD_SERVICE_CLASS - clear the bits in the input 762 ** GAP_SET_COD_ALL - overwrite major, minor, set the bits in service class 763 ** GAP_INIT_COD - overwrite major, minor, and service class 764 ** 765 ** Returns BT_PASS (0) if successful, 766 ** GAP_ERR_BUSY if a discovery is already in progress 767 ** GAP_ERR_ILL_PARM if an illegal parameter was detected 768 ** GAP_ERR_PROCESSING if any other BTM error has been returned 769 ** 770 *******************************************************************************/ 771 UINT16 GAP_SetDeviceClass(tGAP_COD *p_cod, UINT8 cmd) 772 { 773 tBTM_STATUS btm_status; 774 UINT8 *dev; 775 UINT16 service; 776 UINT8 minor, major; 777 DEV_CLASS dev_class; 778 779 dev = BTM_ReadDeviceClass(); 780 BTM_COD_SERVICE_CLASS( service, dev ); 781 BTM_COD_MINOR_CLASS(minor, dev ); 782 BTM_COD_MAJOR_CLASS(major, dev ); 783 784 switch(cmd) 785 { 786 case GAP_SET_COD_MAJOR_MINOR: 787 minor = p_cod->minor & BTM_COD_MINOR_CLASS_MASK; 788 major = p_cod->major & BTM_COD_MAJOR_CLASS_MASK; 789 break; 790 791 case GAP_SET_COD_SERVICE_CLASS: 792 /* clear out the bits that is not SERVICE_CLASS bits */ 793 p_cod->service &= BTM_COD_SERVICE_CLASS_MASK; 794 service = service | p_cod->service; 795 break; 796 797 case GAP_CLR_COD_SERVICE_CLASS: 798 p_cod->service &= BTM_COD_SERVICE_CLASS_MASK; 799 service = service & (~p_cod->service); 800 break; 801 802 case GAP_SET_COD_ALL: 803 minor = p_cod->minor & BTM_COD_MINOR_CLASS_MASK; 804 major = p_cod->major & BTM_COD_MAJOR_CLASS_MASK; 805 p_cod->service &= BTM_COD_SERVICE_CLASS_MASK; 806 service = service | p_cod->service; 807 break; 808 809 case GAP_INIT_COD: 810 minor = p_cod->minor & BTM_COD_MINOR_CLASS_MASK; 811 major = p_cod->major & BTM_COD_MAJOR_CLASS_MASK; 812 service = p_cod->service & BTM_COD_SERVICE_CLASS_MASK; 813 break; 814 815 default: 816 return GAP_ERR_ILL_PARM; 817 } 818 819 /* convert the fields into the device class type */ 820 FIELDS_TO_COD(dev_class, minor, major, service); 821 822 btm_status = BTM_SetDeviceClass(dev_class); 823 return (gap_convert_btm_status (btm_status)); 824 } 825 826 /******************************************************************************* 827 ** 828 ** Function GAP_ReadDeviceClass 829 ** 830 ** Description This function reads the local Device Class. 831 ** 832 ** Parameters: 833 ** 834 ** Returns PASS 835 ** 836 *******************************************************************************/ 837 UINT16 GAP_ReadDeviceClass(tGAP_COD *p_cod) 838 { 839 UINT8 *dev; 840 841 dev = BTM_ReadDeviceClass(); 842 843 BTM_COD_SERVICE_CLASS( p_cod->service, dev ); 844 BTM_COD_MINOR_CLASS( p_cod->minor, dev ); 845 BTM_COD_MAJOR_CLASS( p_cod->major, dev ); 846 847 return (BT_PASS); 848 } 849 850 /******************************************************************************* 851 ** 852 ** Function GAP_SetTraceLevel 853 ** 854 ** Description This function sets the trace level for GAP. If called with 855 ** a value of 0xFF, it simply returns the current trace level. 856 ** 857 ** Returns The new or current trace level 858 ** 859 *******************************************************************************/ 860 UINT8 GAP_SetTraceLevel (UINT8 new_level) 861 { 862 if (new_level != 0xFF) 863 gap_cb.trace_level = new_level; 864 865 return (gap_cb.trace_level); 866 } 867 868 /******************************************************************************* 869 ** 870 ** Function GAP_Init 871 ** 872 ** Description Initializes the control blocks used by GAP. 873 ** 874 ** This routine should not be called except once per 875 ** stack invocation. 876 ** 877 ** Returns Nothing 878 ** 879 *******************************************************************************/ 880 void GAP_Init(void) 881 { 882 memset (&gap_cb, 0, sizeof (tGAP_CB)); 883 884 /*** Initialize the callbacks for BTM; Needs to be one per GAP_MAX_BLOCKS ***/ 885 gap_cb.btm_cback[0] = gap_btm_cback0; 886 #if GAP_MAX_BLOCKS > 1 887 gap_cb.btm_cback[1] = gap_btm_cback1; 888 #endif 889 #if GAP_MAX_BLOCKS > 2 890 gap_cb.btm_cback[2] = gap_btm_cback2; 891 #endif 892 893 #if defined(GAP_INITIAL_TRACE_LEVEL) 894 gap_cb.trace_level = GAP_INITIAL_TRACE_LEVEL; 895 #else 896 gap_cb.trace_level = BT_TRACE_LEVEL_NONE; /* No traces */ 897 #endif 898 899 /* Initialize the connection control block if included in build */ 900 #if GAP_CONN_INCLUDED == TRUE 901 gap_conn_init(); 902 #endif /* GAP_CONN_INCLUDED */ 903 904 #if BLE_INCLUDED == TRUE 905 gap_attr_db_init(); 906 #endif 907 } 908 909
