1/****************************************************************************** 2 * 3 * Copyright (C) 2005-2012 Broadcom Corporation 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ******************************************************************************/ 18 19/****************************************************************************** 20 * 21 * This file contains the HID HOST API in the subsystem of BTA. 22 * 23 ******************************************************************************/ 24 25#include "bt_target.h" 26 27#if defined(BTA_HH_INCLUDED) && (BTA_HH_INCLUDED == TRUE) 28 29#include <stdlib.h> 30#include <string.h> 31#include <stdio.h> 32 33#include "bta_hh_api.h" 34#include "bta_hh_int.h" 35#include "l2c_api.h" 36 37/***************************************************************************** 38** Constants 39*****************************************************************************/ 40 41static const tBTA_SYS_REG bta_hh_reg = 42{ 43 bta_hh_hdl_event, 44 BTA_HhDisable 45}; 46 47/******************************************************************************* 48** 49** Function BTA_HhEnable 50** 51** Description Enable the HID host. This function must be called before 52** any other functions in the HID host API are called. When the 53** enable operation is complete the callback function will be 54** called with BTA_HH_ENABLE_EVT. 55** 56** 57** Returns void 58** 59*******************************************************************************/ 60void BTA_HhEnable(tBTA_SEC sec_mask, tBTA_HH_CBACK *p_cback) 61{ 62 tBTA_HH_API_ENABLE *p_buf; 63 64 /* register with BTA system manager */ 65 GKI_sched_lock(); 66 bta_sys_register(BTA_ID_HH, &bta_hh_reg); 67 GKI_sched_unlock(); 68 69 APPL_TRACE_ERROR0("Calling BTA_HhEnable"); 70 p_buf = (tBTA_HH_API_ENABLE *)GKI_getbuf((UINT16)sizeof(tBTA_HH_API_ENABLE)); 71 72 if (p_buf != NULL) 73 { 74 memset(p_buf, 0, sizeof(tBTA_HH_API_ENABLE)); 75 76 p_buf->hdr.event = BTA_HH_API_ENABLE_EVT; 77 p_buf->p_cback = p_cback; 78 p_buf->sec_mask = sec_mask; 79 80 bta_sys_sendmsg(p_buf); 81 } 82} 83 84/******************************************************************************* 85** 86** Function BTA_HhDisable 87** 88** Description Disable the HID host. If the server is currently 89** connected, the connection will be closed. 90** 91** Returns void 92** 93*******************************************************************************/ 94void BTA_HhDisable(void) 95{ 96 BT_HDR *p_buf; 97 98 bta_sys_deregister(BTA_ID_HH); 99 if ((p_buf = (BT_HDR *)GKI_getbuf(sizeof(BT_HDR))) != NULL) 100 { 101 p_buf->event = BTA_HH_API_DISABLE_EVT; 102 bta_sys_sendmsg(p_buf); 103 } 104} 105 106/******************************************************************************* 107** 108** Function BTA_HhClose 109** 110** Description Disconnect a connection. 111** 112** Returns void 113** 114*******************************************************************************/ 115void BTA_HhClose(UINT8 dev_handle) 116{ 117 BT_HDR *p_buf; 118 119 if ((p_buf = (BT_HDR *)GKI_getbuf((UINT16)sizeof(BT_HDR))) != NULL) 120 { 121 memset(p_buf, 0, sizeof(BT_HDR)); 122 p_buf->event = BTA_HH_API_CLOSE_EVT; 123 p_buf->layer_specific = (UINT16) dev_handle; 124 125 bta_sys_sendmsg(p_buf); 126 } 127} 128 129/******************************************************************************* 130** 131** Function BTA_HhOpen 132** 133** Description Connect to a device of specified BD address in specified 134** protocol mode and security level. 135** 136** Returns void 137** 138*******************************************************************************/ 139void BTA_HhOpen(BD_ADDR dev_bda, tBTA_HH_PROTO_MODE mode, tBTA_SEC sec_mask) 140{ 141 tBTA_HH_API_CONN *p_buf; 142 143 p_buf = (tBTA_HH_API_CONN *)GKI_getbuf((UINT16)sizeof(tBTA_HH_API_CONN)); 144 145 if (p_buf!= NULL) 146 { 147 memset((void *)p_buf, 0, sizeof(tBTA_HH_API_CONN)); 148 149 p_buf->hdr.event = BTA_HH_API_OPEN_EVT; 150 p_buf->hdr.layer_specific = BTA_HH_INVALID_HANDLE; 151 p_buf->sec_mask = sec_mask; 152 p_buf->mode = mode; 153 bdcpy(p_buf->bd_addr, dev_bda); 154 155 bta_sys_sendmsg((void *)p_buf); 156 } 157 else 158 { 159 APPL_TRACE_ERROR0("No resource to send HID host Connect request."); 160 } 161} 162 163/******************************************************************************* 164** 165** Function bta_hh_snd_write_dev 166** 167*******************************************************************************/ 168static void bta_hh_snd_write_dev(UINT8 dev_handle, UINT8 t_type, UINT8 param, 169 UINT16 data, UINT8 rpt_id, BT_HDR *p_data) 170{ 171 tBTA_HH_CMD_DATA *p_buf; 172 UINT16 len = (UINT16) (sizeof(tBTA_HH_CMD_DATA) ); 173 174 if ((p_buf = (tBTA_HH_CMD_DATA *)GKI_getbuf(len))!= NULL) 175 { 176 memset(p_buf, 0, sizeof(tBTA_HH_CMD_DATA)); 177 178 p_buf->hdr.event = BTA_HH_API_WRITE_DEV_EVT; 179 p_buf->hdr.layer_specific = (UINT16) dev_handle; 180 p_buf->t_type = t_type; 181 p_buf->data = data; 182 p_buf->param = param; 183 p_buf->p_data = p_data; 184 p_buf->rpt_id = rpt_id; 185 186 bta_sys_sendmsg(p_buf); 187 } 188} 189/******************************************************************************* 190** 191** Function BTA_HhSetReport 192** 193** Description send SET_REPORT to device. 194** 195** Parameter dev_handle: device handle 196** r_type: report type, could be BTA_HH_RPTT_OUTPUT or 197** BTA_HH_RPTT_FEATURE. 198** Returns void 199** 200*******************************************************************************/ 201void BTA_HhSetReport(UINT8 dev_handle, tBTA_HH_RPT_TYPE r_type, BT_HDR *p_data) 202{ 203 bta_hh_snd_write_dev(dev_handle, HID_TRANS_SET_REPORT, r_type, 0, 0, p_data); 204} 205/******************************************************************************* 206** 207** Function BTA_HhGetReport 208** 209** Description Send a GET_REPORT to HID device. 210** 211** Returns void 212** 213*******************************************************************************/ 214void BTA_HhGetReport(UINT8 dev_handle, tBTA_HH_RPT_TYPE r_type, UINT8 rpt_id, UINT16 buf_size) 215{ 216 UINT8 param = (buf_size) ? (r_type | 0x08) : r_type; 217 218 bta_hh_snd_write_dev(dev_handle, HID_TRANS_GET_REPORT, param, 219 buf_size, rpt_id, NULL); 220} 221/******************************************************************************* 222** 223** Function BTA_HhSetProtoMode 224** 225** Description This function set the protocol mode at specified HID handle 226** 227** Returns void 228** 229*******************************************************************************/ 230void BTA_HhSetProtoMode(UINT8 dev_handle, tBTA_HH_PROTO_MODE p_type) 231{ 232 bta_hh_snd_write_dev(dev_handle, HID_TRANS_SET_PROTOCOL, (UINT8)p_type, 233 0, 0, NULL); 234} 235/******************************************************************************* 236** 237** Function BTA_HhGetProtoMode 238** 239** Description This function get protocol mode information. 240** 241** Returns void 242** 243*******************************************************************************/ 244void BTA_HhGetProtoMode(UINT8 dev_handle) 245{ 246 bta_hh_snd_write_dev(dev_handle, HID_TRANS_GET_PROTOCOL, 0, 0, 0, NULL); 247} 248/******************************************************************************* 249** 250** Function BTA_HhSetIdle 251** 252** Description send SET_IDLE to device. 253** 254** Returns void 255** 256*******************************************************************************/ 257void BTA_HhSetIdle(UINT8 dev_handle, UINT16 idle_rate) 258{ 259 bta_hh_snd_write_dev(dev_handle, HID_TRANS_SET_IDLE, 0, idle_rate, 0, NULL); 260} 261 262/******************************************************************************* 263** 264** Function BTA_HhGetIdle 265** 266** Description Send a GET_IDLE from HID device. 267** 268** Returns void 269** 270*******************************************************************************/ 271void BTA_HhGetIdle(UINT8 dev_handle) 272{ 273 bta_hh_snd_write_dev(dev_handle, HID_TRANS_GET_IDLE, 0, 0, 0, NULL); 274} 275/******************************************************************************* 276** 277** Function BTA_HhSendCtrl 278** 279** Description Send a control command to HID device. 280** 281** Returns void 282** 283*******************************************************************************/ 284void BTA_HhSendCtrl(UINT8 dev_handle, tBTA_HH_TRANS_CTRL_TYPE c_type) 285{ 286 bta_hh_snd_write_dev(dev_handle, HID_TRANS_CONTROL, (UINT8)c_type, 0, 0, NULL); 287} 288/******************************************************************************* 289** 290** Function BTA_HhSendData 291** 292** Description This function send DATA transaction to HID device. 293** 294** Parameter dev_handle: device handle 295** dev_bda: remote device address 296** p_data: data to be sent in the DATA transaction; or 297** the data to be write into the Output Report of a LE HID 298** device. The report is identified the report ID which is 299** the value of the byte (UINT8 *)(p_buf + 1) + p_buf->offset. 300** p_data->layer_specific needs to be set to the report type, 301** it can be OUTPUT report, or FEATURE report. 302** 303** Returns void 304** 305*******************************************************************************/ 306void BTA_HhSendData(UINT8 dev_handle, BD_ADDR dev_bda, BT_HDR *p_data) 307{ 308#if (defined BTA_HH_LE_INCLUDED && BTA_HH_LE_INCLUDED == TRUE) 309 if (p_data->layer_specific != BTA_HH_RPTT_OUTPUT) 310 { 311 APPL_TRACE_ERROR0("ERROR! Wrong report type! Write Command only valid for output report!"); 312 return; 313 } 314#endif 315 bta_hh_snd_write_dev(dev_handle, HID_TRANS_DATA, (UINT8)p_data->layer_specific, 0, 0, p_data); 316} 317 318/******************************************************************************* 319** 320** Function BTA_HhGetDscpInfo 321** 322** Description Get HID device report descriptor 323** 324** Returns void 325** 326*******************************************************************************/ 327void BTA_HhGetDscpInfo(UINT8 dev_handle) 328{ 329 BT_HDR *p_buf; 330 331 if ((p_buf = (BT_HDR *)GKI_getbuf((UINT16)sizeof(BT_HDR))) != NULL) 332 { 333 memset(p_buf, 0, sizeof(BT_HDR)); 334 p_buf->event = BTA_HH_API_GET_DSCP_EVT; 335 p_buf->layer_specific = (UINT16) dev_handle; 336 337 bta_sys_sendmsg(p_buf); 338 } 339} 340 341/******************************************************************************* 342** 343** Function BTA_HhAddDev 344** 345** Description Add a virtually cabled device into HID-Host device list 346** to manage and assign a device handle for future API call, 347** host applciation call this API at start-up to initialize its 348** virtually cabled devices. 349** 350** Returns void 351** 352*******************************************************************************/ 353void BTA_HhAddDev(BD_ADDR bda, tBTA_HH_ATTR_MASK attr_mask, UINT8 sub_class, 354 UINT8 app_id, tBTA_HH_DEV_DSCP_INFO dscp_info) 355{ 356 tBTA_HH_MAINT_DEV *p_buf; 357 UINT16 len = sizeof(tBTA_HH_MAINT_DEV) + dscp_info.descriptor.dl_len; 358 359 p_buf = (tBTA_HH_MAINT_DEV *)GKI_getbuf(len); 360 361 if (p_buf != NULL) 362 { 363 memset(p_buf, 0, sizeof(tBTA_HH_MAINT_DEV)); 364 365 p_buf->hdr.event = BTA_HH_API_MAINT_DEV_EVT; 366 p_buf->sub_event = BTA_HH_ADD_DEV_EVT; 367 p_buf->hdr.layer_specific = BTA_HH_INVALID_HANDLE; 368 369 p_buf->attr_mask = (UINT16) attr_mask; 370 p_buf->sub_class = sub_class; 371 p_buf->app_id = app_id; 372 bdcpy(p_buf->bda, bda); 373 374 memcpy(&p_buf->dscp_info, &dscp_info, sizeof(tBTA_HH_DEV_DSCP_INFO)); 375 if ( dscp_info.descriptor.dl_len != 0 && dscp_info.descriptor.dsc_list) 376 { 377 p_buf->dscp_info.descriptor.dl_len = dscp_info.descriptor.dl_len; 378 p_buf->dscp_info.descriptor.dsc_list = (UINT8 *)(p_buf + 1); 379 memcpy(p_buf->dscp_info.descriptor.dsc_list, dscp_info.descriptor.dsc_list, dscp_info.descriptor.dl_len); 380 } 381 else 382 { 383 p_buf->dscp_info.descriptor.dsc_list = NULL; 384 p_buf->dscp_info.descriptor.dl_len = 0; 385 } 386 387 bta_sys_sendmsg(p_buf); 388 } 389} 390/******************************************************************************* 391** 392** Function BTA_HhRemoveDev 393** 394** Description Remove a device from the HID host devices list. 395** 396** Returns void 397** 398*******************************************************************************/ 399void BTA_HhRemoveDev(UINT8 dev_handle ) 400{ 401 tBTA_HH_MAINT_DEV *p_buf; 402 403 p_buf = (tBTA_HH_MAINT_DEV *)GKI_getbuf((UINT16)sizeof(tBTA_HH_MAINT_DEV)); 404 405 if (p_buf != NULL) 406 { 407 memset(p_buf, 0, sizeof(tBTA_HH_MAINT_DEV)); 408 409 p_buf->hdr.event = BTA_HH_API_MAINT_DEV_EVT; 410 p_buf->sub_event = BTA_HH_RMV_DEV_EVT; 411 p_buf->hdr.layer_specific = (UINT16) dev_handle; 412 413 bta_sys_sendmsg(p_buf); 414 } 415} 416#if BTA_HH_LE_INCLUDED == TRUE 417 418/******************************************************************************* 419** 420** Function BTA_HhUpdateLeScanParam 421** 422** Description Update the scan paramteters if connected to a LE hid device as 423** report host. 424** 425** Returns void 426** 427*******************************************************************************/ 428void BTA_HhUpdateLeScanParam(UINT8 dev_handle, UINT16 scan_int, UINT16 scan_win) 429{ 430 tBTA_HH_SCPP_UPDATE *p_buf; 431 432 p_buf = (tBTA_HH_SCPP_UPDATE *)GKI_getbuf((UINT16)sizeof(tBTA_HH_SCPP_UPDATE)); 433 434 if (p_buf != NULL) 435 { 436 memset(p_buf, 0, sizeof(tBTA_HH_SCPP_UPDATE)); 437 438 p_buf->hdr.event = BTA_HH_API_SCPP_UPDATE_EVT; 439 p_buf->hdr.layer_specific = (UINT16) dev_handle; 440 p_buf->scan_int = scan_int; 441 p_buf->scan_win = scan_win; 442 443 bta_sys_sendmsg(p_buf); 444 } 445} 446#endif 447/*******************************************************************************/ 448/* Utility Function */ 449/*******************************************************************************/ 450 451/******************************************************************************* 452** 453** Function BTA_HhParseBootRpt 454** 455** Description This utility function parse a boot mode report. 456** For keyboard report, report data will carry the keycode max 457** up to 6 key press in one report. Application need to convert 458** the keycode into keypress character according to keyboard 459** language. 460** 461** Returns void 462** 463*******************************************************************************/ 464void BTA_HhParseBootRpt(tBTA_HH_BOOT_RPT *p_data, UINT8 *p_report, 465 UINT16 report_len) 466{ 467 p_data->dev_type = BTA_HH_DEVT_UNKNOWN; 468 469 if (p_report) 470 { 471 /* first byte is report ID */ 472 switch (p_report[0]) 473 { 474 case BTA_HH_KEYBD_RPT_ID: /* key board report ID */ 475 p_data->dev_type = p_report[0]; 476 bta_hh_parse_keybd_rpt(p_data, p_report + 1, (UINT16)(report_len -1)); 477 break; 478 479 case BTA_HH_MOUSE_RPT_ID: /* mouse report ID */ 480 p_data->dev_type = p_report[0]; 481 bta_hh_parse_mice_rpt(p_data, p_report + 1, (UINT16)(report_len - 1)); 482 break; 483 484 default: 485 APPL_TRACE_DEBUG1("Unknown boot report: %d", p_report[0]);; 486 break; 487 } 488 } 489 490 return; 491} 492 493#endif /* BTA_HH_INCLUDED */ 494