1 /******************************************************************************
2 *
3 * Copyright (C) 2003-2012 Broadcom Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18
19 /******************************************************************************
20 *
21 * This file contains the GATT Server action functions for the state
22 * machine.
23 *
24 ******************************************************************************/
25
26
27 #include "common/bt_target.h"
28
29 #if defined(GATTS_INCLUDED) && (GATTS_INCLUDED == TRUE)
30
31 #include "bta/utl.h"
32 #include "bta/bta_sys.h"
33 #include "bta_gatts_int.h"
34 #include "bta/bta_gatts_co.h"
35 #include "stack/btm_ble_api.h"
36 #include <string.h>
37 #include "osi/allocator.h"
38 #include "l2c_int.h"
39
40 static void bta_gatts_nv_save_cback(BOOLEAN is_saved, tGATTS_HNDL_RANGE *p_hndl_range);
41 static BOOLEAN bta_gatts_nv_srv_chg_cback(tGATTS_SRV_CHG_CMD cmd, tGATTS_SRV_CHG_REQ *p_req,
42 tGATTS_SRV_CHG_RSP *p_rsp);
43
44 static void bta_gatts_conn_cback (tGATT_IF gatt_if, BD_ADDR bda, UINT16 conn_id,
45 BOOLEAN connected, tGATT_DISCONN_REASON reason,
46 tGATT_TRANSPORT transport);
47 static void bta_gatts_send_request_cback (UINT16 conn_id,
48 UINT32 trans_id,
49 tGATTS_REQ_TYPE req_type, tGATTS_DATA *p_data);
50 static void bta_gatts_cong_cback (UINT16 conn_id, BOOLEAN congested);
51 extern void btc_congest_callback(tBTA_GATTS *param);
52
53 static const tGATT_CBACK bta_gatts_cback = {
54 bta_gatts_conn_cback,
55 NULL,
56 NULL,
57 NULL,
58 bta_gatts_send_request_cback,
59 NULL,
60 bta_gatts_cong_cback
61 };
62
63 const tGATT_APPL_INFO bta_gatts_nv_cback = {
64 bta_gatts_nv_save_cback,
65 bta_gatts_nv_srv_chg_cback
66 };
67
68 /*******************************************************************************
69 **
70 ** Function bta_gatts_nv_save_cback
71 **
72 ** Description NV save callback function.
73 **
74 ** Parameter is_add: true is to add a handle range; otherwise is to delete.
75 ** Returns none.
76 **
77 *******************************************************************************/
bta_gatts_nv_save_cback(BOOLEAN is_add,tGATTS_HNDL_RANGE * p_hndl_range)78 static void bta_gatts_nv_save_cback(BOOLEAN is_add, tGATTS_HNDL_RANGE *p_hndl_range)
79 {
80 bta_gatts_co_update_handle_range(is_add, (tBTA_GATTS_HNDL_RANGE *)p_hndl_range);
81 }
82
83
84 /*******************************************************************************
85 **
86 ** Function bta_gatts_nv_srv_chg_cback
87 **
88 ** Description NV save callback function.
89 **
90 ** Parameter is_add: true is to add a handle range; otherwise is to delete.
91 ** Returns none.
92 **
93 *******************************************************************************/
bta_gatts_nv_srv_chg_cback(tGATTS_SRV_CHG_CMD cmd,tGATTS_SRV_CHG_REQ * p_req,tGATTS_SRV_CHG_RSP * p_rsp)94 static BOOLEAN bta_gatts_nv_srv_chg_cback(tGATTS_SRV_CHG_CMD cmd,
95 tGATTS_SRV_CHG_REQ *p_req, tGATTS_SRV_CHG_RSP *p_rsp)
96 {
97 return bta_gatts_co_srv_chg((tBTA_GATTS_SRV_CHG_CMD) cmd,
98 (tBTA_GATTS_SRV_CHG_REQ *) p_req,
99 (tBTA_GATTS_SRV_CHG_RSP *) p_rsp);
100 }
101
102
103 /*******************************************************************************
104 **
105 ** Function bta_gatts_enable
106 **
107 ** Description enable BTA GATTS module.
108 **
109 ** Returns none.
110 **
111 *******************************************************************************/
bta_gatts_enable(tBTA_GATTS_CB * p_cb)112 void bta_gatts_enable(tBTA_GATTS_CB *p_cb)
113 {
114 UINT8 index = 0;
115 tBTA_GATTS_HNDL_RANGE handle_range;
116
117 if (p_cb->enabled) {
118 APPL_TRACE_DEBUG("GATTS already enabled.");
119 } else {
120 memset(p_cb, 0, sizeof(tBTA_GATTS_CB));
121
122 p_cb->enabled = TRUE;
123
124 while ( bta_gatts_co_load_handle_range(index, &handle_range)) {
125 GATTS_AddHandleRange((tGATTS_HNDL_RANGE *)&handle_range);
126 memset(&handle_range, 0, sizeof(tGATTS_HNDL_RANGE));
127 index++;
128 }
129
130 APPL_TRACE_DEBUG("bta_gatts_enable: num of handle range added=%d", index);
131
132 if (!GATTS_NVRegister(&bta_gatts_nv_cback)) {
133 APPL_TRACE_ERROR("BTA GATTS NV register failed.");
134 }
135 }
136 }
137
138 /*******************************************************************************
139 **
140 ** Function bta_gatts_api_disable
141 **
142 ** Description disable BTA GATTS module.
143 **
144 ** Returns none.
145 **
146 *******************************************************************************/
bta_gatts_api_disable(tBTA_GATTS_CB * p_cb)147 void bta_gatts_api_disable(tBTA_GATTS_CB *p_cb)
148 {
149 UINT8 i;
150
151 if (p_cb->enabled) {
152 for (i = 0; i < BTA_GATTS_MAX_APP_NUM; i ++) {
153 if (p_cb->rcb[i].in_use) {
154 GATT_Deregister(p_cb->rcb[i].gatt_if);
155 }
156 }
157 memset(p_cb, 0, sizeof(tBTA_GATTS_CB));
158 } else {
159 APPL_TRACE_ERROR("GATTS not enabled");
160 }
161 }
162
163 /*******************************************************************************
164 **
165 ** Function bta_gatts_register
166 **
167 ** Description register an application.
168 **
169 ** Returns none.
170 **
171 *******************************************************************************/
bta_gatts_register(tBTA_GATTS_CB * p_cb,tBTA_GATTS_DATA * p_msg)172 void bta_gatts_register(tBTA_GATTS_CB *p_cb, tBTA_GATTS_DATA *p_msg)
173 {
174 tBTA_GATTS_INT_START_IF *p_buf;
175 tBTA_GATTS cb_data;
176 tBTA_GATT_STATUS status = BTA_GATT_OK;
177 UINT8 i, first_unuse = 0xff;
178
179 if (p_cb->enabled == FALSE) {
180 bta_gatts_enable(p_cb);
181 }
182
183 for (i = 0; i < BTA_GATTS_MAX_APP_NUM; i ++) {
184 if (p_cb->rcb[i].in_use) {
185 if (bta_gatts_uuid_compare(p_cb->rcb[i].app_uuid, p_msg->api_reg.app_uuid)) {
186 APPL_TRACE_ERROR("application already registered.\n");
187 status = BTA_GATT_DUP_REG;
188 break;
189 }
190 }
191 }
192
193 if (status == BTA_GATT_OK) {
194 for (i = 0; i < BTA_GATTS_MAX_APP_NUM; i ++) {
195 if (first_unuse == 0xff && !p_cb->rcb[i].in_use) {
196 first_unuse = i;
197 break;
198 }
199 }
200
201 cb_data.reg_oper.server_if = BTA_GATTS_INVALID_IF;
202 // btla-specific ++
203 memcpy(&cb_data.reg_oper.uuid, &p_msg->api_reg.app_uuid, sizeof(tBT_UUID));
204 // btla-specific --
205 if (first_unuse != 0xff) {
206 APPL_TRACE_VERBOSE("register application first_unuse rcb_idx = %d", first_unuse);
207
208 p_cb->rcb[first_unuse].in_use = TRUE;
209 p_cb->rcb[first_unuse].p_cback = p_msg->api_reg.p_cback;
210 memcpy(&p_cb->rcb[first_unuse].app_uuid, &p_msg->api_reg.app_uuid, sizeof(tBT_UUID));
211 cb_data.reg_oper.server_if =
212 p_cb->rcb[first_unuse].gatt_if =
213 GATT_Register(&p_msg->api_reg.app_uuid, &bta_gatts_cback);
214 if ( !p_cb->rcb[first_unuse].gatt_if) {
215 status = BTA_GATT_NO_RESOURCES;
216 } else {
217 if ((p_buf =
218 (tBTA_GATTS_INT_START_IF *) osi_malloc(sizeof(tBTA_GATTS_INT_START_IF))) != NULL) {
219 p_buf->hdr.event = BTA_GATTS_INT_START_IF_EVT;
220 p_buf->server_if = p_cb->rcb[first_unuse].gatt_if;
221
222 bta_sys_sendmsg(p_buf);
223 } else {
224 status = BTA_GATT_NO_RESOURCES;
225 memset( &p_cb->rcb[first_unuse], 0 , sizeof(tBTA_GATTS_RCB));
226 }
227 }
228 } else {
229 status = BTA_GATT_NO_RESOURCES;
230 }
231
232 }
233 cb_data.reg_oper.status = status;
234 if (p_msg->api_reg.p_cback) {
235 (*p_msg->api_reg.p_cback)(BTA_GATTS_REG_EVT, &cb_data);
236 }
237 }
238
239
240 /*******************************************************************************
241 **
242 ** Function bta_gatts_start_if
243 **
244 ** Description start an application interface.
245 **
246 ** Returns none.
247 **
248 *******************************************************************************/
bta_gatts_start_if(tBTA_GATTS_CB * p_cb,tBTA_GATTS_DATA * p_msg)249 void bta_gatts_start_if(tBTA_GATTS_CB *p_cb, tBTA_GATTS_DATA *p_msg)
250 {
251 UNUSED(p_cb);
252
253 if (bta_gatts_find_app_rcb_by_app_if(p_msg->int_start_if.server_if)) {
254 GATT_StartIf(p_msg->int_start_if.server_if);
255 } else {
256 APPL_TRACE_ERROR("Unable to start app.: Unknown interface =%d",
257 p_msg->int_start_if.server_if );
258 }
259 }
260 /*******************************************************************************
261 **
262 ** Function bta_gatts_deregister
263 **
264 ** Description deregister an application.
265 **
266 ** Returns none.
267 **
268 *******************************************************************************/
bta_gatts_deregister(tBTA_GATTS_CB * p_cb,tBTA_GATTS_DATA * p_msg)269 void bta_gatts_deregister(tBTA_GATTS_CB *p_cb, tBTA_GATTS_DATA *p_msg)
270 {
271 tBTA_GATT_STATUS status = BTA_GATT_ERROR;
272 tBTA_GATTS_CBACK *p_cback = NULL;
273 UINT8 i;
274 tBTA_GATTS cb_data;
275
276 cb_data.reg_oper.server_if = p_msg->api_dereg.server_if;
277 cb_data.reg_oper.status = status;
278
279 for (i = 0; i < BTA_GATTS_MAX_APP_NUM; i ++) {
280 if (p_cb->rcb[i].in_use && p_cb->rcb[i].gatt_if == p_msg->api_dereg.server_if) {
281 p_cback = p_cb->rcb[i].p_cback;
282 status = BTA_GATT_OK;
283
284 /* deregister the app */
285 GATT_Deregister(p_cb->rcb[i].gatt_if);
286
287 /* reset cb */
288 memset(&p_cb->rcb[i], 0, sizeof(tBTA_GATTS_RCB));
289 cb_data.reg_oper.status = status;
290 break;
291 }
292 }
293
294 if (p_cback) {
295 (*p_cback)(BTA_GATTS_DEREG_EVT, &cb_data);
296 } else {
297 APPL_TRACE_ERROR("application not registered.");
298 }
299 }
300 /*******************************************************************************
301 **
302 ** Function bta_gatts_create_srvc
303 **
304 ** Description action function to create a service.
305 **
306 ** Returns none.
307 **
308 *******************************************************************************/
bta_gatts_create_srvc(tBTA_GATTS_CB * p_cb,tBTA_GATTS_DATA * p_msg)309 void bta_gatts_create_srvc(tBTA_GATTS_CB *p_cb, tBTA_GATTS_DATA *p_msg)
310 {
311 UINT8 rcb_idx;
312 tBTA_GATTS cb_data;
313 UINT8 srvc_idx;
314 UINT16 service_id = 0;
315
316 cb_data.create.status = BTA_GATT_ERROR;
317
318 rcb_idx = bta_gatts_find_app_rcb_idx_by_app_if(p_cb, p_msg->api_create_svc.server_if);
319
320 APPL_TRACE_DEBUG("create service rcb_idx = %d", rcb_idx);
321
322 if (rcb_idx != BTA_GATTS_INVALID_APP) {
323 if ((srvc_idx = bta_gatts_alloc_srvc_cb(p_cb, rcb_idx)) != BTA_GATTS_INVALID_APP) {
324 /* create the service now */
325 service_id = GATTS_CreateService (p_cb->rcb[rcb_idx].gatt_if,
326 &p_msg->api_create_svc.service_uuid,
327 p_msg->api_create_svc.inst,
328 p_msg->api_create_svc.num_handle,
329 p_msg->api_create_svc.is_pri);
330
331 if (service_id != 0) {
332 memcpy(&p_cb->srvc_cb[srvc_idx].service_uuid,
333 &p_msg->api_create_svc.service_uuid, sizeof(tBT_UUID));
334 p_cb->srvc_cb[srvc_idx].service_id = service_id;
335 p_cb->srvc_cb[srvc_idx].inst_num = p_msg->api_create_svc.inst;
336 p_cb->srvc_cb[srvc_idx].idx = srvc_idx;
337
338 cb_data.create.status = BTA_GATT_OK;
339 cb_data.create.service_id = service_id;
340
341 cb_data.create.is_primary = p_msg->api_create_svc.is_pri;
342
343 cb_data.create.server_if = p_cb->rcb[rcb_idx].gatt_if;
344 } else {
345 cb_data.status = BTA_GATT_ERROR;
346 memset(&p_cb->srvc_cb[srvc_idx], 0, sizeof(tBTA_GATTS_SRVC_CB));
347 APPL_TRACE_ERROR("service creation failed.");
348 }
349
350 memcpy(&cb_data.create.uuid, &p_msg->api_create_svc.service_uuid, sizeof(tBT_UUID));
351 cb_data.create.svc_instance = p_msg->api_create_svc.inst;
352
353 }
354 if (p_cb->rcb[rcb_idx].p_cback) {
355 (* p_cb->rcb[rcb_idx].p_cback)(BTA_GATTS_CREATE_EVT, &cb_data);
356 }
357 } else { /* application not registered */
358 APPL_TRACE_ERROR("Application not registered");
359 }
360 }
361 /*******************************************************************************
362 **
363 ** Function bta_gatts_add_include_srvc
364 **
365 ** Description action function to add an included service.
366 **
367 ** Returns none.
368 **
369 *******************************************************************************/
bta_gatts_add_include_srvc(tBTA_GATTS_SRVC_CB * p_srvc_cb,tBTA_GATTS_DATA * p_msg)370 void bta_gatts_add_include_srvc(tBTA_GATTS_SRVC_CB *p_srvc_cb, tBTA_GATTS_DATA *p_msg)
371 {
372 tBTA_GATTS_RCB *p_rcb = &bta_gatts_cb.rcb[p_srvc_cb->rcb_idx];
373 UINT16 attr_id = 0;
374 tBTA_GATTS cb_data;
375
376 attr_id = GATTS_AddIncludeService(p_msg->api_add_incl_srvc.hdr.layer_specific,
377 p_msg->api_add_incl_srvc.included_service_id);
378
379 cb_data.add_result.server_if = p_rcb->gatt_if;
380 cb_data.add_result.service_id = p_msg->api_add_incl_srvc.hdr.layer_specific;
381 cb_data.add_result.attr_id = attr_id;
382
383 if (attr_id) {
384 cb_data.add_result.status = BTA_GATT_OK;
385 } else {
386 cb_data.add_result.status = BTA_GATT_ERROR;
387 }
388
389 if (p_rcb->p_cback) {
390 (*p_rcb->p_cback)(BTA_GATTS_ADD_INCL_SRVC_EVT, &cb_data);
391 }
392 }
393 /*******************************************************************************
394 **
395 ** Function bta_gatts_add_char
396 **
397 ** Description action function to add characteristic.
398 **
399 ** Returns none.
400 **
401 *******************************************************************************/
bta_gatts_add_char(tBTA_GATTS_SRVC_CB * p_srvc_cb,tBTA_GATTS_DATA * p_msg)402 void bta_gatts_add_char(tBTA_GATTS_SRVC_CB *p_srvc_cb, tBTA_GATTS_DATA *p_msg)
403 {
404 tBTA_GATTS_RCB *p_rcb = &bta_gatts_cb.rcb[p_srvc_cb->rcb_idx];
405 UINT16 attr_id = 0;
406 tBTA_GATTS cb_data;
407
408 tGATT_ATTR_VAL *p_attr_val = NULL;
409 tGATTS_ATTR_CONTROL *p_control = NULL;
410
411 if(p_msg->api_add_char.attr_val.attr_max_len != 0){
412 p_attr_val = &p_msg->api_add_char.attr_val;
413 }
414
415 if(p_msg->api_add_char.control.auto_rsp != 0){
416 p_control = &p_msg->api_add_char.control;
417 }
418
419
420 attr_id = GATTS_AddCharacteristic(p_msg->api_add_char.hdr.layer_specific,
421 &p_msg->api_add_char.char_uuid,
422 p_msg->api_add_char.perm,
423 p_msg->api_add_char.property, p_attr_val, p_control);
424 cb_data.add_result.server_if = p_rcb->gatt_if;
425 cb_data.add_result.service_id = p_msg->api_add_char.hdr.layer_specific;
426 cb_data.add_result.attr_id = attr_id;
427 // btla-specific ++
428 memcpy(&cb_data.add_result.char_uuid, &p_msg->api_add_char.char_uuid, sizeof(tBT_UUID));
429 // btla-specific --
430
431 if (attr_id) {
432 cb_data.add_result.status = BTA_GATT_OK;
433 } else {
434 cb_data.add_result.status = BTA_GATT_ERROR;
435 }
436 if((p_attr_val != NULL) && (p_attr_val->attr_val != NULL)){
437 osi_free(p_attr_val->attr_val);
438 }
439
440 if (p_rcb->p_cback) {
441 (*p_rcb->p_cback)(BTA_GATTS_ADD_CHAR_EVT, &cb_data);
442 }
443 }
444
445 /*******************************************************************************
446 **
447 ** Function bta_gatts_add_char_descr
448 **
449 ** Description action function to add characteristic descriptor.
450 **
451 ** Returns none.
452 **
453 *******************************************************************************/
bta_gatts_add_char_descr(tBTA_GATTS_SRVC_CB * p_srvc_cb,tBTA_GATTS_DATA * p_msg)454 void bta_gatts_add_char_descr(tBTA_GATTS_SRVC_CB *p_srvc_cb, tBTA_GATTS_DATA *p_msg)
455 {
456 tBTA_GATTS_RCB *p_rcb = &bta_gatts_cb.rcb[p_srvc_cb->rcb_idx];
457 UINT16 attr_id = 0;
458 tBTA_GATTS cb_data;
459 tGATT_ATTR_VAL *p_attr_val = NULL;
460 tGATTS_ATTR_CONTROL *p_control = NULL;
461
462 if (p_msg->api_add_char_descr.attr_val.attr_max_len != 0) {
463 p_attr_val = &p_msg->api_add_char_descr.attr_val;
464 }
465
466 if (p_msg->api_add_char_descr.control.auto_rsp != 0) {
467 p_control = &p_msg->api_add_char_descr.control;
468 }
469 attr_id = GATTS_AddCharDescriptor(p_msg->api_add_char_descr.hdr.layer_specific,
470 p_msg->api_add_char_descr.perm,
471 &p_msg->api_add_char_descr.descr_uuid, p_attr_val,
472 p_control);
473
474 cb_data.add_result.server_if = p_rcb->gatt_if;
475 cb_data.add_result.service_id = p_msg->api_add_char_descr.hdr.layer_specific;
476 cb_data.add_result.attr_id = attr_id;
477 // btla-specific ++
478 memcpy(&cb_data.add_result.char_uuid, &p_msg->api_add_char_descr.descr_uuid, sizeof(tBT_UUID));
479 // btla-specific --
480
481 if (attr_id) {
482 cb_data.add_result.status = BTA_GATT_OK;
483 } else {
484 cb_data.add_result.status = BTA_GATT_ERROR;
485 }
486 if((p_attr_val != NULL) && (p_attr_val->attr_val != NULL)){
487 osi_free(p_attr_val->attr_val);
488 }
489
490 if (p_rcb->p_cback) {
491 (*p_rcb->p_cback)(BTA_GATTS_ADD_CHAR_DESCR_EVT, &cb_data);
492 }
493
494 }
495
496 /*******************************************************************************
497 **
498 ** Function bta_gatts_set_attr_value
499 **
500 ** Description This function is used to set the attribute value.
501 **
502 ** Returns None.
503 **
504 *******************************************************************************/
bta_gatts_set_attr_value(tBTA_GATTS_SRVC_CB * p_srvc_cb,tBTA_GATTS_DATA * p_msg)505 void bta_gatts_set_attr_value(tBTA_GATTS_SRVC_CB *p_srvc_cb, tBTA_GATTS_DATA *p_msg)
506 {
507 tBTA_GATTS_RCB *p_rcb = &bta_gatts_cb.rcb[p_srvc_cb->rcb_idx];
508 UINT16 service_id = p_srvc_cb->service_id;
509 tBTA_GATTS cb_data;
510 tBTA_GATT_STATUS gatts_status;
511 gatts_status = GATTS_SetAttributeValue(p_msg->api_set_val.hdr.layer_specific,
512 p_msg->api_set_val.length,
513 p_msg->api_set_val.value);
514
515 cb_data.attr_val.server_if = p_rcb->gatt_if;
516 cb_data.attr_val.service_id = service_id;
517 cb_data.attr_val.attr_id = p_msg->api_set_val.hdr.layer_specific;
518 cb_data.attr_val.status = gatts_status;
519
520 if (p_msg->api_set_val.value != NULL){
521 osi_free(p_msg->api_set_val.value);
522 }
523
524 if (p_rcb->p_cback) {
525 (*p_rcb->p_cback)(BTA_GATTS_SET_ATTR_VAL_EVT, &cb_data);
526 }
527 }
528
529 /*******************************************************************************
530 **
531 ** Function bta_gatts_get_attr_value
532 **
533 ** Description This function retrieves the attribute value associated with
534 ** the given attribute handle.
535 **
536 ** Returns tGATT_STATUS - GATT status indicating success or failure in
537 ** retrieving the attribute value.
538 **
539 *******************************************************************************/
540
bta_gatts_get_attr_value(UINT16 attr_handle,UINT16 * length,UINT8 ** value)541 tGATT_STATUS bta_gatts_get_attr_value(UINT16 attr_handle, UINT16 *length, UINT8 **value)
542 {
543 if (GATTS_GetAttributeValueInternal(attr_handle, length, value) == 0) {
544 return 0;
545 }
546
547 return GATTS_GetAttributeValue(attr_handle, length, value);
548 }
549
550 /*******************************************************************************
551 **
552 ** Function bta_gatts_delete_service
553 **
554 ** Description action function to delete a service.
555 **
556 ** Returns none.
557 **
558 *******************************************************************************/
bta_gatts_delete_service(tBTA_GATTS_SRVC_CB * p_srvc_cb,tBTA_GATTS_DATA * p_msg)559 void bta_gatts_delete_service(tBTA_GATTS_SRVC_CB *p_srvc_cb, tBTA_GATTS_DATA *p_msg)
560 {
561 tBTA_GATTS_RCB *p_rcb = &bta_gatts_cb.rcb[p_srvc_cb->rcb_idx];
562 tBTA_GATTS cb_data;
563
564 cb_data.srvc_oper.server_if = p_rcb->gatt_if;
565 cb_data.srvc_oper.service_id = p_msg->api_add_incl_srvc.hdr.layer_specific;
566
567 if (GATTS_DeleteService(p_rcb->gatt_if,
568 &p_srvc_cb->service_uuid,
569 p_srvc_cb->inst_num)) {
570 cb_data.srvc_oper.status = BTA_GATT_OK;
571 memset(p_srvc_cb, 0, sizeof(tBTA_GATTS_SRVC_CB));
572 } else {
573 cb_data.srvc_oper.status = BTA_GATT_ERROR;
574 }
575
576 if (p_rcb->p_cback) {
577 (*p_rcb->p_cback)(BTA_GATTS_DELELTE_EVT, &cb_data);
578 }
579
580 }
581 /*******************************************************************************
582 **
583 ** Function bta_gatts_start_service
584 **
585 ** Description action function to start a service.
586 **
587 ** Returns none.
588 **
589 *******************************************************************************/
bta_gatts_start_service(tBTA_GATTS_SRVC_CB * p_srvc_cb,tBTA_GATTS_DATA * p_msg)590 void bta_gatts_start_service(tBTA_GATTS_SRVC_CB *p_srvc_cb, tBTA_GATTS_DATA *p_msg)
591 {
592 tBTA_GATTS_RCB *p_rcb = &bta_gatts_cb.rcb[p_srvc_cb->rcb_idx];
593 tBTA_GATTS cb_data;
594
595 cb_data.srvc_oper.server_if = p_rcb->gatt_if;
596 cb_data.srvc_oper.service_id = p_msg->api_add_incl_srvc.hdr.layer_specific;
597
598 if (GATTS_StartService(p_rcb->gatt_if,
599 p_srvc_cb->service_id,
600 p_msg->api_start.transport) == GATT_SUCCESS) {
601 APPL_TRACE_DEBUG("bta_gatts_start_service service_id= %d", p_srvc_cb->service_id);
602 cb_data.srvc_oper.status = BTA_GATT_OK;
603 } else {
604 cb_data.srvc_oper.status = BTA_GATT_ERROR;
605 }
606
607 if (p_rcb->p_cback) {
608 (*p_rcb->p_cback)(BTA_GATTS_START_EVT, &cb_data);
609 }
610
611 }
612 /*******************************************************************************
613 **
614 ** Function bta_gatts_stop_service
615 **
616 ** Description action function to stop a service.
617 **
618 ** Returns none.
619 **
620 *******************************************************************************/
bta_gatts_stop_service(tBTA_GATTS_SRVC_CB * p_srvc_cb,tBTA_GATTS_DATA * p_msg)621 void bta_gatts_stop_service(tBTA_GATTS_SRVC_CB *p_srvc_cb, tBTA_GATTS_DATA *p_msg)
622 {
623 tBTA_GATTS_RCB *p_rcb = &bta_gatts_cb.rcb[p_srvc_cb->rcb_idx];
624 tBTA_GATTS cb_data;
625 UNUSED(p_msg);
626
627 GATTS_StopService(p_srvc_cb->service_id);
628 cb_data.srvc_oper.server_if = p_rcb->gatt_if;
629 cb_data.srvc_oper.service_id = p_srvc_cb->service_id;
630 cb_data.srvc_oper.status = BTA_GATT_OK;
631 APPL_TRACE_DEBUG("bta_gatts_stop_service service_id= %d", p_srvc_cb->service_id);
632
633 if (p_rcb->p_cback) {
634 (*p_rcb->p_cback)(BTA_GATTS_STOP_EVT, &cb_data);
635 }
636
637 }
638 /*******************************************************************************
639 **
640 ** Function bta_gatts_send_rsp
641 **
642 ** Description GATTS send response.
643 **
644 ** Returns none.
645 **
646 *******************************************************************************/
bta_gatts_send_rsp(tBTA_GATTS_CB * p_cb,tBTA_GATTS_DATA * p_msg)647 void bta_gatts_send_rsp (tBTA_GATTS_CB *p_cb, tBTA_GATTS_DATA *p_msg)
648 {
649 UNUSED(p_cb);
650
651 if (GATTS_SendRsp (p_msg->api_rsp.hdr.layer_specific,
652 p_msg->api_rsp.trans_id,
653 p_msg->api_rsp.status,
654 (tGATTS_RSP *)p_msg->api_rsp.p_rsp) != GATT_SUCCESS) {
655 APPL_TRACE_ERROR("Sending response failed\n");
656 }
657
658 }
659 /*******************************************************************************
660 **
661 ** Function bta_gatts_indicate_handle
662 **
663 ** Description GATTS send handle value indication or notification.
664 **
665 ** Returns none.
666 **
667 *******************************************************************************/
bta_gatts_indicate_handle(tBTA_GATTS_CB * p_cb,tBTA_GATTS_DATA * p_msg)668 void bta_gatts_indicate_handle (tBTA_GATTS_CB *p_cb, tBTA_GATTS_DATA *p_msg)
669 {
670 tBTA_GATTS_SRVC_CB *p_srvc_cb;
671 tBTA_GATTS_RCB *p_rcb = NULL;
672 tBTA_GATT_STATUS status = BTA_GATT_ILLEGAL_PARAMETER;
673 tGATT_IF gatt_if;
674 BD_ADDR remote_bda;
675 tBTA_TRANSPORT transport;
676 tBTA_GATTS cb_data;
677
678 p_srvc_cb = bta_gatts_find_srvc_cb_by_attr_id (p_cb, p_msg->api_indicate.attr_id);
679
680 if (p_srvc_cb ) {
681 if (GATT_GetConnectionInfor(p_msg->api_indicate.hdr.layer_specific,
682 &gatt_if, remote_bda, &transport)) {
683 p_rcb = bta_gatts_find_app_rcb_by_app_if(gatt_if);
684
685 if (p_msg->api_indicate.need_confirm) {
686
687 status = GATTS_HandleValueIndication (p_msg->api_indicate.hdr.layer_specific,
688 p_msg->api_indicate.attr_id,
689 p_msg->api_indicate.len,
690 p_msg->api_indicate.value);
691 } else {
692 l2ble_update_att_acl_pkt_num(L2CA_DECREASE_BTU_NUM, NULL);
693 status = GATTS_HandleValueNotification (p_msg->api_indicate.hdr.layer_specific,
694 p_msg->api_indicate.attr_id,
695 p_msg->api_indicate.len,
696 p_msg->api_indicate.value);
697 }
698
699 /* if over BR_EDR, inform PM for mode change */
700 if (transport == BTA_TRANSPORT_BR_EDR) {
701 bta_sys_busy(BTA_ID_GATTS, BTA_ALL_APP_ID, remote_bda);
702 bta_sys_idle(BTA_ID_GATTS, BTA_ALL_APP_ID, remote_bda);
703 }
704 } else {
705 APPL_TRACE_ERROR("Unknown connection ID: %d fail sending notification",
706 p_msg->api_indicate.hdr.layer_specific);
707 }
708
709 if ((status != GATT_SUCCESS || !p_msg->api_indicate.need_confirm) &&
710 p_rcb && p_cb->rcb[p_srvc_cb->rcb_idx].p_cback) {
711 cb_data.req_data.status = status;
712 cb_data.req_data.conn_id = p_msg->api_indicate.hdr.layer_specific;
713 cb_data.req_data.value = NULL;
714 cb_data.req_data.data_len = 0;
715 cb_data.req_data.handle = p_msg->api_indicate.attr_id;
716
717 if (p_msg->api_indicate.len > 0) {
718 cb_data.req_data.value = (uint8_t *) osi_malloc(p_msg->api_indicate.len);
719 if (cb_data.req_data.value != NULL) {
720 memset(cb_data.req_data.value, 0, p_msg->api_indicate.len);
721 cb_data.req_data.data_len = p_msg->api_indicate.len;
722 memcpy(cb_data.req_data.value, p_msg->api_indicate.value, p_msg->api_indicate.len);
723 } else {
724 APPL_TRACE_ERROR("%s, malloc failed", __func__);
725 }
726 } else {
727 APPL_TRACE_ERROR("%s, incorrect length", __func__);
728 }
729 (*p_rcb->p_cback)(BTA_GATTS_CONF_EVT, &cb_data);
730 if (cb_data.req_data.value != NULL) {
731 osi_free(cb_data.req_data.value);
732 cb_data.req_data.value = NULL;
733 }
734 }
735 } else {
736 APPL_TRACE_ERROR("Not an registered servce attribute ID: 0x%04x",
737 p_msg->api_indicate.attr_id);
738 }
739 }
740
741
742 /*******************************************************************************
743 **
744 ** Function bta_gatts_open
745 **
746 ** Description
747 **
748 ** Returns none.
749 **
750 *******************************************************************************/
bta_gatts_open(tBTA_GATTS_CB * p_cb,tBTA_GATTS_DATA * p_msg)751 void bta_gatts_open (tBTA_GATTS_CB *p_cb, tBTA_GATTS_DATA *p_msg)
752 {
753 tBTA_GATTS_RCB *p_rcb = NULL;
754 tBTA_GATT_STATUS status = BTA_GATT_ERROR;
755 UINT16 conn_id;
756 tBTA_GATTS_OPEN open;
757 UNUSED(p_cb);
758
759 if ((p_rcb = bta_gatts_find_app_rcb_by_app_if(p_msg->api_open.server_if)) != NULL) {
760 /* should always get the connection ID */
761 if (GATT_Connect(p_rcb->gatt_if, p_msg->api_open.remote_bda, BLE_ADDR_UNKNOWN_TYPE,
762 p_msg->api_open.is_direct, p_msg->api_open.transport, FALSE)) {
763 status = BTA_GATT_OK;
764
765 if (GATT_GetConnIdIfConnected(p_rcb->gatt_if, p_msg->api_open.remote_bda,
766 &conn_id, p_msg->api_open.transport)) {
767 status = BTA_GATT_ALREADY_OPEN;
768 }
769 }
770 } else {
771 APPL_TRACE_ERROR("Inavlide server_if=%d", p_msg->api_open.server_if);
772 }
773
774 if (p_rcb && p_rcb->p_cback) {
775 open.status = status;
776 open.server_if = p_msg->api_open.server_if;
777 (*p_rcb->p_cback)(BTA_GATTS_OPEN_EVT, (tBTA_GATTS *)&open);
778 }
779
780 }
781 /*******************************************************************************
782 **
783 ** Function bta_gatts_cancel_open
784 **
785 ** Description
786 **
787 ** Returns none.
788 **
789 *******************************************************************************/
bta_gatts_cancel_open(tBTA_GATTS_CB * p_cb,tBTA_GATTS_DATA * p_msg)790 void bta_gatts_cancel_open (tBTA_GATTS_CB *p_cb, tBTA_GATTS_DATA *p_msg)
791 {
792 tBTA_GATTS_RCB *p_rcb;
793 tBTA_GATT_STATUS status = BTA_GATT_ERROR;
794 tBTA_GATTS_CANCEL_OPEN cancel_open;
795 UNUSED(p_cb);
796
797 if ((p_rcb = bta_gatts_find_app_rcb_by_app_if(p_msg->api_cancel_open.server_if)) != NULL) {
798 if (!GATT_CancelConnect(p_rcb->gatt_if, p_msg->api_cancel_open.remote_bda,
799 p_msg->api_cancel_open.is_direct)) {
800 APPL_TRACE_ERROR("bta_gatts_cancel_open failed for open request");
801 } else {
802 status = BTA_GATT_OK;
803 }
804 } else {
805 APPL_TRACE_ERROR("Inavlide server_if=%d", p_msg->api_cancel_open.server_if);
806 }
807
808 if (p_rcb && p_rcb->p_cback) {
809 cancel_open.status = status;
810 cancel_open.server_if = p_msg->api_cancel_open.server_if;
811 (*p_rcb->p_cback)(BTA_GATTS_CANCEL_OPEN_EVT, (tBTA_GATTS *)&cancel_open);
812
813 }
814 }
815 /*******************************************************************************
816 **
817 ** Function bta_gatts_close
818 **
819 ** Description
820 **
821 ** Returns none.
822 **
823 *******************************************************************************/
bta_gatts_close(tBTA_GATTS_CB * p_cb,tBTA_GATTS_DATA * p_msg)824 void bta_gatts_close (tBTA_GATTS_CB *p_cb, tBTA_GATTS_DATA *p_msg)
825 {
826 tBTA_GATTS_RCB *p_rcb;
827 tBTA_GATT_STATUS status = BTA_GATT_ERROR;
828 tGATT_IF gatt_if;
829 BD_ADDR remote_bda;
830 tBTA_GATT_TRANSPORT transport;
831 tBTA_GATTS_CLOSE close;
832 UNUSED(p_cb);
833
834 if (GATT_GetConnectionInfor(p_msg->hdr.layer_specific, &gatt_if, remote_bda, &transport)) {
835 if (GATT_Disconnect(p_msg->hdr.layer_specific) != GATT_SUCCESS) {
836 APPL_TRACE_ERROR("bta_gatts_close fail conn_id=%d", p_msg->hdr.layer_specific);
837 } else {
838 status = BTA_GATT_OK;
839 }
840
841 p_rcb = bta_gatts_find_app_rcb_by_app_if(gatt_if);
842
843 if (p_rcb && p_rcb->p_cback) {
844 if (transport == BTA_TRANSPORT_BR_EDR) {
845 bta_sys_conn_close( BTA_ID_GATTS , BTA_ALL_APP_ID, remote_bda);
846 }
847
848 close.status = status;
849 close.conn_id = p_msg->hdr.layer_specific;
850 (*p_rcb->p_cback)(BTA_GATTS_CLOSE_EVT, (tBTA_GATTS *)&close);
851 }
852 } else {
853 APPL_TRACE_ERROR("Unknown connection ID: %d", p_msg->hdr.layer_specific);
854 }
855
856 }
857
858 /*******************************************************************************
859 **
860 ** Function bta_gatts_send_service_change_indication
861 **
862 ** Description gatts send service change indication
863 **
864 ** Returns none.
865 **
866 *******************************************************************************/
bta_gatts_send_service_change_indication(tBTA_GATTS_DATA * p_msg)867 void bta_gatts_send_service_change_indication (tBTA_GATTS_DATA *p_msg)
868 {
869 tBTA_GATTS_RCB *p_rcb = bta_gatts_find_app_rcb_by_app_if(p_msg->api_send_service_change.server_if);
870 tBTA_GATTS_SERVICE_CHANGE service_change;
871 tBTA_GATT_STATUS status = BTA_GATT_OK;
872 UINT16 addr[BD_ADDR_LEN] = {0};
873 if(memcmp(p_msg->api_send_service_change.remote_bda, addr, BD_ADDR_LEN) != 0) {
874 BD_ADDR bd_addr;
875 memcpy(bd_addr, p_msg->api_send_service_change.remote_bda, BD_ADDR_LEN);
876 status = GATT_SendServiceChangeIndication(bd_addr);
877 } else {
878 status = GATT_SendServiceChangeIndication(NULL);
879 }
880 if (p_rcb && p_rcb->p_cback) {
881 service_change.status = status;
882 service_change.server_if = p_msg->api_send_service_change.server_if;
883 (*p_rcb->p_cback)(BTA_GATTS_SEND_SERVICE_CHANGE_EVT, (tBTA_GATTS *)&service_change);
884 }
885 }
886
887 /*******************************************************************************
888 **
889 ** Function bta_gatts_listen
890 **
891 ** Description Start or stop listening for LE connection on a GATT server
892 **
893 ** Returns none.
894 **
895 *******************************************************************************/
bta_gatts_listen(tBTA_GATTS_CB * p_cb,tBTA_GATTS_DATA * p_msg)896 void bta_gatts_listen(tBTA_GATTS_CB *p_cb, tBTA_GATTS_DATA *p_msg)
897 {
898 tBTA_GATTS_RCB *p_rcb = bta_gatts_find_app_rcb_by_app_if(p_msg->api_listen.server_if);
899 tBTA_GATTS cb_data;
900 UNUSED(p_cb);
901
902 cb_data.reg_oper.status = BTA_GATT_OK;
903 cb_data.reg_oper.server_if = p_msg->api_listen.server_if;
904
905 if (p_rcb == NULL) {
906 APPL_TRACE_ERROR("Unknown GATTS application");
907 return;
908 }
909
910 if (!GATT_Listen(p_msg->api_listen.server_if,
911 p_msg->api_listen.start,
912 p_msg->api_listen.remote_bda)) {
913 cb_data.status = BTA_GATT_ERROR;
914 APPL_TRACE_ERROR("bta_gatts_listen Listen failed");
915 }
916
917 if (p_rcb->p_cback) {
918 (*p_rcb->p_cback)(BTA_GATTS_LISTEN_EVT, &cb_data);
919 }
920 }
921
922 /*******************************************************************************
923 **
924 ** Function bta_gatts_show_local_database
925 **
926 ** Description print loacl service database
927 **
928 ** Returns none.
929 **
930 *******************************************************************************/
bta_gatts_show_local_database(void)931 void bta_gatts_show_local_database (void)
932 {
933 if (GATTS_ShowLocalDatabase()) {
934 APPL_TRACE_ERROR("%s failed", __func__);
935 }
936 }
937
938 /*******************************************************************************
939 **
940 ** Function bta_gatts_request_cback
941 **
942 ** Description GATTS attribute request callback.
943 **
944 ** Returns none.
945 **
946 *******************************************************************************/
bta_gatts_send_request_cback(UINT16 conn_id,UINT32 trans_id,tGATTS_REQ_TYPE req_type,tGATTS_DATA * p_data)947 static void bta_gatts_send_request_cback (UINT16 conn_id,
948 UINT32 trans_id,
949 tGATTS_REQ_TYPE req_type, tGATTS_DATA *p_data)
950 {
951 tBTA_GATTS cb_data;
952 tBTA_GATTS_RCB *p_rcb;
953 tGATT_IF gatt_if;
954 tBTA_GATT_TRANSPORT transport;
955
956 memset(&cb_data, 0 , sizeof(tBTA_GATTS));
957
958 if (GATT_GetConnectionInfor(conn_id, &gatt_if, cb_data.req_data.remote_bda, &transport)) {
959 p_rcb = bta_gatts_find_app_rcb_by_app_if(gatt_if);
960
961 APPL_TRACE_DEBUG ("bta_gatts_send_request_cback conn_id=%d trans_id=%d req_type=%d",
962 conn_id, trans_id, req_type);
963
964 if (p_rcb && p_rcb->p_cback) {
965 /* if over BR_EDR, inform PM for mode change */
966 if (transport == BTA_TRANSPORT_BR_EDR) {
967 bta_sys_busy(BTA_ID_GATTS, BTA_ALL_APP_ID, cb_data.req_data.remote_bda);
968 bta_sys_idle(BTA_ID_GATTS, BTA_ALL_APP_ID, cb_data.req_data.remote_bda);
969 }
970
971 cb_data.req_data.conn_id = conn_id;
972 cb_data.req_data.trans_id = trans_id;
973 cb_data.req_data.p_data = (tBTA_GATTS_REQ_DATA *)p_data;
974
975 if(req_type == BTA_GATTS_CONF_EVT) {
976 cb_data.req_data.handle = p_data->handle;
977 }
978 (*p_rcb->p_cback)(req_type, &cb_data);
979 } else {
980 APPL_TRACE_ERROR("connection request on gatt_if[%d] is not interested", gatt_if);
981 }
982 } else {
983 APPL_TRACE_ERROR("request received on unknown connection ID: %d", conn_id);
984 }
985 }
986
987 /*******************************************************************************
988 **
989 ** Function bta_gatts_conn_cback
990 **
991 ** Description connection callback.
992 **
993 ** Returns none.
994 **
995 *******************************************************************************/
bta_gatts_conn_cback(tGATT_IF gatt_if,BD_ADDR bda,UINT16 conn_id,BOOLEAN connected,tGATT_DISCONN_REASON reason,tGATT_TRANSPORT transport)996 static void bta_gatts_conn_cback (tGATT_IF gatt_if, BD_ADDR bda, UINT16 conn_id,
997 BOOLEAN connected, tGATT_DISCONN_REASON reason,
998 tGATT_TRANSPORT transport)
999 {
1000 tBTA_GATTS cb_data = {0};
1001 UINT8 evt = connected ? BTA_GATTS_CONNECT_EVT : BTA_GATTS_DISCONNECT_EVT;
1002 tBTA_GATTS_RCB *p_reg;
1003
1004 APPL_TRACE_DEBUG ("bta_gatts_conn_cback gatt_if=%d conn_id=%d connected=%d reason = 0x%04d",
1005 gatt_if, conn_id, connected, reason);
1006 APPL_TRACE_DEBUG("bta_gatts_conn_cback bda :%02x-%02x-%02x-%02x-%02x-%02x ",
1007 bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
1008
1009 bt_bdaddr_t bdaddr;
1010 bdcpy(bdaddr.address, bda);
1011 /*
1012 if (connected)
1013 btif_debug_conn_state(bdaddr, BTIF_DEBUG_CONNECTED, GATT_CONN_UNKNOWN);
1014 else
1015 btif_debug_conn_state(bdaddr, BTIF_DEBUG_DISCONNECTED, reason);
1016 */
1017 p_reg = bta_gatts_find_app_rcb_by_app_if(gatt_if);
1018
1019 if (p_reg && p_reg->p_cback) {
1020 /* there is no RM for GATT */
1021 if (transport == BTA_TRANSPORT_BR_EDR) {
1022 if (connected) {
1023 bta_sys_conn_open(BTA_ID_GATTS, BTA_ALL_APP_ID, bda);
1024 } else {
1025 bta_sys_conn_close( BTA_ID_GATTS , BTA_ALL_APP_ID, bda);
1026 }
1027 }
1028 if(evt == BTA_GATTS_CONNECT_EVT) {
1029 tL2C_LCB *p_lcb = l2cu_find_lcb_by_bd_addr(bda, BT_TRANSPORT_LE);
1030 if(p_lcb != NULL) {
1031 cb_data.conn.conn_params.interval = p_lcb->current_used_conn_interval;
1032 cb_data.conn.conn_params.latency = p_lcb->current_used_conn_latency;
1033 cb_data.conn.conn_params.timeout = p_lcb->current_used_conn_timeout;
1034 cb_data.conn.link_role = p_lcb->link_role;
1035 #if (BLE_INCLUDED == TRUE)
1036 cb_data.conn.ble_addr_type = p_lcb->ble_addr_type;
1037 #endif
1038 cb_data.conn.conn_handle = p_lcb->handle;
1039 }else {
1040 APPL_TRACE_WARNING("%s not found connection parameters of the device ", __func__);
1041 }
1042 }
1043 cb_data.conn.conn_id = conn_id;
1044 cb_data.conn.server_if = gatt_if;
1045 cb_data.conn.reason = reason;
1046 cb_data.conn.transport = transport;
1047 memcpy(cb_data.conn.remote_bda, bda, BD_ADDR_LEN);
1048 (*p_reg->p_cback)(evt, &cb_data);
1049 } else {
1050 APPL_TRACE_ERROR("bta_gatts_conn_cback server_if=%d not found", gatt_if);
1051 }
1052 }
1053
1054 /*******************************************************************************
1055 **
1056 ** Function bta_gatts_cong_cback
1057 **
1058 ** Description congestion callback.
1059 **
1060 ** Returns none.
1061 **
1062 *******************************************************************************/
bta_gatts_cong_cback(UINT16 conn_id,BOOLEAN congested)1063 static void bta_gatts_cong_cback (UINT16 conn_id, BOOLEAN congested)
1064 {
1065 tBTA_GATTS cb_data;
1066 cb_data.congest.conn_id = conn_id;
1067 cb_data.congest.congested = congested;
1068 btc_congest_callback(&cb_data);
1069 }
1070 #endif /* GATTS_INCLUDED */
1071
