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