Matthew Lister
X_NUCLEO_IDB0XA1
Embed:
(wiki syntax)
Show/hide line numbers
bluenrg_gap_aci.c
00001 /******************** (C) COPYRIGHT 2014 STMicroelectronics ******************** 00002 * File Name : bluenrg_hci.c 00003 * Author : AMS - HEA&RF BU 00004 * Version : V1.0.0 00005 * Date : 4-Oct-2013 00006 * Description : File with HCI commands for BlueNRG FW6.0 and above. 00007 ******************************************************************************** 00008 * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS 00009 * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME. 00010 * AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT, 00011 * INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE 00012 * CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING 00013 * INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS. 00014 *******************************************************************************/ 00015 00016 #include "ble_hal_types.h" 00017 #include "ble_osal.h" 00018 #include "ble_status.h" 00019 #include "ble_hal.h" 00020 #include "ble_osal.h" 00021 #include "ble_hci_const.h" 00022 #include "bluenrg_aci_const.h" 00023 #include "bluenrg_gap_aci.h" 00024 #include "bluenrg_gatt_server.h" 00025 #include "bluenrg_gap.h" 00026 00027 #define MIN(a,b) ((a) < (b) )? (a) : (b) 00028 #define MAX(a,b) ((a) > (b) )? (a) : (b) 00029 00030 tBleStatus aci_gap_init_IDB05A1(uint8_t role, uint8_t privacy_enabled, uint8_t device_name_char_len, uint16_t* service_handle, uint16_t* dev_name_char_handle, uint16_t* appearance_char_handle) 00031 { 00032 struct hci_request rq; 00033 gap_init_cp_IDB05A1 cp; 00034 gap_init_rp resp; 00035 00036 cp.role = role; 00037 cp.privacy_enabled = privacy_enabled; 00038 cp.device_name_char_len = device_name_char_len; 00039 00040 Osal_MemSet(&resp, 0, sizeof(resp)); 00041 00042 Osal_MemSet(&rq, 0, sizeof(rq)); 00043 rq.ogf = OGF_VENDOR_CMD; 00044 rq.ocf = OCF_GAP_INIT; 00045 rq.cparam = &cp; 00046 rq.clen = sizeof(cp); 00047 rq.rparam = &resp; 00048 rq.rlen = GAP_INIT_RP_SIZE; 00049 00050 if (hci_send_req(&rq, FALSE) < 0) 00051 return BLE_STATUS_TIMEOUT; 00052 00053 if (resp.status) { 00054 return resp.status; 00055 } 00056 00057 *service_handle = btohs(resp.service_handle); 00058 *dev_name_char_handle = btohs(resp.dev_name_char_handle); 00059 *appearance_char_handle = btohs(resp.appearance_char_handle); 00060 00061 return 0; 00062 } 00063 tBleStatus aci_gap_init_IDB04A1(uint8_t role, uint16_t* service_handle, uint16_t* dev_name_char_handle, uint16_t* appearance_char_handle) 00064 { 00065 struct hci_request rq; 00066 gap_init_cp_IDB04A1 cp; 00067 gap_init_rp resp; 00068 00069 cp.role = role; 00070 00071 Osal_MemSet(&resp, 0, sizeof(resp)); 00072 00073 Osal_MemSet(&rq, 0, sizeof(rq)); 00074 rq.ogf = OGF_VENDOR_CMD; 00075 rq.ocf = OCF_GAP_INIT; 00076 rq.cparam = &cp; 00077 rq.clen = sizeof(cp); 00078 rq.rparam = &resp; 00079 rq.rlen = GAP_INIT_RP_SIZE; 00080 00081 if (hci_send_req(&rq, FALSE) < 0) 00082 return BLE_STATUS_TIMEOUT; 00083 00084 if (resp.status) { 00085 return resp.status; 00086 } 00087 00088 *service_handle = btohs(resp.service_handle); 00089 *dev_name_char_handle = btohs(resp.dev_name_char_handle); 00090 *appearance_char_handle = btohs(resp.appearance_char_handle); 00091 00092 return 0; 00093 } 00094 00095 tBleStatus aci_gap_set_non_discoverable(void) 00096 { 00097 struct hci_request rq; 00098 uint8_t status; 00099 00100 Osal_MemSet(&rq, 0, sizeof(rq)); 00101 rq.ogf = OGF_VENDOR_CMD; 00102 rq.ocf = OCF_GAP_SET_NON_DISCOVERABLE; 00103 rq.rparam = &status; 00104 rq.rlen = 1; 00105 00106 if (hci_send_req(&rq, FALSE) < 0) 00107 return BLE_STATUS_TIMEOUT; 00108 00109 return status; 00110 } 00111 00112 tBleStatus aci_gap_set_limited_discoverable(uint8_t AdvType, uint16_t AdvIntervMin, uint16_t AdvIntervMax, 00113 uint8_t OwnAddrType, uint8_t AdvFilterPolicy, uint8_t LocalNameLen, 00114 const char *LocalName, uint8_t ServiceUUIDLen, uint8_t* ServiceUUIDList, 00115 uint16_t SlaveConnIntervMin, uint16_t SlaveConnIntervMax) 00116 { 00117 struct hci_request rq; 00118 uint8_t status; 00119 uint8_t buffer[40]; 00120 uint8_t indx = 0; 00121 00122 if((unsigned int)(LocalNameLen+ServiceUUIDLen+14) > sizeof(buffer)) 00123 return BLE_STATUS_INVALID_PARAMS; 00124 00125 buffer[indx] = AdvType; 00126 indx++; 00127 00128 AdvIntervMin = htobs(AdvIntervMin); 00129 Osal_MemCpy(buffer + indx, &AdvIntervMin, 2); 00130 indx += 2; 00131 00132 AdvIntervMax = htobs(AdvIntervMax); 00133 Osal_MemCpy(buffer + indx, &AdvIntervMax, 2); 00134 indx += 2; 00135 00136 buffer[indx] = OwnAddrType; 00137 indx++; 00138 00139 buffer[indx] = AdvFilterPolicy; 00140 indx++; 00141 00142 buffer[indx] = LocalNameLen; 00143 indx++; 00144 00145 Osal_MemCpy(buffer + indx, LocalName, LocalNameLen); 00146 indx += LocalNameLen; 00147 00148 buffer[indx] = ServiceUUIDLen; 00149 indx++; 00150 00151 Osal_MemCpy(buffer + indx, ServiceUUIDList, ServiceUUIDLen); 00152 indx += ServiceUUIDLen; 00153 00154 Osal_MemCpy(buffer + indx, &SlaveConnIntervMin, 2); 00155 indx += 2; 00156 00157 Osal_MemCpy(buffer + indx, &SlaveConnIntervMax, 2); 00158 indx += 2; 00159 00160 Osal_MemSet(&rq, 0, sizeof(rq)); 00161 rq.ogf = OGF_VENDOR_CMD; 00162 rq.ocf = OCF_GAP_SET_LIMITED_DISCOVERABLE; 00163 rq.cparam = (void *)buffer; 00164 rq.clen = indx; 00165 rq.event = EVT_CMD_STATUS; 00166 rq.rparam = &status; 00167 rq.rlen = 1; 00168 00169 if (hci_send_req(&rq, FALSE) < 0) 00170 return BLE_STATUS_TIMEOUT; 00171 00172 return status; 00173 } 00174 00175 tBleStatus aci_gap_set_discoverable(uint8_t AdvType, uint16_t AdvIntervMin, uint16_t AdvIntervMax, 00176 uint8_t OwnAddrType, uint8_t AdvFilterPolicy, uint8_t LocalNameLen, 00177 const char *LocalName, uint8_t ServiceUUIDLen, uint8_t* ServiceUUIDList, 00178 uint16_t SlaveConnIntervMin, uint16_t SlaveConnIntervMax) 00179 { 00180 struct hci_request rq; 00181 uint8_t status; 00182 uint8_t buffer[40]; 00183 uint8_t indx = 0; 00184 00185 if ((unsigned int)(LocalNameLen+ServiceUUIDLen+14) > sizeof(buffer)) 00186 return BLE_STATUS_INVALID_PARAMS; 00187 00188 buffer[indx] = AdvType; 00189 indx++; 00190 00191 AdvIntervMin = htobs(AdvIntervMin); 00192 Osal_MemCpy(buffer + indx, &AdvIntervMin, 2); 00193 indx += 2; 00194 00195 AdvIntervMax = htobs(AdvIntervMax); 00196 Osal_MemCpy(buffer + indx, &AdvIntervMax, 2); 00197 indx += 2; 00198 00199 buffer[indx] = OwnAddrType; 00200 indx++; 00201 00202 buffer[indx] = AdvFilterPolicy; 00203 indx++; 00204 00205 buffer[indx] = LocalNameLen; 00206 indx++; 00207 00208 Osal_MemCpy(buffer + indx, LocalName, LocalNameLen); 00209 indx += LocalNameLen; 00210 00211 buffer[indx] = ServiceUUIDLen; 00212 indx++; 00213 00214 Osal_MemCpy(buffer + indx, ServiceUUIDList, ServiceUUIDLen); 00215 indx += ServiceUUIDLen; 00216 00217 SlaveConnIntervMin = htobs(SlaveConnIntervMin); 00218 Osal_MemCpy(buffer + indx, &SlaveConnIntervMin, 2); 00219 indx += 2; 00220 00221 SlaveConnIntervMax = htobs(SlaveConnIntervMax); 00222 Osal_MemCpy(buffer + indx, &SlaveConnIntervMax, 2); 00223 indx += 2; 00224 00225 Osal_MemSet(&rq, 0, sizeof(rq)); 00226 rq.ogf = OGF_VENDOR_CMD; 00227 rq.ocf = OCF_GAP_SET_DISCOVERABLE; 00228 rq.cparam = (void *)buffer; 00229 rq.clen = indx; 00230 rq.rparam = &status; 00231 rq.rlen = 1; 00232 00233 if (hci_send_req(&rq, FALSE) < 0) 00234 return BLE_STATUS_TIMEOUT; 00235 00236 if (status) { 00237 return status; 00238 } 00239 00240 return 0; 00241 } 00242 00243 tBleStatus aci_gap_set_direct_connectable_IDB05A1(uint8_t own_addr_type, uint8_t directed_adv_type, uint8_t initiator_addr_type, const uint8_t *initiator_addr) 00244 { 00245 struct hci_request rq; 00246 gap_set_direct_conectable_cp_IDB05A1 cp; 00247 uint8_t status; 00248 00249 cp.own_bdaddr_type = own_addr_type; 00250 cp.directed_adv_type = directed_adv_type; 00251 cp.direct_bdaddr_type = initiator_addr_type; 00252 Osal_MemCpy(cp.direct_bdaddr, initiator_addr, 6); 00253 00254 Osal_MemSet(&rq, 0, sizeof(rq)); 00255 rq.ogf = OGF_VENDOR_CMD; 00256 rq.ocf = OCF_GAP_SET_DIRECT_CONNECTABLE; 00257 rq.cparam = &cp; 00258 rq.clen = sizeof(cp); 00259 rq.rparam = &status; 00260 rq.rlen = 1; 00261 00262 if (hci_send_req(&rq, FALSE) < 0) 00263 return BLE_STATUS_TIMEOUT; 00264 00265 return status; 00266 } 00267 00268 tBleStatus aci_gap_set_direct_connectable_IDB04A1(uint8_t own_addr_type, uint8_t initiator_addr_type, const uint8_t *initiator_addr) 00269 { 00270 struct hci_request rq; 00271 gap_set_direct_conectable_cp_IDB04A1 cp; 00272 uint8_t status; 00273 00274 cp.own_bdaddr_type = own_addr_type; 00275 cp.direct_bdaddr_type = initiator_addr_type; 00276 Osal_MemCpy(cp.direct_bdaddr, initiator_addr, 6); 00277 00278 Osal_MemSet(&rq, 0, sizeof(rq)); 00279 rq.ogf = OGF_VENDOR_CMD; 00280 rq.ocf = OCF_GAP_SET_DIRECT_CONNECTABLE; 00281 rq.cparam = &cp; 00282 rq.clen = sizeof(cp); 00283 rq.rparam = &status; 00284 rq.rlen = 1; 00285 00286 if (hci_send_req(&rq, FALSE) < 0) 00287 return BLE_STATUS_TIMEOUT; 00288 00289 return status; 00290 } 00291 00292 tBleStatus aci_gap_set_io_capability(uint8_t io_capability) 00293 { 00294 struct hci_request rq; 00295 uint8_t status; 00296 gap_set_io_capability_cp cp; 00297 00298 cp.io_capability = io_capability; 00299 00300 Osal_MemSet(&rq, 0, sizeof(rq)); 00301 rq.ogf = OGF_VENDOR_CMD; 00302 rq.ocf = OCF_GAP_SET_IO_CAPABILITY; 00303 rq.cparam = &cp; 00304 rq.clen = sizeof(cp); 00305 rq.rparam = &status; 00306 rq.rlen = 1; 00307 00308 if (hci_send_req(&rq, FALSE) < 0) 00309 return BLE_STATUS_TIMEOUT; 00310 00311 return status; 00312 } 00313 00314 tBleStatus aci_gap_set_auth_requirement(uint8_t mitm_mode, 00315 uint8_t oob_enable, 00316 uint8_t oob_data[16], 00317 uint8_t min_encryption_key_size, 00318 uint8_t max_encryption_key_size, 00319 uint8_t use_fixed_pin, 00320 uint32_t fixed_pin, 00321 uint8_t bonding_mode) 00322 { 00323 struct hci_request rq; 00324 gap_set_auth_requirement_cp cp; 00325 uint8_t status; 00326 00327 cp.mitm_mode = mitm_mode; 00328 cp.oob_enable = oob_enable; 00329 Osal_MemCpy(cp.oob_data, oob_data, 16); 00330 cp.min_encryption_key_size = min_encryption_key_size; 00331 cp.max_encryption_key_size = max_encryption_key_size; 00332 cp.use_fixed_pin = use_fixed_pin; 00333 cp.fixed_pin = htobl(fixed_pin); 00334 cp.bonding_mode = bonding_mode; 00335 00336 Osal_MemSet(&rq, 0, sizeof(rq)); 00337 rq.ogf = OGF_VENDOR_CMD; 00338 rq.ocf = OCF_GAP_SET_AUTH_REQUIREMENT; 00339 rq.cparam = &cp; 00340 rq.clen = sizeof(cp); 00341 rq.rparam = &status; 00342 rq.rlen = 1; 00343 00344 if (hci_send_req(&rq, FALSE) < 0) 00345 return BLE_STATUS_TIMEOUT; 00346 00347 if (status) { 00348 return status; 00349 } 00350 00351 return 0; 00352 } 00353 00354 tBleStatus aci_gap_set_author_requirement(uint16_t conn_handle, uint8_t authorization_enable) 00355 { 00356 struct hci_request rq; 00357 gap_set_author_requirement_cp cp; 00358 uint8_t status; 00359 00360 cp.conn_handle = htobs(conn_handle); 00361 cp.authorization_enable = authorization_enable; 00362 00363 Osal_MemSet(&rq, 0, sizeof(rq)); 00364 rq.ogf = OGF_VENDOR_CMD; 00365 rq.ocf = OCF_GAP_SET_AUTHOR_REQUIREMENT; 00366 rq.cparam = &cp; 00367 rq.clen = sizeof(cp); 00368 rq.rparam = &status; 00369 rq.rlen = 1; 00370 00371 if (hci_send_req(&rq, FALSE) < 0) 00372 return BLE_STATUS_TIMEOUT; 00373 00374 return status; 00375 } 00376 00377 tBleStatus aci_gap_pass_key_response(uint16_t conn_handle, uint32_t passkey) 00378 { 00379 struct hci_request rq; 00380 gap_passkey_response_cp cp; 00381 uint8_t status; 00382 00383 cp.conn_handle = htobs(conn_handle); 00384 cp.passkey = htobl(passkey); 00385 00386 Osal_MemSet(&rq, 0, sizeof(rq)); 00387 rq.ogf = OGF_VENDOR_CMD; 00388 rq.ocf = OCF_GAP_PASSKEY_RESPONSE; 00389 rq.cparam = &cp; 00390 rq.clen = sizeof(cp); 00391 rq.event = EVT_CMD_STATUS; 00392 rq.rparam = &status; 00393 rq.rlen = 1; 00394 00395 if (hci_send_req(&rq, FALSE) < 0) 00396 return BLE_STATUS_TIMEOUT; 00397 00398 return status; 00399 } 00400 00401 tBleStatus aci_gap_authorization_response(uint16_t conn_handle, uint8_t authorize) 00402 { 00403 struct hci_request rq; 00404 gap_authorization_response_cp cp; 00405 uint8_t status; 00406 00407 cp.conn_handle = htobs(conn_handle); 00408 cp.authorize = authorize; 00409 00410 Osal_MemSet(&rq, 0, sizeof(rq)); 00411 rq.ogf = OGF_VENDOR_CMD; 00412 rq.ocf = OCF_GAP_AUTHORIZATION_RESPONSE; 00413 rq.cparam = &cp; 00414 rq.clen = sizeof(cp); 00415 rq.rparam = &status; 00416 rq.rlen = 1; 00417 00418 if (hci_send_req(&rq, FALSE) < 0) 00419 return BLE_STATUS_TIMEOUT; 00420 00421 return status; 00422 } 00423 00424 tBleStatus aci_gap_set_non_connectable_IDB05A1(uint8_t adv_type, uint8_t own_address_type) 00425 { 00426 struct hci_request rq; 00427 gap_set_non_connectable_cp_IDB05A1 cp; 00428 uint8_t status; 00429 00430 cp.advertising_event_type = adv_type; 00431 cp.own_address_type = own_address_type; 00432 Osal_MemSet(&rq, 0, sizeof(rq)); 00433 rq.ogf = OGF_VENDOR_CMD; 00434 rq.ocf = OCF_GAP_SET_NON_CONNECTABLE; 00435 rq.cparam = &cp; 00436 rq.clen = sizeof(cp); 00437 rq.rparam = &status; 00438 rq.rlen = 1; 00439 00440 if (hci_send_req(&rq, FALSE) < 0) 00441 return BLE_STATUS_TIMEOUT; 00442 00443 return status; 00444 } 00445 00446 tBleStatus aci_gap_set_non_connectable_IDB04A1(uint8_t adv_type) 00447 { 00448 struct hci_request rq; 00449 gap_set_non_connectable_cp_IDB04A1 cp; 00450 uint8_t status; 00451 00452 cp.advertising_event_type = adv_type; 00453 00454 Osal_MemSet(&rq, 0, sizeof(rq)); 00455 rq.ogf = OGF_VENDOR_CMD; 00456 rq.ocf = OCF_GAP_SET_NON_CONNECTABLE; 00457 rq.cparam = &cp; 00458 rq.clen = sizeof(cp); 00459 rq.rparam = &status; 00460 rq.rlen = 1; 00461 00462 if (hci_send_req(&rq, FALSE) < 0) 00463 return BLE_STATUS_TIMEOUT; 00464 00465 return status; 00466 } 00467 00468 tBleStatus aci_gap_set_undirected_connectable(uint8_t own_addr_type, uint8_t adv_filter_policy) 00469 { 00470 struct hci_request rq; 00471 gap_set_undirected_connectable_cp cp; 00472 uint8_t status; 00473 00474 cp.own_addr_type = own_addr_type; 00475 cp.adv_filter_policy = adv_filter_policy; 00476 00477 Osal_MemSet(&rq, 0, sizeof(rq)); 00478 rq.ogf = OGF_VENDOR_CMD; 00479 rq.ocf = OCF_GAP_SET_UNDIRECTED_CONNECTABLE; 00480 rq.cparam = &cp; 00481 rq.clen = sizeof(cp); 00482 rq.rparam = &status; 00483 rq.rlen = 1; 00484 00485 if (hci_send_req(&rq, FALSE) < 0) 00486 return BLE_STATUS_TIMEOUT; 00487 00488 return status; 00489 } 00490 00491 tBleStatus aci_gap_slave_security_request(uint16_t conn_handle, uint8_t bonding, uint8_t mitm_protection) 00492 { 00493 struct hci_request rq; 00494 gap_slave_security_request_cp cp; 00495 uint8_t status; 00496 00497 cp.conn_handle = htobs(conn_handle); 00498 cp.bonding = bonding; 00499 cp.mitm_protection = mitm_protection; 00500 00501 Osal_MemSet(&rq, 0, sizeof(rq)); 00502 rq.ogf = OGF_VENDOR_CMD; 00503 rq.ocf = OCF_GAP_SLAVE_SECURITY_REQUEST; 00504 rq.cparam = &cp; 00505 rq.clen = sizeof(cp); 00506 rq.event = EVT_CMD_STATUS; 00507 rq.rparam = &status; 00508 rq.rlen = 1; 00509 00510 if (hci_send_req(&rq, FALSE) < 0) 00511 return BLE_STATUS_TIMEOUT; 00512 00513 return status; 00514 00515 } 00516 00517 tBleStatus aci_gap_update_adv_data(uint8_t AdvLen, const uint8_t *AdvData) 00518 { 00519 struct hci_request rq; 00520 uint8_t status; 00521 uint8_t buffer[32]; 00522 uint8_t indx = 0; 00523 00524 if (AdvLen > (sizeof(buffer)-1)) 00525 return BLE_STATUS_INVALID_PARAMS; 00526 00527 buffer[indx] = AdvLen; 00528 indx++; 00529 00530 Osal_MemCpy(buffer + indx, AdvData, AdvLen); 00531 indx += AdvLen; 00532 00533 Osal_MemSet(&rq, 0, sizeof(rq)); 00534 rq.ogf = OGF_VENDOR_CMD; 00535 rq.ocf = OCF_GAP_UPDATE_ADV_DATA; 00536 rq.cparam = (void *)buffer; 00537 rq.clen = indx; 00538 rq.rparam = &status; 00539 rq.rlen = 1; 00540 00541 if (hci_send_req(&rq, FALSE) < 0) 00542 return BLE_STATUS_TIMEOUT; 00543 00544 return status; 00545 } 00546 00547 tBleStatus aci_gap_delete_ad_type(uint8_t ad_type) 00548 { 00549 struct hci_request rq; 00550 gap_delete_ad_type_cp cp; 00551 uint8_t status; 00552 00553 cp.ad_type = ad_type; 00554 00555 Osal_MemSet(&rq, 0, sizeof(rq)); 00556 rq.ogf = OGF_VENDOR_CMD; 00557 rq.ocf = OCF_GAP_DELETE_AD_TYPE; 00558 rq.cparam = &cp; 00559 rq.clen = sizeof(cp); 00560 rq.rparam = &status; 00561 rq.rlen = 1; 00562 00563 if (hci_send_req(&rq, FALSE) < 0) 00564 return BLE_STATUS_TIMEOUT; 00565 00566 return status; 00567 } 00568 00569 tBleStatus aci_gap_get_security_level(uint8_t* mitm_protection, uint8_t* bonding, 00570 uint8_t* oob_data, uint8_t* passkey_required) 00571 { 00572 struct hci_request rq; 00573 gap_get_security_level_rp resp; 00574 00575 Osal_MemSet(&resp, 0, sizeof(resp)); 00576 00577 Osal_MemSet(&rq, 0, sizeof(rq)); 00578 rq.ogf = OGF_VENDOR_CMD; 00579 rq.ocf = OCF_GAP_GET_SECURITY_LEVEL; 00580 rq.rparam = &resp; 00581 rq.rlen = GAP_GET_SECURITY_LEVEL_RP_SIZE; 00582 00583 if (hci_send_req(&rq, FALSE) < 0) 00584 return BLE_STATUS_TIMEOUT; 00585 00586 if (resp.status) { 00587 return resp.status; 00588 } 00589 00590 *mitm_protection = resp.mitm_protection; 00591 *bonding = resp.bonding; 00592 *oob_data = resp.oob_data; 00593 *passkey_required = resp.passkey_required; 00594 00595 return resp.status; 00596 } 00597 00598 tBleStatus aci_gap_configure_whitelist(void) 00599 { 00600 struct hci_request rq; 00601 uint8_t status; 00602 00603 Osal_MemSet(&rq, 0, sizeof(rq)); 00604 rq.ogf = OGF_VENDOR_CMD; 00605 rq.ocf = OCF_GAP_CONFIGURE_WHITELIST; 00606 rq.rparam = &status; 00607 rq.rlen = 1; 00608 00609 if (hci_send_req(&rq, FALSE) < 0) 00610 return BLE_STATUS_TIMEOUT; 00611 00612 return status; 00613 } 00614 00615 tBleStatus aci_gap_terminate(uint16_t conn_handle, uint8_t reason) 00616 { 00617 struct hci_request rq; 00618 gap_terminate_cp cp; 00619 uint8_t status; 00620 00621 cp.handle = htobs(conn_handle); 00622 cp.reason = reason; 00623 00624 Osal_MemSet(&rq, 0, sizeof(rq)); 00625 rq.ogf = OGF_VENDOR_CMD; 00626 rq.ocf = OCF_GAP_TERMINATE; 00627 rq.cparam = &cp; 00628 rq.clen = sizeof(cp); 00629 rq.event = EVT_CMD_STATUS; 00630 rq.rparam = &status; 00631 rq.rlen = 1; 00632 00633 if (hci_send_req(&rq, FALSE) < 0) 00634 return BLE_STATUS_TIMEOUT; 00635 00636 return status; 00637 } 00638 00639 tBleStatus aci_gap_clear_security_database(void) 00640 { 00641 struct hci_request rq; 00642 uint8_t status; 00643 00644 Osal_MemSet(&rq, 0, sizeof(rq)); 00645 rq.ogf = OGF_VENDOR_CMD; 00646 rq.ocf = OCF_GAP_CLEAR_SECURITY_DB; 00647 rq.rparam = &status; 00648 rq.rlen = 1; 00649 00650 if (hci_send_req(&rq, FALSE) < 0) 00651 return BLE_STATUS_TIMEOUT; 00652 00653 return status; 00654 } 00655 00656 tBleStatus aci_gap_allow_rebond_IDB05A1(uint16_t conn_handle) 00657 { 00658 struct hci_request rq; 00659 gap_allow_rebond_cp_IDB05A1 cp; 00660 uint8_t status; 00661 00662 cp.conn_handle = conn_handle; 00663 00664 Osal_MemSet(&rq, 0, sizeof(rq)); 00665 rq.ogf = OGF_VENDOR_CMD; 00666 rq.ocf = OCF_GAP_ALLOW_REBOND_DB; 00667 rq.cparam = &cp; 00668 rq.clen = sizeof(cp); 00669 rq.rparam = &status; 00670 rq.rlen = 1; 00671 00672 if (hci_send_req(&rq, FALSE) < 0) 00673 return BLE_STATUS_TIMEOUT; 00674 00675 return status; 00676 } 00677 tBleStatus aci_gap_allow_rebond_IDB04A1(void) 00678 { 00679 struct hci_request rq; 00680 uint8_t status; 00681 00682 Osal_MemSet(&rq, 0, sizeof(rq)); 00683 rq.ogf = OGF_VENDOR_CMD; 00684 rq.ocf = OCF_GAP_ALLOW_REBOND_DB; 00685 rq.rparam = &status; 00686 rq.rlen = 1; 00687 00688 if (hci_send_req(&rq, FALSE) < 0) 00689 return BLE_STATUS_TIMEOUT; 00690 00691 return status; 00692 } 00693 00694 tBleStatus aci_gap_start_limited_discovery_proc(uint16_t scanInterval, uint16_t scanWindow, 00695 uint8_t own_address_type, uint8_t filterDuplicates) 00696 { 00697 struct hci_request rq; 00698 gap_start_limited_discovery_proc_cp cp; 00699 uint8_t status; 00700 00701 cp.scanInterval = htobs(scanInterval); 00702 cp.scanWindow = htobs(scanWindow); 00703 cp.own_address_type = own_address_type; 00704 cp.filterDuplicates = filterDuplicates; 00705 00706 Osal_MemSet(&rq, 0, sizeof(rq)); 00707 rq.ogf = OGF_VENDOR_CMD; 00708 rq.ocf = OCF_GAP_START_LIMITED_DISCOVERY_PROC; 00709 rq.cparam = &cp; 00710 rq.clen = sizeof(cp); 00711 rq.event = EVT_CMD_STATUS; 00712 rq.rparam = &status; 00713 rq.rlen = 1; 00714 00715 if (hci_send_req(&rq, FALSE) < 0) 00716 return BLE_STATUS_TIMEOUT; 00717 00718 return status; 00719 } 00720 00721 tBleStatus aci_gap_start_general_discovery_proc(uint16_t scanInterval, uint16_t scanWindow, 00722 uint8_t own_address_type, uint8_t filterDuplicates) 00723 { 00724 struct hci_request rq; 00725 gap_start_general_discovery_proc_cp cp; 00726 uint8_t status; 00727 00728 cp.scanInterval = htobs(scanInterval); 00729 cp.scanWindow = htobs(scanWindow); 00730 cp.own_address_type = own_address_type; 00731 cp.filterDuplicates = filterDuplicates; 00732 00733 Osal_MemSet(&rq, 0, sizeof(rq)); 00734 rq.ogf = OGF_VENDOR_CMD; 00735 rq.ocf = OCF_GAP_START_GENERAL_DISCOVERY_PROC; 00736 rq.cparam = &cp; 00737 rq.clen = sizeof(cp); 00738 rq.event = EVT_CMD_STATUS; 00739 rq.rparam = &status; 00740 rq.rlen = 1; 00741 00742 if (hci_send_req(&rq, FALSE) < 0) 00743 return BLE_STATUS_TIMEOUT; 00744 00745 return status; 00746 } 00747 00748 00749 tBleStatus aci_gap_start_name_discovery_proc(uint16_t scanInterval, uint16_t scanWindow, 00750 uint8_t peer_bdaddr_type, tBDAddr peer_bdaddr, 00751 uint8_t own_bdaddr_type, uint16_t conn_min_interval, 00752 uint16_t conn_max_interval, uint16_t conn_latency, 00753 uint16_t supervision_timeout, uint16_t min_conn_length, 00754 uint16_t max_conn_length) 00755 { 00756 struct hci_request rq; 00757 gap_start_name_discovery_proc_cp cp; 00758 uint8_t status; 00759 00760 cp.scanInterval = htobs(scanInterval); 00761 cp.scanWindow = htobs(scanWindow); 00762 cp.peer_bdaddr_type = peer_bdaddr_type; 00763 Osal_MemCpy(cp.peer_bdaddr, peer_bdaddr, 6); 00764 cp.own_bdaddr_type = own_bdaddr_type; 00765 cp.conn_min_interval = htobs(conn_min_interval); 00766 cp.conn_max_interval = htobs(conn_max_interval); 00767 cp.conn_latency = htobs(conn_latency); 00768 cp.supervision_timeout = htobs(supervision_timeout); 00769 cp.min_conn_length = htobs(min_conn_length); 00770 cp.max_conn_length = htobs(max_conn_length); 00771 00772 Osal_MemSet(&rq, 0, sizeof(rq)); 00773 rq.ogf = OGF_VENDOR_CMD; 00774 rq.ocf = OCF_GAP_START_NAME_DISCOVERY_PROC; 00775 rq.cparam = &cp; 00776 rq.clen = sizeof(cp); 00777 rq.event = EVT_CMD_STATUS; 00778 rq.rparam = &status; 00779 rq.rlen = 1; 00780 00781 if (hci_send_req(&rq, FALSE) < 0) 00782 return BLE_STATUS_TIMEOUT; 00783 00784 return status; 00785 } 00786 00787 tBleStatus aci_gap_start_auto_conn_establish_proc_IDB05A1(uint16_t scanInterval, uint16_t scanWindow, 00788 uint8_t own_bdaddr_type, uint16_t conn_min_interval, 00789 uint16_t conn_max_interval, uint16_t conn_latency, 00790 uint16_t supervision_timeout, uint16_t min_conn_length, 00791 uint16_t max_conn_length, 00792 uint8_t num_whitelist_entries, 00793 const uint8_t *addr_array) 00794 { 00795 struct hci_request rq; 00796 uint8_t status; 00797 uint8_t buffer[HCI_MAX_PAYLOAD_SIZE]; 00798 uint8_t indx = 0; 00799 00800 if (((num_whitelist_entries*7)+25) > HCI_MAX_PAYLOAD_SIZE) 00801 return BLE_STATUS_INVALID_PARAMS; 00802 00803 scanInterval = htobs(scanInterval); 00804 Osal_MemCpy(buffer + indx, &scanInterval, 2); 00805 indx += 2; 00806 00807 scanWindow = htobs(scanWindow); 00808 Osal_MemCpy(buffer + indx, &scanWindow, 2); 00809 indx += 2; 00810 00811 buffer[indx] = own_bdaddr_type; 00812 indx++; 00813 00814 conn_min_interval = htobs(conn_min_interval); 00815 Osal_MemCpy(buffer + indx, &conn_min_interval, 2); 00816 indx += 2; 00817 00818 conn_max_interval = htobs(conn_max_interval); 00819 Osal_MemCpy(buffer + indx, &conn_max_interval, 2); 00820 indx += 2; 00821 00822 conn_latency = htobs(conn_latency); 00823 Osal_MemCpy(buffer + indx, &conn_latency, 2); 00824 indx += 2; 00825 00826 supervision_timeout = htobs(supervision_timeout); 00827 Osal_MemCpy(buffer + indx, &supervision_timeout, 2); 00828 indx += 2; 00829 00830 min_conn_length = htobs(min_conn_length); 00831 Osal_MemCpy(buffer + indx, &min_conn_length, 2); 00832 indx += 2; 00833 00834 max_conn_length = htobs(max_conn_length); 00835 Osal_MemCpy(buffer + indx, &max_conn_length, 2); 00836 indx += 2; 00837 00838 buffer[indx] = num_whitelist_entries; 00839 indx++; 00840 00841 Osal_MemCpy(buffer + indx, addr_array, (num_whitelist_entries*7)); 00842 indx += num_whitelist_entries * 7; 00843 00844 Osal_MemSet(&rq, 0, sizeof(rq)); 00845 rq.ogf = OGF_VENDOR_CMD; 00846 rq.ocf = OCF_GAP_START_AUTO_CONN_ESTABLISH_PROC; 00847 rq.cparam = (void *)buffer; 00848 rq.clen = indx; 00849 rq.event = EVT_CMD_STATUS; 00850 rq.rparam = &status; 00851 rq.rlen = 1; 00852 00853 if (hci_send_req(&rq, FALSE) < 0) 00854 return BLE_STATUS_TIMEOUT; 00855 00856 return status; 00857 } 00858 00859 tBleStatus aci_gap_start_auto_conn_establish_proc_IDB04A1(uint16_t scanInterval, uint16_t scanWindow, 00860 uint8_t own_bdaddr_type, uint16_t conn_min_interval, 00861 uint16_t conn_max_interval, uint16_t conn_latency, 00862 uint16_t supervision_timeout, uint16_t min_conn_length, 00863 uint16_t max_conn_length, 00864 uint8_t use_reconn_addr, 00865 const tBDAddr reconn_addr, 00866 uint8_t num_whitelist_entries, 00867 const uint8_t *addr_array) 00868 { 00869 struct hci_request rq; 00870 uint8_t status; 00871 uint8_t buffer[HCI_MAX_PAYLOAD_SIZE]; 00872 uint8_t indx = 0; 00873 00874 if (((num_whitelist_entries*7)+25) > HCI_MAX_PAYLOAD_SIZE) 00875 return BLE_STATUS_INVALID_PARAMS; 00876 00877 scanInterval = htobs(scanInterval); 00878 Osal_MemCpy(buffer + indx, &scanInterval, 2); 00879 indx += 2; 00880 00881 scanWindow = htobs(scanWindow); 00882 Osal_MemCpy(buffer + indx, &scanWindow, 2); 00883 indx += 2; 00884 00885 buffer[indx] = own_bdaddr_type; 00886 indx++; 00887 00888 conn_min_interval = htobs(conn_min_interval); 00889 Osal_MemCpy(buffer + indx, &conn_min_interval, 2); 00890 indx += 2; 00891 00892 conn_max_interval = htobs(conn_max_interval); 00893 Osal_MemCpy(buffer + indx, &conn_max_interval, 2); 00894 indx += 2; 00895 00896 conn_latency = htobs(conn_latency); 00897 Osal_MemCpy(buffer + indx, &conn_latency, 2); 00898 indx += 2; 00899 00900 supervision_timeout = htobs(supervision_timeout); 00901 Osal_MemCpy(buffer + indx, &supervision_timeout, 2); 00902 indx += 2; 00903 00904 min_conn_length = htobs(min_conn_length); 00905 Osal_MemCpy(buffer + indx, &min_conn_length, 2); 00906 indx += 2; 00907 00908 max_conn_length = htobs(max_conn_length); 00909 Osal_MemCpy(buffer + indx, &max_conn_length, 2); 00910 indx += 2; 00911 00912 buffer[indx] = use_reconn_addr; 00913 indx++; 00914 00915 Osal_MemCpy(buffer + indx, reconn_addr, 6); 00916 indx += 6; 00917 00918 buffer[indx] = num_whitelist_entries; 00919 indx++; 00920 00921 Osal_MemCpy(buffer + indx, addr_array, (num_whitelist_entries*7)); 00922 indx += num_whitelist_entries * 7; 00923 00924 Osal_MemSet(&rq, 0, sizeof(rq)); 00925 rq.ogf = OGF_VENDOR_CMD; 00926 rq.ocf = OCF_GAP_START_AUTO_CONN_ESTABLISH_PROC; 00927 rq.cparam = (void *)buffer; 00928 rq.clen = indx; 00929 rq.event = EVT_CMD_STATUS; 00930 rq.rparam = &status; 00931 rq.rlen = 1; 00932 00933 if (hci_send_req(&rq, FALSE) < 0) 00934 return BLE_STATUS_TIMEOUT; 00935 00936 return status; 00937 } 00938 00939 tBleStatus aci_gap_start_general_conn_establish_proc_IDB05A1(uint8_t scan_type, uint16_t scan_interval, uint16_t scan_window, 00940 uint8_t own_address_type, uint8_t filter_duplicates) 00941 { 00942 struct hci_request rq; 00943 gap_start_general_conn_establish_proc_cp_IDB05A1 cp; 00944 uint8_t status; 00945 00946 cp.scan_type = scan_type; 00947 cp.scan_interval = htobs(scan_interval); 00948 cp.scan_window = htobs(scan_window); 00949 cp.own_address_type = own_address_type; 00950 cp.filter_duplicates = filter_duplicates; 00951 00952 Osal_MemSet(&rq, 0, sizeof(rq)); 00953 rq.ogf = OGF_VENDOR_CMD; 00954 rq.ocf = OCF_GAP_START_GENERAL_CONN_ESTABLISH_PROC; 00955 rq.cparam = &cp; 00956 rq.clen = sizeof(cp); 00957 rq.event = EVT_CMD_STATUS; 00958 rq.rparam = &status; 00959 rq.rlen = 1; 00960 00961 if (hci_send_req(&rq, FALSE) < 0) 00962 return BLE_STATUS_TIMEOUT; 00963 00964 return status; 00965 } 00966 tBleStatus aci_gap_start_general_conn_establish_proc_IDB04A1(uint8_t scan_type, uint16_t scan_interval, uint16_t scan_window, 00967 uint8_t own_address_type, uint8_t filter_duplicates, uint8_t use_reconn_addr, const tBDAddr reconn_addr) 00968 { 00969 struct hci_request rq; 00970 gap_start_general_conn_establish_proc_cp_IDB04A1 cp; 00971 uint8_t status; 00972 00973 cp.scan_type = scan_type; 00974 cp.scan_interval = htobs(scan_interval); 00975 cp.scan_window = htobs(scan_window); 00976 cp.own_address_type = own_address_type; 00977 cp.filter_duplicates = filter_duplicates; 00978 cp.use_reconn_addr = use_reconn_addr; 00979 Osal_MemCpy(cp.reconn_addr, reconn_addr, 6); 00980 00981 Osal_MemSet(&rq, 0, sizeof(rq)); 00982 rq.ogf = OGF_VENDOR_CMD; 00983 rq.ocf = OCF_GAP_START_GENERAL_CONN_ESTABLISH_PROC; 00984 rq.cparam = &cp; 00985 rq.clen = sizeof(cp); 00986 rq.event = EVT_CMD_STATUS; 00987 rq.rparam = &status; 00988 rq.rlen = 1; 00989 00990 if (hci_send_req(&rq, FALSE) < 0) 00991 return BLE_STATUS_TIMEOUT; 00992 00993 return status; 00994 } 00995 00996 tBleStatus aci_gap_start_selective_conn_establish_proc(uint8_t scan_type, uint16_t scan_interval, uint16_t scan_window, 00997 uint8_t own_address_type, uint8_t filter_duplicates, uint8_t num_whitelist_entries, 00998 const uint8_t *addr_array) 00999 { 01000 struct hci_request rq; 01001 gap_start_selective_conn_establish_proc_cp cp; 01002 uint8_t status; 01003 01004 if (((num_whitelist_entries*7)+GAP_START_SELECTIVE_CONN_ESTABLISH_PROC_CP_SIZE) > HCI_MAX_PAYLOAD_SIZE) 01005 return BLE_STATUS_INVALID_PARAMS; 01006 01007 cp.scan_type = scan_type; 01008 cp.scan_interval = htobs(scan_interval); 01009 cp.scan_window = htobs(scan_window); 01010 cp.own_address_type = own_address_type; 01011 cp.filter_duplicates = filter_duplicates; 01012 cp.num_whitelist_entries = num_whitelist_entries; 01013 01014 Osal_MemCpy(cp.addr_array, addr_array, (num_whitelist_entries*7)); 01015 01016 Osal_MemSet(&rq, 0, sizeof(rq)); 01017 rq.ogf = OGF_VENDOR_CMD; 01018 rq.ocf = OCF_GAP_START_SELECTIVE_CONN_ESTABLISH_PROC; 01019 rq.cparam = &cp; 01020 rq.clen = GAP_START_SELECTIVE_CONN_ESTABLISH_PROC_CP_SIZE + (num_whitelist_entries*7); 01021 rq.event = EVT_CMD_STATUS; 01022 rq.rparam = &status; 01023 rq.rlen = 1; 01024 01025 if (hci_send_req(&rq, FALSE) < 0) 01026 return BLE_STATUS_TIMEOUT; 01027 01028 return status; 01029 } 01030 01031 tBleStatus aci_gap_create_connection(uint16_t scanInterval, uint16_t scanWindow, 01032 uint8_t peer_bdaddr_type, tBDAddr peer_bdaddr, 01033 uint8_t own_bdaddr_type, uint16_t conn_min_interval, 01034 uint16_t conn_max_interval, uint16_t conn_latency, 01035 uint16_t supervision_timeout, uint16_t min_conn_length, 01036 uint16_t max_conn_length) 01037 { 01038 struct hci_request rq; 01039 gap_create_connection_cp cp; 01040 uint8_t status; 01041 01042 cp.scanInterval = htobs(scanInterval); 01043 cp.scanWindow = htobs(scanWindow); 01044 cp.peer_bdaddr_type = peer_bdaddr_type; 01045 Osal_MemCpy(cp.peer_bdaddr, peer_bdaddr, 6); 01046 cp.own_bdaddr_type = own_bdaddr_type; 01047 cp.conn_min_interval = htobs(conn_min_interval); 01048 cp.conn_max_interval = htobs(conn_max_interval); 01049 cp.conn_latency = htobs(conn_latency); 01050 cp.supervision_timeout = htobs(supervision_timeout); 01051 cp.min_conn_length = htobs(min_conn_length); 01052 cp.max_conn_length = htobs(max_conn_length); 01053 01054 Osal_MemSet(&rq, 0, sizeof(rq)); 01055 rq.ogf = OGF_VENDOR_CMD; 01056 rq.ocf = OCF_GAP_CREATE_CONNECTION; 01057 rq.cparam = &cp; 01058 rq.clen = sizeof(cp); 01059 rq.event = EVT_CMD_STATUS; 01060 rq.rparam = &status; 01061 rq.rlen = 1; 01062 01063 if (hci_send_req(&rq, FALSE) < 0) 01064 return BLE_STATUS_TIMEOUT; 01065 01066 return status; 01067 } 01068 01069 tBleStatus aci_gap_terminate_gap_procedure(uint8_t procedure_code) 01070 { 01071 struct hci_request rq; 01072 uint8_t status; 01073 01074 Osal_MemSet(&rq, 0, sizeof(rq)); 01075 rq.ogf = OGF_VENDOR_CMD; 01076 rq.ocf = OCF_GAP_TERMINATE_GAP_PROCEDURE; 01077 rq.cparam = &procedure_code; 01078 rq.clen = 1; 01079 rq.rparam = &status; 01080 rq.rlen = 1; 01081 01082 if (hci_send_req(&rq, FALSE) < 0) 01083 return BLE_STATUS_TIMEOUT; 01084 01085 return status; 01086 01087 } 01088 01089 tBleStatus aci_gap_start_connection_update(uint16_t conn_handle, uint16_t conn_min_interval, 01090 uint16_t conn_max_interval, uint16_t conn_latency, 01091 uint16_t supervision_timeout, uint16_t min_conn_length, 01092 uint16_t max_conn_length) 01093 { 01094 struct hci_request rq; 01095 gap_start_connection_update_cp cp; 01096 uint8_t status; 01097 01098 cp.conn_handle = htobs(conn_handle); 01099 cp.conn_min_interval = htobs(conn_min_interval); 01100 cp.conn_max_interval = htobs(conn_max_interval); 01101 cp.conn_latency = htobs(conn_latency); 01102 cp.supervision_timeout = htobs(supervision_timeout); 01103 cp.min_conn_length = htobs(min_conn_length); 01104 cp.max_conn_length = htobs(max_conn_length); 01105 01106 Osal_MemSet(&rq, 0, sizeof(rq)); 01107 rq.ogf = OGF_VENDOR_CMD; 01108 rq.ocf = OCF_GAP_START_CONNECTION_UPDATE; 01109 rq.cparam = &cp; 01110 rq.clen = sizeof(cp); 01111 rq.event = EVT_CMD_STATUS; 01112 rq.rparam = &status; 01113 rq.rlen = 1; 01114 01115 if (hci_send_req(&rq, FALSE) < 0) 01116 return BLE_STATUS_TIMEOUT; 01117 01118 return status; 01119 } 01120 01121 tBleStatus aci_gap_send_pairing_request(uint16_t conn_handle, uint8_t force_rebond) 01122 { 01123 struct hci_request rq; 01124 gap_send_pairing_request_cp cp; 01125 uint8_t status; 01126 01127 cp.conn_handle = htobs(conn_handle); 01128 cp.force_rebond = force_rebond; 01129 01130 Osal_MemSet(&rq, 0, sizeof(rq)); 01131 rq.ogf = OGF_VENDOR_CMD; 01132 rq.ocf = OCF_GAP_SEND_PAIRING_REQUEST; 01133 rq.cparam = &cp; 01134 rq.clen = sizeof(cp); 01135 rq.event = EVT_CMD_STATUS; 01136 rq.rparam = &status; 01137 rq.rlen = 1; 01138 01139 if (hci_send_req(&rq, FALSE) < 0) 01140 return BLE_STATUS_TIMEOUT; 01141 01142 return status; 01143 } 01144 01145 tBleStatus aci_gap_resolve_private_address_IDB05A1(const tBDAddr private_address, tBDAddr actual_address) 01146 { 01147 struct hci_request rq; 01148 gap_resolve_private_address_cp cp; 01149 gap_resolve_private_address_rp rp; 01150 01151 Osal_MemCpy(cp.address, private_address, 6); 01152 01153 Osal_MemSet(&rq, 0, sizeof(rq)); 01154 rq.ogf = OGF_VENDOR_CMD; 01155 rq.ocf = OCF_GAP_RESOLVE_PRIVATE_ADDRESS; 01156 rq.cparam = &cp; 01157 rq.clen = sizeof(cp); 01158 rq.rparam = &rp; 01159 rq.rlen = sizeof(rp); 01160 01161 if (hci_send_req(&rq, FALSE) < 0) 01162 return BLE_STATUS_TIMEOUT; 01163 01164 if(rp.status) 01165 return rp.status; 01166 01167 Osal_MemCpy(actual_address, rp.address, 6); 01168 01169 return 0; 01170 } 01171 tBleStatus aci_gap_resolve_private_address_IDB04A1(const tBDAddr address) 01172 { 01173 struct hci_request rq; 01174 gap_resolve_private_address_cp cp; 01175 uint8_t status; 01176 01177 Osal_MemCpy(cp.address, address, 6); 01178 01179 Osal_MemSet(&rq, 0, sizeof(rq)); 01180 rq.ogf = OGF_VENDOR_CMD; 01181 rq.ocf = OCF_GAP_RESOLVE_PRIVATE_ADDRESS; 01182 rq.cparam = &cp; 01183 rq.clen = sizeof(cp); 01184 rq.rparam = &status; 01185 rq.rlen = 1; 01186 01187 if (hci_send_req(&rq, FALSE) < 0) 01188 return BLE_STATUS_TIMEOUT; 01189 01190 return status; 01191 } 01192 01193 tBleStatus aci_gap_set_broadcast_mode(uint16_t adv_interv_min, uint16_t adv_interv_max, uint8_t adv_type, 01194 uint8_t own_addr_type, uint8_t adv_data_length, const uint8_t *adv_data, uint8_t num_whitelist_entries, 01195 const uint8_t *addr_array) 01196 { 01197 struct hci_request rq; 01198 gap_set_broadcast_mode_cp cp; 01199 uint8_t status; 01200 uint8_t indx = 0; 01201 uint8_t variable_size = 1 + adv_data_length + 1 + num_whitelist_entries*7; 01202 01203 if (variable_size > sizeof(cp.var_len_data) ) 01204 return BLE_STATUS_INVALID_PARAMS; 01205 01206 cp.adv_interv_min = htobs(adv_interv_min); 01207 cp.adv_interv_max = htobs(adv_interv_max); 01208 cp.adv_type = adv_type; 01209 cp.own_addr_type = own_addr_type; 01210 01211 cp.var_len_data[indx] = adv_data_length; 01212 indx++; 01213 Osal_MemCpy(cp.var_len_data + indx, adv_data, adv_data_length); 01214 indx += adv_data_length; 01215 cp.var_len_data[indx] = num_whitelist_entries; 01216 indx ++; 01217 Osal_MemCpy(cp.var_len_data + indx, addr_array, num_whitelist_entries*7); 01218 01219 Osal_MemSet(&rq, 0, sizeof(rq)); 01220 rq.ogf = OGF_VENDOR_CMD; 01221 rq.ocf = OCF_GAP_SET_BROADCAST_MODE; 01222 rq.cparam = &cp; 01223 rq.clen = GAP_SET_BROADCAST_MODE_CP_SIZE + variable_size; 01224 rq.rparam = &status; 01225 rq.rlen = 1; 01226 01227 if (hci_send_req(&rq, FALSE) < 0) 01228 return BLE_STATUS_TIMEOUT; 01229 01230 return status; 01231 } 01232 01233 tBleStatus aci_gap_start_observation_procedure(uint16_t scan_interval, uint16_t scan_window, uint8_t scan_type, 01234 uint8_t own_address_type, uint8_t filter_duplicates) 01235 { 01236 struct hci_request rq; 01237 gap_start_observation_proc_cp cp; 01238 uint8_t status; 01239 01240 cp.scan_interval = scan_interval; 01241 cp.scan_window = scan_window; 01242 cp.scan_type = scan_type; 01243 cp.own_address_type = own_address_type; 01244 cp.filter_duplicates = filter_duplicates; 01245 01246 Osal_MemSet(&rq, 0, sizeof(rq)); 01247 rq.ogf = OGF_VENDOR_CMD; 01248 rq.ocf = OCF_GAP_START_OBSERVATION_PROC; 01249 rq.cparam = &cp; 01250 rq.clen = sizeof(cp); 01251 rq.event = EVT_CMD_STATUS; 01252 rq.rparam = &status; 01253 rq.rlen = 1; 01254 01255 if (hci_send_req(&rq, FALSE) < 0) 01256 return BLE_STATUS_TIMEOUT; 01257 01258 return status; 01259 } 01260 01261 tBleStatus aci_gap_is_device_bonded(uint8_t peer_address_type, const tBDAddr peer_address) 01262 { 01263 struct hci_request rq; 01264 gap_is_device_bonded_cp cp; 01265 uint8_t status; 01266 01267 cp.peer_address_type = peer_address_type; 01268 Osal_MemCpy(cp.peer_address, peer_address, sizeof(cp.peer_address)); 01269 01270 Osal_MemSet(&rq, 0, sizeof(rq)); 01271 rq.ogf = OGF_VENDOR_CMD; 01272 rq.ocf = OCF_GAP_IS_DEVICE_BONDED; 01273 rq.cparam = &cp; 01274 rq.clen = sizeof(cp); 01275 rq.rparam = &status; 01276 rq.rlen = 1; 01277 01278 if (hci_send_req(&rq, FALSE) < 0) 01279 return BLE_STATUS_TIMEOUT; 01280 01281 return status; 01282 } 01283 01284 tBleStatus aci_gap_get_bonded_devices(uint8_t *num_devices, uint8_t *device_list, uint8_t device_list_size) 01285 { 01286 struct hci_request rq; 01287 gap_get_bonded_devices_rp rp; 01288 01289 Osal_MemSet(&rq, 0, sizeof(rq)); 01290 rq.ogf = OGF_VENDOR_CMD; 01291 rq.ocf = OCF_GAP_GET_BONDED_DEVICES; 01292 rq.rparam = &rp; 01293 rq.rlen = sizeof(rp); 01294 01295 if (hci_send_req(&rq, FALSE) < 0) 01296 return BLE_STATUS_TIMEOUT; 01297 01298 if (rp.status) { 01299 return rp.status; 01300 } 01301 01302 *num_devices = rp.num_addr; 01303 if(device_list != NULL) 01304 Osal_MemCpy(device_list, rp.dev_list, MIN(device_list_size,rp.num_addr*7)); 01305 01306 return 0; 01307 }
Generated on Thu Jul 14 2022 02:49:15 by
1.7.2