4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Hocheol Seo <hocheol.seo@samsung.com>
7 * Girishashok Joshi <girish.joshi@samsung.com>
8 * Chanyeol Park <chanyeol.park@samsung.com>
10 * Licensed under the Apache License, Version 2.0 (the "License");
11 * you may not use this file except in compliance with the License.
12 * You may obtain a copy of the License at
14 * http://www.apache.org/licenses/LICENSE-2.0
16 * Unless required by applicable law or agreed to in writing, software
17 * distributed under the License is distributed on an "AS IS" BASIS,
18 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19 * See the License for the specific language governing permissions and
20 * limitations under the License.
24 #include <gio/gunixfdlist.h>
25 #include <sys/socket.h>
27 #include "bluetooth-api.h"
28 #include "bt-internal-types.h"
29 #include "bluetooth-hid-api.h"
30 #include "bt-common.h"
31 #include "bt-request-sender.h"
32 #include "bt-event-handler.h"
34 #define HID_UUID "00001124-0000-1000-8000-00805f9b34fb"
35 #define REPORTID_MOUSE 1
36 #define BT_HID_BUFFER_LEN 100
38 /* The types of HIDP transaction */
39 #define BT_HIDP_TRANSACTION_SET_PROTOCOL 0x70
40 #define BT_HIDP_TRANSACTION_GET_IDLE 0x80
41 #define BT_HIDP_TRANSACTION_SET_IDLE 0x90
42 #define BT_HIDP_TRANSACTION_DATA 0xa0
43 #define BT_HIDP_TRANSACTION_DATC 0xb0
44 #define BT_HIDP_TRANSACTION_HANDSHAKE 0x00
45 #define BT_HIDP_TRANSACTION_HID_CONTROL 0x10
46 #define BT_HIDP_TRANSACTION_GET_REPORT 0x40
47 #define BT_HIDP_TRANSACTION_SET_REPORT 0x50
48 #define BT_HIDP_TRANSACTION_GET_PROTOCOL 0x60
50 #define BT_HIDP_DATA_OUT_RTYPE 0x02
51 #define BT_HIDP_DATA_IN_RTYPE 0x01
53 #define BT_HIDP_HSHK_ERROR_UNSUPPORTED_REQUEST 0x03
54 #define BT_HIDP_HSHK_ERROR_INVALID_PARAM 0x04
55 #define BT_HIDP_HSHK_ERROR_UNKNOWN 0x0E
56 #define BT_HIDP_HSHK_ERROR_FATAL 0x0F
57 #define BT_HIDP_HSHK_OK_SUCCESSFUL 0x00
58 #define BT_HIDP_HSHK_NOT_AVAILABLE 0x01
59 #define BT_HIDP_HSHK_ERROR_INVALID_REPORT_ID 0x02
61 /* The masks of BT_HIDP header */
62 #define BT_HIDP_HEADER_PARAMETER_MASK 0x0f
63 #define BT_HIDP_HEADER_TRANSACTION_MASK 0xf0
76 GIOChannel *ctrl_data_io;
77 GIOChannel *intr_data_io;
81 guint disconnect_idle_id;
82 } hid_connected_device_info_t;
87 }__attribute__((__packed__));
89 static hid_info_t *hid_info = NULL;
91 /* Variable for privilege, only for write API,
92 before we should reduce time to bt-service dbus calling
93 -1 : Don't have a permission to access API
94 0 : Initial value, not yet check
95 1 : Have a permission to access API
97 static int privilege_token_send_mouse = 0;
98 static int privilege_token_send_key = 0;
99 static int privilege_token_reply = 0;
101 static gboolean __hid_disconnect(hid_connected_device_info_t *info);
103 static hid_connected_device_info_t *__find_hid_info_with_address(const char *remote_addr)
107 for ( l = hid_info->device_list; l != NULL; l = l->next) {
108 hid_connected_device_info_t *info = l->data;
109 if (g_strcmp0((const char *)info->address, (const char *)remote_addr) == 0)
115 static void __hid_connected_cb(hid_connected_device_info_t *info,
116 bt_event_info_t *event_info)
118 bluetooth_hid_request_t conn_info;
120 memset(&conn_info, 0x00, sizeof(bluetooth_hid_request_t));
121 if (info->intr_fd != -1 && info->ctrl_fd == -1)
122 conn_info.socket_fd = info->intr_fd;
124 conn_info.socket_fd = info->ctrl_fd;
125 _bt_convert_addr_string_to_type (conn_info.device_addr.addr , info->address);
127 BT_INFO_C("Connected [HID Device]");
128 _bt_common_event_cb(BLUETOOTH_HID_DEVICE_CONNECTED,
129 BLUETOOTH_ERROR_NONE, &conn_info,
130 event_info->cb, event_info->user_data);
133 static gboolean __hid_disconnect(hid_connected_device_info_t *info)
135 bluetooth_hid_request_t disconn_info;
136 int fd = info->ctrl_fd;
137 bt_event_info_t *event_info;
139 BT_INFO_C("Disconnected [HID Device]");
140 hid_info->device_list = g_slist_remove(hid_info->device_list, info);
141 if (info->ctrl_data_id > 0) {
142 g_source_remove(info->ctrl_data_id);
143 info->ctrl_data_id = 0;
145 if (info->intr_data_id > 0) {
146 g_source_remove(info->intr_data_id);
147 info->intr_data_id = 0;
150 if (info->intr_fd >= 0) {
151 close(info->ctrl_fd);
152 close(info->intr_fd);
157 if (info->ctrl_data_io) {
158 g_io_channel_shutdown(info->ctrl_data_io, TRUE, NULL);
159 g_io_channel_unref(info->ctrl_data_io);
160 info->ctrl_data_io = NULL;
162 if (info->intr_data_io) {
163 g_io_channel_shutdown(info->intr_data_io, TRUE, NULL);
164 g_io_channel_unref(info->intr_data_io);
165 info->intr_data_io = NULL;
167 info->disconnect_idle_id = 0;
168 event_info = _bt_event_get_cb_data(BT_HID_DEVICE_EVENT);
169 if (event_info == NULL)
172 memset(&disconn_info, 0x00, sizeof(bluetooth_hid_request_t));
173 disconn_info.socket_fd = fd;
174 _bt_convert_addr_string_to_type (disconn_info.device_addr.addr , info->address);
175 _bt_common_event_cb(BLUETOOTH_HID_DEVICE_DISCONNECTED,
176 BLUETOOTH_ERROR_NONE, &disconn_info,
177 event_info->cb, event_info->user_data);
179 g_free(info->address);
186 void __free_hid_info(hid_info_t *info)
190 _bt_unregister_gdbus(info->object_id);
192 while (info->device_list) {
193 hid_connected_device_info_t *dev_info = NULL;
194 dev_info = (hid_connected_device_info_t *)info->device_list->data;
196 if (dev_info->disconnect_idle_id > 0) {
197 BT_INFO("Disconnect idle still not process remove source");
198 g_source_remove(dev_info->disconnect_idle_id);
199 dev_info->disconnect_idle_id = 0;
201 __hid_disconnect(dev_info);
209 static gboolean __received_cb(GIOChannel *chan, GIOCondition cond,
212 hid_connected_device_info_t *info = data;
213 GIOStatus status = G_IO_STATUS_NORMAL;
217 guint8 header, type, param;
218 bt_event_info_t *event_info;
219 retv_if(info == NULL, FALSE);
221 if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR)) {
222 BT_ERR_C("HID disconnected: %d", info->ctrl_fd);
223 if (info->disconnect_idle_id > 0) {
224 BT_INFO("Disconnect idle still not process remove source");
225 g_source_remove(info->disconnect_idle_id);
226 info->disconnect_idle_id = 0;
228 __hid_disconnect(info);
231 status = g_io_channel_read_chars(chan, buffer, BT_RFCOMM_BUFFER_LEN,
233 if (status == G_IO_STATUS_NORMAL) {
234 BT_INFO("Parsing Data");
235 bluetooth_hid_received_data_t data = {0};
237 type = header & BT_HIDP_HEADER_TRANSACTION_MASK;
238 param = header & BT_HIDP_HEADER_PARAMETER_MASK;
239 BT_INFO("type %d , param %d", type, param);
240 BT_INFO("Data Reveived from %s" , info->address);
241 data.address = g_strdup(info->address);
243 case BT_HIDP_TRANSACTION_HANDSHAKE:
244 BT_INFO("TRANS HANDSHAKE");
245 data.type = HTYPE_TRANS_HANDSHAKE;
246 data.buffer_size = len;
247 data.buffer = (char *) malloc(sizeof(char) * len);
249 memcpy(data.buffer, buffer, len);
251 case BT_HIDP_TRANSACTION_HID_CONTROL:
252 BT_INFO("HID CONTROL");
253 data.type = HTYPE_TRANS_HID_CONTROL;
254 data.buffer_size = len;
255 data.buffer = (char *) malloc(sizeof(char) * len);
257 memcpy(data.buffer, buffer, len);
259 case BT_HIDP_TRANSACTION_DATA:
260 BT_INFO("TRANS DATA");
261 data.type = HTYPE_TRANS_DATA;
262 if ( param & BT_HIDP_DATA_IN_RTYPE) {
263 BT_INFO("Input Report");
264 data.param = PTYPE_DATA_RTYPE_INPUT;
265 data.buffer_size = len;
266 data.buffer = (char *) malloc(sizeof(char) * len);
268 memcpy(data.buffer, buffer, len);
271 BT_INFO("Out Report");
272 data.param = PTYPE_DATA_RTYPE_OUTPUT;
273 data.buffer_size = len;
274 data.buffer = (char *) malloc(sizeof(char) * len);
276 memcpy(data.buffer, buffer, len);
279 case BT_HIDP_TRANSACTION_GET_REPORT: {
280 BT_INFO("Get Report");
281 data.type = HTYPE_TRANS_GET_REPORT;
282 if (param & BT_HIDP_DATA_IN_RTYPE) {
283 BT_INFO("Input Report");
284 data.param = PTYPE_DATA_RTYPE_INPUT;
286 BT_INFO("Output Report");
287 data.param = PTYPE_DATA_RTYPE_OUTPUT;
289 data.buffer_size = len;
290 data.buffer = (char *) malloc(sizeof(char) * len);
292 memcpy(data.buffer, buffer, len);
295 case BT_HIDP_TRANSACTION_SET_REPORT: {
296 BT_INFO("Set Report");
297 data.type = HTYPE_TRANS_SET_REPORT;
298 if (param & BT_HIDP_DATA_IN_RTYPE) {
299 BT_INFO("Input Report");
300 data.param = PTYPE_DATA_RTYPE_INPUT;
302 BT_INFO("Output Report");
303 data.param = PTYPE_DATA_RTYPE_OUTPUT;
305 data.buffer_size = len;
306 data.buffer = (char *) malloc(sizeof(char) * len);
308 memcpy(data.buffer, buffer, len);
311 case BT_HIDP_TRANSACTION_GET_PROTOCOL:{
312 BT_INFO("Get_PROTOCOL");
313 data.type = HTYPE_TRANS_GET_PROTOCOL;
314 data.param = PTYPE_DATA_RTYPE_INPUT;
315 data.buffer_size = len;
316 data.buffer = (char *) malloc(sizeof(char) * len);
318 memcpy(data.buffer, buffer, len);
321 case BT_HIDP_TRANSACTION_SET_PROTOCOL:{
322 BT_INFO("Set_PROTOCOL");
323 data.type = HTYPE_TRANS_SET_PROTOCOL;
324 data.param = PTYPE_DATA_RTYPE_INPUT;
325 data.buffer_size = len;
326 data.buffer = (char *) malloc(sizeof(char) * len);
328 memcpy(data.buffer, buffer, len);
332 BT_INFO("unsupported HIDP control message");
333 BT_ERR("Send Handshake Message");
334 guint8 type = BT_HIDP_TRANSACTION_HANDSHAKE |
335 BT_HIDP_HSHK_ERROR_UNSUPPORTED_REQUEST;
336 data.type = HTYPE_TRANS_UNKNOWN;
337 int fd = g_io_channel_unix_get_fd(chan);
338 int bytes = write(fd, &type, sizeof(type));
339 BT_INFO("Bytes Written %d", bytes);
343 event_info = _bt_event_get_cb_data(BT_HID_DEVICE_EVENT);
344 if (event_info == NULL) {
346 g_free((char *)data.address);
350 _bt_common_event_cb(BLUETOOTH_HID_DEVICE_DATA_RECEIVED,
351 BLUETOOTH_ERROR_NONE, &data,
352 event_info->cb, event_info->user_data);
355 g_free((char *)data.address);
357 BT_INFO("Error while reading data");
362 int new_hid_connection(const char *path, int fd, bluetooth_device_address_t *addr)
364 hid_info_t *info = NULL;
365 hid_connected_device_info_t *dev_info = NULL;
366 bt_event_info_t *event_info = NULL;
372 _bt_convert_addr_type_to_string((char *)address, addr->addr);
373 BT_INFO("Address [%s]", address);
374 dev_info = __find_hid_info_with_address(address);
375 if (dev_info == NULL) {
376 dev_info = (hid_connected_device_info_t *)
377 g_malloc0(sizeof(hid_connected_device_info_t));
378 if (dev_info == NULL) {
379 BT_ERR("Fail to allocation memory");
383 dev_info->intr_fd = -1;
384 dev_info->ctrl_fd = -1;
385 dev_info->intr_fd = fd;
386 dev_info->address = g_strdup(address);
387 dev_info->intr_data_io = g_io_channel_unix_new(dev_info->intr_fd);
388 g_io_channel_set_encoding(dev_info->intr_data_io, NULL, NULL);
389 g_io_channel_set_flags(dev_info->intr_data_io, G_IO_FLAG_NONBLOCK, NULL);
391 dev_info->intr_data_id = g_io_add_watch(dev_info->intr_data_io,
392 G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
393 __received_cb, dev_info);
394 hid_info->device_list = g_slist_append(hid_info->device_list, dev_info);
396 dev_info->ctrl_fd = fd;
397 dev_info->ctrl_data_io = g_io_channel_unix_new(dev_info->ctrl_fd);
398 g_io_channel_set_encoding(dev_info->ctrl_data_io, NULL, NULL);
399 g_io_channel_set_flags(dev_info->ctrl_data_io, G_IO_FLAG_NONBLOCK, NULL);
401 dev_info->ctrl_data_id = g_io_add_watch(dev_info->ctrl_data_io,
402 G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
403 __received_cb, dev_info);
405 if (dev_info->ctrl_fd != -1 && dev_info->intr_fd != -1) {
406 event_info = _bt_event_get_cb_data(BT_HID_DEVICE_EVENT);
408 __hid_connected_cb(dev_info, event_info);
413 static hid_info_t *__register_method()
416 hid_info_t *info = NULL;
418 path = g_strdup_printf("/org/socket/server/%d", getpid());
420 object_id = _bt_register_new_conn(path, new_hid_connection);
424 info = g_new(hid_info_t, 1);
425 info->object_id = (guint)object_id;
428 info->device_list = NULL;
433 BT_EXPORT_API int bluetooth_hid_device_init(hid_cb_func_ptr callback_ptr, void *user_data)
437 /* Register HID Device events */
438 BT_INFO("BT_HID_DEVICE_EVENT");
439 ret = _bt_register_event(BT_HID_DEVICE_EVENT , (void *)callback_ptr, user_data);
441 if (ret != BLUETOOTH_ERROR_NONE &&
442 ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
443 BT_ERR("Fail to init the event handler");
447 _bt_set_user_data(BT_HID, (void *)callback_ptr, user_data);
449 return BLUETOOTH_ERROR_NONE;
452 BT_EXPORT_API int bluetooth_hid_device_deinit(void)
456 ret = _bt_unregister_event(BT_HID_DEVICE_EVENT);
458 if (ret != BLUETOOTH_ERROR_NONE) {
459 BT_ERR("Fail to deinit the event handler");
463 _bt_set_user_data(BT_HID, NULL, NULL);
465 return BLUETOOTH_ERROR_NONE;
468 BT_EXPORT_API int bluetooth_hid_device_activate(void)
470 bt_register_profile_info_t profile_info;
471 int result = BLUETOOTH_ERROR_NONE;
473 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_ACTIVATE)
474 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
475 BT_ERR("Don't have a privilege to use this API");
476 return BLUETOOTH_ERROR_PERMISSION_DEINED;
479 if (hid_info != NULL)
480 return BLUETOOTH_ERROR_IN_PROGRESS;
482 hid_info = __register_method();
483 if (hid_info == NULL)
484 return BLUETOOTH_ERROR_INTERNAL;
486 hid_info->uuid = g_strdup(HID_UUID);
488 profile_info.authentication = TRUE;
489 profile_info.authorization = TRUE;
490 profile_info.obj_path = hid_info->path;
491 profile_info.role = g_strdup("Hid");
492 profile_info.service = hid_info->uuid;
493 profile_info.uuid = hid_info->uuid;
495 BT_INFO("uuid %s", profile_info.uuid);
496 result = _bt_register_profile_platform(&profile_info, FALSE);
501 BT_EXPORT_API int bluetooth_hid_device_deactivate(void)
503 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_DEACTIVATE)
504 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
505 BT_ERR("Don't have a privilege to use this API");
506 return BLUETOOTH_ERROR_PERMISSION_DEINED;
509 if (hid_info == NULL)
510 return BLUETOOTH_ERROR_NOT_IN_OPERATION;
512 _bt_unregister_profile(hid_info->path);
514 __free_hid_info(hid_info);
516 return BLUETOOTH_ERROR_NONE;
519 BT_EXPORT_API int bluetooth_hid_device_connect(const char *remote_addr)
521 char device_address[BT_ADDRESS_STRING_SIZE] = {0};
522 hid_connected_device_info_t *info = NULL;
525 BT_CHECK_PARAMETER(remote_addr, return);
527 info = __find_hid_info_with_address(remote_addr);
529 BT_ERR("Connection Already Exists");
530 return BLUETOOTH_ERROR_ALREADY_CONNECT;
532 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_CONNECT)
533 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
534 BT_ERR("Don't have a privilege to use this API");
535 return BLUETOOTH_ERROR_PERMISSION_DEINED;
538 memcpy(device_address, remote_addr, BT_ADDRESS_STRING_SIZE);
539 ret = _bt_connect_profile(device_address, HID_UUID, NULL, NULL);
543 BT_EXPORT_API int bluetooth_hid_device_disconnect(const char *remote_addr)
545 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_DISCONNECT)
546 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
547 BT_ERR("Don't have a privilege to use this API");
548 return BLUETOOTH_ERROR_PERMISSION_DEINED;
550 hid_connected_device_info_t *info = NULL;
552 info = __find_hid_info_with_address(remote_addr);
554 return BLUETOOTH_ERROR_INVALID_PARAM;
556 _bt_disconnect_profile((char *)remote_addr, HID_UUID, NULL, NULL);
558 info->disconnect_idle_id = g_idle_add((GSourceFunc)__hid_disconnect, info);
561 return BLUETOOTH_ERROR_NONE;
563 BT_EXPORT_API int bluetooth_hid_device_send_mouse_event(const char *remote_addr,
564 hid_send_mouse_event_t send_event)
569 hid_connected_device_info_t *info = NULL;
571 switch (privilege_token_send_mouse) {
573 result = _bt_check_privilege(BT_BLUEZ_SERVICE, BT_HID_DEVICE_SEND_MOUSE_EVENT);
575 if (result == BLUETOOTH_ERROR_NONE) {
576 privilege_token_send_mouse = 1; /* Have a permission */
577 } else if (result == BLUETOOTH_ERROR_PERMISSION_DEINED) {
578 BT_ERR("Don't have a privilege to use this API");
579 privilege_token_send_mouse = -1; /* Don't have a permission */
580 return BLUETOOTH_ERROR_PERMISSION_DEINED;
582 /* Just break - It is not related with permission error */
586 /* Already have a privilege */
589 return BLUETOOTH_ERROR_PERMISSION_DEINED;
591 /* Invalid privilge token value */
592 return BLUETOOTH_ERROR_INTERNAL;
594 info = __find_hid_info_with_address(remote_addr);
596 BT_ERR("Connection Information not found");
597 return BLUETOOTH_ERROR_INVALID_PARAM;
600 if (info->intr_fd != -1 && info->ctrl_fd == -1)
601 socket_fd = info->intr_fd;
603 socket_fd = info->ctrl_fd;
605 written = write(socket_fd, &send_event, sizeof(send_event));
610 BT_EXPORT_API int bluetooth_hid_device_send_key_event(const char *remote_addr,
611 hid_send_key_event_t send_event)
616 hid_connected_device_info_t *info = NULL;
618 switch (privilege_token_send_key) {
620 result = _bt_check_privilege(BT_BLUEZ_SERVICE, BT_HID_DEVICE_SEND_KEY_EVENT);
622 if (result == BLUETOOTH_ERROR_NONE) {
623 privilege_token_send_key = 1; /* Have a permission */
624 } else if (result == BLUETOOTH_ERROR_PERMISSION_DEINED) {
625 BT_ERR("Don't have a privilege to use this API");
626 privilege_token_send_key = -1; /* Don't have a permission */
627 return BLUETOOTH_ERROR_PERMISSION_DEINED;
629 /* Just break - It is not related with permission error */
633 /* Already have a privilege */
636 return BLUETOOTH_ERROR_PERMISSION_DEINED;
638 /* Invalid privilge token value */
639 return BLUETOOTH_ERROR_INTERNAL;
642 info = __find_hid_info_with_address(remote_addr);
644 BT_ERR("Connection Information not found");
645 return BLUETOOTH_ERROR_INVALID_PARAM;
648 if (info->intr_fd != -1 && info->ctrl_fd == -1)
649 socket_fd = info->intr_fd;
651 socket_fd = info->ctrl_fd;
653 written = write(socket_fd, &send_event, sizeof(send_event));
657 BT_EXPORT_API int bluetooth_hid_device_reply_to_report(const char *remote_addr,
658 bt_hid_header_type_t htype,
659 bt_hid_param_type_t ptype,
661 unsigned int data_len)
664 struct reports output_report = { 0 };
666 hid_connected_device_info_t *info = NULL;
667 info = __find_hid_info_with_address(remote_addr);
669 BT_ERR("Connection Information not found");
670 return BLUETOOTH_ERROR_INVALID_PARAM;
673 switch (privilege_token_reply) {
675 result = _bt_check_privilege(BT_BLUEZ_SERVICE, BT_HID_DEVICE_SEND_REPLY_TO_REPORT);
677 if (result == BLUETOOTH_ERROR_NONE) {
678 privilege_token_reply = 1; /* Have a permission */
679 } else if (result == BLUETOOTH_ERROR_PERMISSION_DEINED) {
680 BT_ERR("Don't have a privilege to use this API");
681 privilege_token_reply = -1; /* Don't have a permission */
682 return BLUETOOTH_ERROR_PERMISSION_DEINED;
684 /* Just break - It is not related with permission error */
688 /* Already have a privilege */
691 return BLUETOOTH_ERROR_PERMISSION_DEINED;
693 /* Invalid privilge token value */
694 return BLUETOOTH_ERROR_INTERNAL;
697 BT_INFO("htype %d ptype %d", htype, ptype);
699 case HTYPE_TRANS_GET_REPORT: {
701 case PTYPE_DATA_RTYPE_INPUT: {
702 output_report.type = BT_HIDP_TRANSACTION_DATA |
703 BT_HIDP_DATA_IN_RTYPE;
704 memcpy(output_report.rep_data, data, data_len);
705 bytes = write(info->intr_fd, &output_report,
706 sizeof(output_report));
707 BT_DBG("Bytes Written %d", bytes);
711 BT_INFO("Not Supported");
715 case HTYPE_TRANS_GET_PROTOCOL: {
716 BT_DBG("Replying to Get_PROTOCOL");
717 output_report.type = BT_HIDP_TRANSACTION_DATA | BT_HIDP_DATA_OUT_RTYPE;
718 output_report.rep_data[0] = data[0];
719 bytes = write(info->intr_fd, &output_report, 2);
720 BT_DBG("Bytes Written %d", bytes);
723 case HTYPE_TRANS_SET_PROTOCOL: {
724 BT_DBG("Reply to Set_Protocol");
725 output_report.type = BT_HIDP_TRANSACTION_DATA | BT_HIDP_DATA_IN_RTYPE;
726 memcpy(output_report.rep_data, data, data_len);
727 bytes = write(info->ctrl_fd, &output_report,
728 sizeof(output_report));
729 BT_DBG("Bytes Written %d", bytes);
732 case HTYPE_TRANS_HANDSHAKE: {
733 BT_DBG("Replying Handshake");
734 output_report.type = BT_HIDP_TRANSACTION_HANDSHAKE | data[0];
735 memset(output_report.rep_data, 0, sizeof(output_report.rep_data));
736 bytes = write(info->intr_fd, &output_report.type,
737 sizeof(output_report.type));
738 BT_DBG("Bytes Written %d", bytes);