Merge "Add the exception case for audio initialize" into tizen
[platform/core/connectivity/bluetooth-frwk.git] / bt-oal / bluez_hal / src / bt-hal-bluetooth.c
1 /*
2  * BLUETOOTH HAL
3  *
4  * Copyright (c) 2015 -2016 Samsung Electronics Co., Ltd All Rights Reserved.
5  *
6  * Contact: Anupam Roy <anupam.r@samsung.com>
7  *
8  * Licensed under the Apache License, Version 2.0 (the "License");
9  * you may not use this file except in compliance with the License.
10  * You may obtain a copy of the License at
11  *
12  *              http://www.apache.org/licenses/LICENSE-2.0
13  *
14  * Unless required by applicable law or agreed to in writing, software
15  * distributed under the License is distributed on an "AS IS" BASIS,
16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17  * See the License for the specific language governing permissions and
18  * limitations under the License.
19  *
20  */
21
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <stdbool.h>
25 #include <string.h>
26 #include <dlog.h>
27
28 #include "bt-hal.h"
29 #include "bt-hal-log.h"
30 #include "bt-hal-msg.h"
31 #include "bt-hal-utils.h"
32
33 #include <bt-hal-adapter-dbus-handler.h>
34 #include <bt-hal-device-dbus-handler.h>
35 #include <bt-hal-hidhost.h>
36 #include <bt-hal-hiddevice.h>
37 #include <bt-hal-socket.h>
38 #include <bt-hal-av.h>
39 #include <bt-hal-hf.h>
40 #include <bt-hal-hdp.h>
41 #include <bt-hal-a2dp-sink.h>
42 #include <bt-hal-avrcp-tg.h>
43 #include <bt-hal-avrcp-ctrl.h>
44 #include <bt-hal-gatt.h>
45 #ifdef TIZEN_BT_HAL
46 #include <bt-hal-adapter-le.h>
47 #include <bt-hal-agent.h>
48 #endif
49 #include <bt-hal-hf-client.h>
50
51 #define enum_prop_to_hal(prop, hal_prop, type) do { \
52         static type e; \
53         prop.val = &e; \
54         prop.len = sizeof(e); \
55         e = *((uint8_t *) (hal_prop->val)); \
56 } while (0)
57
58 static const bt_callbacks_t *bt_hal_cbacks = NULL;
59
60
61 /* Forward declarations */
62 static void __bt_adapter_props_to_hal(bt_property_t *send_props, struct hal_property *prop, uint8_t num_props, uint16_t len);
63 static void __bt_device_props_to_hal(bt_property_t *send_props,
64                 struct hal_property *prop, uint8_t num_props,
65                 uint16_t len);
66 static void __bt_hal_handle_adapter_state_changed(void *buf, uint16_t len);
67 static void __bt_hal_handle_adapter_property_changed(void *buf, uint16_t len);
68 static void __bt_hal_handle_stack_messages(int message, void *buf, uint16_t len);
69 static void __bt_hal_handle_adapter_discovery_state_changed(void *buf, uint16_t len);
70 static void __bt_hal_handle_device_found_event(void *buf, uint16_t len);
71 static void __bt_hal_handle_bond_state_changed_event(void *buf, uint16_t len);
72 static void __bt_hal_handle_device_acl_state_changed_event(void *buf, uint16_t len);
73 static void __bt_hal_handle_ssp_request_event(void *buf, uint16_t len);
74 static void __bt_hal_handle_pin_request_event(void *buf, uint16_t len);
75
76 static void __bt_hal_handle_device_trust_state_changed_event(void *buf, uint16_t len);
77
78 static bool interface_ready(void)
79 {
80         return bt_hal_cbacks != NULL;
81 }
82
83 static int init(bt_callbacks_t *callbacks)
84 {
85         int ret;
86         DBG("HAL library Initialization..");
87
88         if (interface_ready())
89                 return BT_STATUS_DONE;
90         else {
91                 bt_hal_cbacks = callbacks;
92                 DBG("Store HAL stack msg handler callback");
93                 _bt_hal_dbus_store_stack_msg_cb(__bt_hal_handle_stack_messages);
94                 ret = _bt_hal_initialize_event_receiver(__bt_hal_handle_stack_messages);
95
96                 if (ret == BT_STATUS_SUCCESS)
97                         return BT_STATUS_SUCCESS;
98                 else
99                         return BT_STATUS_FAIL;
100
101         }
102         return BT_STATUS_SUCCESS;
103 }
104
105 /* Enable Adapter */
106 static int enable(void)
107 {
108         return _bt_hal_dbus_enable_adapter();
109 }
110
111 /* Disable Adapter */
112 static int disable(void)
113 {
114         return _bt_hal_dbus_disable_adapter();
115 }
116
117 #ifdef  TIZEN_BT_HAL
118 /* Tizen Specific Reset Adapter */
119 static int reset(void)
120 {
121         return _bt_hal_dbus_reset_adapter();
122 }
123 #endif
124
125 static void cleanup(void)
126 {
127         return;
128 }
129
130 #ifdef  TIZEN_BT_HAL
131 /* Tizen Specific Get Powered state */
132 static int get_adapter_powered_status(uint8_t *state)
133 {
134         if (!state) {
135                 ERR("Invalid param");
136                 return BT_STATUS_PARM_INVALID;
137         }
138
139         return _bt_hal_get_adapter_powered_state(state);
140 }
141 #endif
142
143 static int get_adapter_properties(void)
144 {
145         return _bt_hal_dbus_get_adapter_properties();
146 }
147
148 static int get_adapter_property(bt_property_type_t type)
149 {
150         return _bt_hal_dbus_get_adapter_property(type);
151 }
152
153 static int set_adapter_property(const bt_property_t *property)
154 {
155         if (!property) {
156                 ERR("Invalid param");
157                 return BT_STATUS_PARM_INVALID;
158         }
159
160         return _bt_hal_dbus_set_adapter_property(property);
161 }
162
163 static int get_remote_device_properties(bt_bdaddr_t *remote_addr)
164 {
165         if (!remote_addr) {
166                 ERR("Invalid param");
167                 return BT_STATUS_PARM_INVALID;
168         }
169
170         return _bt_hal_dbus_get_remote_device_properties(remote_addr);
171 }
172
173 static int get_remote_device_property(bt_bdaddr_t *remote_addr,
174                 bt_property_type_t type)
175 {
176         return BT_STATUS_UNSUPPORTED;
177 }
178
179 static int set_remote_device_property(bt_bdaddr_t *remote_addr,
180                 const bt_property_t *property)
181 {
182         return _bt_hal_dbus_set_remote_device_property(remote_addr, property);
183 }
184
185 static int get_remote_service_record(bt_bdaddr_t *remote_addr, bt_uuid_t *uuid)
186 {
187         return BT_STATUS_UNSUPPORTED;
188 }
189
190 static int get_remote_services(bt_bdaddr_t *remote_addr)
191 {
192         if (!remote_addr) {
193                 ERR("Invalid param");
194                 return BT_STATUS_PARM_INVALID;
195         }
196         return _bt_hal_dbus_get_remote_device_services(remote_addr);
197 }
198
199 static int start_discovery(void)
200 {
201         return _bt_hal_dbus_start_discovery(false, 0x00);
202 }
203
204 #ifdef  TIZEN_BT_HAL
205 static int start_custom_discovery(bt_disc_role_type_t disc_type)
206 {
207         return _bt_hal_dbus_start_discovery(true, disc_type);
208 }
209 #endif
210
211 static int cancel_discovery(void)
212 {
213         return _bt_hal_dbus_stop_discovery();
214 }
215
216 static int create_bond(const bt_bdaddr_t *bd_addr, int transport)
217 {
218         DBG("+");
219         return _bt_hal_device_create_bond(bd_addr, transport);
220 }
221
222 static int cancel_bond(const bt_bdaddr_t *bd_addr)
223 {
224         return _bt_hal_device_cancel_bond(bd_addr);
225 }
226
227 static int remove_bond(const bt_bdaddr_t *bd_addr)
228 {
229         DBG("+");
230         return _bt_hal_device_remove_bond(bd_addr);
231 }
232
233 static int pin_reply(const bt_bdaddr_t *bd_addr, uint8_t accept,
234                 uint8_t pin_len, bt_pin_code_t *pin_code)
235 {
236         return _bt_hal_device_legacy_pin_reply(bd_addr, accept, pin_len, (char*)pin_code);
237 }
238
239 static int ssp_reply(const bt_bdaddr_t *bd_addr, bt_ssp_variant_t variant,
240                 uint8_t accept, uint32_t passkey)
241 {
242         return _bt_hal_device_ssp_reply(bd_addr, variant, accept, passkey);
243 }
244
245 static const void *get_profile_interface(const char *profile_id)
246 {
247         /*TODO: Profile interfaces to be included later*/
248         DBG("%s", profile_id);
249
250         if (!interface_ready())
251                 return NULL;
252
253         if (!strncmp(profile_id, BT_PROFILE_HIDHOST_ID, strlen(profile_id)))
254                 return bt_get_hidhost_interface();
255
256         if (!strcmp(profile_id, BT_PROFILE_HIDDEVICE_ID))
257                 return bt_get_hiddevice_interface();
258
259         if (!strcmp(profile_id, BT_PROFILE_SOCKETS_ID))
260                 return bt_get_socket_interface();
261
262         if (!strcmp(profile_id, BT_PROFILE_PAN_ID))
263                 return NULL;
264
265         if (!strcmp(profile_id, BT_PROFILE_ADVANCED_AUDIO_ID))
266                 return bt_get_av_interface();
267
268         if (!strcmp(profile_id, BT_PROFILE_AV_RC_ID))
269                 return bt_get_avrcp_tg_interface();
270
271         if (!strcmp(profile_id, BT_PROFILE_HANDSFREE_ID))
272                 return bt_get_hf_interface();
273
274         if (!strcmp(profile_id, BT_PROFILE_HANDSFREE_CLIENT_ID))
275                 return bt_get_hf_client_interface();
276
277         if (!strcmp(profile_id, BT_PROFILE_GATT_ID))
278                 return bt_get_gatt_interface();
279
280         if (!strcmp(profile_id, BT_PROFILE_HEALTH_ID))
281                 return bt_get_hl_interface();
282
283         if (!strcmp(profile_id, BT_PROFILE_AV_RC_CTRL_ID))
284                 return bt_get_avrcp_ctrl_interface();
285
286         if (!strcmp(profile_id, BT_PROFILE_HANDSFREE_CLIENT_ID))
287                 return NULL;
288
289         if (!strcmp(profile_id, BT_PROFILE_MAP_CLIENT_ID))
290                 return NULL;
291
292         if (!strcmp(profile_id, BT_PROFILE_ADVANCED_AUDIO_SINK_ID))
293                 return bt_get_a2dp_sink_interface();
294
295         return NULL;
296 }
297
298 static int dut_mode_configure(uint8_t enable)
299 {
300         return BT_STATUS_UNSUPPORTED;
301 }
302
303 static int dut_mode_send(uint16_t opcode, uint8_t *buf, uint8_t buf_len)
304 {
305         return BT_STATUS_UNSUPPORTED;
306 }
307
308 static int le_test_mode(uint16_t opcode, uint8_t *buf, uint8_t buf_len)
309 {
310         return BT_STATUS_UNSUPPORTED;
311 }
312
313 static int config_hci_snoop_log(uint8_t enable)
314 {
315         return BT_STATUS_UNSUPPORTED;
316 }
317
318 static int get_connection_state(const bt_bdaddr_t *bd_addr)
319 {
320         DBG("");
321         return _bt_hal_device_get_connection_state(bd_addr);
322 }
323
324 static int set_os_callouts(bt_os_callouts_t *callouts)
325 {
326         DBG("callouts: %p", callouts);
327
328         /* TODO: implement */
329
330         return BT_STATUS_UNSUPPORTED;
331 }
332
333 static int read_energy_info(void)
334 {
335         return BT_STATUS_UNSUPPORTED;
336 }
337
338 static int authorize_response(const bt_bdaddr_t *bd_addr, bt_service_id_t service_id,
339                 uint8_t authorize, uint8_t save_settings)
340 {
341         DBG("+");
342         return _bt_hal_device_authorize_response(bd_addr, service_id, authorize, save_settings);
343 }
344
345 int set_authorization(bt_bdaddr_t *bd_addr, uint8_t auth)
346 {
347         DBG("+");
348         return _bt_hal_device_set_trust(bd_addr, auth);
349 }
350
351 #ifdef TIZEN_BT_HAL
352 static int get_service_connection_state(const bt_bdaddr_t *bd_addr, bt_service_id_t rem_svc_id)
353 {
354         DBG("");
355         return _bt_hal_device_get_service_connection_state(bd_addr, rem_svc_id);
356 }
357
358 static int register_agent_osp_server(uint32_t type, char *uuid, char *path, int fd)
359 {
360         DBG("");
361         return _bt_hal_device_register_osp_server(type, uuid, path, fd);
362 }
363
364 static int unregister_agent_osp_server(uint32_t type, char *uuid)
365 {
366         DBG("");
367         return _bt_hal_device_unregister_osp_server(type, uuid);
368 }
369
370 static int set_trusted_profile(bt_bdaddr_t *bd_addr, bt_trusted_profile_t profile, uint8_t trust)
371 {
372         DBG("");
373         return _bt_hal_device_set_trusted_profile(bd_addr, profile, trust);
374 }
375
376 static int get_trusted_profile(bt_bdaddr_t *bd_addr, bt_trusted_profile_t profile, uint32_t *trusted)
377 {
378         DBG("");
379         return _bt_hal_device_get_trusted_profile(bd_addr, profile, trusted);
380 }
381
382 static int get_connected_link_rssi_strength(bt_bdaddr_t *bd_addr, uint32_t conn_link_type)
383 {
384         DBG("");
385         return _bt_hal_device_get_connected_link_rssi_strength(bd_addr, conn_link_type);
386 }
387
388 static int enable_rssi_monitoring(bt_bdaddr_t *bd_addr, uint32_t conn_link_type,
389                 int low_threshold, int in_range_threshold, int high_threshold)
390 {
391         DBG("");
392         return _bt_hal_device_enable_rssi_monitoring(bd_addr, conn_link_type,
393                         low_threshold, in_range_threshold, high_threshold);
394 }
395
396 static int enable_gap_auth_notifications(uint32_t type, uint8_t enable)
397 {
398         DBG("");
399         _bt_hal_enable_gap_auth_notifications(type, ((enable == 0) ? FALSE : TRUE));
400         return BT_STATUS_SUCCESS;
401 }
402
403 static int set_hal_adapter_request_state(int enable)
404 {
405         DBG("");
406         _bt_hal_set_adapter_request_state(enable);
407         return BT_STATUS_SUCCESS;
408 }
409
410 static int set_hal_le_request_state(int enable)
411 {
412         DBG("");
413         _bt_hal_set_le_request_state(enable);
414         return BT_STATUS_SUCCESS;
415 }
416
417 static int dev_disconnect(const bt_bdaddr_t *bd_addr)
418 {
419         DBG("+");
420         return _bt_hal_device_disconnect(bd_addr);
421 }
422 #endif
423
424 static const bt_interface_t bluetooth_if = {
425         .size = sizeof(bt_interface_t),
426         .init = init,
427         .enable = enable,
428         .disable = disable,
429 #ifdef TIZEN_BT_HAL
430         .reset = reset,
431 #endif
432
433 #ifdef TIZEN_BT_HAL
434         .le_enable = _bt_hal_le_enable,
435         .le_disable = _bt_hal_le_disable,
436         .le_init = _bt_hal_le_init,
437         .le_deinit = _bt_hal_le_deinit,
438         .is_advertising = _bt_hal_is_advertising,
439 #endif
440         .cleanup = cleanup,
441 #ifdef TIZEN_BT_HAL
442         .get_adapter_powered_status = get_adapter_powered_status,
443 #endif
444         .get_adapter_properties = get_adapter_properties,
445         .get_adapter_property = get_adapter_property,
446         .set_adapter_property = set_adapter_property,
447         .get_remote_device_properties = get_remote_device_properties,
448         .get_remote_device_property = get_remote_device_property,
449         .set_remote_device_property = set_remote_device_property,
450         .get_remote_service_record = get_remote_service_record,
451         .get_remote_services = get_remote_services,
452         .start_discovery = start_discovery,
453 #ifdef TIZEN_BT_HAL
454         .start_custom_discovery = start_custom_discovery,
455 #endif
456         .cancel_discovery = cancel_discovery,
457         .create_bond = create_bond,
458         .remove_bond = remove_bond,
459         .cancel_bond = cancel_bond,
460         .pin_reply = pin_reply,
461         .ssp_reply = ssp_reply,
462         .get_profile_interface = get_profile_interface,
463         .dut_mode_configure = dut_mode_configure,
464         .dut_mode_send = dut_mode_send,
465         .le_test_mode = le_test_mode,
466         .config_hci_snoop_log = config_hci_snoop_log,
467         .get_connection_state = get_connection_state,
468         .set_os_callouts = set_os_callouts,
469         .read_energy_info = read_energy_info,
470         /* Tizen Specific API's*/
471         .authorize_response = authorize_response,
472         .set_authorization = set_authorization,
473 #ifdef TIZEN_BT_HAL
474         .get_service_connection_state = get_service_connection_state,
475         .register_agent_osp_server = register_agent_osp_server,
476         .unregister_agent_osp_server = unregister_agent_osp_server,
477         .set_trusted_profile = set_trusted_profile,
478         .get_trusted_profile = get_trusted_profile,
479         .enable_rssi_monitoring = enable_rssi_monitoring,
480         .get_connected_link_rssi_strength = get_connected_link_rssi_strength,
481         .enable_gap_auth_notifications = enable_gap_auth_notifications,
482         .set_le_static_random_address = _bt_hal_set_le_static_random_address,
483         .set_hal_adapter_request_state = set_hal_adapter_request_state,
484         .set_hal_le_request_state = set_hal_le_request_state,
485         .adapter_le_set_manufacturer_data = _bt_hal_adapter_le_set_manufacturer_data,
486         .adapter_le_set_white_list = _bt_hal_adapter_le_set_white_list,
487         .adapter_le_set_privacy = _bt_hal_adapter_le_set_privacy,
488         .device_disconnect = dev_disconnect,
489 #endif
490 };
491
492 static const bt_interface_t *get_bluetooth_interface(void)
493 {
494         DBG("");
495         return &bluetooth_if;
496 }
497
498 static int close_bluetooth(struct hw_device_t *device)
499 {
500         DBG("");
501         cleanup();
502         free(device);
503         return 0;
504 }
505
506 static int open_bluetooth(const struct hw_module_t *module, char const *name,
507                 struct hw_device_t **device)
508 {
509         bluetooth_device_t *dev = g_malloc0(sizeof(bluetooth_device_t));
510
511         DBG("");
512
513         memset(dev, 0, sizeof(bluetooth_device_t));
514         dev->common.tag = HARDWARE_DEVICE_TAG;
515         dev->common.version = 0;
516         dev->common.module = (struct hw_module_t *) module;
517         dev->common.close = close_bluetooth;
518         dev->get_bluetooth_interface = get_bluetooth_interface;
519
520         *device = (struct hw_device_t *) dev;
521
522         return 0;
523 }
524
525 static struct hw_module_methods_t bluetooth_module_methods = {
526         .open = open_bluetooth,
527 };
528
529 struct hw_module_t HAL_MODULE_INFO_SYM = {
530         .tag = HARDWARE_MODULE_TAG,
531         .version_major = 1,
532         .version_minor = 0,
533         .id = BT_HARDWARE_MODULE_ID,
534         .name = "Bluetooth stack",
535         .author = "Intel Corporation",
536         .methods = &bluetooth_module_methods
537 };
538
539 static void __bt_hal_handle_adapter_state_changed(void *buf, uint16_t len)
540 {
541         struct hal_ev_adapter_state_changed *ev = buf;
542
543         DBG("Adapter State: %d", ev->state);
544
545         if (bt_hal_cbacks->adapter_state_changed_cb)
546                 bt_hal_cbacks->adapter_state_changed_cb(ev->state);
547 }
548
549 #ifdef TIZEN_BT_HAL
550 static void __bt_hal_handle_le_state_changed(void *buf, uint16_t len)
551 {
552         struct hal_ev_le_state_changed *ev = buf;
553
554         DBG("Adapter State: %d", ev->state);
555
556         if (bt_hal_cbacks->le_state_changed_cb)
557                 bt_hal_cbacks->le_state_changed_cb(ev->state);
558 }
559 #endif
560
561 static void __bt_adapter_props_to_hal(bt_property_t *send_props, struct hal_property *prop,
562                 uint8_t num_props, uint16_t len)
563 {
564         void *buf = prop;
565         uint8_t i;
566
567         for (i = 0; i < num_props; i++) {
568                 if (sizeof(*prop) + prop->len > len) {
569                         ERR("invalid adapter properties(%zu > %u), cant process further properties!!!",
570                                         sizeof(*prop) + prop->len, len);
571                         return;
572                 }
573
574                 send_props[i].type = prop->type;
575
576                 switch (prop->type) {
577                         /* TODO: Add Adapter Properties */
578                 default:
579                         send_props[i].len = prop->len;
580                         send_props[i].val = prop->val;
581                         break;
582                 }
583
584                 DBG("prop[%d]: %s", i, btproperty2str(&send_props[i]));
585
586                 len -= sizeof(*prop) + prop->len;
587                 buf += sizeof(*prop) + prop->len;
588                 prop = buf;
589         }
590
591         if (!len)
592                 return;
593 }
594
595 static void __bt_device_props_to_hal(bt_property_t *send_props,
596                 struct hal_property *prop, uint8_t num_props,
597                 uint16_t len)
598 {
599         void *buf = prop;
600         uint8_t i;
601
602         DBG("+");
603
604         for (i = 0; i < num_props; i++) {
605
606                 if (sizeof(*prop) + prop->len > len) {
607                         ERR("invalid device properties (%zu > %u), cant process further properties!!!",
608                                         sizeof(*prop) + prop->len, len);
609                         return;
610                 }
611
612                 send_props[i].type = prop->type;
613
614                 DBG("HAL prop Type [%d]", prop->type);
615
616                 switch (prop->type) {
617                 case HAL_PROP_DEVICE_TYPE:
618                 {
619                         DBG("Device property:HAL_PROP_DEVICE_TYPE:");
620                         enum_prop_to_hal(send_props[i], prop,
621                                         bt_device_type_t);
622                         break;
623                 }
624                 case HAL_PROP_DEVICE_VERSION_INFO:
625                 {
626                         DBG("Device property: HAL_PROP_DEVICE_VERSION_INFO");
627                         static bt_remote_version_t e;
628                         const struct hal_prop_device_info *p;
629                         send_props[i].val = &e;
630                         send_props[i].len = sizeof(e);
631                                 p = (struct hal_prop_device_info *) prop->val;
632                                 e.manufacturer = p->manufacturer;
633                         e.sub_ver = p->sub_version;
634                         e.version = p->version;
635                         break;
636                 }
637                 case HAL_PROP_DEVICE_SERVICE_REC:
638                 {
639                         DBG("Device property: HAL_PROP_DEVICE_SERVICE_REC");
640                         static bt_service_record_t e;
641                         const struct hal_prop_device_service_rec *p;
642                         send_props[i].val = &e;
643                         send_props[i].len = sizeof(e);
644                                 p = (struct hal_prop_device_service_rec *) prop->val;
645                                         memset(&e, 0, sizeof(e));
646                         memcpy(&e.channel, &p->channel, sizeof(e.channel));
647                         memcpy(e.uuid.uu, p->uuid, sizeof(e.uuid.uu));
648                         memcpy(e.name, p->name, p->name_len);
649                         break;
650                 }
651                 default:
652                         send_props[i].len = prop->len;
653                         send_props[i].val = prop->val;
654                         break;
655                 }
656
657                 DBG("prop[%d]: %s, len: %d", i, btproperty2str(&send_props[i]), prop->len);
658                 len -= sizeof(*prop) + prop->len;
659                 buf += sizeof(*prop) + prop->len;
660                 prop = buf;
661
662         }
663
664         if (!len) {
665                 DBG("-");
666                 return;
667         }
668
669         ERR("invalid device properties (%u bytes left), ", len);
670 }
671
672 static void __bt_hal_handle_adapter_property_changed(void *buf, uint16_t len)
673 {
674         struct hal_ev_adapter_props_changed *ev = (struct hal_ev_adapter_props_changed *)buf;
675         bt_property_t props[ev->num_props];
676         DBG("+");
677
678         if (!bt_hal_cbacks->adapter_properties_cb)
679                 return;
680
681         len -= sizeof(*ev);
682         __bt_adapter_props_to_hal(props, ev->props, ev->num_props, len);
683
684         if (bt_hal_cbacks->adapter_properties_cb)
685                 bt_hal_cbacks->adapter_properties_cb(ev->status, ev->num_props, props);
686 }
687
688 static void __bt_hal_handle_adapter_discovery_state_changed(void *buf, uint16_t len)
689 {
690         struct hal_ev_discovery_state_changed *ev = (struct hal_ev_discovery_state_changed *)buf;
691
692         DBG("+");
693
694         if (bt_hal_cbacks->discovery_state_changed_cb)
695                 bt_hal_cbacks->discovery_state_changed_cb(ev->state);
696 }
697
698 static void __bt_hal_handle_device_found_event(void *buf, uint16_t len)
699 {
700         struct hal_ev_device_found *ev =  (struct hal_ev_device_found *) buf;
701         bt_property_t props[ev->num_props];
702         DBG("+");
703
704         if (!bt_hal_cbacks->device_found_cb)
705                 return;
706
707         len -= sizeof(*ev);
708         __bt_device_props_to_hal(props, ev->props, ev->num_props, len);
709
710         bt_hal_cbacks->device_found_cb(ev->num_props, props);
711 }
712
713 static void __bt_hal_handle_remote_device_properties_event(void *buf, uint16_t len)
714 {
715         struct hal_ev_remote_device_props *ev = (struct hal_ev_remote_device_props *) buf;
716         bt_bdaddr_t bd_addr;
717         bt_property_t props[ev->num_props];
718
719         DBG("+");
720
721         if (!bt_hal_cbacks->remote_device_properties_cb)
722                 return;
723
724         len -= sizeof(*ev);
725         __bt_device_props_to_hal(props, ev->props, ev->num_props, len);
726         memcpy(bd_addr.address, ev->bdaddr, 6);
727         bt_hal_cbacks->remote_device_properties_cb(
728                         ev->status, &bd_addr, ev->num_props, props);
729         DBG("-");
730 }
731
732 static void __bt_hal_handle_bond_state_changed_event(void *buf, uint16_t len)
733 {
734
735         struct hal_ev_bond_state_changed *ev = (struct hal_ev_bond_state_changed *)buf;
736         bt_bdaddr_t bd_addr;
737         DBG("+");
738
739         memcpy(bd_addr.address, ev->bdaddr, 6);
740         /* BD address*/
741         DBG("[0x%x]", bd_addr.address[0]);
742         DBG("[0x%x]", bd_addr.address[1]);
743         DBG("[0x%x]", bd_addr.address[2]);
744         DBG("[0x%x]", bd_addr.address[3]);
745         DBG("[0x%x]", bd_addr.address[4]);
746         DBG("[0x%x]", bd_addr.address[5]);
747
748         DBG("Bonding  State changed Status [0x%x]", ev->status);
749         DBG("Bonding  State [0x%x]", ev->state);
750
751         if (!bt_hal_cbacks->bond_state_changed_cb) {
752                 ERR("HAL User bond_state_changed_callback is not set!!");
753                 return;
754         }
755
756         bt_hal_cbacks->bond_state_changed_cb(ev->status, &bd_addr, ev->state);
757         DBG("-");
758 }
759
760 static void __bt_hal_handle_device_acl_state_changed_event(void *buf, uint16_t len)
761 {
762         struct hal_ev_acl_state_changed *ev = (struct hal_ev_acl_state_changed*)buf;
763         bt_bdaddr_t bd_addr;
764         DBG("+");
765
766         memcpy(bd_addr.address, ev->bdaddr, 6);
767         /* BD address*/
768         DBG("[0x%x]", bd_addr.address[0]);
769         DBG("[0x%x]", bd_addr.address[1]);
770         DBG("[0x%x]", bd_addr.address[2]);
771         DBG("[0x%x]", bd_addr.address[3]);
772         DBG("[0x%x]", bd_addr.address[4]);
773         DBG("[0x%x]", bd_addr.address[5]);
774
775         DBG("ACL Status [0x%x]", ev->status);
776         DBG("ACL State  [0x%x]", ev->state);
777
778         if (!bt_hal_cbacks->acl_state_changed_cb) {
779                 ERR("HAL User acl_state_changed_cb is not set!!");
780                 return;
781         }
782
783         bt_hal_cbacks->acl_state_changed_cb(ev->status, &bd_addr, ev->state);
784         DBG("-");
785 }
786
787 static void __bt_hal_handle_device_le_conn_state_changed_event(void *buf, uint16_t len)
788 {
789         struct hal_ev_acl_state_changed *ev = (struct hal_ev_acl_state_changed*)buf;
790         bt_bdaddr_t bd_addr;
791         DBG("+");
792
793         memcpy(bd_addr.address, ev->bdaddr, 6);
794         /* BD address */
795         DBG("Address: [%02X:%02X:%02X:%02X:%02X:%02X]", bd_addr.address[0],
796                         bd_addr.address[1], bd_addr.address[2], bd_addr.address[3],
797                         bd_addr.address[4], bd_addr.address[5]);
798         DBG("LE conn Status [0x%x]", ev->status);
799         DBG("LE conn State  [0x%x]", ev->state);
800
801 #ifdef TIZEN_BT_HAL
802         if (!bt_hal_cbacks->le_conn_state_changed_cb) {
803                 ERR("HAL User le_conn_state_changed_cb is not set!!");
804                 return;
805         }
806
807         bt_hal_cbacks->le_conn_state_changed_cb(ev->status, &bd_addr, ev->state);
808 #endif
809         DBG("-");
810 }
811
812 static void __bt_hal_handle_authorize_request_event(void *buf, uint16_t len)
813 {
814         struct hal_ev_authorize_request *ev = (struct hal_ev_authorize_request *)buf;
815         bt_bdaddr_t bd_addr;
816
817         DBG("+");
818
819         memcpy(bd_addr.address, ev->bdaddr, 6);
820
821         /* BD address*/
822         DBG("[0x%x]", bd_addr.address[0]);
823         DBG("[0x%x]", bd_addr.address[1]);
824         DBG("[0x%x]", bd_addr.address[2]);
825         DBG("[0x%x]", bd_addr.address[3]);
826         DBG("[0x%x]", bd_addr.address[4]);
827         DBG("[0x%x]", bd_addr.address[5]);
828
829         DBG("Service Id: [%u]", ev->service_id);
830
831         if (!bt_hal_cbacks->authorize_request_cb) {
832                 ERR("HAL User authorize_request_cb is not set!!");
833                 return;
834         }
835
836         bt_hal_cbacks->authorize_request_cb(&bd_addr, ev->service_id);
837         DBG("-");
838 }
839
840 #ifdef TIZEN_BT_HAL
841 static void __bt_hal_handle_socket_authorize_request_event(void *buf, uint16_t len)
842 {
843         struct hal_ev_sock_conn_auth *ev = buf;
844         bt_bdaddr_t bd_addr;
845         bt_uuid_t uuid;
846         uint8_t name[249] = {0, };
847         uint8_t path[249] = {0, };
848         uint32_t fd;
849
850         DBG("+");
851
852         memcpy(bd_addr.address, ev->bdaddr, 6);
853         memcpy(uuid.uu, ev->uuid, 16);
854         memcpy(name, ev->name, sizeof(name) - 1);
855         memcpy(path, ev->path, sizeof(name) - 1);
856         fd = ev->fd;
857
858         if (!bt_hal_cbacks->socket_authorize_request_cb) {
859                 ERR("HAL User socket_authorize_request_cb is not set!!");
860                 return;
861         }
862
863         bt_hal_cbacks->socket_authorize_request_cb(&bd_addr, &uuid, name, path, fd);
864         DBG("-");
865 }
866 #endif
867
868 static void __bt_hal_handle_ssp_request_event(void *buf, uint16_t len)
869 {
870         struct hal_ev_ssp_request *ev = (struct hal_ev_ssp_request *)buf;
871         bt_bdaddr_t bd_addr;
872         bt_bdname_t bd_name;
873         DBG("+");
874
875         memcpy(bd_addr.address, ev->bdaddr, 6);
876         memcpy(bd_name.name, ev->name, 248);
877
878         /* BD address*/
879         DBG("[0x%x]", bd_addr.address[0]);
880         DBG("[0x%x]", bd_addr.address[1]);
881         DBG("[0x%x]", bd_addr.address[2]);
882         DBG("[0x%x]", bd_addr.address[3]);
883         DBG("[0x%x]", bd_addr.address[4]);
884         DBG("[0x%x]", bd_addr.address[5]);
885
886         DBG("COD [%d]", ev->class_of_dev);
887         DBG("pairing variant [%d]", ev->pairing_variant);
888         DBG("passkey [%d]", ev->passkey);
889
890         if (!bt_hal_cbacks->ssp_request_cb) {
891                 ERR("HAL User ssp_request_cb is not set!!");
892                 return;
893         }
894
895         bt_hal_cbacks->ssp_request_cb(&bd_addr, &bd_name,
896                         ev->class_of_dev,
897                         ev->pairing_variant, ev->passkey);
898         DBG("-");
899 }
900
901 static void __bt_hal_handle_pin_request_event(void *buf, uint16_t len)
902 {
903         struct hal_ev_pin_request *ev = (struct hal_ev_pin_request *)buf;
904         bt_bdaddr_t bd_addr;
905         bt_bdname_t bd_name;
906         DBG("+");
907
908         memcpy(bd_addr.address, ev->bdaddr, 6);
909         memcpy(bd_name.name, ev->name, 248);
910
911         /* BD address*/
912         DBG("[0x%x]", bd_addr.address[0]);
913         DBG("[0x%x]", bd_addr.address[1]);
914         DBG("[0x%x]", bd_addr.address[2]);
915         DBG("[0x%x]", bd_addr.address[3]);
916         DBG("[0x%x]", bd_addr.address[4]);
917         DBG("[0x%x]", bd_addr.address[5]);
918
919         DBG("COD [%u]", ev->class_of_dev);
920
921         if (!bt_hal_cbacks->pin_request_cb) {
922                 ERR("HAL User pin_request_cb is not set!!");
923                 return;
924         }
925
926         bt_hal_cbacks->pin_request_cb(&bd_addr, &bd_name,
927                         ev->class_of_dev);
928         DBG("-");
929 }
930
931 static void __bt_hal_handle_device_trust_state_changed_event(void *buf, uint16_t len)
932 {
933         struct hal_ev_device_trust_state_changed *ev = (struct hal_ev_device_trust_state_changed*)buf;
934         bt_bdaddr_t bd_addr;
935         DBG("+");
936
937         memcpy(bd_addr.address, ev->bdaddr, 6);
938         /* BD address*/
939         DBG("[0x%x]", bd_addr.address[0]);
940         DBG("[0x%x]", bd_addr.address[1]);
941         DBG("[0x%x]", bd_addr.address[2]);
942         DBG("[0x%x]", bd_addr.address[3]);
943         DBG("[0x%x]", bd_addr.address[4]);
944         DBG("[0x%x]", bd_addr.address[5]);
945
946         DBG("Device Trusted?  [0x%x]", ev->trust);
947
948         if (!bt_hal_cbacks->device_trust_state_changed_cb) {
949                 ERR("HAL User device_trust_state_changed_cb is not set!!");
950                 return;
951         }
952
953         bt_hal_cbacks->device_trust_state_changed_cb(&bd_addr, ev->trust);
954         DBG("-");
955 }
956
957 static void __bt_hal_handle_device_trusted_profiles_changed_event(void *buf, uint16_t len)
958 {
959         struct hal_ev_device_trusted_profiles_changed *ev = buf;
960         bt_bdaddr_t bd_addr;
961
962         DBG("+");
963 #ifdef TIZEN_BT_HAL
964         memcpy(bd_addr.address, ev->bdaddr, 6);
965         DBG("[0x%02X:%02X:%02X:%02X:%02X:%02X]",
966                         bd_addr.address[0], bd_addr.address[1],
967                         bd_addr.address[2], bd_addr.address[3],
968                         bd_addr.address[4], bd_addr.address[5]);
969
970         if (!bt_hal_cbacks->device_trusted_profiles_changed_cb) {
971                 ERR("device_trusted_profiles_changed_cb is NULL");
972                 return;
973         }
974
975         bt_hal_cbacks->device_trusted_profiles_changed_cb(&bd_addr, ev->trust_val);
976 #endif
977         DBG("-");
978 }
979
980 static void __bt_handle_rssi_monitor_state_changed(void *buf, uint16_t len)
981 {
982         struct hal_ev_rssi_monitor_state_changed *ev = buf;
983         bt_bdaddr_t bd_addr;
984
985         DBG("+");
986 #ifdef TIZEN_BT_HAL
987         memcpy(bd_addr.address, ev->bdaddr, 6);
988         DBG("[0x%02X:%02X:%02X:%02X:%02X:%02X]",
989                         bd_addr.address[0], bd_addr.address[1],
990                         bd_addr.address[2], bd_addr.address[3],
991                         bd_addr.address[4], bd_addr.address[5]);
992
993         if (bt_hal_cbacks->rssi_monitor_state_changed_cb)
994                 bt_hal_cbacks->rssi_monitor_state_changed_cb(
995                                 &bd_addr, ev->link_type, ev->state);
996 #endif
997         DBG("-");
998 }
999
1000 static void __bt_handle_rssi_alert_recieved(void *buf, uint16_t len)
1001 {
1002         struct hal_ev_rssi_alert_recieved *ev = buf;
1003         bt_bdaddr_t bd_addr;
1004
1005         DBG("+");
1006 #ifdef TIZEN_BT_HAL
1007         memcpy(bd_addr.address, ev->bdaddr, 6);
1008         DBG("[0x%02X:%02X:%02X:%02X:%02X:%02X]",
1009                         bd_addr.address[0], bd_addr.address[1],
1010                         bd_addr.address[2], bd_addr.address[3],
1011                         bd_addr.address[4], bd_addr.address[5]);
1012
1013         if (bt_hal_cbacks->rssi_alert_cb)
1014                 bt_hal_cbacks->rssi_alert_cb(
1015                                 &bd_addr, ev->link_type, ev->alert_type, ev->rssi);
1016 #endif
1017         DBG("-");
1018 }
1019
1020 static void __bt_handle_raw_rssi_recieved(void *buf, uint16_t len)
1021 {
1022         struct hal_ev_raw_rssi_recieved *ev = buf;
1023         bt_bdaddr_t bd_addr;
1024
1025         DBG("+");
1026 #ifdef TIZEN_BT_HAL
1027         memcpy(bd_addr.address, ev->bdaddr, 6);
1028         DBG("[0x%02X:%02X:%02X:%02X:%02X:%02X]",
1029                         bd_addr.address[0], bd_addr.address[1],
1030                         bd_addr.address[2], bd_addr.address[3],
1031                         bd_addr.address[4], bd_addr.address[5]);
1032
1033         if (bt_hal_cbacks->raw_rssi_received_cb)
1034                 bt_hal_cbacks->raw_rssi_received_cb(
1035                                 &bd_addr, ev->link_type, ev->rssi);
1036 #endif
1037         DBG("-");
1038 }
1039
1040 static void __bt_hal_handle_stack_messages(int message, void *buf, uint16_t len)
1041 {
1042         DBG("+");
1043         switch (message) {
1044         case HAL_EV_ADAPTER_STATE_CHANGED:
1045                 DBG("Event: HAL_EV_ADAPTER_STATE_CHANGED");
1046                 __bt_hal_handle_adapter_state_changed(buf, len);
1047                 break;
1048         case HAL_EV_ADAPTER_PROPS_CHANGED:
1049                 DBG("Event: HAL_EV_ADAPTER_PROPS_CHANGED");
1050                 __bt_hal_handle_adapter_property_changed(buf, len);
1051                 break;
1052         case HAL_EV_DISCOVERY_STATE_CHANGED:
1053                 DBG("Event: HAL_EV_DISCOVERY_STATE_CHANGED");
1054                 __bt_hal_handle_adapter_discovery_state_changed(buf, len);
1055                 break;
1056         case HAL_EV_DEVICE_FOUND:
1057                 DBG("Event: HAL_EV_DEVICE_FOUND");
1058                 __bt_hal_handle_device_found_event(buf, len);
1059                 break;
1060         case HAL_EV_REMOTE_DEVICE_PROPS:
1061                 DBG("Event: HAL_EV_REMOTE_DEVICE_PROPS");
1062                 __bt_hal_handle_remote_device_properties_event(buf, len);
1063                 break;
1064         case HAL_EV_BOND_STATE_CHANGED:
1065                 DBG("Event: HAL_EV_BOND_STATE_CHANGED:");
1066                 __bt_hal_handle_bond_state_changed_event(buf, len);
1067                 break;
1068         case HAL_EV_ACL_STATE_CHANGED:
1069                 DBG("Event: HAL_ACL_STATE_CONNECTED or Disconnected");
1070                 __bt_hal_handle_device_acl_state_changed_event(buf, len);
1071                 break;
1072         case HAL_EV_LE_CONN_STATE_CHANGED:
1073                 DBG("Event: HAL_LE_CONN_STATE_CONNECTED or Disconnected");
1074                 __bt_hal_handle_device_le_conn_state_changed_event(buf, len);
1075                 break;
1076         case HAL_EV_SSP_REQUEST:
1077                 DBG("Event: HAL_EV_SSP_REQUEST");
1078                 __bt_hal_handle_ssp_request_event(buf, len);
1079                 break;
1080         case HAL_EV_PIN_REQUEST:
1081                 DBG("Event: HAL_EV_PIN_REQUEST");
1082                 __bt_hal_handle_pin_request_event(buf, len);
1083                 break;
1084         case HAL_EV_AUTHORIZE_REQUEST:
1085                 DBG("Event: HAL_EV_AUTHORIZE_REQUEST");
1086                 __bt_hal_handle_authorize_request_event(buf, len);
1087                 break;
1088         case HAL_EV_DEVICE_TRUST_CHANGED:
1089                 DBG("Event: HAL_EV_DEVICE_TRUST_CHANGED");
1090                 __bt_hal_handle_device_trust_state_changed_event(buf, len);
1091                 break;
1092 #ifdef TIZEN_BT_HAL
1093         case HAL_EV_SOCK_AUTHORIZE_REQUEST:
1094                 DBG("Event: HAL_EV_AUTHORIZE_REQUEST");
1095                 __bt_hal_handle_socket_authorize_request_event(buf, len);
1096                 break;
1097         case HAL_EV_LE_STATE_CHANGED:
1098                 DBG("Event: HAL_EV_LE_STATE_CHANGED");
1099                 __bt_hal_handle_le_state_changed(buf, len);
1100                 break;
1101 #endif
1102         case HAL_EV_DEVICE_TRUSTED_PROFILES_CHANGED:
1103                 DBG("Event: HAL_EV_DEVICE_TRUST_CHANGED");
1104                 __bt_hal_handle_device_trusted_profiles_changed_event(buf, len);
1105                 break;
1106         case HAL_EV_RSSI_MONITOR_STATE_CHANGED:
1107                 DBG("Event: HAL_EV_RSSI_MONITOR_STATE_CHANGED");
1108                 __bt_handle_rssi_monitor_state_changed(buf, len);
1109                 break;
1110         case HAL_EV_RSSI_ALERT_RECIEVED:
1111                 DBG("Event: HAL_EV_RSSI_ALERT_RECIEVED");
1112                 __bt_handle_rssi_alert_recieved(buf, len);
1113                 break;
1114         case HAL_EV_RAW_RSSI_RECIEVED:
1115                 DBG("Event: HAL_EV_RAW_RSSI_RECIEVED");
1116                 __bt_handle_raw_rssi_recieved(buf, len);
1117                 break;
1118         default:
1119                 DBG("Event Currently not handled!!");
1120                 break;
1121         }
1122         DBG("-");
1123 }