android/hal-gatt.c

   1 /*
   2  * Copyright (C) 2014 Intel Corporation
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <stdbool.h>
  19 #include <string.h>
  20 #include <stdlib.h>
  21
  22 #include "hal-log.h"
  23 #include "hal.h"
  24 #include "hal-msg.h"
  25 #include "ipc-common.h"
  26 #include "hal-ipc.h"
  27 #include "hal-utils.h"
  28
  29 static const btgatt_callbacks_t *cbs = NULL;
  30
  31 static bool interface_ready(void)
  32 {
  33         return cbs != NULL;
  34 }
  35
  36 static void gatt_id_from_hal(btgatt_gatt_id_t *to,
  37                                                 struct hal_gatt_gatt_id *from)
  38 {
  39         memcpy(&to->uuid, from->uuid, sizeof(to->uuid));
  40         to->inst_id = from->inst_id;
  41 }
  42
  43 static void gatt_id_to_hal(struct hal_gatt_gatt_id *to, btgatt_gatt_id_t *from)
  44 {
  45         memcpy(to->uuid, &from->uuid, sizeof(from->uuid));
  46         to->inst_id = from->inst_id;
  47 }
  48
  49 static void srvc_id_from_hal(btgatt_srvc_id_t *to,
  50                                                 struct hal_gatt_srvc_id *from)
  51 {
  52         memcpy(&to->id.uuid, from->uuid, sizeof(to->id.uuid));
  53         to->id.inst_id = from->inst_id;
  54         to->is_primary = from->is_primary;
  55 }
  56
  57 static void srvc_id_to_hal(struct hal_gatt_srvc_id *to, btgatt_srvc_id_t *from)
  58 {
  59         memcpy(to->uuid, &from->id.uuid, sizeof(from->id.uuid));
  60         to->inst_id = from->id.inst_id;
  61         to->is_primary = from->is_primary;
  62 }
  63
  64 /* Client Event Handlers */
  65
  66 static void handle_register_client(void *buf, uint16_t len, int fd)
  67 {
  68         struct hal_ev_gatt_client_register_client *ev = buf;
  69
  70         if (cbs->client->register_client_cb)
  71                 cbs->client->register_client_cb(ev->status, ev->client_if,
  72                                                 (bt_uuid_t *) ev->app_uuid);
  73 }
  74
  75 static void handle_scan_result(void *buf, uint16_t len, int fd)
  76 {
  77         struct hal_ev_gatt_client_scan_result *ev = buf;
  78         uint8_t ad[62];
  79
  80         if (len != sizeof(*ev) + ev->len) {
  81                 error("gatt: invalid scan result event, aborting");
  82                 exit(EXIT_FAILURE);
  83         }
  84
  85         /* Java assumes that passed data has 62 bytes */
  86         memset(ad, 0, sizeof(ad));
  87         memcpy(ad, ev->adv_data, ev->len > sizeof(ad) ? sizeof(ad) : ev->len);
  88
  89         if (cbs->client->scan_result_cb)
  90                 cbs->client->scan_result_cb((bt_bdaddr_t *) ev->bda, ev->rssi,
  91                                                                         ad);
  92 }
  93
  94 static void handle_connect(void *buf, uint16_t len, int fd)
  95 {
  96         struct hal_ev_gatt_client_connect *ev = buf;
  97
  98         if (cbs->client->open_cb)
  99                 cbs->client->open_cb(ev->conn_id, ev->status, ev->client_if,
 100                                                 (bt_bdaddr_t *) ev->bda);
 101 }
 102
 103 static void handle_disconnect(void *buf, uint16_t len, int fd)
 104 {
 105         struct hal_ev_gatt_client_disconnect *ev = buf;
 106
 107         if (cbs->client->close_cb)
 108                 cbs->client->close_cb(ev->conn_id, ev->status, ev->client_if,
 109                                                 (bt_bdaddr_t *) ev->bda);
 110 }
 111
 112 static void handle_search_complete(void *buf, uint16_t len, int fd)
 113 {
 114         struct hal_ev_gatt_client_search_complete *ev = buf;
 115
 116         if (cbs->client->search_complete_cb)
 117                 cbs->client->search_complete_cb(ev->conn_id, ev->status);
 118 }
 119
 120 static void handle_search_result(void *buf, uint16_t len, int fd)
 121 {
 122         struct hal_ev_gatt_client_search_result *ev = buf;
 123         btgatt_srvc_id_t srvc_id;
 124
 125         srvc_id_from_hal(&srvc_id, &ev->srvc_id);
 126
 127         if (cbs->client->search_result_cb)
 128                 cbs->client->search_result_cb(ev->conn_id, &srvc_id);
 129 }
 130
 131 static void handle_get_characteristic(void *buf, uint16_t len, int fd)
 132 {
 133         struct hal_ev_gatt_client_get_characteristic *ev = buf;
 134         btgatt_gatt_id_t char_id;
 135         btgatt_srvc_id_t srvc_id;
 136
 137         srvc_id_from_hal(&srvc_id, &ev->srvc_id);
 138         gatt_id_from_hal(&char_id, &ev->char_id);
 139
 140         if (cbs->client->get_characteristic_cb)
 141                 cbs->client->get_characteristic_cb(ev->conn_id, ev->status,
 142                                                         &srvc_id, &char_id,
 143                                                         ev->char_prop);
 144 }
 145
 146 static void handle_get_descriptor(void *buf, uint16_t len, int fd)
 147 {
 148         struct hal_ev_gatt_client_get_descriptor *ev = buf;
 149         btgatt_gatt_id_t descr_id;
 150         btgatt_gatt_id_t char_id;
 151         btgatt_srvc_id_t srvc_id;
 152
 153         srvc_id_from_hal(&srvc_id, &ev->srvc_id);
 154         gatt_id_from_hal(&char_id, &ev->char_id);
 155         gatt_id_from_hal(&descr_id, &ev->descr_id);
 156
 157         if (cbs->client->get_descriptor_cb)
 158                 cbs->client->get_descriptor_cb(ev->conn_id, ev->status,
 159                                                 &srvc_id, &char_id, &descr_id);
 160 }
 161
 162 static void handle_get_included_service(void *buf, uint16_t len, int fd)
 163 {
 164         struct hal_ev_gatt_client_get_inc_service *ev = buf;
 165         btgatt_srvc_id_t srvc_id;
 166         btgatt_srvc_id_t incl_srvc_id;
 167
 168         srvc_id_from_hal(&srvc_id, &ev->srvc_id);
 169         srvc_id_from_hal(&incl_srvc_id, &ev->incl_srvc_id);
 170
 171         if (cbs->client->get_included_service_cb)
 172                 cbs->client->get_included_service_cb(ev->conn_id, ev->status,
 173                                                                 &srvc_id,
 174                                                                 &incl_srvc_id);
 175 }
 176
 177 static void handle_register_for_notification(void *buf, uint16_t len, int fd)
 178 {
 179         struct hal_ev_gatt_client_reg_for_notif *ev = buf;
 180         btgatt_gatt_id_t char_id;
 181         btgatt_srvc_id_t srvc_id;
 182
 183         srvc_id_from_hal(&srvc_id, &ev->srvc_id);
 184         gatt_id_from_hal(&char_id, &ev->char_id);
 185
 186         if (cbs->client->register_for_notification_cb)
 187                 cbs->client->register_for_notification_cb(ev->conn_id,
 188                                                                 ev->registered,
 189                                                                 ev->status,
 190                                                                 &srvc_id,
 191                                                                 &char_id);
 192 }
 193
 194 static void handle_notify(void *buf, uint16_t len, int fd)
 195 {
 196         struct hal_ev_gatt_client_notify *ev = buf;
 197         btgatt_notify_params_t params;
 198
 199         if (len != sizeof(*ev) + ev->len) {
 200                 error("gatt: invalid notify event, aborting");
 201                 exit(EXIT_FAILURE);
 202         }
 203
 204         memset(&params, 0, sizeof(params));
 205         memcpy(params.value, ev->value, ev->len);
 206         memcpy(&params.bda, ev->bda, sizeof(params.bda));
 207
 208         srvc_id_from_hal(&params.srvc_id, &ev->srvc_id);
 209         gatt_id_from_hal(&params.char_id, &ev->char_id);
 210
 211         params.len = ev->len;
 212         params.is_notify = ev->is_notify;
 213
 214         if (cbs->client->notify_cb)
 215                 cbs->client->notify_cb(ev->conn_id, &params);
 216 }
 217
 218 static void handle_read_characteristic(void *buf, uint16_t len, int fd)
 219 {
 220         struct hal_ev_gatt_client_read_characteristic *ev = buf;
 221         btgatt_read_params_t params;
 222
 223         if (len != sizeof(*ev) + ev->data.len) {
 224                 error("gatt: invalid read characteristic event, aborting");
 225                 exit(EXIT_FAILURE);
 226         }
 227
 228         memset(&params, 0, sizeof(params));
 229
 230         srvc_id_from_hal(&params.srvc_id, &ev->data.srvc_id);
 231         gatt_id_from_hal(&params.char_id, &ev->data.char_id);
 232         gatt_id_from_hal(&params.descr_id, &ev->data.descr_id);
 233
 234         memcpy(&params.value.value, ev->data.value, ev->data.len);
 235
 236         params.value_type = ev->data.value_type;
 237         params.value.len = ev->data.len;
 238         params.status = ev->data.status;
 239
 240         if (cbs->client->read_characteristic_cb)
 241                 cbs->client->read_characteristic_cb(ev->conn_id, ev->status,
 242                                                                 &params);
 243 }
 244
 245 static void handle_write_characteristic(void *buf, uint16_t len, int fd)
 246 {
 247         struct hal_ev_gatt_client_write_characteristic *ev = buf;
 248         btgatt_write_params_t params;
 249
 250         memset(&params, 0, sizeof(params));
 251
 252         srvc_id_from_hal(&params.srvc_id, &ev->data.srvc_id);
 253         gatt_id_from_hal(&params.char_id, &ev->data.char_id);
 254         gatt_id_from_hal(&params.descr_id, &ev->data.descr_id);
 255
 256         params.status = ev->data.status;
 257
 258         if (cbs->client->write_characteristic_cb)
 259                 cbs->client->write_characteristic_cb(ev->conn_id, ev->status,
 260                                                                 &params);
 261 }
 262
 263 static void handle_read_descriptor(void *buf, uint16_t len, int fd)
 264 {
 265         struct hal_ev_gatt_client_read_descriptor *ev = buf;
 266         btgatt_read_params_t params;
 267
 268         if (len != sizeof(*ev) + ev->data.len) {
 269                 error("gatt: invalid read descriptor event, aborting");
 270                 exit(EXIT_FAILURE);
 271         }
 272
 273         memset(&params, 0, sizeof(params));
 274
 275         srvc_id_from_hal(&params.srvc_id, &ev->data.srvc_id);
 276         gatt_id_from_hal(&params.char_id, &ev->data.char_id);
 277         gatt_id_from_hal(&params.descr_id, &ev->data.descr_id);
 278
 279         memcpy(&params.value.value, ev->data.value, ev->data.len);
 280
 281         params.value_type = ev->data.value_type;
 282         params.value.len = ev->data.len;
 283         params.status = ev->data.status;
 284
 285         if (cbs->client->read_descriptor_cb)
 286                 cbs->client->read_descriptor_cb(ev->conn_id, ev->status,
 287                                                                 &params);
 288 }
 289
 290 static void handle_write_descriptor(void *buf, uint16_t len, int fd)
 291 {
 292         struct hal_ev_gatt_client_write_descriptor *ev = buf;
 293         btgatt_write_params_t params;
 294
 295         memset(&params, 0, sizeof(params));
 296
 297         srvc_id_from_hal(&params.srvc_id, &ev->data.srvc_id);
 298         gatt_id_from_hal(&params.char_id, &ev->data.char_id);
 299         gatt_id_from_hal(&params.descr_id, &ev->data.descr_id);
 300
 301         params.status = ev->data.status;
 302
 303         if (cbs->client->write_descriptor_cb)
 304                 cbs->client->write_descriptor_cb(ev->conn_id, ev->status,
 305                                                                 &params);
 306 }
 307
 308 static void handle_execute_write(void *buf, uint16_t len, int fd)
 309 {
 310         struct hal_ev_gatt_client_exec_write *ev = buf;
 311
 312         if (cbs->client->execute_write_cb)
 313                 cbs->client->execute_write_cb(ev->conn_id, ev->status);
 314 }
 315
 316 static void handle_read_remote_rssi(void *buf, uint16_t len, int fd)
 317 {
 318         struct hal_ev_gatt_client_read_remote_rssi *ev = buf;
 319
 320         if (cbs->client->read_remote_rssi_cb)
 321                 cbs->client->read_remote_rssi_cb(ev->client_if,
 322                                                 (bt_bdaddr_t *) ev->address,
 323                                                 ev->rssi, ev->status);
 324 }
 325
 326 static void handle_listen(void *buf, uint16_t len, int fd)
 327 {
 328         struct hal_ev_gatt_client_listen *ev = buf;
 329
 330         if (cbs->client->listen_cb)
 331                 cbs->client->listen_cb(ev->status, ev->server_if);
 332 }
 333
 334 /* Server Event Handlers */
 335
 336 static void handle_register_server(void *buf, uint16_t len, int fd)
 337 {
 338         struct hal_ev_gatt_server_register *ev = buf;
 339
 340         if (cbs->server->register_server_cb)
 341                 cbs->server->register_server_cb(ev->status, ev->server_if,
 342                                                 (bt_uuid_t *) &ev->uuid);
 343 }
 344
 345 static void handle_connection(void *buf, uint16_t len, int fd)
 346 {
 347         struct hal_ev_gatt_server_connection *ev = buf;
 348
 349         if (cbs->server->connection_cb)
 350                 cbs->server->connection_cb(ev->conn_id, ev->server_if,
 351                                                 ev->connected,
 352                                                 (bt_bdaddr_t *) &ev->bdaddr);
 353 }
 354
 355 static void handle_service_added(void *buf, uint16_t len, int fd)
 356 {
 357         struct hal_ev_gatt_server_service_added *ev = buf;
 358         btgatt_srvc_id_t srvc_id;
 359
 360         srvc_id_from_hal(&srvc_id, &ev->srvc_id);
 361
 362         if (cbs->server->service_added_cb)
 363                 cbs->server->service_added_cb(ev->status, ev->server_if,
 364                                                 &srvc_id, ev->srvc_handle);
 365 }
 366
 367 static void handle_included_service_added(void *buf, uint16_t len, int fd)
 368 {
 369         struct hal_ev_gatt_server_inc_srvc_added *ev = buf;
 370
 371         if (cbs->server->included_service_added_cb)
 372                 cbs->server->included_service_added_cb(ev->status,
 373                                                         ev->server_if,
 374                                                         ev->srvc_handle,
 375                                                         ev->incl_srvc_handle);
 376 }
 377
 378 static void handle_characteristic_added(void *buf, uint16_t len, int fd)
 379 {
 380         struct hal_ev_gatt_server_characteristic_added *ev = buf;
 381
 382         if (cbs->server->characteristic_added_cb)
 383                 cbs->server->characteristic_added_cb(ev->status, ev->server_if,
 384                                                         (bt_uuid_t *) &ev->uuid,
 385                                                         ev->srvc_handle,
 386                                                         ev->char_handle);
 387 }
 388
 389 static void handle_descriptor_added(void *buf, uint16_t len, int fd)
 390 {
 391         struct hal_ev_gatt_server_descriptor_added *ev = buf;
 392
 393         if (cbs->server->descriptor_added_cb)
 394                 cbs->server->descriptor_added_cb(ev->status, ev->server_if,
 395                                                         (bt_uuid_t *) &ev->uuid,
 396                                                         ev->srvc_handle,
 397                                                         ev->descr_handle);
 398 }
 399
 400 static void handle_service_started(void *buf, uint16_t len, int fd)
 401 {
 402         struct hal_ev_gatt_server_service_started *ev = buf;
 403
 404         if (cbs->server->service_started_cb)
 405                 cbs->server->service_started_cb(ev->status, ev->server_if,
 406                                                         ev->srvc_handle);
 407 }
 408
 409 static void handle_service_stopped(void *buf, uint16_t len, int fd)
 410 {
 411         struct hal_ev_gatt_server_service_stopped *ev = buf;
 412
 413         if (cbs->server->service_stopped_cb)
 414                 cbs->server->service_stopped_cb(ev->status, ev->server_if,
 415                                                         ev->srvc_handle);
 416 }
 417
 418 static void handle_service_deleted(void *buf, uint16_t len, int fd)
 419 {
 420         struct hal_ev_gatt_server_service_deleted *ev = buf;
 421
 422         if (cbs->server->service_deleted_cb)
 423                 cbs->server->service_deleted_cb(ev->status, ev->server_if,
 424                                                         ev->srvc_handle);
 425 }
 426
 427 static void handle_request_read(void *buf, uint16_t len, int fd)
 428 {
 429         struct hal_ev_gatt_server_request_read *ev = buf;
 430
 431         if (cbs->server->request_read_cb)
 432                 cbs->server->request_read_cb(ev->conn_id, ev->trans_id,
 433                                                 (bt_bdaddr_t *) &ev->bdaddr,
 434                                                 ev->attr_handle, ev->offset,
 435                                                 ev->is_long);
 436 }
 437
 438 static void handle_request_write(void *buf, uint16_t len, int fd)
 439 {
 440         struct hal_ev_gatt_server_request_write *ev = buf;
 441
 442         if (len != sizeof(*ev) + ev->length) {
 443                 error("gatt: invalid request write event, aborting");
 444                 exit(EXIT_FAILURE);
 445         }
 446
 447         if (cbs->server->request_write_cb)
 448                 cbs->server->request_write_cb(ev->conn_id, ev->trans_id,
 449                                                 (bt_bdaddr_t *) ev->bdaddr,
 450                                                 ev->attr_handle, ev->offset,
 451                                                 ev->length, ev->need_rsp,
 452                                                 ev->is_prep, ev->value);
 453 }
 454
 455 static void handle_request_exec_write(void *buf, uint16_t len, int fd)
 456 {
 457         struct hal_ev_gatt_server_request_exec_write *ev = buf;
 458
 459         if (cbs->server->request_exec_write_cb)
 460                 cbs->server->request_exec_write_cb(ev->conn_id, ev->trans_id,
 461                                                 (bt_bdaddr_t *) ev->bdaddr,
 462                                                 ev->exec_write);
 463 }
 464
 465 static void handle_response_confirmation(void *buf, uint16_t len, int fd)
 466 {
 467         struct hal_ev_gatt_server_rsp_confirmation *ev = buf;
 468
 469         if (cbs->server->response_confirmation_cb)
 470                 cbs->server->response_confirmation_cb(ev->status, ev->handle);
 471 }
 472
 473 static void handle_configure_mtu(void *buf, uint16_t len, int fd)
 474 {
 475 #if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
 476         struct hal_ev_gatt_client_configure_mtu *ev = buf;
 477
 478         if (cbs->client->configure_mtu_cb)
 479                 cbs->client->configure_mtu_cb(ev->conn_id, ev->status, ev->mtu);
 480 #endif
 481 }
 482
 483 static void handle_filter_config(void *buf, uint16_t len, int fd)
 484 {
 485 #if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
 486         struct hal_ev_gatt_client_filter_config *ev = buf;
 487
 488         if (cbs->client->scan_filter_cfg_cb)
 489                 cbs->client->scan_filter_cfg_cb(ev->action, ev->client_if,
 490                                                 ev->status, ev->type,
 491                                                 ev->space);
 492 #endif
 493 }
 494
 495 static void handle_filter_params(void *buf, uint16_t len, int fd)
 496 {
 497 #if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
 498         struct hal_ev_gatt_client_filter_params *ev = buf;
 499
 500         if (cbs->client->scan_filter_param_cb)
 501                 cbs->client->scan_filter_param_cb(ev->action, ev->client_if,
 502                                                         ev->status, ev->space);
 503 #endif
 504 }
 505
 506 static void handle_filter_status(void *buf, uint16_t len, int fd)
 507 {
 508 #if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
 509         struct hal_ev_gatt_client_filter_status *ev = buf;
 510
 511         if (cbs->client->scan_filter_status_cb)
 512                 cbs->client->scan_filter_status_cb(ev->enable, ev->client_if,
 513                                                                 ev->status);
 514 #endif
 515 }
 516
 517 static void handle__multi_adv_enable(void *buf, uint16_t len, int fd)
 518 {
 519 #if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
 520         struct hal_ev_gatt_client_multi_adv_enable *ev = buf;
 521
 522         if (cbs->client->multi_adv_enable_cb)
 523                 cbs->client->multi_adv_enable_cb(ev->client_if, ev->status);
 524 #endif
 525 }
 526
 527 static void handle_multi_adv_update(void *buf, uint16_t len, int fd)
 528 {
 529 #if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
 530         struct hal_ev_gatt_client_multi_adv_update *ev = buf;
 531
 532         if (cbs->client->multi_adv_update_cb)
 533                 cbs->client->multi_adv_update_cb(ev->client_if, ev->status);
 534 #endif
 535 }
 536
 537 static void handle_multi_adv_data(void *buf, uint16_t len, int fd)
 538 {
 539 #if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
 540         struct hal_ev_gatt_client_multi_adv_data *ev = buf;
 541
 542         if (cbs->client->multi_adv_data_cb)
 543                 cbs->client->multi_adv_data_cb(ev->client_if, ev->status);
 544 #endif
 545 }
 546
 547 static void handle_multi_adv_disable(void *buf, uint16_t len, int fd)
 548 {
 549 #if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
 550         struct hal_ev_gatt_client_multi_adv_disable *ev = buf;
 551
 552         if (cbs->client->multi_adv_disable_cb)
 553                 cbs->client->multi_adv_disable_cb(ev->client_if, ev->status);
 554 #endif
 555 }
 556
 557 static void handle_client_congestion(void *buf, uint16_t len, int fd)
 558 {
 559 #if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
 560         struct hal_ev_gatt_client_congestion *ev = buf;
 561
 562         if (cbs->client->congestion_cb)
 563                 cbs->client->congestion_cb(ev->conn_id, ev->congested);
 564 #endif
 565 }
 566
 567 static void handle_config_batchscan(void *buf, uint16_t len, int fd)
 568 {
 569 #if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
 570         struct hal_ev_gatt_client_config_batchscan *ev = buf;
 571
 572         if (cbs->client->batchscan_cfg_storage_cb)
 573                 cbs->client->batchscan_cfg_storage_cb(ev->client_if,
 574                                                                 ev->status);
 575 #endif
 576 }
 577
 578 static void handle_enable_batchscan(void *buf, uint16_t len, int fd)
 579 {
 580 #if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
 581         struct hal_ev_gatt_client_enable_batchscan *ev = buf;
 582
 583         if (cbs->client->batchscan_enb_disable_cb)
 584                 cbs->client->batchscan_enb_disable_cb(ev->action, ev->client_if,
 585                                                                 ev->status);
 586 #endif
 587 }
 588
 589 static void handle_client_batchscan_reports(void *buf, uint16_t len, int fd)
 590 {
 591 #if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
 592         struct hal_ev_gatt_client_batchscan_reports *ev = buf;
 593
 594         if (cbs->client->batchscan_reports_cb)
 595                 cbs->client->batchscan_reports_cb(ev->client_if, ev->status,
 596                                                         ev->format, ev->num,
 597                                                         ev->data_len, ev->data);
 598 #endif
 599 }
 600
 601 static void handle_batchscan_threshold(void *buf, uint16_t len, int fd)
 602 {
 603 #if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
 604         struct hal_ev_gatt_client_batchscan_threshold *ev = buf;
 605
 606         if (cbs->client->batchscan_threshold_cb)
 607                 cbs->client->batchscan_threshold_cb(ev->client_if);
 608 #endif
 609 }
 610
 611 static void handle_track_adv(void *buf, uint16_t len, int fd)
 612 {
 613 #if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
 614         struct hal_ev_gatt_client_track_adv *ev = buf;
 615
 616         if (cbs->client->track_adv_event_cb)
 617                 cbs->client->track_adv_event_cb(ev->client_if, ev->filetr_index,
 618                                                 ev->address_type,
 619                                                 (bt_bdaddr_t *) ev->address,
 620                                                 ev->state);
 621 #endif
 622 }
 623
 624 static void handle_indication_send(void *buf, uint16_t len, int fd)
 625 {
 626 #if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
 627         struct hal_ev_gatt_server_indication_sent *ev = buf;
 628
 629         if (cbs->server->indication_sent_cb)
 630                 cbs->server->indication_sent_cb(ev->conn_id, ev->status);
 631 #endif
 632 }
 633
 634 static void handle_server_congestion(void *buf, uint16_t len, int fd)
 635 {
 636 #if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
 637         struct hal_ev_gatt_server_congestion *ev = buf;
 638
 639         if (cbs->server->congestion_cb)
 640                 cbs->server->congestion_cb(ev->conn_id, ev->congested);
 641 #endif
 642 }
 643
 644 static void handle_server_mtu_changed(void *buf, uint16_t len, int fd)
 645 {
 646 #if ANDROID_VERSION >= PLATFORM_VER(5, 1, 0)
 647         struct hal_ev_gatt_server_mtu_changed *ev = buf;
 648
 649         if (cbs->server->mtu_changed_cb)
 650                 cbs->server->mtu_changed_cb(ev->conn_id, ev->mtu);
 651 #endif
 652 }
 653
 654 /*
 655  * handlers will be called from notification thread context,
 656  * index in table equals to 'opcode - HAL_MINIMUM_EVENT'
 657  */
 658 static const struct hal_ipc_handler ev_handlers[] = {
 659         /* HAL_EV_GATT_CLIENT_REGISTER_CLIENT */
 660         { handle_register_client, false,
 661                 sizeof(struct hal_ev_gatt_client_register_client) },
 662         /* HAL_EV_GATT_CLIENT_SCAN_RESULT */
 663         { handle_scan_result, true,
 664                 sizeof(struct hal_ev_gatt_client_scan_result) },
 665         /* HAL_EV_GATT_CLIENT_CONNECT */
 666         { handle_connect, false, sizeof(struct hal_ev_gatt_client_connect) },
 667         /* HAL_EV_GATT_CLIENT_DISCONNECT */
 668         { handle_disconnect, false,
 669                 sizeof(struct hal_ev_gatt_client_disconnect) },
 670         /* HAL_EV_GATT_CLIENT_SEARCH_COMPLETE */
 671         { handle_search_complete, false,
 672                 sizeof(struct hal_ev_gatt_client_search_complete) },
 673         /* HAL_EV_GATT_CLIENT_SEARCH_RESULT */
 674         { handle_search_result, false,
 675                 sizeof(struct hal_ev_gatt_client_search_result) },
 676         /* HAL_EV_GATT_CLIENT_GET_CHARACTERISTIC */
 677         { handle_get_characteristic, false,
 678                 sizeof(struct hal_ev_gatt_client_get_characteristic) },
 679         /* HAL_EV_GATT_CLIENT_GET_DESCRIPTOR */
 680         { handle_get_descriptor, false,
 681                 sizeof(struct hal_ev_gatt_client_get_descriptor) },
 682         /* HAL_EV_GATT_CLIENT_GET_INC_SERVICE */
 683         { handle_get_included_service, false,
 684                 sizeof(struct hal_ev_gatt_client_get_inc_service) },
 685         /* HAL_EV_GATT_CLIENT_REGISTER_FOR_NOTIF */
 686         { handle_register_for_notification, false,
 687                 sizeof(struct hal_ev_gatt_client_reg_for_notif) },
 688         /* HAL_EV_GATT_CLIENT_NOTIFY */
 689         { handle_notify, true, sizeof(struct hal_ev_gatt_client_notify) },
 690         /* HAL_EV_GATT_CLIENT_READ_CHARACTERISTIC */
 691         { handle_read_characteristic, true,
 692                 sizeof(struct hal_ev_gatt_client_read_characteristic) },
 693         /* HAL_EV_GATT_CLIENT_WRITE_CHARACTERISTIC */
 694         { handle_write_characteristic, false,
 695                 sizeof(struct hal_ev_gatt_client_write_characteristic) },
 696         /* HAL_EV_GATT_CLIENT_READ_DESCRIPTOR */
 697         { handle_read_descriptor, true,
 698                 sizeof(struct hal_ev_gatt_client_read_descriptor) },
 699         /* HAL_EV_GATT_CLIENT_WRITE_DESCRIPTOR */
 700         { handle_write_descriptor, false,
 701                 sizeof(struct hal_ev_gatt_client_write_descriptor) },
 702         /* HAL_EV_GATT_CLIENT_EXEC_WRITE */
 703         { handle_execute_write, false,
 704                 sizeof(struct hal_ev_gatt_client_exec_write) },
 705         /* HAL_EV_GATT_CLIENT_READ_REMOTE_RSSI */
 706         { handle_read_remote_rssi, false,
 707                 sizeof(struct hal_ev_gatt_client_read_remote_rssi) },
 708         /* HAL_EV_GATT_CLIENT_LISTEN */
 709         { handle_listen, false, sizeof(struct hal_ev_gatt_client_listen) },
 710         /* HAL_EV_GATT_SERVER_REGISTER */
 711         { handle_register_server, false,
 712                 sizeof(struct hal_ev_gatt_server_register) },
 713         /* HAL_EV_GATT_SERVER_CONNECTION */
 714         { handle_connection, false,
 715                 sizeof(struct hal_ev_gatt_server_connection) },
 716         /* HAL_EV_GATT_SERVER_SERVICE_ADDED */
 717         { handle_service_added, false,
 718                 sizeof(struct hal_ev_gatt_server_service_added) },
 719         /* HAL_EV_GATT_SERVER_INC_SRVC_ADDED */
 720         { handle_included_service_added, false,
 721                 sizeof(struct hal_ev_gatt_server_inc_srvc_added) },
 722         /* HAL_EV_GATT_SERVER_CHAR_ADDED */
 723         { handle_characteristic_added, false,
 724                 sizeof(struct hal_ev_gatt_server_characteristic_added) },
 725         /* HAL_EV_GATT_SERVER_DESCRIPTOR_ADDED */
 726         { handle_descriptor_added, false,
 727                 sizeof(struct hal_ev_gatt_server_descriptor_added) },
 728         /* HAL_EV_GATT_SERVER_SERVICE_STARTED */
 729         { handle_service_started, false,
 730                 sizeof(struct hal_ev_gatt_server_service_started) },
 731         /* HAL_EV_GATT_SERVER_SERVICE_STOPPED */
 732         { handle_service_stopped, false,
 733                 sizeof(struct hal_ev_gatt_server_service_stopped) },
 734         /* HAL_EV_GATT_SERVER_SERVICE_DELETED */
 735         { handle_service_deleted, false,
 736                 sizeof(struct hal_ev_gatt_server_service_deleted) },
 737         /* HAL_EV_GATT_SERVER_REQUEST_READ */
 738         { handle_request_read, false,
 739                 sizeof(struct hal_ev_gatt_server_request_read) },
 740         /* HAL_EV_GATT_SERVER_REQUEST_WRITE */
 741         { handle_request_write, true,
 742                 sizeof(struct hal_ev_gatt_server_request_write) },
 743         /* HAL_EV_GATT_SERVER_REQUEST_EXEC_WRITE */
 744         { handle_request_exec_write, false,
 745                 sizeof(struct hal_ev_gatt_server_request_exec_write) },
 746         /* HAL_EV_GATT_SERVER_RSP_CONFIRMATION */
 747         { handle_response_confirmation, false,
 748                 sizeof(struct hal_ev_gatt_server_rsp_confirmation) },
 749         /* HAL_EV_GATT_CLIENT_CONFIGURE_MTU */
 750         { handle_configure_mtu, false,
 751                 sizeof(struct hal_ev_gatt_client_configure_mtu) },
 752         /* HAL_EV_GATT_CLIENT_FILTER_CONFIG */
 753         { handle_filter_config, false,
 754                 sizeof(struct hal_ev_gatt_client_filter_config) },
 755         /* HAL_EV_GATT_CLIENT_FILTER_PARAMS */
 756         { handle_filter_params, false,
 757                 sizeof(struct hal_ev_gatt_client_filter_params) },
 758         /* HAL_EV_GATT_CLIENT_FILTER_STATUS */
 759         { handle_filter_status, false,
 760                 sizeof(struct hal_ev_gatt_client_filter_status) },
 761         /* HAL_EV_GATT_CLIENT_MULTI_ADV_ENABLE */
 762         { handle__multi_adv_enable, false,
 763                 sizeof(struct hal_ev_gatt_client_multi_adv_enable) },
 764         /* HAL_EV_GATT_CLIENT_MULTI_ADV_UPDATE */
 765         { handle_multi_adv_update, false,
 766                 sizeof(struct hal_ev_gatt_client_multi_adv_update) },
 767         /* HAL_EV_GATT_CLIENT_MULTI_ADV_DATA */
 768         { handle_multi_adv_data, false,
 769                 sizeof(struct hal_ev_gatt_client_multi_adv_data) },
 770         /* HAL_EV_GATT_CLIENT_MULTI_ADV_DISABLE */
 771         { handle_multi_adv_disable, false,
 772                 sizeof(struct hal_ev_gatt_client_multi_adv_disable) },
 773         /* HAL_EV_GATT_CLIENT_CONGESTION */
 774         { handle_client_congestion, false,
 775                 sizeof(struct hal_ev_gatt_client_congestion) },
 776         /* HAL_EV_GATT_CLIENT_CONFIG_BATCHSCAN */
 777         { handle_config_batchscan, false,
 778                 sizeof(struct hal_ev_gatt_client_config_batchscan) },
 779         /* HAL_EV_GATT_CLIENT_ENABLE_BATCHSCAN */
 780         { handle_enable_batchscan, false,
 781                 sizeof(struct hal_ev_gatt_client_enable_batchscan) },
 782         /* HAL_EV_GATT_CLIENT_BATCHSCAN_REPORTS */
 783         { handle_client_batchscan_reports, true,
 784                 sizeof(struct hal_ev_gatt_client_batchscan_reports) },
 785         /* HAL_EV_GATT_CLIENT_BATCHSCAN_THRESHOLD */
 786         { handle_batchscan_threshold, false,
 787                 sizeof(struct hal_ev_gatt_client_batchscan_threshold) },
 788         /* HAL_EV_GATT_CLIENT_TRACK_ADV */
 789         { handle_track_adv, false,
 790                 sizeof(struct hal_ev_gatt_client_track_adv) },
 791         /* HAL_EV_GATT_SERVER_INDICATION_SENT */
 792         { handle_indication_send, false,
 793                 sizeof(struct hal_ev_gatt_server_indication_sent) },
 794         /* HAL_EV_GATT_SERVER_CONGESTION */
 795         { handle_server_congestion, false,
 796                 sizeof(struct hal_ev_gatt_server_congestion) },
 797         /* HAL_EV_GATT_SERVER_MTU_CHANGED */
 798         { handle_server_mtu_changed, false,
 799                 sizeof(struct hal_ev_gatt_server_mtu_changed) },
 800         };
 801
 802 /* Client API */
 803
 804 static bt_status_t register_client(bt_uuid_t *uuid)
 805 {
 806         struct hal_cmd_gatt_client_register cmd;
 807
 808         if (!interface_ready())
 809                 return BT_STATUS_NOT_READY;
 810
 811         memcpy(cmd.uuid, uuid, sizeof(*uuid));
 812
 813         return hal_ipc_cmd(HAL_SERVICE_ID_GATT, HAL_OP_GATT_CLIENT_REGISTER,
 814                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
 815 }
 816
 817 static bt_status_t unregister_client(int client_if)
 818 {
 819         struct hal_cmd_gatt_client_unregister cmd;
 820
 821         if (!interface_ready())
 822                 return BT_STATUS_NOT_READY;
 823
 824         cmd.client_if = client_if;
 825
 826         return hal_ipc_cmd(HAL_SERVICE_ID_GATT, HAL_OP_GATT_CLIENT_UNREGISTER,
 827                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
 828 }
 829
 830 static bt_status_t scan_real(int client_if, bool start)
 831 {
 832         struct hal_cmd_gatt_client_scan cmd;
 833
 834         if (!interface_ready())
 835                 return BT_STATUS_NOT_READY;
 836
 837         cmd.client_if = client_if;
 838         cmd.start = start;
 839
 840         return hal_ipc_cmd(HAL_SERVICE_ID_GATT, HAL_OP_GATT_CLIENT_SCAN,
 841                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
 842 }
 843
 844 #if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
 845 static bt_status_t scan(bool start)
 846 {
 847         return scan_real(0, start);
 848 }
 849 #else
 850 static bt_status_t scan(int client_if, bool start)
 851 {
 852         return scan_real(client_if, start);
 853 }
 854 #endif
 855
 856 static bt_status_t connect_real(int client_if, const bt_bdaddr_t *bd_addr,
 857                                                 bool is_direct, int transport)
 858 {
 859         struct hal_cmd_gatt_client_connect cmd;
 860
 861         if (!interface_ready())
 862                 return BT_STATUS_NOT_READY;
 863
 864         cmd.client_if = client_if;
 865         cmd.is_direct = is_direct;
 866         cmd.transport = transport;
 867
 868         memcpy(cmd.bdaddr, bd_addr, sizeof(*bd_addr));
 869
 870         return hal_ipc_cmd(HAL_SERVICE_ID_GATT, HAL_OP_GATT_CLIENT_CONNECT,
 871                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
 872 }
 873
 874 #if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
 875 static bt_status_t connect(int client_if, const bt_bdaddr_t *bd_addr,
 876                                                 bool is_direct, int transport)
 877 {
 878         return connect_real(client_if, bd_addr, is_direct, transport);
 879 }
 880 #else
 881 static bt_status_t connect(int client_if, const bt_bdaddr_t *bd_addr,
 882                                                                 bool is_direct)
 883 {
 884         return connect_real(client_if, bd_addr, is_direct,
 885                                                         BT_TRANSPORT_UNKNOWN);
 886 }
 887 #endif
 888
 889 static bt_status_t disconnect(int client_if, const bt_bdaddr_t *bd_addr,
 890                                                                 int conn_id)
 891 {
 892         struct hal_cmd_gatt_client_disconnect cmd;
 893
 894         if (!interface_ready())
 895                 return BT_STATUS_NOT_READY;
 896
 897         cmd.client_if = client_if;
 898         cmd.conn_id = conn_id;
 899
 900         memcpy(cmd.bdaddr, bd_addr, sizeof(*bd_addr));
 901
 902         return hal_ipc_cmd(HAL_SERVICE_ID_GATT, HAL_OP_GATT_CLIENT_DISCONNECT,
 903                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
 904 }
 905
 906 static bt_status_t listen(int client_if, bool start)
 907 {
 908         struct hal_cmd_gatt_client_listen cmd;
 909
 910         if (!interface_ready())
 911                 return BT_STATUS_NOT_READY;
 912
 913         cmd.client_if = client_if;
 914         cmd.start = start;
 915
 916         return hal_ipc_cmd(HAL_SERVICE_ID_GATT, HAL_OP_GATT_CLIENT_LISTEN,
 917                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
 918 }
 919
 920 static bt_status_t refresh(int client_if, const bt_bdaddr_t *bd_addr)
 921 {
 922         struct hal_cmd_gatt_client_refresh cmd;
 923
 924         if (!interface_ready())
 925                 return BT_STATUS_NOT_READY;
 926
 927         cmd.client_if = client_if;
 928
 929         memcpy(cmd.bdaddr, bd_addr, sizeof(*bd_addr));
 930
 931         return hal_ipc_cmd(HAL_SERVICE_ID_GATT, HAL_OP_GATT_CLIENT_REFRESH,
 932                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
 933 }
 934
 935 static bt_status_t search_service(int conn_id, bt_uuid_t *filter_uuid)
 936 {
 937         char buf[IPC_MTU];
 938         struct hal_cmd_gatt_client_search_service *cmd = (void *) buf;
 939         size_t len = sizeof(*cmd);
 940
 941         if (!interface_ready())
 942                 return BT_STATUS_NOT_READY;
 943
 944         memset(cmd, 0, sizeof(*cmd));
 945
 946         cmd->conn_id = conn_id;
 947
 948         if (filter_uuid) {
 949                 memcpy(cmd->filter_uuid, filter_uuid, sizeof(*filter_uuid));
 950                 len += sizeof(*filter_uuid);
 951                 cmd->filtered = 1;
 952         }
 953
 954         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
 955                                         HAL_OP_GATT_CLIENT_SEARCH_SERVICE,
 956                                         len, cmd, NULL, NULL, NULL);
 957 }
 958
 959 static bt_status_t get_included_service(int conn_id, btgatt_srvc_id_t *srvc_id,
 960                                         btgatt_srvc_id_t *start_incl_srvc_id)
 961 {
 962         char buf[IPC_MTU];
 963         struct hal_cmd_gatt_client_get_included_service *cmd = (void *) buf;
 964         size_t len = sizeof(*cmd);
 965
 966         if (!interface_ready())
 967                 return BT_STATUS_NOT_READY;
 968
 969         cmd->conn_id = conn_id;
 970
 971         srvc_id_to_hal(&cmd->srvc_id, srvc_id);
 972         cmd->continuation = 0;
 973
 974         if (start_incl_srvc_id) {
 975                 srvc_id_to_hal(&cmd->incl_srvc_id[0], start_incl_srvc_id);
 976                 len += sizeof(cmd->incl_srvc_id[0]);
 977                 cmd->continuation = 1;
 978         }
 979
 980         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
 981                                         HAL_OP_GATT_CLIENT_GET_INCLUDED_SERVICE,
 982                                         len, cmd, NULL, NULL, NULL);
 983 }
 984
 985 static bt_status_t get_characteristic(int conn_id, btgatt_srvc_id_t *srvc_id,
 986                                                 btgatt_gatt_id_t *start_char_id)
 987 {
 988         char buf[IPC_MTU];
 989         struct hal_cmd_gatt_client_get_characteristic *cmd = (void *) buf;
 990         size_t len = sizeof(*cmd);
 991
 992         if (!interface_ready())
 993                 return BT_STATUS_NOT_READY;
 994
 995         cmd->conn_id = conn_id;
 996
 997         srvc_id_to_hal(&cmd->srvc_id, srvc_id);
 998         cmd->continuation = 0;
 999
1000         if (start_char_id) {
1001                 gatt_id_to_hal(&cmd->char_id[0], start_char_id);
1002                 len += sizeof(cmd->char_id[0]);
1003                 cmd->continuation = 1;
1004         }
1005
1006         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1007                                         HAL_OP_GATT_CLIENT_GET_CHARACTERISTIC,
1008                                         len, cmd, NULL, NULL, NULL);
1009 }
1010
1011 static bt_status_t get_descriptor(int conn_id, btgatt_srvc_id_t *srvc_id,
1012                                         btgatt_gatt_id_t *char_id,
1013                                         btgatt_gatt_id_t *start_descr_id)
1014 {
1015         char buf[IPC_MTU];
1016         struct hal_cmd_gatt_client_get_descriptor *cmd = (void *) buf;
1017         size_t len = sizeof(*cmd);
1018
1019         if (!interface_ready())
1020                 return BT_STATUS_NOT_READY;
1021
1022         cmd->conn_id = conn_id;
1023
1024         srvc_id_to_hal(&cmd->srvc_id, srvc_id);
1025         gatt_id_to_hal(&cmd->char_id, char_id);
1026         cmd->continuation = 0;
1027
1028         if (start_descr_id) {
1029                 gatt_id_to_hal(&cmd->descr_id[0], start_descr_id);
1030                 len += sizeof(cmd->descr_id[0]);
1031                 cmd->continuation = 1;
1032         }
1033
1034         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1035                                         HAL_OP_GATT_CLIENT_GET_DESCRIPTOR,
1036                                         len, cmd, NULL , NULL, NULL);
1037 }
1038
1039 static bt_status_t read_characteristic(int conn_id, btgatt_srvc_id_t *srvc_id,
1040                                         btgatt_gatt_id_t *char_id,
1041                                         int auth_req)
1042 {
1043         struct hal_cmd_gatt_client_read_characteristic cmd;
1044
1045         if (!interface_ready())
1046                 return BT_STATUS_NOT_READY;
1047
1048         cmd.conn_id = conn_id;
1049         cmd.auth_req = auth_req;
1050
1051         srvc_id_to_hal(&cmd.srvc_id, srvc_id);
1052         gatt_id_to_hal(&cmd.char_id, char_id);
1053
1054         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1055                                         HAL_OP_GATT_CLIENT_READ_CHARACTERISTIC,
1056                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1057 }
1058
1059 static bt_status_t write_characteristic(int conn_id, btgatt_srvc_id_t *srvc_id,
1060                                         btgatt_gatt_id_t *char_id,
1061                                         int write_type, int len, int auth_req,
1062                                         char *p_value)
1063 {
1064         char buf[IPC_MTU];
1065         struct hal_cmd_gatt_client_write_characteristic *cmd = (void *) buf;
1066         size_t cmd_len = sizeof(*cmd) + len;
1067
1068         if (!interface_ready())
1069                 return BT_STATUS_NOT_READY;
1070
1071         cmd->conn_id = conn_id;
1072         cmd->write_type = write_type;
1073         cmd->len = len;
1074         cmd->auth_req = auth_req;
1075
1076         srvc_id_to_hal(&cmd->srvc_id, srvc_id);
1077         gatt_id_to_hal(&cmd->char_id, char_id);
1078
1079         memcpy(cmd->value, p_value, len);
1080
1081         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1082                                         HAL_OP_GATT_CLIENT_WRITE_CHARACTERISTIC,
1083                                         cmd_len, cmd, NULL, NULL, NULL);
1084 }
1085
1086 static bt_status_t read_descriptor(int conn_id, btgatt_srvc_id_t *srvc_id,
1087                                                 btgatt_gatt_id_t *char_id,
1088                                                 btgatt_gatt_id_t *descr_id,
1089                                                 int auth_req)
1090 {
1091         struct hal_cmd_gatt_client_read_descriptor cmd;
1092
1093         if (!interface_ready())
1094                 return BT_STATUS_NOT_READY;
1095
1096         cmd.conn_id = conn_id;
1097         cmd.auth_req = auth_req;
1098
1099         srvc_id_to_hal(&cmd.srvc_id, srvc_id);
1100         gatt_id_to_hal(&cmd.char_id, char_id);
1101         gatt_id_to_hal(&cmd.descr_id, descr_id);
1102
1103         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1104                                         HAL_OP_GATT_CLIENT_READ_DESCRIPTOR,
1105                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1106 }
1107
1108 static bt_status_t write_descriptor(int conn_id, btgatt_srvc_id_t *srvc_id,
1109                                         btgatt_gatt_id_t *char_id,
1110                                         btgatt_gatt_id_t *descr_id,
1111                                         int write_type, int len, int auth_req,
1112                                         char *p_value)
1113 {
1114         char buf[IPC_MTU];
1115         struct hal_cmd_gatt_client_write_descriptor *cmd = (void *) buf;
1116         size_t cmd_len = sizeof(*cmd) + len;
1117
1118         if (!interface_ready())
1119                 return BT_STATUS_NOT_READY;
1120
1121         cmd->conn_id = conn_id;
1122         cmd->write_type = write_type;
1123         cmd->len = len;
1124         cmd->auth_req = auth_req;
1125
1126         srvc_id_to_hal(&cmd->srvc_id, srvc_id);
1127         gatt_id_to_hal(&cmd->char_id, char_id);
1128         gatt_id_to_hal(&cmd->descr_id, descr_id);
1129
1130         memcpy(cmd->value, p_value, len);
1131
1132         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1133                                         HAL_OP_GATT_CLIENT_WRITE_DESCRIPTOR,
1134                                         cmd_len, cmd, NULL, NULL, NULL);
1135 }
1136
1137 static bt_status_t execute_write(int conn_id, int execute)
1138 {
1139         struct hal_cmd_gatt_client_execute_write cmd;
1140
1141         if (!interface_ready())
1142                 return BT_STATUS_NOT_READY;
1143
1144         cmd.conn_id = conn_id;
1145         cmd.execute = execute;
1146
1147         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1148                                         HAL_OP_GATT_CLIENT_EXECUTE_WRITE,
1149                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1150 }
1151
1152 static bt_status_t register_for_notification(int client_if,
1153                                                 const bt_bdaddr_t *bd_addr,
1154                                                 btgatt_srvc_id_t *srvc_id,
1155                                                 btgatt_gatt_id_t *char_id)
1156 {
1157         struct hal_cmd_gatt_client_register_for_notification cmd;
1158
1159         if (!interface_ready())
1160                 return BT_STATUS_NOT_READY;
1161
1162         cmd.client_if = client_if;
1163
1164         memcpy(cmd.bdaddr, bd_addr, sizeof(*bd_addr));
1165
1166         srvc_id_to_hal(&cmd.srvc_id, srvc_id);
1167         gatt_id_to_hal(&cmd.char_id, char_id);
1168
1169         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1170                                 HAL_OP_GATT_CLIENT_REGISTER_FOR_NOTIFICATION,
1171                                 sizeof(cmd), &cmd, NULL, NULL, NULL);
1172 }
1173
1174 static bt_status_t deregister_for_notification(int client_if,
1175                                                 const bt_bdaddr_t *bd_addr,
1176                                                 btgatt_srvc_id_t *srvc_id,
1177                                                 btgatt_gatt_id_t *char_id)
1178 {
1179         struct hal_cmd_gatt_client_deregister_for_notification cmd;
1180
1181         if (!interface_ready())
1182                 return BT_STATUS_NOT_READY;
1183
1184         cmd.client_if = client_if;
1185
1186         memcpy(cmd.bdaddr, bd_addr, sizeof(*bd_addr));
1187
1188         srvc_id_to_hal(&cmd.srvc_id, srvc_id);
1189         gatt_id_to_hal(&cmd.char_id, char_id);
1190
1191         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1192                                 HAL_OP_GATT_CLIENT_DEREGISTER_FOR_NOTIFICATION,
1193                                 sizeof(cmd), &cmd, NULL, NULL, NULL);
1194 }
1195
1196 static bt_status_t read_remote_rssi(int client_if, const bt_bdaddr_t *bd_addr)
1197 {
1198         struct hal_cmd_gatt_client_read_remote_rssi cmd;
1199
1200         if (!interface_ready())
1201                 return BT_STATUS_NOT_READY;
1202
1203         cmd.client_if = client_if;
1204
1205         memcpy(cmd.bdaddr, bd_addr, sizeof(*bd_addr));
1206
1207         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1208                                         HAL_OP_GATT_CLIENT_READ_REMOTE_RSSI,
1209                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1210 }
1211
1212 static int get_device_type(const bt_bdaddr_t *bd_addr)
1213 {
1214         struct hal_cmd_gatt_client_get_device_type cmd;
1215         uint8_t dev_type;
1216         size_t resp_len = sizeof(dev_type);
1217         bt_status_t status;
1218
1219         if (!interface_ready())
1220                 return BT_STATUS_NOT_READY;
1221
1222         memcpy(cmd.bdaddr, bd_addr, sizeof(*bd_addr));
1223
1224         status = hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1225                                 HAL_OP_GATT_CLIENT_GET_DEVICE_TYPE,
1226                                 sizeof(cmd), &cmd, &resp_len, &dev_type, NULL);
1227
1228         if (status != BT_STATUS_SUCCESS || resp_len != sizeof(dev_type))
1229                 return 0;
1230
1231         return dev_type;
1232 }
1233
1234 static bt_status_t set_adv_data_real(int server_if, bool set_scan_rsp,
1235                                 bool include_name, bool include_txpower,
1236                                 int min_interval, int max_interval,
1237                                 int appearance, uint16_t manufacturer_len,
1238                                 char *manufacturer_data,
1239                                 uint16_t service_data_len, char *service_data,
1240                                 uint16_t service_uuid_len, char *service_uuid)
1241 {
1242         char buf[IPC_MTU];
1243         struct hal_cmd_gatt_client_set_adv_data *cmd = (void *) buf;
1244         size_t cmd_len;
1245         uint8_t *data;
1246
1247         if (!interface_ready())
1248                 return BT_STATUS_NOT_READY;
1249
1250         cmd_len = sizeof(*cmd) + manufacturer_len + service_data_len +
1251                                                         service_uuid_len;
1252
1253         if (cmd_len > IPC_MTU)
1254                 return BT_STATUS_FAIL;
1255
1256         cmd->server_if = server_if;
1257         cmd->set_scan_rsp = set_scan_rsp;
1258         cmd->include_name = include_name;
1259         cmd->include_txpower = include_txpower;
1260         cmd->min_interval = min_interval;
1261         cmd->max_interval = max_interval;
1262         cmd->appearance = appearance;
1263         cmd->manufacturer_len = manufacturer_len;
1264         cmd->service_data_len = service_data_len;
1265         cmd->service_uuid_len = service_uuid_len;
1266
1267         data = cmd->data;
1268
1269         if (manufacturer_data && manufacturer_len) {
1270                 memcpy(data, manufacturer_data, manufacturer_len);
1271                 data += manufacturer_len;
1272         }
1273
1274         if (service_data && service_data_len) {
1275                 memcpy(data, service_data, service_data_len);
1276                 data += service_data_len;
1277         }
1278
1279         if (service_uuid && service_uuid_len)
1280                 memcpy(data, service_uuid, service_uuid_len);
1281
1282         return hal_ipc_cmd(HAL_SERVICE_ID_GATT, HAL_OP_GATT_CLIENT_SET_ADV_DATA,
1283                                                 cmd_len, cmd, NULL, NULL, NULL);
1284 }
1285
1286 /*
1287  * This is temporary solution and support for older Android versions might
1288  * be removed at any time.
1289  */
1290 #if ANDROID_VERSION < PLATFORM_VER(4, 4, 3)
1291 static bt_status_t set_adv_data(int server_if, bool set_scan_rsp,
1292                                 bool include_name, bool include_txpower,
1293                                 int min_interval, int max_interval,
1294                                 int appearance, uint16_t manufacturer_len,
1295                                 char *manufacturer_data)
1296 {
1297         return set_adv_data_real(server_if, set_scan_rsp, include_name,
1298                                         include_txpower, min_interval,
1299                                         max_interval, appearance,
1300                                         manufacturer_len, manufacturer_data,
1301                                         0, NULL, 0, NULL);
1302 }
1303 #else
1304 static bt_status_t set_adv_data(int server_if, bool set_scan_rsp,
1305                                 bool include_name, bool include_txpower,
1306                                 int min_interval, int max_interval,
1307                                 int appearance, uint16_t manufacturer_len,
1308                                 char *manufacturer_data,
1309                                 uint16_t service_data_len, char *service_data,
1310                                 uint16_t service_uuid_len, char *service_uuid)
1311 {
1312         return set_adv_data_real(server_if, set_scan_rsp, include_name,
1313                                         include_txpower, min_interval,
1314                                         max_interval, appearance,
1315                                         manufacturer_len, manufacturer_data,
1316                                         service_data_len, service_data,
1317                                         service_uuid_len, service_uuid);
1318 }
1319 #endif
1320
1321 static bt_status_t test_command(int command, btgatt_test_params_t *params)
1322 {
1323         struct hal_cmd_gatt_client_test_command cmd;
1324
1325         if (!interface_ready())
1326                 return BT_STATUS_NOT_READY;
1327
1328         cmd.command = command;
1329
1330         memcpy(cmd.bda1, params->bda1, sizeof(*params->bda1));
1331         memcpy(cmd.uuid1, params->uuid1, sizeof(*params->uuid1));
1332
1333         cmd.u1 = params->u1;
1334         cmd.u2 = params->u2;
1335         cmd.u3 = params->u3;
1336         cmd.u4 = params->u4;
1337         cmd.u5 = params->u5;
1338
1339         return hal_ipc_cmd(HAL_SERVICE_ID_GATT, HAL_OP_GATT_CLIENT_TEST_COMMAND,
1340                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1341 }
1342
1343 #if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
1344 static bt_status_t scan_filter_param_setup(int client_if, int action,
1345                                                 int filt_index, int feat_seln,
1346                                                 int list_logic_type,
1347                                                 int filt_logic_type,
1348                                                 int rssi_high_thres,
1349                                                 int rssi_low_thres,
1350                                                 int dely_mode,
1351                                                 int found_timeout,
1352                                                 int lost_timeout,
1353                                                 int found_timeout_cnt)
1354 {
1355         struct hal_cmd_gatt_client_scan_filter_setup cmd;
1356
1357         if (!interface_ready())
1358                 return BT_STATUS_NOT_READY;
1359
1360         cmd.client_if = client_if;
1361         cmd.action = action;
1362         cmd.filter_index = filt_index;
1363         cmd.features = feat_seln;
1364         cmd.list_type = list_logic_type;
1365         cmd.filter_type = filt_logic_type;
1366         cmd.rssi_hi = rssi_high_thres;
1367         cmd.rssi_lo = rssi_low_thres;
1368         cmd.delivery_mode = dely_mode;
1369         cmd.found_timeout = found_timeout;
1370         cmd.lost_timeout = lost_timeout;
1371         cmd.found_timeout_cnt = found_timeout_cnt;
1372
1373         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1374                                         HAL_OP_GATT_CLIENT_SCAN_FILTER_SETUP,
1375                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1376 }
1377
1378 static bt_status_t scan_filter_add_remove(int client_if, int action,
1379                                                 int filt_type, int filt_index,
1380                                                 int company_id,
1381                                                 int company_id_mask,
1382                                                 const bt_uuid_t *p_uuid,
1383                                                 const bt_uuid_t *p_uuid_mask,
1384                                                 const bt_bdaddr_t *bd_addr,
1385                                                 char addr_type,
1386                                                 int data_len, char *p_data,
1387                                                 int mask_len, char *p_mask)
1388 {
1389         char buf[IPC_MTU];
1390         struct hal_cmd_gatt_client_scan_filter_add_remove *cmd = (void *) buf;
1391         size_t cmd_len;
1392
1393         if (!interface_ready())
1394                 return BT_STATUS_NOT_READY;
1395
1396         if (!p_uuid || !p_uuid_mask || !bd_addr)
1397                 return BT_STATUS_PARM_INVALID;
1398
1399         cmd_len = sizeof(*cmd) + data_len + mask_len;
1400         if (cmd_len > IPC_MTU)
1401                 return BT_STATUS_FAIL;
1402
1403         cmd->client_if = client_if;
1404         cmd->action = action;
1405         cmd->filter_type = filt_type;
1406         cmd->filter_index = filt_index;
1407         cmd->company_id = company_id;
1408         cmd->company_id_mask = company_id_mask;
1409         memcpy(cmd->uuid, p_uuid, sizeof(*p_uuid));
1410         memcpy(cmd->uuid_mask, p_uuid_mask, sizeof(*p_uuid_mask));
1411         memcpy(cmd->address, bd_addr, sizeof(*bd_addr));
1412         cmd->address_type = addr_type;
1413
1414         cmd->data_len = data_len;
1415         memcpy(cmd->data_mask, p_data, data_len);
1416
1417         cmd->mask_len = mask_len;
1418         memcpy(cmd->data_mask + data_len, p_mask, mask_len);
1419
1420         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1421                                 HAL_OP_GATT_CLIENT_SCAN_FILTER_ADD_REMOVE,
1422                                 cmd_len, cmd, NULL, NULL, NULL);
1423 }
1424
1425 static bt_status_t scan_filter_clear(int client_if, int filt_index)
1426 {
1427         struct hal_cmd_gatt_client_scan_filter_clear cmd;
1428
1429         if (!interface_ready())
1430                 return BT_STATUS_NOT_READY;
1431
1432         cmd.client_if = client_if;
1433         cmd.index = filt_index;
1434
1435         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1436                                         HAL_OP_GATT_CLIENT_SCAN_FILTER_CLEAR,
1437                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1438 }
1439
1440 static bt_status_t scan_filter_enable(int client_if, bool enable)
1441 {
1442         struct hal_cmd_gatt_client_scan_filter_enable cmd;
1443
1444         if (!interface_ready())
1445                 return BT_STATUS_NOT_READY;
1446
1447         cmd.client_if = client_if;
1448         cmd.enable = enable;
1449
1450         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1451                                         HAL_OP_GATT_CLIENT_SCAN_FILTER_ENABLE,
1452                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1453 }
1454
1455 static bt_status_t configure_mtu(int conn_id, int mtu)
1456 {
1457         struct hal_cmd_gatt_client_configure_mtu cmd;
1458
1459         if (!interface_ready())
1460                 return BT_STATUS_NOT_READY;
1461
1462         cmd.conn_id = conn_id;
1463         cmd.mtu = mtu;
1464
1465         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1466                                         HAL_OP_GATT_CLIENT_CONFIGURE_MTU,
1467                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1468 }
1469
1470 static bt_status_t conn_parameter_update(const bt_bdaddr_t *bd_addr,
1471                                                 int min_interval,
1472                                                 int max_interval, int latency,
1473                                                 int timeout)
1474 {
1475         struct hal_cmd_gatt_client_conn_param_update cmd;
1476
1477         if (!interface_ready())
1478                 return BT_STATUS_NOT_READY;
1479
1480         if (!bd_addr)
1481                 return BT_STATUS_PARM_INVALID;
1482
1483         memcpy(cmd.address, bd_addr, sizeof(*bd_addr));
1484         cmd.min_interval = min_interval;
1485         cmd.max_interval = max_interval;
1486         cmd.latency = latency;
1487         cmd.timeout = timeout;
1488
1489         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1490                                         HAL_OP_GATT_CLIENT_CONN_PARAM_UPDATE,
1491                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1492 }
1493
1494 static bt_status_t set_scan_parameters(int scan_interval, int scan_window)
1495 {
1496         struct hal_cmd_gatt_client_set_scan_param cmd;
1497
1498         if (!interface_ready())
1499                 return BT_STATUS_NOT_READY;
1500
1501         cmd.interval = scan_interval;
1502         cmd.window = scan_window;
1503
1504         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1505                                         HAL_OP_GATT_CLIENT_SET_SCAN_PARAM,
1506                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1507 }
1508
1509 static bt_status_t multi_adv_enable(int client_if, int min_interval,
1510                                         int max_interval, int adv_type,
1511                                         int chnl_map, int tx_power,
1512                                         int timeout_s)
1513 {
1514         struct hal_cmd_gatt_client_setup_multi_adv cmd;
1515
1516         if (!interface_ready())
1517                 return BT_STATUS_NOT_READY;
1518
1519         cmd.client_if = client_if;
1520         cmd.min_interval = min_interval;
1521         cmd.max_interval = max_interval;
1522         cmd.type = adv_type;
1523         cmd.channel_map = chnl_map;
1524         cmd.tx_power = tx_power;
1525         cmd.timeout = timeout_s;
1526
1527         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1528                                         HAL_OP_GATT_CLIENT_SETUP_MULTI_ADV,
1529                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1530 }
1531
1532 static bt_status_t multi_adv_update(int client_if, int min_interval,
1533                                         int max_interval, int adv_type,
1534                                         int chnl_map, int tx_power,
1535                                         int timeout_s)
1536 {
1537         struct hal_cmd_gatt_client_update_multi_adv cmd;
1538
1539         if (!interface_ready())
1540                 return BT_STATUS_NOT_READY;
1541
1542         cmd.client_if = client_if;
1543         cmd.min_interval = min_interval;
1544         cmd.max_interval = max_interval;
1545         cmd.type = adv_type;
1546         cmd.channel_map = chnl_map;
1547         cmd.tx_power = tx_power;
1548         cmd.timeout = timeout_s;
1549
1550         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1551                                         HAL_OP_GATT_CLIENT_UPDATE_MULTI_ADV,
1552                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1553 }
1554
1555 static bt_status_t multi_adv_set_inst_data(int client_if, bool set_scan_rsp,
1556                                                 bool include_name,
1557                                                 bool incl_txpower,
1558                                                 int appearance,
1559                                                 int manufacturer_len,
1560                                                 char *manufacturer_data,
1561                                                 int service_data_len,
1562                                                 char *service_data,
1563                                                 int service_uuid_len,
1564                                                 char *service_uuid)
1565 {
1566         char buf[IPC_MTU];
1567         struct hal_cmd_gatt_client_setup_multi_adv_inst *cmd = (void *) buf;
1568         int off = 0;
1569
1570         if (!interface_ready())
1571                 return BT_STATUS_NOT_READY;
1572
1573         if (manufacturer_len > 0 && !manufacturer_data)
1574                 return BT_STATUS_PARM_INVALID;
1575
1576         if (service_data_len > 0 && !service_data)
1577                 return BT_STATUS_PARM_INVALID;
1578
1579         if (service_uuid_len > 0 && !service_uuid)
1580                 return BT_STATUS_PARM_INVALID;
1581
1582         if (sizeof(*cmd) + manufacturer_len + service_data_len
1583                                                 + service_uuid_len > IPC_MTU)
1584                 return BT_STATUS_FAIL;
1585
1586         cmd->client_if = client_if;
1587         cmd->set_scan_rsp = set_scan_rsp;
1588         cmd->include_name = include_name;
1589         cmd->include_tx_power = incl_txpower;
1590         cmd->appearance = appearance;
1591         cmd->manufacturer_data_len = manufacturer_len;
1592         cmd->service_data_len = service_data_len;
1593         cmd->service_uuid_len = service_uuid_len;
1594
1595         if (manufacturer_len > 0) {
1596                 memcpy(cmd->data_service_uuid, manufacturer_data,
1597                                                         manufacturer_len);
1598                 off += manufacturer_len;
1599         }
1600
1601         if (service_data_len > 0) {
1602                 memcpy(cmd->data_service_uuid + off, service_data,
1603                                                         service_data_len);
1604                 off += service_data_len;
1605         }
1606
1607         if (service_uuid_len > 0) {
1608                 memcpy(cmd->data_service_uuid + off, service_uuid,
1609                                                         service_uuid_len);
1610                 off += service_uuid_len;
1611         }
1612
1613         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1614                                 HAL_OP_GATT_CLIENT_SETUP_MULTI_ADV_INST,
1615                                 sizeof(*cmd) + off, cmd, NULL, NULL, NULL);
1616 }
1617
1618 static bt_status_t multi_adv_disable(int client_if)
1619 {
1620         struct hal_cmd_gatt_client_disable_multi_adv_inst cmd;
1621
1622         if (!interface_ready())
1623                 return BT_STATUS_NOT_READY;
1624
1625         cmd.client_if = client_if;
1626
1627         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1628                                 HAL_OP_GATT_CLIENT_DISABLE_MULTI_ADV_INST,
1629                                 sizeof(cmd), &cmd, NULL, NULL, NULL);
1630 }
1631
1632 static bt_status_t batchscan_cfg_storage(int client_if, int batch_scan_full_max,
1633                                                 int batch_scan_trunc_max,
1634                                                 int batch_scan_notify_threshold)
1635 {
1636         struct hal_cmd_gatt_client_configure_batchscan cmd;
1637
1638         if (!interface_ready())
1639                 return BT_STATUS_NOT_READY;
1640
1641         cmd.client_if = client_if;
1642         cmd.full_max = batch_scan_full_max;
1643         cmd.trunc_max = batch_scan_trunc_max;
1644         cmd.notify_threshold = batch_scan_notify_threshold;
1645
1646         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1647                                         HAL_OP_GATT_CLIENT_CONFIGURE_BATCHSCAN,
1648                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1649 }
1650
1651 static bt_status_t batchscan_enb_batch_scan(int client_if, int scan_mode,
1652                                                 int scan_interval,
1653                                                 int scan_window, int addr_type,
1654                                                 int discard_rule)
1655 {
1656         struct hal_cmd_gatt_client_enable_batchscan cmd;
1657
1658         if (!interface_ready())
1659                 return BT_STATUS_NOT_READY;
1660
1661         cmd.client_if = client_if;
1662         cmd.mode = scan_mode;
1663         cmd.interval = scan_interval;
1664         cmd.window = scan_window;
1665         cmd.address_type = addr_type;
1666         cmd.discard_rule = discard_rule;
1667
1668         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1669                                         HAL_OP_GATT_CLIENT_ENABLE_BATCHSCAN,
1670                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1671 }
1672
1673 static bt_status_t batchscan_dis_batch_scan(int client_if)
1674 {
1675         struct hal_cmd_gatt_client_disable_batchscan cmd;
1676
1677         if (!interface_ready())
1678                 return BT_STATUS_NOT_READY;
1679
1680         cmd.client_if = client_if;
1681
1682         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1683                                         HAL_OP_GATT_CLIENT_DISABLE_BATCHSCAN,
1684                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1685 }
1686
1687 static bt_status_t batchscan_read_reports(int client_if, int scan_mode)
1688 {
1689         struct hal_cmd_gatt_client_read_batchscan_reports cmd;
1690
1691         if (!interface_ready())
1692                 return BT_STATUS_NOT_READY;
1693
1694         cmd.client_if = client_if;
1695         cmd.scan_mode = scan_mode;
1696
1697         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1698                                 HAL_OP_GATT_CLIENT_READ_BATCHSCAN_REPORTS,
1699                                 sizeof(cmd), &cmd, NULL, NULL, NULL);
1700 }
1701 #endif
1702
1703 /* Server API */
1704
1705 static bt_status_t register_server(bt_uuid_t *uuid)
1706 {
1707         struct hal_cmd_gatt_server_register cmd;
1708
1709         if (!interface_ready())
1710                 return BT_STATUS_NOT_READY;
1711
1712         memcpy(cmd.uuid, uuid, sizeof(*uuid));
1713
1714         return hal_ipc_cmd(HAL_SERVICE_ID_GATT, HAL_OP_GATT_SERVER_REGISTER,
1715                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1716 }
1717
1718 static bt_status_t unregister_server(int server_if)
1719 {
1720         struct hal_cmd_gatt_server_unregister cmd;
1721
1722         if (!interface_ready())
1723                 return BT_STATUS_NOT_READY;
1724
1725         cmd.server_if = server_if;
1726
1727         return hal_ipc_cmd(HAL_SERVICE_ID_GATT, HAL_OP_GATT_SERVER_UNREGISTER,
1728                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1729 }
1730
1731 static bt_status_t server_connect_real(int server_if,
1732                                                 const bt_bdaddr_t *bd_addr,
1733                                                 bool is_direct, int transport)
1734 {
1735         struct hal_cmd_gatt_server_connect cmd;
1736
1737         if (!interface_ready())
1738                 return BT_STATUS_NOT_READY;
1739
1740         cmd.server_if = server_if;
1741         cmd.is_direct = is_direct;
1742         cmd.transport = transport;
1743
1744         memcpy(cmd.bdaddr, bd_addr, sizeof(*bd_addr));
1745
1746         return hal_ipc_cmd(HAL_SERVICE_ID_GATT, HAL_OP_GATT_SERVER_CONNECT,
1747                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1748 }
1749
1750 #if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
1751 static bt_status_t server_connect(int server_if, const bt_bdaddr_t *bd_addr,
1752                                                 bool is_direct, int transport)
1753 {
1754         return server_connect_real(server_if, bd_addr, is_direct, transport);
1755 }
1756 #else
1757 static bt_status_t server_connect(int server_if, const bt_bdaddr_t *bd_addr,
1758                                                                 bool is_direct)
1759 {
1760         return server_connect_real(server_if, bd_addr, is_direct,
1761                                                         BT_TRANSPORT_UNKNOWN);
1762 }
1763 #endif
1764
1765 static bt_status_t server_disconnect(int server_if, const bt_bdaddr_t *bd_addr,
1766                                                                 int conn_id)
1767 {
1768         struct hal_cmd_gatt_server_disconnect cmd;
1769
1770         if (!interface_ready())
1771                 return BT_STATUS_NOT_READY;
1772
1773         cmd.server_if = server_if;
1774         cmd.conn_id = conn_id;
1775
1776         memcpy(cmd.bdaddr, bd_addr, sizeof(*bd_addr));
1777
1778         return hal_ipc_cmd(HAL_SERVICE_ID_GATT, HAL_OP_GATT_SERVER_DISCONNECT,
1779                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1780 }
1781
1782 static bt_status_t add_service(int server_if, btgatt_srvc_id_t *srvc_id,
1783                                                                 int num_handles)
1784 {
1785         struct hal_cmd_gatt_server_add_service cmd;
1786
1787         if (!interface_ready())
1788                 return BT_STATUS_NOT_READY;
1789
1790         cmd.server_if = server_if;
1791         cmd.num_handles = num_handles;
1792
1793         srvc_id_to_hal(&cmd.srvc_id, srvc_id);
1794
1795         return hal_ipc_cmd(HAL_SERVICE_ID_GATT, HAL_OP_GATT_SERVER_ADD_SERVICE,
1796                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1797 }
1798
1799 static bt_status_t add_included_service(int server_if, int service_handle,
1800                                                 int included_handle)
1801 {
1802         struct hal_cmd_gatt_server_add_inc_service cmd;
1803
1804         if (!interface_ready())
1805                 return BT_STATUS_NOT_READY;
1806
1807         cmd.server_if = server_if;
1808         cmd.service_handle = service_handle;
1809         cmd.included_handle = included_handle;
1810
1811         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1812                                         HAL_OP_GATT_SERVER_ADD_INC_SERVICE,
1813                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1814 }
1815
1816 static bt_status_t add_characteristic(int server_if, int service_handle,
1817                                                 bt_uuid_t *uuid, int properties,
1818                                                 int permissions)
1819 {
1820         struct hal_cmd_gatt_server_add_characteristic cmd;
1821
1822         if (!interface_ready())
1823                 return BT_STATUS_NOT_READY;
1824
1825         cmd.server_if = server_if;
1826         cmd.service_handle = service_handle;
1827         cmd.properties = properties;
1828         cmd.permissions = permissions;
1829
1830         memcpy(cmd.uuid, uuid, sizeof(*uuid));
1831
1832         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1833                                         HAL_OP_GATT_SERVER_ADD_CHARACTERISTIC,
1834                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1835 }
1836
1837 static bt_status_t add_descriptor(int server_if, int service_handle,
1838                                         bt_uuid_t *uuid, int permissions)
1839 {
1840         struct hal_cmd_gatt_server_add_descriptor cmd;
1841
1842         if (!interface_ready())
1843                 return BT_STATUS_NOT_READY;
1844
1845         cmd.server_if = server_if;
1846         cmd.service_handle = service_handle;
1847         cmd.permissions = permissions;
1848
1849         memcpy(cmd.uuid, uuid, sizeof(*uuid));
1850
1851         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1852                                         HAL_OP_GATT_SERVER_ADD_DESCRIPTOR,
1853                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1854 }
1855
1856 static bt_status_t start_service_real(int server_if, int service_handle,
1857                                                                 int transport)
1858 {
1859         struct hal_cmd_gatt_server_start_service cmd;
1860
1861         if (!interface_ready())
1862                 return BT_STATUS_NOT_READY;
1863
1864         cmd.server_if = server_if;
1865         cmd.service_handle = service_handle;
1866         cmd.transport = transport;
1867
1868         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1869                                         HAL_OP_GATT_SERVER_START_SERVICE,
1870                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1871 }
1872
1873 #if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
1874 static bt_status_t start_service(int server_if, int service_handle,
1875                                                                 int transport)
1876 {
1877         return start_service_real(server_if, service_handle, transport);
1878 }
1879 #else
1880 static bt_status_t start_service(int server_if, int service_handle,
1881                                                                 int transport)
1882 {
1883         int transport_mask = 0;
1884
1885         /* Android 5 changes transport enum to bit mask. */
1886         switch (transport) {
1887         case 0:
1888                 transport_mask = GATT_SERVER_TRANSPORT_LE_BIT;
1889                 break;
1890         case 1:
1891                 transport_mask = GATT_SERVER_TRANSPORT_BREDR_BIT;
1892                 break;
1893         case 2:
1894                 transport_mask = GATT_SERVER_TRANSPORT_LE_BIT |
1895                                                 GATT_SERVER_TRANSPORT_BREDR_BIT;
1896                 break;
1897         }
1898
1899         return start_service_real(server_if, service_handle, transport_mask);
1900 }
1901 #endif
1902
1903 static bt_status_t stop_service(int server_if, int service_handle)
1904 {
1905         struct hal_cmd_gatt_server_stop_service cmd;
1906
1907         if (!interface_ready())
1908                 return BT_STATUS_NOT_READY;
1909
1910         cmd.server_if = server_if;
1911         cmd.service_handle = service_handle;
1912
1913         return hal_ipc_cmd(HAL_SERVICE_ID_GATT, HAL_OP_GATT_SERVER_STOP_SERVICE,
1914                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1915 }
1916
1917 static bt_status_t delete_service(int server_if, int service_handle)
1918 {
1919         struct hal_cmd_gatt_server_delete_service cmd;
1920
1921         if (!interface_ready())
1922                 return BT_STATUS_NOT_READY;
1923
1924         cmd.server_if = server_if;
1925         cmd.service_handle = service_handle;
1926
1927         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1928                                         HAL_OP_GATT_SERVER_DELETE_SERVICE,
1929                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
1930 }
1931
1932 static bt_status_t send_indication(int server_if, int attribute_handle,
1933                                         int conn_id, int len, int confirm,
1934                                         char *p_value)
1935 {
1936         char buf[IPC_MTU];
1937         struct hal_cmd_gatt_server_send_indication *cmd = (void *) buf;
1938         size_t cmd_len = sizeof(*cmd) + len;
1939
1940         if (!interface_ready())
1941                 return BT_STATUS_NOT_READY;
1942
1943         cmd->server_if = server_if;
1944         cmd->attribute_handle = attribute_handle;
1945         cmd->conn_id = conn_id;
1946         cmd->len = len;
1947         cmd->confirm = confirm;
1948
1949         memcpy(cmd->value, p_value, len);
1950
1951         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1952                                         HAL_OP_GATT_SERVER_SEND_INDICATION,
1953                                         cmd_len, cmd, NULL, NULL, NULL);
1954 }
1955
1956 static bt_status_t send_response(int conn_id, int trans_id, int status,
1957                                                 btgatt_response_t *response)
1958 {
1959         char buf[IPC_MTU];
1960         struct hal_cmd_gatt_server_send_response *cmd = (void *) buf;
1961         size_t cmd_len = sizeof(*cmd) + sizeof(*response);
1962
1963         memset(buf, 0 , IPC_MTU);
1964
1965         if (!interface_ready())
1966                 return BT_STATUS_NOT_READY;
1967
1968         cmd->conn_id = conn_id;
1969         cmd->trans_id = trans_id;
1970         cmd->status = status;
1971         cmd->handle = response->attr_value.handle;
1972         cmd->offset = response->attr_value.offset;
1973         cmd->auth_req = response->attr_value.auth_req;
1974         cmd->len = response->attr_value.len;
1975
1976         memcpy(cmd->data, response->attr_value.value, cmd->len);
1977
1978         return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
1979                                         HAL_OP_GATT_SERVER_SEND_RESPONSE,
1980                                         cmd_len, cmd, NULL, NULL, NULL);
1981 }
1982
1983 static bt_status_t init(const btgatt_callbacks_t *callbacks)
1984 {
1985         struct hal_cmd_register_module cmd;
1986         int ret;
1987
1988         DBG("");
1989
1990         if (interface_ready())
1991                 return BT_STATUS_DONE;
1992
1993         cbs = callbacks;
1994
1995         hal_ipc_register(HAL_SERVICE_ID_GATT, ev_handlers,
1996                                 sizeof(ev_handlers)/sizeof(ev_handlers[0]));
1997
1998         cmd.service_id = HAL_SERVICE_ID_GATT;
1999         cmd.mode = HAL_MODE_DEFAULT;
2000         cmd.max_clients = 1;
2001
2002         ret = hal_ipc_cmd(HAL_SERVICE_ID_CORE, HAL_OP_REGISTER_MODULE,
2003                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
2004
2005         if (ret != BT_STATUS_SUCCESS) {
2006                 cbs = NULL;
2007                 hal_ipc_unregister(HAL_SERVICE_ID_GATT);
2008         }
2009
2010         return ret;
2011 }
2012
2013 static void cleanup(void)
2014 {
2015         struct hal_cmd_unregister_module cmd;
2016
2017         DBG("");
2018
2019         if (!interface_ready())
2020                 return;
2021
2022         cmd.service_id = HAL_SERVICE_ID_GATT;
2023
2024         hal_ipc_cmd(HAL_SERVICE_ID_CORE, HAL_OP_UNREGISTER_MODULE,
2025                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
2026
2027         hal_ipc_unregister(HAL_SERVICE_ID_GATT);
2028
2029         cbs = NULL;
2030 }
2031
2032 static btgatt_client_interface_t client_iface = {
2033         .register_client = register_client,
2034         .unregister_client = unregister_client,
2035         .scan = scan,
2036         .connect = connect,
2037         .disconnect = disconnect,
2038         .listen = listen,
2039         .refresh = refresh,
2040         .search_service = search_service,
2041         .get_included_service = get_included_service,
2042         .get_characteristic = get_characteristic,
2043         .get_descriptor = get_descriptor,
2044         .read_characteristic = read_characteristic,
2045         .write_characteristic = write_characteristic,
2046         .read_descriptor = read_descriptor,
2047         .write_descriptor = write_descriptor,
2048         .execute_write = execute_write,
2049         .register_for_notification = register_for_notification,
2050         .deregister_for_notification = deregister_for_notification,
2051         .read_remote_rssi = read_remote_rssi,
2052 #if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
2053         .scan_filter_param_setup = scan_filter_param_setup,
2054         .scan_filter_add_remove = scan_filter_add_remove,
2055         .scan_filter_clear = scan_filter_clear,
2056         .scan_filter_enable = scan_filter_enable,
2057 #endif
2058         .get_device_type = get_device_type,
2059         .set_adv_data = set_adv_data,
2060 #if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
2061         .configure_mtu = configure_mtu,
2062         .conn_parameter_update = conn_parameter_update,
2063         .set_scan_parameters = set_scan_parameters,
2064         .multi_adv_enable = multi_adv_enable,
2065         .multi_adv_update = multi_adv_update,
2066         .multi_adv_set_inst_data = multi_adv_set_inst_data,
2067         .multi_adv_disable = multi_adv_disable,
2068         .batchscan_cfg_storage = batchscan_cfg_storage,
2069         .batchscan_enb_batch_scan = batchscan_enb_batch_scan,
2070         .batchscan_dis_batch_scan = batchscan_dis_batch_scan,
2071         .batchscan_read_reports = batchscan_read_reports,
2072 #endif
2073         .test_command = test_command,
2074 };
2075
2076 static btgatt_server_interface_t server_iface = {
2077         .register_server = register_server,
2078         .unregister_server = unregister_server,
2079         .connect = server_connect,
2080         .disconnect = server_disconnect,
2081         .add_service = add_service,
2082         .add_included_service = add_included_service,
2083         .add_characteristic = add_characteristic,
2084         .add_descriptor = add_descriptor,
2085         .start_service = start_service,
2086         .stop_service = stop_service,
2087         .delete_service = delete_service,
2088         .send_indication = send_indication,
2089         .send_response = send_response,
2090 };
2091
2092 static btgatt_interface_t iface = {
2093         .size = sizeof(iface),
2094         .init = init,
2095         .cleanup = cleanup,
2096         .client = &client_iface,
2097         .server = &server_iface,
2098 };
2099
2100 btgatt_interface_t *bt_get_gatt_interface(void)
2101 {
2102         return &iface;
2103 }