xref: /btstack/port/stm32-wb55xx-nucleo-freertos/Middlewares/STM32_WPAN/ble/core/auto/ble_gap_aci.c (revision 0561b2d8d5dba972c7daa57d5e677f7a1327edfd) 
1 /******************************************************************************
2  * @file    ble_gap_aci.c
3  * @author  MCD Application Team
4  * @date    23 May 2019
5  * @brief   Source file for ble api STM32WB (gap_aci)
6  *          Auto-generated file: do not edit!
7  ******************************************************************************
8  * @attention
9  *
10  * <h2><center>&copy; Copyright (c) 2019 STMicroelectronics.
11  * All rights reserved.</center></h2>
12  *
13  * This software component is licensed by ST under Ultimate Liberty license
14  * SLA0044, the "License"; You may not use this file except in compliance with
15  * the License. You may obtain a copy of the License at:
16  *                             www.st.com/SLA0044
17  *
18  ******************************************************************************
19  */
20 
21 #include "ble_gap_aci.h"
22 
aci_gap_set_non_discoverable(void)23 tBleStatus aci_gap_set_non_discoverable(void)
24 {
25   struct hci_request rq;
26   tBleStatus status = 0;
27   Osal_MemSet(&rq, 0, sizeof(rq));
28   rq.ogf = 0x3f;
29   rq.ocf = 0x081;
30   rq.rparam = &status;
31   rq.rlen = 1;
32   if (hci_send_req(&rq, FALSE) < 0)
33     return BLE_STATUS_TIMEOUT;
34   if (status)
35   {
36     return status;
37   }
38   return BLE_STATUS_SUCCESS;
39 }
40 
aci_gap_set_limited_discoverable(uint8_t Advertising_Type,uint16_t Advertising_Interval_Min,uint16_t Advertising_Interval_Max,uint8_t Own_Address_Type,uint8_t Advertising_Filter_Policy,uint8_t Local_Name_Length,uint8_t Local_Name[],uint8_t Service_Uuid_length,uint8_t Service_Uuid_List[],uint16_t Slave_Conn_Interval_Min,uint16_t Slave_Conn_Interval_Max)41 tBleStatus aci_gap_set_limited_discoverable(uint8_t Advertising_Type,
42                                             uint16_t Advertising_Interval_Min,
43                                             uint16_t Advertising_Interval_Max,
44                                             uint8_t Own_Address_Type,
45                                             uint8_t Advertising_Filter_Policy,
46                                             uint8_t Local_Name_Length,
47                                             uint8_t Local_Name[],
48                                             uint8_t Service_Uuid_length,
49                                             uint8_t Service_Uuid_List[],
50                                             uint16_t Slave_Conn_Interval_Min,
51                                             uint16_t Slave_Conn_Interval_Max)
52 {
53   struct hci_request rq;
54   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
55   aci_gap_set_limited_discoverable_cp0 *cp0 = (aci_gap_set_limited_discoverable_cp0*)(cmd_buffer);
56   aci_gap_set_limited_discoverable_cp1 *cp1 = (aci_gap_set_limited_discoverable_cp1*)(cmd_buffer + 1 + 2 + 2 + 1 + 1 + 1 + Local_Name_Length * (sizeof(uint8_t)));
57   aci_gap_set_limited_discoverable_cp2 *cp2 = (aci_gap_set_limited_discoverable_cp2*)(cmd_buffer + 1 + 2 + 2 + 1 + 1 + 1 + Local_Name_Length * (sizeof(uint8_t)) + 1 + Service_Uuid_length * (sizeof(uint8_t)));
58   tBleStatus status = 0;
59   int index_input = 0;
60   cp0->Advertising_Type = htob(Advertising_Type, 1);
61   index_input += 1;
62   cp0->Advertising_Interval_Min = htob(Advertising_Interval_Min, 2);
63   index_input += 2;
64   cp0->Advertising_Interval_Max = htob(Advertising_Interval_Max, 2);
65   index_input += 2;
66   cp0->Own_Address_Type = htob(Own_Address_Type, 1);
67   index_input += 1;
68   cp0->Advertising_Filter_Policy = htob(Advertising_Filter_Policy, 1);
69   index_input += 1;
70   cp0->Local_Name_Length = htob(Local_Name_Length, 1);
71   index_input += 1;
72   /* var_len_data input */
73   {
74     Osal_MemCpy((void *) &cp0->Local_Name, (const void *) Local_Name, Local_Name_Length);
75     index_input += Local_Name_Length;
76     {
77       cp1->Service_Uuid_length = htob(Service_Uuid_length, 1);
78     }
79     index_input += 1;
80     Osal_MemCpy((void *) &cp1->Service_Uuid_List, (const void *) Service_Uuid_List, Service_Uuid_length);
81     index_input += Service_Uuid_length;
82     {
83       cp2->Slave_Conn_Interval_Min = htob(Slave_Conn_Interval_Min, 2);
84     }
85     index_input += 2;
86     {
87       cp2->Slave_Conn_Interval_Max = htob(Slave_Conn_Interval_Max, 2);
88     }
89     index_input += 2;
90   }
91   Osal_MemSet(&rq, 0, sizeof(rq));
92   rq.ogf = 0x3f;
93   rq.ocf = 0x082;
94   rq.event = 0x0F;
95   rq.cparam = cmd_buffer;
96   rq.clen = index_input;
97   rq.rparam = &status;
98   rq.rlen = 1;
99   if (hci_send_req(&rq, FALSE) < 0)
100     return BLE_STATUS_TIMEOUT;
101   if (status)
102   {
103     return status;
104   }
105   return BLE_STATUS_SUCCESS;
106 }
107 
aci_gap_set_discoverable(uint8_t Advertising_Type,uint16_t Advertising_Interval_Min,uint16_t Advertising_Interval_Max,uint8_t Own_Address_Type,uint8_t Advertising_Filter_Policy,uint8_t Local_Name_Length,uint8_t Local_Name[],uint8_t Service_Uuid_length,uint8_t Service_Uuid_List[],uint16_t Slave_Conn_Interval_Min,uint16_t Slave_Conn_Interval_Max)108 tBleStatus aci_gap_set_discoverable(uint8_t Advertising_Type,
109                                     uint16_t Advertising_Interval_Min,
110                                     uint16_t Advertising_Interval_Max,
111                                     uint8_t Own_Address_Type,
112                                     uint8_t Advertising_Filter_Policy,
113                                     uint8_t Local_Name_Length,
114                                     uint8_t Local_Name[],
115                                     uint8_t Service_Uuid_length,
116                                     uint8_t Service_Uuid_List[],
117                                     uint16_t Slave_Conn_Interval_Min,
118                                     uint16_t Slave_Conn_Interval_Max)
119 {
120   struct hci_request rq;
121   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
122   aci_gap_set_discoverable_cp0 *cp0 = (aci_gap_set_discoverable_cp0*)(cmd_buffer);
123   aci_gap_set_discoverable_cp1 *cp1 = (aci_gap_set_discoverable_cp1*)(cmd_buffer + 1 + 2 + 2 + 1 + 1 + 1 + Local_Name_Length * (sizeof(uint8_t)));
124   aci_gap_set_discoverable_cp2 *cp2 = (aci_gap_set_discoverable_cp2*)(cmd_buffer + 1 + 2 + 2 + 1 + 1 + 1 + Local_Name_Length * (sizeof(uint8_t)) + 1 + Service_Uuid_length * (sizeof(uint8_t)));
125   tBleStatus status = 0;
126   int index_input = 0;
127   cp0->Advertising_Type = htob(Advertising_Type, 1);
128   index_input += 1;
129   cp0->Advertising_Interval_Min = htob(Advertising_Interval_Min, 2);
130   index_input += 2;
131   cp0->Advertising_Interval_Max = htob(Advertising_Interval_Max, 2);
132   index_input += 2;
133   cp0->Own_Address_Type = htob(Own_Address_Type, 1);
134   index_input += 1;
135   cp0->Advertising_Filter_Policy = htob(Advertising_Filter_Policy, 1);
136   index_input += 1;
137   cp0->Local_Name_Length = htob(Local_Name_Length, 1);
138   index_input += 1;
139   /* var_len_data input */
140   {
141     Osal_MemCpy((void *) &cp0->Local_Name, (const void *) Local_Name, Local_Name_Length);
142     index_input += Local_Name_Length;
143     {
144       cp1->Service_Uuid_length = htob(Service_Uuid_length, 1);
145     }
146     index_input += 1;
147     Osal_MemCpy((void *) &cp1->Service_Uuid_List, (const void *) Service_Uuid_List, Service_Uuid_length);
148     index_input += Service_Uuid_length;
149     {
150       cp2->Slave_Conn_Interval_Min = htob(Slave_Conn_Interval_Min, 2);
151     }
152     index_input += 2;
153     {
154       cp2->Slave_Conn_Interval_Max = htob(Slave_Conn_Interval_Max, 2);
155     }
156     index_input += 2;
157   }
158   Osal_MemSet(&rq, 0, sizeof(rq));
159   rq.ogf = 0x3f;
160   rq.ocf = 0x083;
161   rq.cparam = cmd_buffer;
162   rq.clen = index_input;
163   rq.rparam = &status;
164   rq.rlen = 1;
165   if (hci_send_req(&rq, FALSE) < 0)
166     return BLE_STATUS_TIMEOUT;
167   if (status)
168   {
169     return status;
170   }
171   return BLE_STATUS_SUCCESS;
172 }
173 
aci_gap_set_direct_connectable(uint8_t Own_Address_Type,uint8_t Directed_Advertising_Type,uint8_t Direct_Address_Type,uint8_t Direct_Address[6],uint16_t Advertising_Interval_Min,uint16_t Advertising_Interval_Max)174 tBleStatus aci_gap_set_direct_connectable(uint8_t Own_Address_Type,
175                                           uint8_t Directed_Advertising_Type,
176                                           uint8_t Direct_Address_Type,
177                                           uint8_t Direct_Address[6],
178                                           uint16_t Advertising_Interval_Min,
179                                           uint16_t Advertising_Interval_Max)
180 {
181   struct hci_request rq;
182   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
183   aci_gap_set_direct_connectable_cp0 *cp0 = (aci_gap_set_direct_connectable_cp0*)(cmd_buffer);
184   tBleStatus status = 0;
185   int index_input = 0;
186   cp0->Own_Address_Type = htob(Own_Address_Type, 1);
187   index_input += 1;
188   cp0->Directed_Advertising_Type = htob(Directed_Advertising_Type, 1);
189   index_input += 1;
190   cp0->Direct_Address_Type = htob(Direct_Address_Type, 1);
191   index_input += 1;
192   Osal_MemCpy((void *) &cp0->Direct_Address, (const void *) Direct_Address, 6);
193   index_input += 6;
194   cp0->Advertising_Interval_Min = htob(Advertising_Interval_Min, 2);
195   index_input += 2;
196   cp0->Advertising_Interval_Max = htob(Advertising_Interval_Max, 2);
197   index_input += 2;
198   Osal_MemSet(&rq, 0, sizeof(rq));
199   rq.ogf = 0x3f;
200   rq.ocf = 0x084;
201   rq.cparam = cmd_buffer;
202   rq.clen = index_input;
203   rq.rparam = &status;
204   rq.rlen = 1;
205   if (hci_send_req(&rq, FALSE) < 0)
206     return BLE_STATUS_TIMEOUT;
207   if (status)
208   {
209     return status;
210   }
211   return BLE_STATUS_SUCCESS;
212 }
213 
aci_gap_set_io_capability(uint8_t IO_Capability)214 tBleStatus aci_gap_set_io_capability(uint8_t IO_Capability)
215 {
216   struct hci_request rq;
217   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
218   aci_gap_set_io_capability_cp0 *cp0 = (aci_gap_set_io_capability_cp0*)(cmd_buffer);
219   tBleStatus status = 0;
220   int index_input = 0;
221   cp0->IO_Capability = htob(IO_Capability, 1);
222   index_input += 1;
223   Osal_MemSet(&rq, 0, sizeof(rq));
224   rq.ogf = 0x3f;
225   rq.ocf = 0x085;
226   rq.cparam = cmd_buffer;
227   rq.clen = index_input;
228   rq.rparam = &status;
229   rq.rlen = 1;
230   if (hci_send_req(&rq, FALSE) < 0)
231     return BLE_STATUS_TIMEOUT;
232   if (status)
233   {
234     return status;
235   }
236   return BLE_STATUS_SUCCESS;
237 }
238 
aci_gap_set_authentication_requirement(uint8_t Bonding_Mode,uint8_t MITM_Mode,uint8_t SC_Support,uint8_t KeyPress_Notification_Support,uint8_t Min_Encryption_Key_Size,uint8_t Max_Encryption_Key_Size,uint8_t Use_Fixed_Pin,uint32_t Fixed_Pin,uint8_t Identity_Address_Type)239 tBleStatus aci_gap_set_authentication_requirement(uint8_t Bonding_Mode,
240                                                   uint8_t MITM_Mode,
241                                                   uint8_t SC_Support,
242                                                   uint8_t KeyPress_Notification_Support,
243                                                   uint8_t Min_Encryption_Key_Size,
244                                                   uint8_t Max_Encryption_Key_Size,
245                                                   uint8_t Use_Fixed_Pin,
246                                                   uint32_t Fixed_Pin,
247                                                   uint8_t Identity_Address_Type)
248 {
249   struct hci_request rq;
250   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
251   aci_gap_set_authentication_requirement_cp0 *cp0 = (aci_gap_set_authentication_requirement_cp0*)(cmd_buffer);
252   tBleStatus status = 0;
253   int index_input = 0;
254   cp0->Bonding_Mode = htob(Bonding_Mode, 1);
255   index_input += 1;
256   cp0->MITM_Mode = htob(MITM_Mode, 1);
257   index_input += 1;
258   cp0->SC_Support = htob(SC_Support, 1);
259   index_input += 1;
260   cp0->KeyPress_Notification_Support = htob(KeyPress_Notification_Support, 1);
261   index_input += 1;
262   cp0->Min_Encryption_Key_Size = htob(Min_Encryption_Key_Size, 1);
263   index_input += 1;
264   cp0->Max_Encryption_Key_Size = htob(Max_Encryption_Key_Size, 1);
265   index_input += 1;
266   cp0->Use_Fixed_Pin = htob(Use_Fixed_Pin, 1);
267   index_input += 1;
268   cp0->Fixed_Pin = htob(Fixed_Pin, 4);
269   index_input += 4;
270   cp0->Identity_Address_Type = htob(Identity_Address_Type, 1);
271   index_input += 1;
272   Osal_MemSet(&rq, 0, sizeof(rq));
273   rq.ogf = 0x3f;
274   rq.ocf = 0x086;
275   rq.cparam = cmd_buffer;
276   rq.clen = index_input;
277   rq.rparam = &status;
278   rq.rlen = 1;
279   if (hci_send_req(&rq, FALSE) < 0)
280     return BLE_STATUS_TIMEOUT;
281   if (status)
282   {
283     return status;
284   }
285   return BLE_STATUS_SUCCESS;
286 }
287 
aci_gap_set_authorization_requirement(uint16_t Connection_Handle,uint8_t Authorization_Enable)288 tBleStatus aci_gap_set_authorization_requirement(uint16_t Connection_Handle,
289                                                  uint8_t Authorization_Enable)
290 {
291   struct hci_request rq;
292   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
293   aci_gap_set_authorization_requirement_cp0 *cp0 = (aci_gap_set_authorization_requirement_cp0*)(cmd_buffer);
294   tBleStatus status = 0;
295   int index_input = 0;
296   cp0->Connection_Handle = htob(Connection_Handle, 2);
297   index_input += 2;
298   cp0->Authorization_Enable = htob(Authorization_Enable, 1);
299   index_input += 1;
300   Osal_MemSet(&rq, 0, sizeof(rq));
301   rq.ogf = 0x3f;
302   rq.ocf = 0x087;
303   rq.cparam = cmd_buffer;
304   rq.clen = index_input;
305   rq.rparam = &status;
306   rq.rlen = 1;
307   if (hci_send_req(&rq, FALSE) < 0)
308     return BLE_STATUS_TIMEOUT;
309   if (status)
310   {
311     return status;
312   }
313   return BLE_STATUS_SUCCESS;
314 }
315 
aci_gap_pass_key_resp(uint16_t Connection_Handle,uint32_t Pass_Key)316 tBleStatus aci_gap_pass_key_resp(uint16_t Connection_Handle,
317                                  uint32_t Pass_Key)
318 {
319   struct hci_request rq;
320   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
321   aci_gap_pass_key_resp_cp0 *cp0 = (aci_gap_pass_key_resp_cp0*)(cmd_buffer);
322   tBleStatus status = 0;
323   int index_input = 0;
324   cp0->Connection_Handle = htob(Connection_Handle, 2);
325   index_input += 2;
326   cp0->Pass_Key = htob(Pass_Key, 4);
327   index_input += 4;
328   Osal_MemSet(&rq, 0, sizeof(rq));
329   rq.ogf = 0x3f;
330   rq.ocf = 0x088;
331   rq.cparam = cmd_buffer;
332   rq.clen = index_input;
333   rq.rparam = &status;
334   rq.rlen = 1;
335   if (hci_send_req(&rq, FALSE) < 0)
336     return BLE_STATUS_TIMEOUT;
337   if (status)
338   {
339     return status;
340   }
341   return BLE_STATUS_SUCCESS;
342 }
343 
aci_gap_authorization_resp(uint16_t Connection_Handle,uint8_t Authorize)344 tBleStatus aci_gap_authorization_resp(uint16_t Connection_Handle,
345                                       uint8_t Authorize)
346 {
347   struct hci_request rq;
348   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
349   aci_gap_authorization_resp_cp0 *cp0 = (aci_gap_authorization_resp_cp0*)(cmd_buffer);
350   tBleStatus status = 0;
351   int index_input = 0;
352   cp0->Connection_Handle = htob(Connection_Handle, 2);
353   index_input += 2;
354   cp0->Authorize = htob(Authorize, 1);
355   index_input += 1;
356   Osal_MemSet(&rq, 0, sizeof(rq));
357   rq.ogf = 0x3f;
358   rq.ocf = 0x089;
359   rq.cparam = cmd_buffer;
360   rq.clen = index_input;
361   rq.rparam = &status;
362   rq.rlen = 1;
363   if (hci_send_req(&rq, FALSE) < 0)
364     return BLE_STATUS_TIMEOUT;
365   if (status)
366   {
367     return status;
368   }
369   return BLE_STATUS_SUCCESS;
370 }
371 
aci_gap_init(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)372 tBleStatus aci_gap_init(uint8_t Role,
373                         uint8_t privacy_enabled,
374                         uint8_t device_name_char_len,
375                         uint16_t *Service_Handle,
376                         uint16_t *Dev_Name_Char_Handle,
377                         uint16_t *Appearance_Char_Handle)
378 {
379   struct hci_request rq;
380   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
381   aci_gap_init_cp0 *cp0 = (aci_gap_init_cp0*)(cmd_buffer);
382   aci_gap_init_rp0 resp;
383   Osal_MemSet(&resp, 0, sizeof(resp));
384   int index_input = 0;
385   cp0->Role = htob(Role, 1);
386   index_input += 1;
387   cp0->privacy_enabled = htob(privacy_enabled, 1);
388   index_input += 1;
389   cp0->device_name_char_len = htob(device_name_char_len, 1);
390   index_input += 1;
391   Osal_MemSet(&rq, 0, sizeof(rq));
392   rq.ogf = 0x3f;
393   rq.ocf = 0x08a;
394   rq.cparam = cmd_buffer;
395   rq.clen = index_input;
396   rq.rparam = &resp;
397   rq.rlen = sizeof(resp);
398   if (hci_send_req(&rq, FALSE) < 0)
399     return BLE_STATUS_TIMEOUT;
400   if (resp.Status)
401   {
402     return resp.Status;
403   }
404   *Service_Handle = btoh(resp.Service_Handle, 2);
405   *Dev_Name_Char_Handle = btoh(resp.Dev_Name_Char_Handle, 2);
406   *Appearance_Char_Handle = btoh(resp.Appearance_Char_Handle, 2);
407   return BLE_STATUS_SUCCESS;
408 }
409 
aci_gap_set_non_connectable(uint8_t Advertising_Event_Type,uint8_t Own_Address_Type)410 tBleStatus aci_gap_set_non_connectable(uint8_t Advertising_Event_Type,
411                                        uint8_t Own_Address_Type)
412 {
413   struct hci_request rq;
414   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
415   aci_gap_set_non_connectable_cp0 *cp0 = (aci_gap_set_non_connectable_cp0*)(cmd_buffer);
416   tBleStatus status = 0;
417   int index_input = 0;
418   cp0->Advertising_Event_Type = htob(Advertising_Event_Type, 1);
419   index_input += 1;
420   cp0->Own_Address_Type = htob(Own_Address_Type, 1);
421   index_input += 1;
422   Osal_MemSet(&rq, 0, sizeof(rq));
423   rq.ogf = 0x3f;
424   rq.ocf = 0x08b;
425   rq.cparam = cmd_buffer;
426   rq.clen = index_input;
427   rq.rparam = &status;
428   rq.rlen = 1;
429   if (hci_send_req(&rq, FALSE) < 0)
430     return BLE_STATUS_TIMEOUT;
431   if (status)
432   {
433     return status;
434   }
435   return BLE_STATUS_SUCCESS;
436 }
437 
aci_gap_set_undirected_connectable(uint16_t Advertising_Interval_Min,uint16_t Advertising_Interval_Max,uint8_t Own_Address_Type,uint8_t Adv_Filter_Policy)438 tBleStatus aci_gap_set_undirected_connectable(uint16_t Advertising_Interval_Min,
439                                               uint16_t Advertising_Interval_Max,
440                                               uint8_t Own_Address_Type,
441                                               uint8_t Adv_Filter_Policy)
442 {
443   struct hci_request rq;
444   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
445   aci_gap_set_undirected_connectable_cp0 *cp0 = (aci_gap_set_undirected_connectable_cp0*)(cmd_buffer);
446   tBleStatus status = 0;
447   int index_input = 0;
448   cp0->Advertising_Interval_Min = htob(Advertising_Interval_Min, 2);
449   index_input += 2;
450   cp0->Advertising_Interval_Max = htob(Advertising_Interval_Max, 2);
451   index_input += 2;
452   cp0->Own_Address_Type = htob(Own_Address_Type, 1);
453   index_input += 1;
454   cp0->Adv_Filter_Policy = htob(Adv_Filter_Policy, 1);
455   index_input += 1;
456   Osal_MemSet(&rq, 0, sizeof(rq));
457   rq.ogf = 0x3f;
458   rq.ocf = 0x08c;
459   rq.cparam = cmd_buffer;
460   rq.clen = index_input;
461   rq.rparam = &status;
462   rq.rlen = 1;
463   if (hci_send_req(&rq, FALSE) < 0)
464     return BLE_STATUS_TIMEOUT;
465   if (status)
466   {
467     return status;
468   }
469   return BLE_STATUS_SUCCESS;
470 }
471 
aci_gap_slave_security_req(uint16_t Connection_Handle)472 tBleStatus aci_gap_slave_security_req(uint16_t Connection_Handle)
473 {
474   struct hci_request rq;
475   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
476   aci_gap_slave_security_req_cp0 *cp0 = (aci_gap_slave_security_req_cp0*)(cmd_buffer);
477   tBleStatus status = 0;
478   int index_input = 0;
479   cp0->Connection_Handle = htob(Connection_Handle, 2);
480   index_input += 2;
481   Osal_MemSet(&rq, 0, sizeof(rq));
482   rq.ogf = 0x3f;
483   rq.ocf = 0x08d;
484   rq.event = 0x0F;
485   rq.cparam = cmd_buffer;
486   rq.clen = index_input;
487   rq.rparam = &status;
488   rq.rlen = 1;
489   if (hci_send_req(&rq, FALSE) < 0)
490     return BLE_STATUS_TIMEOUT;
491   if (status)
492   {
493     return status;
494   }
495   return BLE_STATUS_SUCCESS;
496 }
497 
aci_gap_update_adv_data(uint8_t AdvDataLen,uint8_t AdvData[])498 tBleStatus aci_gap_update_adv_data(uint8_t AdvDataLen,
499                                    uint8_t AdvData[])
500 {
501   struct hci_request rq;
502   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
503   aci_gap_update_adv_data_cp0 *cp0 = (aci_gap_update_adv_data_cp0*)(cmd_buffer);
504   tBleStatus status = 0;
505   int index_input = 0;
506   cp0->AdvDataLen = htob(AdvDataLen, 1);
507   index_input += 1;
508   Osal_MemCpy((void *) &cp0->AdvData, (const void *) AdvData, AdvDataLen);
509   index_input += AdvDataLen;
510   Osal_MemSet(&rq, 0, sizeof(rq));
511   rq.ogf = 0x3f;
512   rq.ocf = 0x08e;
513   rq.cparam = cmd_buffer;
514   rq.clen = index_input;
515   rq.rparam = &status;
516   rq.rlen = 1;
517   if (hci_send_req(&rq, FALSE) < 0)
518     return BLE_STATUS_TIMEOUT;
519   if (status)
520   {
521     return status;
522   }
523   return BLE_STATUS_SUCCESS;
524 }
525 
aci_gap_delete_ad_type(uint8_t ADType)526 tBleStatus aci_gap_delete_ad_type(uint8_t ADType)
527 {
528   struct hci_request rq;
529   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
530   aci_gap_delete_ad_type_cp0 *cp0 = (aci_gap_delete_ad_type_cp0*)(cmd_buffer);
531   tBleStatus status = 0;
532   int index_input = 0;
533   cp0->ADType = htob(ADType, 1);
534   index_input += 1;
535   Osal_MemSet(&rq, 0, sizeof(rq));
536   rq.ogf = 0x3f;
537   rq.ocf = 0x08f;
538   rq.cparam = cmd_buffer;
539   rq.clen = index_input;
540   rq.rparam = &status;
541   rq.rlen = 1;
542   if (hci_send_req(&rq, FALSE) < 0)
543     return BLE_STATUS_TIMEOUT;
544   if (status)
545   {
546     return status;
547   }
548   return BLE_STATUS_SUCCESS;
549 }
550 
aci_gap_get_security_level(uint16_t Connection_Handle,uint8_t * Security_Mode,uint8_t * Security_Level)551 tBleStatus aci_gap_get_security_level(uint16_t Connection_Handle,
552                                       uint8_t *Security_Mode,
553                                       uint8_t *Security_Level)
554 {
555   struct hci_request rq;
556   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
557   aci_gap_get_security_level_cp0 *cp0 = (aci_gap_get_security_level_cp0*)(cmd_buffer);
558   aci_gap_get_security_level_rp0 resp;
559   Osal_MemSet(&resp, 0, sizeof(resp));
560   int index_input = 0;
561   cp0->Connection_Handle = htob(Connection_Handle, 2);
562   index_input += 2;
563   Osal_MemSet(&rq, 0, sizeof(rq));
564   rq.ogf = 0x3f;
565   rq.ocf = 0x090;
566   rq.cparam = cmd_buffer;
567   rq.clen = index_input;
568   rq.rparam = &resp;
569   rq.rlen = sizeof(resp);
570   if (hci_send_req(&rq, FALSE) < 0)
571     return BLE_STATUS_TIMEOUT;
572   if (resp.Status)
573   {
574     return resp.Status;
575   }
576   *Security_Mode = btoh(resp.Security_Mode, 1);
577   *Security_Level = btoh(resp.Security_Level, 1);
578   return BLE_STATUS_SUCCESS;
579 }
580 
aci_gap_set_event_mask(uint16_t GAP_Evt_Mask)581 tBleStatus aci_gap_set_event_mask(uint16_t GAP_Evt_Mask)
582 {
583   struct hci_request rq;
584   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
585   aci_gap_set_event_mask_cp0 *cp0 = (aci_gap_set_event_mask_cp0*)(cmd_buffer);
586   tBleStatus status = 0;
587   int index_input = 0;
588   cp0->GAP_Evt_Mask = htob(GAP_Evt_Mask, 2);
589   index_input += 2;
590   Osal_MemSet(&rq, 0, sizeof(rq));
591   rq.ogf = 0x3f;
592   rq.ocf = 0x091;
593   rq.cparam = cmd_buffer;
594   rq.clen = index_input;
595   rq.rparam = &status;
596   rq.rlen = 1;
597   if (hci_send_req(&rq, FALSE) < 0)
598     return BLE_STATUS_TIMEOUT;
599   if (status)
600   {
601     return status;
602   }
603   return BLE_STATUS_SUCCESS;
604 }
605 
aci_gap_configure_whitelist(void)606 tBleStatus aci_gap_configure_whitelist(void)
607 {
608   struct hci_request rq;
609   tBleStatus status = 0;
610   Osal_MemSet(&rq, 0, sizeof(rq));
611   rq.ogf = 0x3f;
612   rq.ocf = 0x092;
613   rq.rparam = &status;
614   rq.rlen = 1;
615   if (hci_send_req(&rq, FALSE) < 0)
616     return BLE_STATUS_TIMEOUT;
617   if (status)
618   {
619     return status;
620   }
621   return BLE_STATUS_SUCCESS;
622 }
623 
aci_gap_terminate(uint16_t Connection_Handle,uint8_t Reason)624 tBleStatus aci_gap_terminate(uint16_t Connection_Handle,
625                              uint8_t Reason)
626 {
627   struct hci_request rq;
628   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
629   aci_gap_terminate_cp0 *cp0 = (aci_gap_terminate_cp0*)(cmd_buffer);
630   tBleStatus status = 0;
631   int index_input = 0;
632   cp0->Connection_Handle = htob(Connection_Handle, 2);
633   index_input += 2;
634   cp0->Reason = htob(Reason, 1);
635   index_input += 1;
636   Osal_MemSet(&rq, 0, sizeof(rq));
637   rq.ogf = 0x3f;
638   rq.ocf = 0x093;
639   rq.event = 0x0F;
640   rq.cparam = cmd_buffer;
641   rq.clen = index_input;
642   rq.rparam = &status;
643   rq.rlen = 1;
644   if (hci_send_req(&rq, FALSE) < 0)
645     return BLE_STATUS_TIMEOUT;
646   if (status)
647   {
648     return status;
649   }
650   return BLE_STATUS_SUCCESS;
651 }
652 
aci_gap_clear_security_db(void)653 tBleStatus aci_gap_clear_security_db(void)
654 {
655   struct hci_request rq;
656   tBleStatus status = 0;
657   Osal_MemSet(&rq, 0, sizeof(rq));
658   rq.ogf = 0x3f;
659   rq.ocf = 0x094;
660   rq.rparam = &status;
661   rq.rlen = 1;
662   if (hci_send_req(&rq, FALSE) < 0)
663     return BLE_STATUS_TIMEOUT;
664   if (status)
665   {
666     return status;
667   }
668   return BLE_STATUS_SUCCESS;
669 }
670 
aci_gap_allow_rebond(uint16_t Connection_Handle)671 tBleStatus aci_gap_allow_rebond(uint16_t Connection_Handle)
672 {
673   struct hci_request rq;
674   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
675   aci_gap_allow_rebond_cp0 *cp0 = (aci_gap_allow_rebond_cp0*)(cmd_buffer);
676   tBleStatus status = 0;
677   int index_input = 0;
678   cp0->Connection_Handle = htob(Connection_Handle, 2);
679   index_input += 2;
680   Osal_MemSet(&rq, 0, sizeof(rq));
681   rq.ogf = 0x3f;
682   rq.ocf = 0x095;
683   rq.cparam = cmd_buffer;
684   rq.clen = index_input;
685   rq.rparam = &status;
686   rq.rlen = 1;
687   if (hci_send_req(&rq, FALSE) < 0)
688     return BLE_STATUS_TIMEOUT;
689   if (status)
690   {
691     return status;
692   }
693   return BLE_STATUS_SUCCESS;
694 }
695 
aci_gap_start_limited_discovery_proc(uint16_t LE_Scan_Interval,uint16_t LE_Scan_Window,uint8_t Own_Address_Type,uint8_t Filter_Duplicates)696 tBleStatus aci_gap_start_limited_discovery_proc(uint16_t LE_Scan_Interval,
697                                                 uint16_t LE_Scan_Window,
698                                                 uint8_t Own_Address_Type,
699                                                 uint8_t Filter_Duplicates)
700 {
701   struct hci_request rq;
702   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
703   aci_gap_start_limited_discovery_proc_cp0 *cp0 = (aci_gap_start_limited_discovery_proc_cp0*)(cmd_buffer);
704   tBleStatus status = 0;
705   int index_input = 0;
706   cp0->LE_Scan_Interval = htob(LE_Scan_Interval, 2);
707   index_input += 2;
708   cp0->LE_Scan_Window = htob(LE_Scan_Window, 2);
709   index_input += 2;
710   cp0->Own_Address_Type = htob(Own_Address_Type, 1);
711   index_input += 1;
712   cp0->Filter_Duplicates = htob(Filter_Duplicates, 1);
713   index_input += 1;
714   Osal_MemSet(&rq, 0, sizeof(rq));
715   rq.ogf = 0x3f;
716   rq.ocf = 0x096;
717   rq.event = 0x0F;
718   rq.cparam = cmd_buffer;
719   rq.clen = index_input;
720   rq.rparam = &status;
721   rq.rlen = 1;
722   if (hci_send_req(&rq, FALSE) < 0)
723     return BLE_STATUS_TIMEOUT;
724   if (status)
725   {
726     return status;
727   }
728   return BLE_STATUS_SUCCESS;
729 }
730 
aci_gap_start_general_discovery_proc(uint16_t LE_Scan_Interval,uint16_t LE_Scan_Window,uint8_t Own_Address_Type,uint8_t Filter_Duplicates)731 tBleStatus aci_gap_start_general_discovery_proc(uint16_t LE_Scan_Interval,
732                                                 uint16_t LE_Scan_Window,
733                                                 uint8_t Own_Address_Type,
734                                                 uint8_t Filter_Duplicates)
735 {
736   struct hci_request rq;
737   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
738   aci_gap_start_general_discovery_proc_cp0 *cp0 = (aci_gap_start_general_discovery_proc_cp0*)(cmd_buffer);
739   tBleStatus status = 0;
740   int index_input = 0;
741   cp0->LE_Scan_Interval = htob(LE_Scan_Interval, 2);
742   index_input += 2;
743   cp0->LE_Scan_Window = htob(LE_Scan_Window, 2);
744   index_input += 2;
745   cp0->Own_Address_Type = htob(Own_Address_Type, 1);
746   index_input += 1;
747   cp0->Filter_Duplicates = htob(Filter_Duplicates, 1);
748   index_input += 1;
749   Osal_MemSet(&rq, 0, sizeof(rq));
750   rq.ogf = 0x3f;
751   rq.ocf = 0x097;
752   rq.event = 0x0F;
753   rq.cparam = cmd_buffer;
754   rq.clen = index_input;
755   rq.rparam = &status;
756   rq.rlen = 1;
757   if (hci_send_req(&rq, FALSE) < 0)
758     return BLE_STATUS_TIMEOUT;
759   if (status)
760   {
761     return status;
762   }
763   return BLE_STATUS_SUCCESS;
764 }
765 
aci_gap_start_name_discovery_proc(uint16_t LE_Scan_Interval,uint16_t LE_Scan_Window,uint8_t Peer_Address_Type,uint8_t Peer_Address[6],uint8_t Own_Address_Type,uint16_t Conn_Interval_Min,uint16_t Conn_Interval_Max,uint16_t Conn_Latency,uint16_t Supervision_Timeout,uint16_t Minimum_CE_Length,uint16_t Maximum_CE_Length)766 tBleStatus aci_gap_start_name_discovery_proc(uint16_t LE_Scan_Interval,
767                                              uint16_t LE_Scan_Window,
768                                              uint8_t Peer_Address_Type,
769                                              uint8_t Peer_Address[6],
770                                              uint8_t Own_Address_Type,
771                                              uint16_t Conn_Interval_Min,
772                                              uint16_t Conn_Interval_Max,
773                                              uint16_t Conn_Latency,
774                                              uint16_t Supervision_Timeout,
775                                              uint16_t Minimum_CE_Length,
776                                              uint16_t Maximum_CE_Length)
777 {
778   struct hci_request rq;
779   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
780   aci_gap_start_name_discovery_proc_cp0 *cp0 = (aci_gap_start_name_discovery_proc_cp0*)(cmd_buffer);
781   tBleStatus status = 0;
782   int index_input = 0;
783   cp0->LE_Scan_Interval = htob(LE_Scan_Interval, 2);
784   index_input += 2;
785   cp0->LE_Scan_Window = htob(LE_Scan_Window, 2);
786   index_input += 2;
787   cp0->Peer_Address_Type = htob(Peer_Address_Type, 1);
788   index_input += 1;
789   Osal_MemCpy((void *) &cp0->Peer_Address, (const void *) Peer_Address, 6);
790   index_input += 6;
791   cp0->Own_Address_Type = htob(Own_Address_Type, 1);
792   index_input += 1;
793   cp0->Conn_Interval_Min = htob(Conn_Interval_Min, 2);
794   index_input += 2;
795   cp0->Conn_Interval_Max = htob(Conn_Interval_Max, 2);
796   index_input += 2;
797   cp0->Conn_Latency = htob(Conn_Latency, 2);
798   index_input += 2;
799   cp0->Supervision_Timeout = htob(Supervision_Timeout, 2);
800   index_input += 2;
801   cp0->Minimum_CE_Length = htob(Minimum_CE_Length, 2);
802   index_input += 2;
803   cp0->Maximum_CE_Length = htob(Maximum_CE_Length, 2);
804   index_input += 2;
805   Osal_MemSet(&rq, 0, sizeof(rq));
806   rq.ogf = 0x3f;
807   rq.ocf = 0x098;
808   rq.event = 0x0F;
809   rq.cparam = cmd_buffer;
810   rq.clen = index_input;
811   rq.rparam = &status;
812   rq.rlen = 1;
813   if (hci_send_req(&rq, FALSE) < 0)
814     return BLE_STATUS_TIMEOUT;
815   if (status)
816   {
817     return status;
818   }
819   return BLE_STATUS_SUCCESS;
820 }
821 
aci_gap_start_auto_connection_establish_proc(uint16_t LE_Scan_Interval,uint16_t LE_Scan_Window,uint8_t Own_Address_Type,uint16_t Conn_Interval_Min,uint16_t Conn_Interval_Max,uint16_t Conn_Latency,uint16_t Supervision_Timeout,uint16_t Minimum_CE_Length,uint16_t Maximum_CE_Length,uint8_t Num_of_Whitelist_Entries,Whitelist_Entry_t Whitelist_Entry[])822 tBleStatus aci_gap_start_auto_connection_establish_proc(uint16_t LE_Scan_Interval,
823                                                         uint16_t LE_Scan_Window,
824                                                         uint8_t Own_Address_Type,
825                                                         uint16_t Conn_Interval_Min,
826                                                         uint16_t Conn_Interval_Max,
827                                                         uint16_t Conn_Latency,
828                                                         uint16_t Supervision_Timeout,
829                                                         uint16_t Minimum_CE_Length,
830                                                         uint16_t Maximum_CE_Length,
831                                                         uint8_t Num_of_Whitelist_Entries,
832                                                         Whitelist_Entry_t Whitelist_Entry[])
833 {
834   struct hci_request rq;
835   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
836   aci_gap_start_auto_connection_establish_proc_cp0 *cp0 = (aci_gap_start_auto_connection_establish_proc_cp0*)(cmd_buffer);
837   tBleStatus status = 0;
838   int index_input = 0;
839   cp0->LE_Scan_Interval = htob(LE_Scan_Interval, 2);
840   index_input += 2;
841   cp0->LE_Scan_Window = htob(LE_Scan_Window, 2);
842   index_input += 2;
843   cp0->Own_Address_Type = htob(Own_Address_Type, 1);
844   index_input += 1;
845   cp0->Conn_Interval_Min = htob(Conn_Interval_Min, 2);
846   index_input += 2;
847   cp0->Conn_Interval_Max = htob(Conn_Interval_Max, 2);
848   index_input += 2;
849   cp0->Conn_Latency = htob(Conn_Latency, 2);
850   index_input += 2;
851   cp0->Supervision_Timeout = htob(Supervision_Timeout, 2);
852   index_input += 2;
853   cp0->Minimum_CE_Length = htob(Minimum_CE_Length, 2);
854   index_input += 2;
855   cp0->Maximum_CE_Length = htob(Maximum_CE_Length, 2);
856   index_input += 2;
857   cp0->Num_of_Whitelist_Entries = htob(Num_of_Whitelist_Entries, 1);
858   index_input += 1;
859   Osal_MemCpy((void*) &cp0->Whitelist_Entry, (const void *) Whitelist_Entry, Num_of_Whitelist_Entries * (sizeof(Whitelist_Entry_t)));
860   index_input += Num_of_Whitelist_Entries * (sizeof(Whitelist_Entry_t));
861   Osal_MemSet(&rq, 0, sizeof(rq));
862   rq.ogf = 0x3f;
863   rq.ocf = 0x099;
864   rq.event = 0x0F;
865   rq.cparam = cmd_buffer;
866   rq.clen = index_input;
867   rq.rparam = &status;
868   rq.rlen = 1;
869   if (hci_send_req(&rq, FALSE) < 0)
870     return BLE_STATUS_TIMEOUT;
871   if (status)
872   {
873     return status;
874   }
875   return BLE_STATUS_SUCCESS;
876 }
877 
aci_gap_start_general_connection_establish_proc(uint8_t LE_Scan_Type,uint16_t LE_Scan_Interval,uint16_t LE_Scan_Window,uint8_t Own_Address_Type,uint8_t Scanning_Filter_Policy,uint8_t Filter_Duplicates)878 tBleStatus aci_gap_start_general_connection_establish_proc(uint8_t LE_Scan_Type,
879                                                            uint16_t LE_Scan_Interval,
880                                                            uint16_t LE_Scan_Window,
881                                                            uint8_t Own_Address_Type,
882                                                            uint8_t Scanning_Filter_Policy,
883                                                            uint8_t Filter_Duplicates)
884 {
885   struct hci_request rq;
886   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
887   aci_gap_start_general_connection_establish_proc_cp0 *cp0 = (aci_gap_start_general_connection_establish_proc_cp0*)(cmd_buffer);
888   tBleStatus status = 0;
889   int index_input = 0;
890   cp0->LE_Scan_Type = htob(LE_Scan_Type, 1);
891   index_input += 1;
892   cp0->LE_Scan_Interval = htob(LE_Scan_Interval, 2);
893   index_input += 2;
894   cp0->LE_Scan_Window = htob(LE_Scan_Window, 2);
895   index_input += 2;
896   cp0->Own_Address_Type = htob(Own_Address_Type, 1);
897   index_input += 1;
898   cp0->Scanning_Filter_Policy = htob(Scanning_Filter_Policy, 1);
899   index_input += 1;
900   cp0->Filter_Duplicates = htob(Filter_Duplicates, 1);
901   index_input += 1;
902   Osal_MemSet(&rq, 0, sizeof(rq));
903   rq.ogf = 0x3f;
904   rq.ocf = 0x09a;
905   rq.event = 0x0F;
906   rq.cparam = cmd_buffer;
907   rq.clen = index_input;
908   rq.rparam = &status;
909   rq.rlen = 1;
910   if (hci_send_req(&rq, FALSE) < 0)
911     return BLE_STATUS_TIMEOUT;
912   if (status)
913   {
914     return status;
915   }
916   return BLE_STATUS_SUCCESS;
917 }
918 
aci_gap_start_selective_connection_establish_proc(uint8_t LE_Scan_Type,uint16_t LE_Scan_Interval,uint16_t LE_Scan_Window,uint8_t Own_Address_Type,uint8_t Scanning_Filter_Policy,uint8_t Filter_Duplicates,uint8_t Num_of_Whitelist_Entries,Whitelist_Entry_t Whitelist_Entry[])919 tBleStatus aci_gap_start_selective_connection_establish_proc(uint8_t LE_Scan_Type,
920                                                              uint16_t LE_Scan_Interval,
921                                                              uint16_t LE_Scan_Window,
922                                                              uint8_t Own_Address_Type,
923                                                              uint8_t Scanning_Filter_Policy,
924                                                              uint8_t Filter_Duplicates,
925                                                              uint8_t Num_of_Whitelist_Entries,
926                                                              Whitelist_Entry_t Whitelist_Entry[])
927 {
928   struct hci_request rq;
929   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
930   aci_gap_start_selective_connection_establish_proc_cp0 *cp0 = (aci_gap_start_selective_connection_establish_proc_cp0*)(cmd_buffer);
931   tBleStatus status = 0;
932   int index_input = 0;
933   cp0->LE_Scan_Type = htob(LE_Scan_Type, 1);
934   index_input += 1;
935   cp0->LE_Scan_Interval = htob(LE_Scan_Interval, 2);
936   index_input += 2;
937   cp0->LE_Scan_Window = htob(LE_Scan_Window, 2);
938   index_input += 2;
939   cp0->Own_Address_Type = htob(Own_Address_Type, 1);
940   index_input += 1;
941   cp0->Scanning_Filter_Policy = htob(Scanning_Filter_Policy, 1);
942   index_input += 1;
943   cp0->Filter_Duplicates = htob(Filter_Duplicates, 1);
944   index_input += 1;
945   cp0->Num_of_Whitelist_Entries = htob(Num_of_Whitelist_Entries, 1);
946   index_input += 1;
947   Osal_MemCpy((void*) &cp0->Whitelist_Entry, (const void *) Whitelist_Entry, Num_of_Whitelist_Entries * (sizeof(Whitelist_Entry_t)));
948   index_input += Num_of_Whitelist_Entries * (sizeof(Whitelist_Entry_t));
949   Osal_MemSet(&rq, 0, sizeof(rq));
950   rq.ogf = 0x3f;
951   rq.ocf = 0x09b;
952   rq.event = 0x0F;
953   rq.cparam = cmd_buffer;
954   rq.clen = index_input;
955   rq.rparam = &status;
956   rq.rlen = 1;
957   if (hci_send_req(&rq, FALSE) < 0)
958     return BLE_STATUS_TIMEOUT;
959   if (status)
960   {
961     return status;
962   }
963   return BLE_STATUS_SUCCESS;
964 }
965 
aci_gap_create_connection(uint16_t LE_Scan_Interval,uint16_t LE_Scan_Window,uint8_t Peer_Address_Type,uint8_t Peer_Address[6],uint8_t Own_Address_Type,uint16_t Conn_Interval_Min,uint16_t Conn_Interval_Max,uint16_t Conn_Latency,uint16_t Supervision_Timeout,uint16_t Minimum_CE_Length,uint16_t Maximum_CE_Length)966 tBleStatus aci_gap_create_connection(uint16_t LE_Scan_Interval,
967                                      uint16_t LE_Scan_Window,
968                                      uint8_t Peer_Address_Type,
969                                      uint8_t Peer_Address[6],
970                                      uint8_t Own_Address_Type,
971                                      uint16_t Conn_Interval_Min,
972                                      uint16_t Conn_Interval_Max,
973                                      uint16_t Conn_Latency,
974                                      uint16_t Supervision_Timeout,
975                                      uint16_t Minimum_CE_Length,
976                                      uint16_t Maximum_CE_Length)
977 {
978   struct hci_request rq;
979   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
980   aci_gap_create_connection_cp0 *cp0 = (aci_gap_create_connection_cp0*)(cmd_buffer);
981   tBleStatus status = 0;
982   int index_input = 0;
983   cp0->LE_Scan_Interval = htob(LE_Scan_Interval, 2);
984   index_input += 2;
985   cp0->LE_Scan_Window = htob(LE_Scan_Window, 2);
986   index_input += 2;
987   cp0->Peer_Address_Type = htob(Peer_Address_Type, 1);
988   index_input += 1;
989   Osal_MemCpy((void *) &cp0->Peer_Address, (const void *) Peer_Address, 6);
990   index_input += 6;
991   cp0->Own_Address_Type = htob(Own_Address_Type, 1);
992   index_input += 1;
993   cp0->Conn_Interval_Min = htob(Conn_Interval_Min, 2);
994   index_input += 2;
995   cp0->Conn_Interval_Max = htob(Conn_Interval_Max, 2);
996   index_input += 2;
997   cp0->Conn_Latency = htob(Conn_Latency, 2);
998   index_input += 2;
999   cp0->Supervision_Timeout = htob(Supervision_Timeout, 2);
1000   index_input += 2;
1001   cp0->Minimum_CE_Length = htob(Minimum_CE_Length, 2);
1002   index_input += 2;
1003   cp0->Maximum_CE_Length = htob(Maximum_CE_Length, 2);
1004   index_input += 2;
1005   Osal_MemSet(&rq, 0, sizeof(rq));
1006   rq.ogf = 0x3f;
1007   rq.ocf = 0x09c;
1008   rq.event = 0x0F;
1009   rq.cparam = cmd_buffer;
1010   rq.clen = index_input;
1011   rq.rparam = &status;
1012   rq.rlen = 1;
1013   if (hci_send_req(&rq, FALSE) < 0)
1014     return BLE_STATUS_TIMEOUT;
1015   if (status)
1016   {
1017     return status;
1018   }
1019   return BLE_STATUS_SUCCESS;
1020 }
1021 
aci_gap_terminate_gap_proc(uint8_t Procedure_Code)1022 tBleStatus aci_gap_terminate_gap_proc(uint8_t Procedure_Code)
1023 {
1024   struct hci_request rq;
1025   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
1026   aci_gap_terminate_gap_proc_cp0 *cp0 = (aci_gap_terminate_gap_proc_cp0*)(cmd_buffer);
1027   tBleStatus status = 0;
1028   int index_input = 0;
1029   cp0->Procedure_Code = htob(Procedure_Code, 1);
1030   index_input += 1;
1031   Osal_MemSet(&rq, 0, sizeof(rq));
1032   rq.ogf = 0x3f;
1033   rq.ocf = 0x09d;
1034   rq.cparam = cmd_buffer;
1035   rq.clen = index_input;
1036   rq.rparam = &status;
1037   rq.rlen = 1;
1038   if (hci_send_req(&rq, FALSE) < 0)
1039     return BLE_STATUS_TIMEOUT;
1040   if (status)
1041   {
1042     return status;
1043   }
1044   return BLE_STATUS_SUCCESS;
1045 }
1046 
aci_gap_start_connection_update(uint16_t Connection_Handle,uint16_t Conn_Interval_Min,uint16_t Conn_Interval_Max,uint16_t Conn_Latency,uint16_t Supervision_Timeout,uint16_t Minimum_CE_Length,uint16_t Maximum_CE_Length)1047 tBleStatus aci_gap_start_connection_update(uint16_t Connection_Handle,
1048                                            uint16_t Conn_Interval_Min,
1049                                            uint16_t Conn_Interval_Max,
1050                                            uint16_t Conn_Latency,
1051                                            uint16_t Supervision_Timeout,
1052                                            uint16_t Minimum_CE_Length,
1053                                            uint16_t Maximum_CE_Length)
1054 {
1055   struct hci_request rq;
1056   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
1057   aci_gap_start_connection_update_cp0 *cp0 = (aci_gap_start_connection_update_cp0*)(cmd_buffer);
1058   tBleStatus status = 0;
1059   int index_input = 0;
1060   cp0->Connection_Handle = htob(Connection_Handle, 2);
1061   index_input += 2;
1062   cp0->Conn_Interval_Min = htob(Conn_Interval_Min, 2);
1063   index_input += 2;
1064   cp0->Conn_Interval_Max = htob(Conn_Interval_Max, 2);
1065   index_input += 2;
1066   cp0->Conn_Latency = htob(Conn_Latency, 2);
1067   index_input += 2;
1068   cp0->Supervision_Timeout = htob(Supervision_Timeout, 2);
1069   index_input += 2;
1070   cp0->Minimum_CE_Length = htob(Minimum_CE_Length, 2);
1071   index_input += 2;
1072   cp0->Maximum_CE_Length = htob(Maximum_CE_Length, 2);
1073   index_input += 2;
1074   Osal_MemSet(&rq, 0, sizeof(rq));
1075   rq.ogf = 0x3f;
1076   rq.ocf = 0x09e;
1077   rq.event = 0x0F;
1078   rq.cparam = cmd_buffer;
1079   rq.clen = index_input;
1080   rq.rparam = &status;
1081   rq.rlen = 1;
1082   if (hci_send_req(&rq, FALSE) < 0)
1083     return BLE_STATUS_TIMEOUT;
1084   if (status)
1085   {
1086     return status;
1087   }
1088   return BLE_STATUS_SUCCESS;
1089 }
1090 
aci_gap_send_pairing_req(uint16_t Connection_Handle,uint8_t Force_Rebond)1091 tBleStatus aci_gap_send_pairing_req(uint16_t Connection_Handle,
1092                                     uint8_t Force_Rebond)
1093 {
1094   struct hci_request rq;
1095   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
1096   aci_gap_send_pairing_req_cp0 *cp0 = (aci_gap_send_pairing_req_cp0*)(cmd_buffer);
1097   tBleStatus status = 0;
1098   int index_input = 0;
1099   cp0->Connection_Handle = htob(Connection_Handle, 2);
1100   index_input += 2;
1101   cp0->Force_Rebond = htob(Force_Rebond, 1);
1102   index_input += 1;
1103   Osal_MemSet(&rq, 0, sizeof(rq));
1104   rq.ogf = 0x3f;
1105   rq.ocf = 0x09f;
1106   rq.event = 0x0F;
1107   rq.cparam = cmd_buffer;
1108   rq.clen = index_input;
1109   rq.rparam = &status;
1110   rq.rlen = 1;
1111   if (hci_send_req(&rq, FALSE) < 0)
1112     return BLE_STATUS_TIMEOUT;
1113   if (status)
1114   {
1115     return status;
1116   }
1117   return BLE_STATUS_SUCCESS;
1118 }
1119 
aci_gap_resolve_private_addr(uint8_t Address[6],uint8_t Actual_Address[6])1120 tBleStatus aci_gap_resolve_private_addr(uint8_t Address[6],
1121                                         uint8_t Actual_Address[6])
1122 {
1123   struct hci_request rq;
1124   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
1125   aci_gap_resolve_private_addr_cp0 *cp0 = (aci_gap_resolve_private_addr_cp0*)(cmd_buffer);
1126   aci_gap_resolve_private_addr_rp0 resp;
1127   Osal_MemSet(&resp, 0, sizeof(resp));
1128   int index_input = 0;
1129   Osal_MemCpy((void *) &cp0->Address, (const void *) Address, 6);
1130   index_input += 6;
1131   Osal_MemSet(&rq, 0, sizeof(rq));
1132   rq.ogf = 0x3f;
1133   rq.ocf = 0x0a0;
1134   rq.cparam = cmd_buffer;
1135   rq.clen = index_input;
1136   rq.rparam = &resp;
1137   rq.rlen = sizeof(resp);
1138   if (hci_send_req(&rq, FALSE) < 0)
1139     return BLE_STATUS_TIMEOUT;
1140   if (resp.Status)
1141   {
1142     return resp.Status;
1143   }
1144   Osal_MemCpy((void *) Actual_Address, (const void *) resp.Actual_Address, 6);
1145   return BLE_STATUS_SUCCESS;
1146 }
1147 
aci_gap_set_broadcast_mode(uint16_t Advertising_Interval_Min,uint16_t Advertising_Interval_Max,uint8_t Advertising_Type,uint8_t Own_Address_Type,uint8_t Adv_Data_Length,uint8_t Adv_Data[],uint8_t Num_of_Whitelist_Entries,Whitelist_Entry_t Whitelist_Entry[])1148 tBleStatus aci_gap_set_broadcast_mode(uint16_t Advertising_Interval_Min,
1149                                       uint16_t Advertising_Interval_Max,
1150                                       uint8_t Advertising_Type,
1151                                       uint8_t Own_Address_Type,
1152                                       uint8_t Adv_Data_Length,
1153                                       uint8_t Adv_Data[],
1154                                       uint8_t Num_of_Whitelist_Entries,
1155                                       Whitelist_Entry_t Whitelist_Entry[])
1156 {
1157   struct hci_request rq;
1158   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
1159   aci_gap_set_broadcast_mode_cp0 *cp0 = (aci_gap_set_broadcast_mode_cp0*)(cmd_buffer);
1160   aci_gap_set_broadcast_mode_cp1 *cp1 = (aci_gap_set_broadcast_mode_cp1*)(cmd_buffer + 2 + 2 + 1 + 1 + 1 + Adv_Data_Length * (sizeof(uint8_t)));
1161   tBleStatus status = 0;
1162   int index_input = 0;
1163   cp0->Advertising_Interval_Min = htob(Advertising_Interval_Min, 2);
1164   index_input += 2;
1165   cp0->Advertising_Interval_Max = htob(Advertising_Interval_Max, 2);
1166   index_input += 2;
1167   cp0->Advertising_Type = htob(Advertising_Type, 1);
1168   index_input += 1;
1169   cp0->Own_Address_Type = htob(Own_Address_Type, 1);
1170   index_input += 1;
1171   cp0->Adv_Data_Length = htob(Adv_Data_Length, 1);
1172   index_input += 1;
1173   /* var_len_data input */
1174   {
1175     Osal_MemCpy((void *) &cp0->Adv_Data, (const void *) Adv_Data, Adv_Data_Length);
1176     index_input += Adv_Data_Length;
1177     {
1178       cp1->Num_of_Whitelist_Entries = htob(Num_of_Whitelist_Entries, 1);
1179     }
1180     index_input += 1;
1181     Osal_MemCpy((void *) &cp1->Whitelist_Entry, (const void *) Whitelist_Entry, Num_of_Whitelist_Entries * (sizeof(Whitelist_Entry_t)));
1182     index_input += Num_of_Whitelist_Entries * (sizeof(Whitelist_Entry_t));
1183   }
1184   Osal_MemSet(&rq, 0, sizeof(rq));
1185   rq.ogf = 0x3f;
1186   rq.ocf = 0x0a1;
1187   rq.cparam = cmd_buffer;
1188   rq.clen = index_input;
1189   rq.rparam = &status;
1190   rq.rlen = 1;
1191   if (hci_send_req(&rq, FALSE) < 0)
1192     return BLE_STATUS_TIMEOUT;
1193   if (status)
1194   {
1195     return status;
1196   }
1197   return BLE_STATUS_SUCCESS;
1198 }
1199 
aci_gap_start_observation_proc(uint16_t LE_Scan_Interval,uint16_t LE_Scan_Window,uint8_t LE_Scan_Type,uint8_t Own_Address_Type,uint8_t Filter_Duplicates,uint8_t Scanning_Filter_Policy)1200 tBleStatus aci_gap_start_observation_proc(uint16_t LE_Scan_Interval,
1201                                           uint16_t LE_Scan_Window,
1202                                           uint8_t LE_Scan_Type,
1203                                           uint8_t Own_Address_Type,
1204                                           uint8_t Filter_Duplicates,
1205                                           uint8_t Scanning_Filter_Policy)
1206 {
1207   struct hci_request rq;
1208   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
1209   aci_gap_start_observation_proc_cp0 *cp0 = (aci_gap_start_observation_proc_cp0*)(cmd_buffer);
1210   tBleStatus status = 0;
1211   int index_input = 0;
1212   cp0->LE_Scan_Interval = htob(LE_Scan_Interval, 2);
1213   index_input += 2;
1214   cp0->LE_Scan_Window = htob(LE_Scan_Window, 2);
1215   index_input += 2;
1216   cp0->LE_Scan_Type = htob(LE_Scan_Type, 1);
1217   index_input += 1;
1218   cp0->Own_Address_Type = htob(Own_Address_Type, 1);
1219   index_input += 1;
1220   cp0->Filter_Duplicates = htob(Filter_Duplicates, 1);
1221   index_input += 1;
1222   cp0->Scanning_Filter_Policy = htob(Scanning_Filter_Policy, 1);
1223   index_input += 1;
1224   Osal_MemSet(&rq, 0, sizeof(rq));
1225   rq.ogf = 0x3f;
1226   rq.ocf = 0x0a2;
1227   rq.event = 0x0F;
1228   rq.cparam = cmd_buffer;
1229   rq.clen = index_input;
1230   rq.rparam = &status;
1231   rq.rlen = 1;
1232   if (hci_send_req(&rq, FALSE) < 0)
1233     return BLE_STATUS_TIMEOUT;
1234   if (status)
1235   {
1236     return status;
1237   }
1238   return BLE_STATUS_SUCCESS;
1239 }
1240 
aci_gap_get_bonded_devices(uint8_t * Num_of_Addresses,Bonded_Device_Entry_t Bonded_Device_Entry[])1241 tBleStatus aci_gap_get_bonded_devices(uint8_t *Num_of_Addresses,
1242                                       Bonded_Device_Entry_t Bonded_Device_Entry[])
1243 {
1244   struct hci_request rq;
1245   aci_gap_get_bonded_devices_rp0 resp;
1246   Osal_MemSet(&resp, 0, sizeof(resp));
1247   Osal_MemSet(&rq, 0, sizeof(rq));
1248   rq.ogf = 0x3f;
1249   rq.ocf = 0x0a3;
1250   rq.rparam = &resp;
1251   rq.rlen = sizeof(resp);
1252   if (hci_send_req(&rq, FALSE) < 0)
1253     return BLE_STATUS_TIMEOUT;
1254   if (resp.Status)
1255   {
1256     return resp.Status;
1257   }
1258   *Num_of_Addresses = btoh(resp.Num_of_Addresses, 1);
1259   Osal_MemCpy((void *) Bonded_Device_Entry, (const void *) resp.Bonded_Device_Entry, *Num_of_Addresses * (sizeof(Bonded_Device_Entry_t)));
1260   return BLE_STATUS_SUCCESS;
1261 }
1262 
aci_gap_is_device_bonded(uint8_t Peer_Address_Type,uint8_t Peer_Address[6])1263 tBleStatus aci_gap_is_device_bonded(uint8_t Peer_Address_Type,
1264                                     uint8_t Peer_Address[6])
1265 {
1266   struct hci_request rq;
1267   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
1268   aci_gap_is_device_bonded_cp0 *cp0 = (aci_gap_is_device_bonded_cp0*)(cmd_buffer);
1269   tBleStatus status = 0;
1270   int index_input = 0;
1271   cp0->Peer_Address_Type = htob(Peer_Address_Type, 1);
1272   index_input += 1;
1273   Osal_MemCpy((void *) &cp0->Peer_Address, (const void *) Peer_Address, 6);
1274   index_input += 6;
1275   Osal_MemSet(&rq, 0, sizeof(rq));
1276   rq.ogf = 0x3f;
1277   rq.ocf = 0x0a4;
1278   rq.cparam = cmd_buffer;
1279   rq.clen = index_input;
1280   rq.rparam = &status;
1281   rq.rlen = 1;
1282   if (hci_send_req(&rq, FALSE) < 0)
1283     return BLE_STATUS_TIMEOUT;
1284   if (status)
1285   {
1286     return status;
1287   }
1288   return BLE_STATUS_SUCCESS;
1289 }
1290 
aci_gap_numeric_comparison_value_confirm_yesno(uint16_t Connection_Handle,uint8_t Confirm_Yes_No)1291 tBleStatus aci_gap_numeric_comparison_value_confirm_yesno(uint16_t Connection_Handle,
1292                                                           uint8_t Confirm_Yes_No)
1293 {
1294   struct hci_request rq;
1295   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
1296   aci_gap_numeric_comparison_value_confirm_yesno_cp0 *cp0 = (aci_gap_numeric_comparison_value_confirm_yesno_cp0*)(cmd_buffer);
1297   tBleStatus status = 0;
1298   int index_input = 0;
1299   cp0->Connection_Handle = htob(Connection_Handle, 2);
1300   index_input += 2;
1301   cp0->Confirm_Yes_No = htob(Confirm_Yes_No, 1);
1302   index_input += 1;
1303   Osal_MemSet(&rq, 0, sizeof(rq));
1304   rq.ogf = 0x3f;
1305   rq.ocf = 0x0a5;
1306   rq.cparam = cmd_buffer;
1307   rq.clen = index_input;
1308   rq.rparam = &status;
1309   rq.rlen = 1;
1310   if (hci_send_req(&rq, FALSE) < 0)
1311     return BLE_STATUS_TIMEOUT;
1312   if (status)
1313   {
1314     return status;
1315   }
1316   return BLE_STATUS_SUCCESS;
1317 }
1318 
aci_gap_passkey_input(uint16_t Connection_Handle,uint8_t Input_Type)1319 tBleStatus aci_gap_passkey_input(uint16_t Connection_Handle,
1320                                  uint8_t Input_Type)
1321 {
1322   struct hci_request rq;
1323   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
1324   aci_gap_passkey_input_cp0 *cp0 = (aci_gap_passkey_input_cp0*)(cmd_buffer);
1325   tBleStatus status = 0;
1326   int index_input = 0;
1327   cp0->Connection_Handle = htob(Connection_Handle, 2);
1328   index_input += 2;
1329   cp0->Input_Type = htob(Input_Type, 1);
1330   index_input += 1;
1331   Osal_MemSet(&rq, 0, sizeof(rq));
1332   rq.ogf = 0x3f;
1333   rq.ocf = 0x0a6;
1334   rq.cparam = cmd_buffer;
1335   rq.clen = index_input;
1336   rq.rparam = &status;
1337   rq.rlen = 1;
1338   if (hci_send_req(&rq, FALSE) < 0)
1339     return BLE_STATUS_TIMEOUT;
1340   if (status)
1341   {
1342     return status;
1343   }
1344   return BLE_STATUS_SUCCESS;
1345 }
1346 
aci_gap_get_oob_data(uint8_t OOB_Data_Type,uint8_t * Address_Type,uint8_t Address[6],uint8_t * OOB_Data_Len,uint8_t OOB_Data[16])1347 tBleStatus aci_gap_get_oob_data(uint8_t OOB_Data_Type,
1348                                 uint8_t *Address_Type,
1349                                 uint8_t Address[6],
1350                                 uint8_t *OOB_Data_Len,
1351                                 uint8_t OOB_Data[16])
1352 {
1353   struct hci_request rq;
1354   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
1355   aci_gap_get_oob_data_cp0 *cp0 = (aci_gap_get_oob_data_cp0*)(cmd_buffer);
1356   aci_gap_get_oob_data_rp0 resp;
1357   Osal_MemSet(&resp, 0, sizeof(resp));
1358   int index_input = 0;
1359   cp0->OOB_Data_Type = htob(OOB_Data_Type, 1);
1360   index_input += 1;
1361   Osal_MemSet(&rq, 0, sizeof(rq));
1362   rq.ogf = 0x3f;
1363   rq.ocf = 0x0a7;
1364   rq.cparam = cmd_buffer;
1365   rq.clen = index_input;
1366   rq.rparam = &resp;
1367   rq.rlen = sizeof(resp);
1368   if (hci_send_req(&rq, FALSE) < 0)
1369     return BLE_STATUS_TIMEOUT;
1370   if (resp.Status)
1371   {
1372     return resp.Status;
1373   }
1374   *Address_Type = btoh(resp.Address_Type, 1);
1375   Osal_MemCpy((void *) Address, (const void *) resp.Address, 6);
1376   *OOB_Data_Len = btoh(resp.OOB_Data_Len, 1);
1377   Osal_MemCpy((void *) OOB_Data, (const void *) resp.OOB_Data, 16);
1378   return BLE_STATUS_SUCCESS;
1379 }
1380 
aci_gap_set_oob_data(uint8_t Device_Type,uint8_t Address_Type,uint8_t Address[6],uint8_t OOB_Data_Type,uint8_t OOB_Data_Len,uint8_t OOB_Data[16])1381 tBleStatus aci_gap_set_oob_data(uint8_t Device_Type,
1382                                 uint8_t Address_Type,
1383                                 uint8_t Address[6],
1384                                 uint8_t OOB_Data_Type,
1385                                 uint8_t OOB_Data_Len,
1386                                 uint8_t OOB_Data[16])
1387 {
1388   struct hci_request rq;
1389   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
1390   aci_gap_set_oob_data_cp0 *cp0 = (aci_gap_set_oob_data_cp0*)(cmd_buffer);
1391   tBleStatus status = 0;
1392   int index_input = 0;
1393   cp0->Device_Type = htob(Device_Type, 1);
1394   index_input += 1;
1395   cp0->Address_Type = htob(Address_Type, 1);
1396   index_input += 1;
1397   Osal_MemCpy((void *) &cp0->Address, (const void *) Address, 6);
1398   index_input += 6;
1399   cp0->OOB_Data_Type = htob(OOB_Data_Type, 1);
1400   index_input += 1;
1401   cp0->OOB_Data_Len = htob(OOB_Data_Len, 1);
1402   index_input += 1;
1403   Osal_MemCpy((void *) &cp0->OOB_Data, (const void *) OOB_Data, 16);
1404   index_input += 16;
1405   Osal_MemSet(&rq, 0, sizeof(rq));
1406   rq.ogf = 0x3f;
1407   rq.ocf = 0x0a8;
1408   rq.cparam = cmd_buffer;
1409   rq.clen = index_input;
1410   rq.rparam = &status;
1411   rq.rlen = 1;
1412   if (hci_send_req(&rq, FALSE) < 0)
1413     return BLE_STATUS_TIMEOUT;
1414   if (status)
1415   {
1416     return status;
1417   }
1418   return BLE_STATUS_SUCCESS;
1419 }
1420 
aci_gap_add_devices_to_resolving_list(uint8_t Num_of_Resolving_list_Entries,Whitelist_Identity_Entry_t Whitelist_Identity_Entry[],uint8_t Clear_Resolving_List)1421 tBleStatus aci_gap_add_devices_to_resolving_list(uint8_t Num_of_Resolving_list_Entries,
1422                                                  Whitelist_Identity_Entry_t Whitelist_Identity_Entry[],
1423                                                  uint8_t Clear_Resolving_List)
1424 {
1425   struct hci_request rq;
1426   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
1427   aci_gap_add_devices_to_resolving_list_cp0 *cp0 = (aci_gap_add_devices_to_resolving_list_cp0*)(cmd_buffer);
1428   aci_gap_add_devices_to_resolving_list_cp1 *cp1 = (aci_gap_add_devices_to_resolving_list_cp1*)(cmd_buffer + 1 + Num_of_Resolving_list_Entries * (sizeof(Whitelist_Identity_Entry_t)));
1429   tBleStatus status = 0;
1430   int index_input = 0;
1431   cp0->Num_of_Resolving_list_Entries = htob(Num_of_Resolving_list_Entries, 1);
1432   index_input += 1;
1433   /* var_len_data input */
1434   {
1435     Osal_MemCpy((void *) &cp0->Whitelist_Identity_Entry, (const void *) Whitelist_Identity_Entry, Num_of_Resolving_list_Entries * (sizeof(Whitelist_Identity_Entry_t)));
1436     index_input += Num_of_Resolving_list_Entries * (sizeof(Whitelist_Identity_Entry_t));
1437     {
1438       cp1->Clear_Resolving_List = htob(Clear_Resolving_List, 1);
1439     }
1440     index_input += 1;
1441   }
1442   Osal_MemSet(&rq, 0, sizeof(rq));
1443   rq.ogf = 0x3f;
1444   rq.ocf = 0x0a9;
1445   rq.cparam = cmd_buffer;
1446   rq.clen = index_input;
1447   rq.rparam = &status;
1448   rq.rlen = 1;
1449   if (hci_send_req(&rq, FALSE) < 0)
1450     return BLE_STATUS_TIMEOUT;
1451   if (status)
1452   {
1453     return status;
1454   }
1455   return BLE_STATUS_SUCCESS;
1456 }
1457 
aci_gap_remove_bonded_device(uint8_t Peer_Identity_Address_Type,uint8_t Peer_Identity_Address[6])1458 tBleStatus aci_gap_remove_bonded_device(uint8_t Peer_Identity_Address_Type,
1459                                         uint8_t Peer_Identity_Address[6])
1460 {
1461   struct hci_request rq;
1462   uint8_t cmd_buffer[BLE_CMD_MAX_PARAM_LEN];
1463   aci_gap_remove_bonded_device_cp0 *cp0 = (aci_gap_remove_bonded_device_cp0*)(cmd_buffer);
1464   tBleStatus status = 0;
1465   int index_input = 0;
1466   cp0->Peer_Identity_Address_Type = htob(Peer_Identity_Address_Type, 1);
1467   index_input += 1;
1468   Osal_MemCpy((void *) &cp0->Peer_Identity_Address, (const void *) Peer_Identity_Address, 6);
1469   index_input += 6;
1470   Osal_MemSet(&rq, 0, sizeof(rq));
1471   rq.ogf = 0x3f;
1472   rq.ocf = 0x0aa;
1473   rq.cparam = cmd_buffer;
1474   rq.clen = index_input;
1475   rq.rparam = &status;
1476   rq.rlen = 1;
1477   if (hci_send_req(&rq, FALSE) < 0)
1478     return BLE_STATUS_TIMEOUT;
1479   if (status)
1480   {
1481     return status;
1482   }
1483   return BLE_STATUS_SUCCESS;
1484 }
1485 
1486