kopia lustrzana https://github.com/espressif/esp-idf
1073 wiersze
41 KiB
C
1073 wiersze
41 KiB
C
/*
|
|
* SPDX-FileCopyrightText: 2017-2024 Espressif Systems (Shanghai) CO LTD
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
#include "bt_hidh.h"
|
|
#if CONFIG_BT_HID_HOST_ENABLED
|
|
#include "esp_private/esp_hidh_private.h"
|
|
#include <string.h>
|
|
#include <stdbool.h>
|
|
#include "esp_check.h"
|
|
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "freertos/semphr.h"
|
|
#include "osi/fixed_queue.h"
|
|
#include "string.h"
|
|
#include "esp_hidh_api.h"
|
|
|
|
static const char *TAG = "BT_HIDH";
|
|
|
|
// element of connection queue
|
|
typedef struct {
|
|
esp_hidh_dev_t* dev;
|
|
} conn_item_t;
|
|
|
|
typedef struct {
|
|
fixed_queue_t *connection_queue; /* Queue of connection */
|
|
esp_event_loop_handle_t event_loop_handle;
|
|
} hidh_local_param_t;
|
|
|
|
static hidh_local_param_t hidh_local_param;
|
|
#define TRANS_TO 1000000 // us
|
|
#define is_init() (hidh_local_param.event_loop_handle != NULL)
|
|
|
|
#define get_protocol_mode(mode) (mode) ? "REPORT" : "BOOT"
|
|
static const char *s_esp_hh_evt_names[] = {"INIT", "DEINIT", "OPEN", "CLOSE", "GET_RPT", "SET_RPT", "GET_PROTO", "SET_PROTO", "GET_IDLE", "SET_IDLE", "GET_DSCP", "ADD_DEV", "RMV_DEV", "VC_UNPLUG", "DATA", "DATA_IND", "SET_INFO"};
|
|
static const char *s_esp_hh_status_names[] = {"OK",
|
|
"HS_HID_NOT_READY",
|
|
"HS_INVALID_RPT_ID",
|
|
"HS_TRANS_NOT_SPT",
|
|
"HS_INVALID_PARAM",
|
|
"HS_ERROR",
|
|
"ERR",
|
|
"ERR_SDP",
|
|
"ERR_PROTO",
|
|
"ERR_DB_FULL",
|
|
"ERR_TOD_UNSPT",
|
|
"ERR_NO_RES",
|
|
"ERR_AUTH_FAILED",
|
|
"ERR_HDL",
|
|
"ERR_SEC",
|
|
"BUSY",
|
|
"NO_DATA",
|
|
"NEED_INIT",
|
|
"NEED_DEINIT",
|
|
"NO_CONNECTION"
|
|
};
|
|
|
|
static esp_hidh_dev_t *hidh_dev_ctor(esp_bd_addr_t bda);
|
|
|
|
static char *get_trans_type_str(esp_hid_trans_type_t trans_type)
|
|
{
|
|
switch (trans_type) {
|
|
case ESP_HID_TRANS_HANDSHAKE:
|
|
return "TRANS_HANDSHAKE";
|
|
case ESP_HID_TRANS_CONTROL:
|
|
return "TRANS_CONTROL";
|
|
case ESP_HID_TRANS_GET_REPORT:
|
|
return "TRANS_GET_REPORT";
|
|
case ESP_HID_TRANS_SET_REPORT:
|
|
return "TRANS_SET_REPORT";
|
|
case ESP_HID_TRANS_GET_PROTOCOL:
|
|
return "TRANS_GET_PROTOCOL";
|
|
case ESP_HID_TRANS_SET_PROTOCOL:
|
|
return "TRANS_SET_PROTOCOL";
|
|
case ESP_HID_TRANS_GET_IDLE:
|
|
return "TRANS_GET_IDLE";
|
|
case ESP_HID_TRANS_SET_IDLE:
|
|
return "TRANS_SET_IDLE";
|
|
case ESP_HID_TRANS_DATA:
|
|
return "TRANS_DATA";
|
|
case ESP_HID_TRANS_DATAC:
|
|
return "TRANS_DATAC";
|
|
case ESP_HID_TRANS_MAX:
|
|
return "TRANS_MAX";
|
|
default:
|
|
return "UNKOWN";
|
|
}
|
|
}
|
|
|
|
static esp_err_t bt_hidh_get_status(esp_hidh_status_t status)
|
|
{
|
|
esp_err_t ret = ESP_OK;
|
|
switch (status) {
|
|
case ESP_HIDH_OK:
|
|
ret = ESP_OK;
|
|
break;
|
|
case ESP_HIDH_ERR_NO_RES:
|
|
ret = ESP_ERR_NO_MEM;
|
|
break;
|
|
default:
|
|
ret = ESP_FAIL;
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static void utl_freebuf(void **p)
|
|
{
|
|
if (*p != NULL) {
|
|
free(*p);
|
|
*p = NULL;
|
|
}
|
|
}
|
|
|
|
static void transaction_timeout_handler(void *arg)
|
|
{
|
|
esp_hidh_dev_t *dev = (esp_hidh_dev_t *)arg;
|
|
if (dev != NULL && esp_hidh_dev_exists(dev)) {
|
|
ESP_LOGW(TAG, "transaction timeout!");
|
|
esp_hidh_dev_lock(dev);
|
|
dev->trans_type = ESP_HID_TRANS_MAX;
|
|
dev->report_id = 0;
|
|
dev->report_type = 0;
|
|
esp_hidh_dev_unlock(dev);
|
|
}
|
|
}
|
|
|
|
static inline void set_trans(esp_hidh_dev_t *dev, esp_hid_trans_type_t trans_type)
|
|
{
|
|
dev->trans_type = trans_type;
|
|
if (dev->trans_timer == NULL) {
|
|
esp_timer_create_args_t config = {
|
|
.callback = &transaction_timeout_handler,
|
|
.arg = (void *)dev,
|
|
.name = "hid_trans"
|
|
};
|
|
if (esp_timer_create(&config, &dev->trans_timer) != ESP_OK) {
|
|
ESP_LOGE(TAG, "create trans timer failed! trans:%s", get_trans_type_str(trans_type));
|
|
return;
|
|
}
|
|
}
|
|
if (!esp_timer_is_active(dev->trans_timer) && esp_timer_start_once(dev->trans_timer, TRANS_TO) != ESP_OK) {
|
|
ESP_LOGE(TAG, "set trans timer failed! trans:%s", get_trans_type_str(trans_type));
|
|
}
|
|
}
|
|
|
|
static inline void reset_trans(esp_hidh_dev_t *dev)
|
|
{
|
|
esp_hidh_dev_lock(dev);
|
|
dev->trans_type = ESP_HID_TRANS_MAX;
|
|
dev->report_id = 0;
|
|
dev->report_type = 0;
|
|
if (dev->trans_timer) {
|
|
esp_timer_stop(dev->trans_timer);
|
|
}
|
|
esp_hidh_dev_unlock(dev);
|
|
}
|
|
|
|
static inline bool is_trans_done(esp_hidh_dev_t *dev)
|
|
{
|
|
bool ret = (dev->trans_type == ESP_HID_TRANS_MAX);
|
|
return ret;
|
|
}
|
|
|
|
static void free_local_param(void)
|
|
{
|
|
if (hidh_local_param.connection_queue) {
|
|
fixed_queue_free(hidh_local_param.connection_queue, free);
|
|
}
|
|
}
|
|
|
|
static void open_failed_cb(esp_hidh_dev_t *dev, esp_hidh_status_t status, esp_hidh_event_data_t *p,
|
|
size_t event_data_size)
|
|
{
|
|
p->open.status = bt_hidh_get_status(status);
|
|
p->open.dev = dev;
|
|
if (dev != NULL) {
|
|
esp_hidh_dev_lock(dev);
|
|
if (dev->connected) {
|
|
esp_bt_hid_host_disconnect(dev->addr.bda);
|
|
} else {
|
|
dev->in_use = false;
|
|
}
|
|
esp_hidh_dev_unlock(dev);
|
|
}
|
|
esp_event_post_to(hidh_local_param.event_loop_handle, ESP_HIDH_EVENTS, ESP_HIDH_OPEN_EVENT, p, event_data_size,
|
|
portMAX_DELAY);
|
|
}
|
|
|
|
static void esp_hh_cb(esp_hidh_cb_event_t event, esp_hidh_cb_param_t *param)
|
|
{
|
|
conn_item_t *conn_item = NULL;
|
|
esp_hidh_dev_t *dev = NULL;
|
|
esp_hidh_dev_report_t *report = NULL;
|
|
bool has_report_id = false;
|
|
size_t data_len = 0;
|
|
uint8_t *p_data = NULL;
|
|
esp_hidh_event_data_t p = {0};
|
|
esp_hidh_event_data_t *p_param = NULL;
|
|
size_t event_data_size = sizeof(esp_hidh_event_data_t);
|
|
|
|
switch (event) {
|
|
case ESP_HIDH_INIT_EVT: {
|
|
p.start.status = bt_hidh_get_status(param->init.status);
|
|
esp_event_post_to(hidh_local_param.event_loop_handle, ESP_HIDH_EVENTS, ESP_HIDH_START_EVENT, &p,
|
|
event_data_size, portMAX_DELAY);
|
|
if (param->init.status != ESP_HIDH_OK) {
|
|
ESP_LOGE(TAG, "ENABLE ERROR: %s", s_esp_hh_status_names[param->init.status]);
|
|
free_local_param();
|
|
}
|
|
break;
|
|
}
|
|
case ESP_HIDH_DEINIT_EVT: {
|
|
p.stop.status = bt_hidh_get_status(param->deinit.status);
|
|
esp_event_post_to(hidh_local_param.event_loop_handle, ESP_HIDH_EVENTS, ESP_HIDH_STOP_EVENT, &p,
|
|
event_data_size, portMAX_DELAY);
|
|
if (param->deinit.status != ESP_HIDH_OK) {
|
|
ESP_LOGE(TAG, "DISABLE ERROR: %s", s_esp_hh_status_names[param->deinit.status]);
|
|
} else {
|
|
free_local_param();
|
|
}
|
|
break;
|
|
}
|
|
case ESP_HIDH_OPEN_EVT: {
|
|
if (param->open.conn_status == ESP_HIDH_CONN_STATE_CONNECTING) {
|
|
// ignore this conn_status
|
|
break;
|
|
}
|
|
|
|
do {
|
|
dev = esp_hidh_dev_get_by_bda(param->open.bd_addr);
|
|
if (dev == NULL) {
|
|
if (param->open.is_orig) {
|
|
ESP_LOGE(TAG, "OPEN ERROR: Device Not Found");
|
|
param->open.status = ESP_HIDH_NO_CONNECTION;
|
|
break;
|
|
} else {
|
|
ESP_LOGD(TAG, "incoming device connect");
|
|
if ((dev = hidh_dev_ctor(param->open.bd_addr)) == NULL) {
|
|
ESP_LOGE(TAG, "%s create device failed!", __func__);
|
|
param->open.status = ESP_HIDH_ERR_NO_RES;
|
|
break;
|
|
}
|
|
esp_hidh_dev_lock(dev);
|
|
dev->opened = false; // not opened by ourself
|
|
dev->is_orig = false;
|
|
esp_hidh_dev_unlock(dev);
|
|
}
|
|
}
|
|
|
|
if (param->open.status != ESP_HIDH_OK) {
|
|
break;
|
|
}
|
|
esp_hidh_dev_lock(dev);
|
|
dev->connected = true;
|
|
dev->bt.handle = param->open.handle;
|
|
esp_hidh_dev_unlock(dev);
|
|
conn_item = malloc(sizeof(conn_item_t));
|
|
if (conn_item == NULL) {
|
|
ESP_LOGE(TAG, "conn_item malloc failed!");
|
|
param->open.status = ESP_HIDH_ERR_NO_RES;
|
|
break;
|
|
}
|
|
conn_item->dev = dev;
|
|
bool ret = fixed_queue_enqueue(hidh_local_param.connection_queue, conn_item, FIXED_QUEUE_MAX_TIMEOUT);
|
|
assert(ret == true);
|
|
} while (0);
|
|
|
|
if (param->open.status != ESP_HIDH_OK) {
|
|
ESP_LOGE(TAG, "OPEN ERROR: %s", s_esp_hh_status_names[param->open.status]);
|
|
open_failed_cb(dev, param->open.status, &p, event_data_size);
|
|
}
|
|
|
|
if (dev != NULL) {
|
|
esp_hidh_dev_lock(dev);
|
|
dev->status = param->open.status;
|
|
esp_hidh_dev_unlock(dev);
|
|
}
|
|
break;
|
|
}
|
|
case ESP_HIDH_GET_DSCP_EVT: {
|
|
do {
|
|
ESP_LOGV(TAG, "DESCRIPTOR: PID: 0x%04x, VID: 0x%04x, VERSION: 0x%04x, REPORT_LEN: %u",
|
|
param->dscp.product_id, param->dscp.vendor_id, param->dscp.version, param->dscp.dl_len);
|
|
if ((conn_item = (conn_item_t *)fixed_queue_dequeue(hidh_local_param.connection_queue,
|
|
FIXED_QUEUE_MAX_TIMEOUT)) == NULL) {
|
|
ESP_LOGE(TAG, "No pending connect device!");
|
|
param->dscp.status = ESP_HIDH_NO_CONNECTION;
|
|
break;
|
|
}
|
|
dev = conn_item->dev;
|
|
utl_freebuf((void **)&conn_item);
|
|
// in case the dev has been freed
|
|
if (!esp_hidh_dev_exists(dev)) {
|
|
ESP_LOGE(TAG, "Device Not Found");
|
|
dev = NULL;
|
|
param->dscp.status = ESP_HIDH_NO_CONNECTION;
|
|
break;
|
|
}
|
|
// check if connected
|
|
esp_hidh_dev_lock(dev);
|
|
if (!dev->connected) {
|
|
esp_hidh_dev_unlock(dev);
|
|
ESP_LOGE(TAG, "Connection has been released!");
|
|
param->dscp.status = ESP_HIDH_NO_CONNECTION;
|
|
break;
|
|
}
|
|
// check if get descriptor failed
|
|
if (param->dscp.status != ESP_HIDH_OK) {
|
|
esp_hidh_dev_unlock(dev);
|
|
ESP_LOGE(TAG, "GET_DSCP ERROR: %s", s_esp_hh_status_names[param->dscp.status]);
|
|
break;
|
|
}
|
|
dev->added = param->dscp.added;
|
|
dev->config.product_id = param->dscp.product_id;
|
|
dev->config.vendor_id = param->dscp.vendor_id;
|
|
dev->config.version = param->dscp.version;
|
|
|
|
dev->config.report_maps_len = 1;
|
|
dev->config.report_maps =
|
|
(esp_hid_raw_report_map_t *)malloc(dev->config.report_maps_len * sizeof(esp_hid_raw_report_map_t));
|
|
if (dev->config.report_maps == NULL) {
|
|
esp_hidh_dev_unlock(dev);
|
|
ESP_LOGE(TAG, "malloc report maps failed");
|
|
param->dscp.status = ESP_HIDH_ERR_NO_RES;
|
|
break;
|
|
}
|
|
|
|
dev->config.report_maps[0].data = (uint8_t *)malloc(param->dscp.dl_len);
|
|
if (dev->config.report_maps[0].data == NULL) {
|
|
ESP_LOGE(TAG, "Malloc Report Map Failed");
|
|
param->dscp.status = ESP_HIDH_ERR_NO_RES;
|
|
} else {
|
|
dev->config.report_maps[0].len = param->dscp.dl_len;
|
|
memcpy((uint8_t *)dev->config.report_maps[0].data, param->dscp.dsc_list,
|
|
dev->config.report_maps[0].len);
|
|
// generate reports
|
|
|
|
if (dev->config.report_maps[0].len && dev->config.report_maps[0].data) {
|
|
esp_hid_report_map_t *map;
|
|
esp_hidh_dev_report_t *report;
|
|
esp_hid_report_item_t *r;
|
|
map = esp_hid_parse_report_map(dev->config.report_maps[0].data, dev->config.report_maps[0].len);
|
|
if (map) {
|
|
if (dev->usage == 0) {
|
|
dev->usage = map->usage;
|
|
}
|
|
dev->reports = NULL;
|
|
for (uint8_t i = 0; i < map->reports_len; i++) {
|
|
r = &map->reports[i];
|
|
report = (esp_hidh_dev_report_t *)malloc(sizeof(esp_hidh_dev_report_t));
|
|
if (report == NULL) {
|
|
ESP_LOGE(TAG, "Malloc Report Failed");
|
|
param->dscp.status = ESP_HIDH_ERR_NO_RES;
|
|
break;
|
|
}
|
|
report->map_index = 0;
|
|
report->protocol_mode = r->protocol_mode;
|
|
report->report_type = r->report_type;
|
|
report->report_id = r->report_id;
|
|
report->value_len = r->value_len;
|
|
report->usage = r->usage;
|
|
report->next = dev->reports;
|
|
dev->reports = report;
|
|
}
|
|
dev->reports_len = map->reports_len;
|
|
free(map->reports);
|
|
free(map);
|
|
map = NULL;
|
|
} else {
|
|
ESP_LOGE(TAG, "Parse Report Map Failed");
|
|
param->dscp.status = ESP_HIDH_ERR;
|
|
}
|
|
}
|
|
}
|
|
esp_hidh_dev_unlock(dev);
|
|
} while (0);
|
|
|
|
if (param->dscp.status != ESP_HIDH_OK) {
|
|
open_failed_cb(dev, param->dscp.status, &p, event_data_size);
|
|
}
|
|
|
|
if (dev != NULL) {
|
|
esp_hidh_dev_lock(dev);
|
|
dev->status = param->dscp.status;
|
|
// if has been added by lower layer, tell up layer
|
|
if (dev->status == ESP_HIDH_OK && dev->connected && dev->added) {
|
|
p.open.status = bt_hidh_get_status(ESP_HIDH_OK);
|
|
p.open.dev = dev;
|
|
esp_hidh_dev_unlock(dev);
|
|
esp_event_post_to(hidh_local_param.event_loop_handle, ESP_HIDH_EVENTS, ESP_HIDH_OPEN_EVENT, &p,
|
|
event_data_size, portMAX_DELAY);
|
|
} else {
|
|
esp_hidh_dev_unlock(dev);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case ESP_HIDH_ADD_DEV_EVT: {
|
|
ESP_LOGV(TAG, "ADD_DEV: BDA: " ESP_BD_ADDR_STR ", handle: %d, status: %s",
|
|
ESP_BD_ADDR_HEX(param->add_dev.bd_addr), param->add_dev.handle,
|
|
s_esp_hh_status_names[param->add_dev.status]);
|
|
do {
|
|
dev = esp_hidh_dev_get_by_handle(param->add_dev.handle);
|
|
if (dev == NULL) {
|
|
ESP_LOGE(TAG, "Device Not Found");
|
|
param->add_dev.status = ESP_HIDH_NO_CONNECTION;
|
|
break;
|
|
}
|
|
esp_hidh_dev_lock(dev);
|
|
dev->added = param->add_dev.status == ESP_HIDH_OK ? true : false;
|
|
esp_hidh_dev_unlock(dev);
|
|
} while (0);
|
|
|
|
if (param->add_dev.status != ESP_HIDH_OK) {
|
|
ESP_LOGE(TAG, "ADD_DEV ERROR: %s", s_esp_hh_status_names[param->add_dev.status]);
|
|
open_failed_cb(dev, param->add_dev.status, &p, event_data_size);
|
|
}
|
|
if (dev != NULL) {
|
|
esp_hidh_dev_lock(dev);
|
|
dev->status = param->add_dev.status;
|
|
if (dev->status == ESP_HIDH_OK && dev->connected && dev->added) {
|
|
p.open.status = bt_hidh_get_status(ESP_HIDH_OK);
|
|
p.open.dev = dev;
|
|
esp_hidh_dev_unlock(dev);
|
|
esp_event_post_to(hidh_local_param.event_loop_handle, ESP_HIDH_EVENTS, ESP_HIDH_OPEN_EVENT, &p,
|
|
event_data_size, portMAX_DELAY);
|
|
} else {
|
|
esp_hidh_dev_unlock(dev);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case ESP_HIDH_CLOSE_EVT: {
|
|
if (param->close.conn_status == ESP_HIDH_CONN_STATE_DISCONNECTING) {
|
|
// ignore this conn_status
|
|
break;
|
|
}
|
|
ESP_LOGV(TAG, "CLOSE: handle: %d, status: %s", param->close.handle, s_esp_hh_status_names[param->close.status]);
|
|
do {
|
|
dev = esp_hidh_dev_get_by_handle(param->close.handle);
|
|
if (dev == NULL) {
|
|
ESP_LOGE(TAG, "Device Not Found");
|
|
param->close.status = ESP_HIDH_NO_CONNECTION;
|
|
break;
|
|
}
|
|
esp_hidh_dev_lock(dev);
|
|
dev->status = param->close.status;
|
|
if (dev->connected) {
|
|
dev->connected = false;
|
|
}
|
|
// free the device in the wrapper event handler
|
|
dev->in_use = false;
|
|
esp_hidh_dev_unlock(dev);
|
|
} while (0);
|
|
|
|
if (param->close.status != ESP_HIDH_OK) {
|
|
ESP_LOGE(TAG, "CLOSE ERROR: %s", s_esp_hh_status_names[param->close.status]);
|
|
}
|
|
p.close.dev = dev;
|
|
p.close.status = bt_hidh_get_status(param->close.status);
|
|
esp_event_post_to(hidh_local_param.event_loop_handle, ESP_HIDH_EVENTS, ESP_HIDH_CLOSE_EVENT, &p,
|
|
event_data_size, portMAX_DELAY);
|
|
|
|
break;
|
|
}
|
|
case ESP_HIDH_SET_RPT_EVT: {
|
|
if (param->set_rpt.status != ESP_HIDH_OK) {
|
|
ESP_LOGE(TAG, "SET_RPT ERROR: handle: %d, status: %s", param->set_rpt.handle,
|
|
s_esp_hh_status_names[param->set_rpt.status]);
|
|
}
|
|
dev = esp_hidh_dev_get_by_handle(param->set_rpt.handle);
|
|
if (dev == NULL) {
|
|
ESP_LOGE(TAG, "SET_RPT ERROR: Device Not Found");
|
|
break;
|
|
}
|
|
esp_hidh_dev_lock(dev);
|
|
dev->status = param->set_rpt.status;
|
|
p.feature.dev = dev;
|
|
esp_hidh_dev_unlock(dev);
|
|
p.feature.status = bt_hidh_get_status(param->set_rpt.status);
|
|
p.feature.trans_type = ESP_HID_TRANS_SET_REPORT;
|
|
esp_event_post_to(hidh_local_param.event_loop_handle, ESP_HIDH_EVENTS, ESP_HIDH_FEATURE_EVENT, &p,
|
|
event_data_size, portMAX_DELAY);
|
|
reset_trans(dev);
|
|
break;
|
|
}
|
|
case ESP_HIDH_GET_RPT_EVT: {
|
|
if (param->get_rpt.status != ESP_HIDH_OK) {
|
|
ESP_LOGE(TAG, "GET_RPT ERROR: handle: %d, status: %s", param->get_rpt.handle,
|
|
s_esp_hh_status_names[param->get_rpt.status]);
|
|
} else if (param->get_rpt.len > 0 && param->get_rpt.data) {
|
|
event_data_size += param->get_rpt.len;
|
|
}
|
|
dev = esp_hidh_dev_get_by_handle(param->get_rpt.handle);
|
|
if (dev == NULL) {
|
|
ESP_LOGE(TAG, "GET_RPT ERROR: Device Not Found");
|
|
break;
|
|
}
|
|
esp_hidh_dev_lock(dev);
|
|
dev->status = param->get_rpt.status;
|
|
if ((p_param = (esp_hidh_event_data_t *)malloc(event_data_size)) != NULL) {
|
|
memset(p_param, 0, event_data_size);
|
|
p_param->feature.dev = dev;
|
|
p_param->feature.status = bt_hidh_get_status(param->get_rpt.status);
|
|
p_param->feature.trans_type = ESP_HID_TRANS_GET_REPORT;
|
|
if (param->get_rpt.status == ESP_HIDH_OK && param->get_rpt.len > 0 && param->get_rpt.data) {
|
|
if (dev->report_id) {
|
|
data_len = param->get_rpt.len - 1;
|
|
p_data = (uint8_t *)param->get_rpt.data + 1;
|
|
} else {
|
|
data_len = param->get_rpt.len;
|
|
p_data = (uint8_t *)param->get_rpt.data;
|
|
}
|
|
memcpy(((uint8_t *)p_param) + sizeof(esp_hidh_event_data_t), p_data, data_len);
|
|
p_param->feature.length = data_len;
|
|
p_param->feature.data = p_data;
|
|
p_param->feature.report_id = dev->report_id;
|
|
esp_hidh_dev_unlock(dev);
|
|
}
|
|
esp_event_post_to(hidh_local_param.event_loop_handle, ESP_HIDH_EVENTS, ESP_HIDH_FEATURE_EVENT, p_param,
|
|
event_data_size, portMAX_DELAY);
|
|
} else {
|
|
esp_hidh_dev_unlock(dev);
|
|
ESP_LOGE(TAG, "GET_RPT ERROR: malloc event data failed!");
|
|
}
|
|
reset_trans(dev);
|
|
break;
|
|
}
|
|
case ESP_HIDH_GET_IDLE_EVT: {
|
|
if (param->get_idle.status != ESP_HIDH_OK) {
|
|
ESP_LOGE(TAG, "GET_IDLE ERROR: handle: %d, status: %s", param->get_idle.handle,
|
|
s_esp_hh_status_names[param->get_idle.status]);
|
|
} else {
|
|
event_data_size += 1;
|
|
}
|
|
dev = esp_hidh_dev_get_by_handle(param->get_idle.handle);
|
|
if (dev == NULL) {
|
|
ESP_LOGE(TAG, "GET_IDLE ERROR: Device Not Found");
|
|
break;
|
|
}
|
|
esp_hidh_dev_lock(dev);
|
|
dev->status = param->get_idle.status;
|
|
if ((p_param = (esp_hidh_event_data_t *)malloc(event_data_size)) != NULL) {
|
|
memset(p_param, 0, event_data_size);
|
|
p_param->feature.dev = dev;
|
|
p_param->feature.status = bt_hidh_get_status(param->get_idle.status);
|
|
p_param->feature.trans_type = ESP_HID_TRANS_GET_IDLE;
|
|
if (param->get_idle.status == ESP_HIDH_OK) {
|
|
*(((uint8_t *)p_param) + sizeof(esp_hidh_event_data_t)) = param->get_idle.idle_rate;
|
|
p_param->feature.length = 1;
|
|
p_param->feature.data = ((uint8_t *)p_param) + sizeof(esp_hidh_event_data_t);
|
|
}
|
|
esp_hidh_dev_unlock(dev);
|
|
esp_event_post_to(hidh_local_param.event_loop_handle, ESP_HIDH_EVENTS, ESP_HIDH_FEATURE_EVENT, p_param,
|
|
event_data_size, portMAX_DELAY);
|
|
} else {
|
|
esp_hidh_dev_unlock(dev);
|
|
ESP_LOGE(TAG, "GET_IDLE ERROR: malloc event data failed!");
|
|
}
|
|
reset_trans(dev);
|
|
break;
|
|
}
|
|
case ESP_HIDH_SET_IDLE_EVT: {
|
|
if (param->set_idle.status != ESP_HIDH_OK) {
|
|
ESP_LOGE(TAG, "SET_IDLE ERROR: handle: %d, status: %s", param->set_idle.handle,
|
|
s_esp_hh_status_names[param->set_idle.status]);
|
|
}
|
|
dev = esp_hidh_dev_get_by_handle(param->set_idle.handle);
|
|
if (dev == NULL) {
|
|
ESP_LOGE(TAG, "SET_IDLE ERROR: Device Not Found");
|
|
break;
|
|
}
|
|
esp_hidh_dev_lock(dev);
|
|
dev->status = param->set_idle.status;
|
|
p.feature.dev = dev;
|
|
esp_hidh_dev_unlock(dev);
|
|
p.feature.status = bt_hidh_get_status(param->set_idle.status);
|
|
p.feature.trans_type = ESP_HID_TRANS_SET_IDLE;
|
|
esp_event_post_to(hidh_local_param.event_loop_handle, ESP_HIDH_EVENTS, ESP_HIDH_FEATURE_EVENT, &p,
|
|
event_data_size, portMAX_DELAY);
|
|
reset_trans(dev);
|
|
break;
|
|
}
|
|
case ESP_HIDH_GET_PROTO_EVT: {
|
|
if (param->get_proto.status != ESP_HIDH_OK) {
|
|
ESP_LOGE(TAG, "GET_PROTO ERROR: handle: %d, status: %s", param->get_proto.handle,
|
|
s_esp_hh_status_names[param->get_proto.status]);
|
|
} else {
|
|
event_data_size += 1;
|
|
}
|
|
dev = esp_hidh_dev_get_by_handle(param->get_proto.handle);
|
|
if (dev == NULL) {
|
|
ESP_LOGE(TAG, "GET_PROTO ERROR: Device Not Found");
|
|
break;
|
|
}
|
|
esp_hidh_dev_lock(dev);
|
|
dev->status = param->get_proto.status;
|
|
if ((p_param = (esp_hidh_event_data_t *)malloc(event_data_size)) != NULL) {
|
|
memset(p_param, 0, event_data_size);
|
|
p_param->feature.dev = dev;
|
|
p_param->feature.status = bt_hidh_get_status(param->get_proto.status);
|
|
p_param->feature.trans_type = ESP_HID_TRANS_GET_PROTOCOL;
|
|
if (param->get_proto.status == ESP_HIDH_OK) {
|
|
dev->protocol_mode = param->get_proto.proto_mode; // update the device protocol mode
|
|
*(((uint8_t *)p_param) + sizeof(esp_hidh_event_data_t)) = param->get_proto.proto_mode;
|
|
p_param->feature.length = 1;
|
|
p_param->feature.data = ((uint8_t *)p_param) + sizeof(esp_hidh_event_data_t);
|
|
}
|
|
esp_hidh_dev_unlock(dev);
|
|
esp_event_post_to(hidh_local_param.event_loop_handle, ESP_HIDH_EVENTS, ESP_HIDH_FEATURE_EVENT, p_param,
|
|
event_data_size, portMAX_DELAY);
|
|
} else {
|
|
esp_hidh_dev_unlock(dev);
|
|
ESP_LOGE(TAG, "GET_PROTO ERROR: malloc event data failed!");
|
|
}
|
|
reset_trans(dev);
|
|
break;
|
|
}
|
|
case ESP_HIDH_SET_PROTO_EVT: {
|
|
if (param->set_proto.status != ESP_HIDH_OK) {
|
|
ESP_LOGE(TAG, "SET_PROTO ERROR: handle: %d, status: %s", param->set_proto.handle,
|
|
s_esp_hh_status_names[param->set_proto.status]);
|
|
}
|
|
dev = esp_hidh_dev_get_by_handle(param->set_proto.handle);
|
|
if (dev == NULL) {
|
|
ESP_LOGE(TAG, "Device Not Found");
|
|
break;
|
|
}
|
|
esp_hidh_dev_lock(dev);
|
|
dev->status = param->set_proto.status;
|
|
p.feature.dev = dev;
|
|
esp_hidh_dev_unlock(dev);
|
|
p.feature.status = bt_hidh_get_status(param->set_proto.status);
|
|
p.feature.trans_type = ESP_HID_TRANS_SET_PROTOCOL;
|
|
esp_event_post_to(hidh_local_param.event_loop_handle, ESP_HIDH_EVENTS, ESP_HIDH_FEATURE_EVENT, &p,
|
|
event_data_size, portMAX_DELAY);
|
|
reset_trans(dev);
|
|
break;
|
|
}
|
|
case ESP_HIDH_DATA_IND_EVT: {
|
|
esp_hid_usage_t _usage;
|
|
if (param->data_ind.status != ESP_HIDH_OK) {
|
|
ESP_LOGE(TAG, "DATA_IND ERROR: handle: %d, status: %s", param->data_ind.handle,
|
|
s_esp_hh_status_names[param->data_ind.status]);
|
|
}
|
|
dev = esp_hidh_dev_get_by_handle(param->data_ind.handle);
|
|
if (dev == NULL) {
|
|
ESP_LOGE(TAG, "Device Not Found: handle %u", param->data_ind.handle);
|
|
break;
|
|
}
|
|
|
|
if (param->data_ind.len > 0 && param->data_ind.data != NULL) {
|
|
esp_hidh_dev_lock(dev);
|
|
event_data_size += param->data_ind.len;
|
|
if (param->data_ind.proto_mode == ESP_HID_PROTOCOL_MODE_BOOT) {
|
|
/**
|
|
* first data shall have report_id, according to HID_SPEC_V10
|
|
* | Device | Report ID | Report Size |
|
|
* --------------------------------------
|
|
* | Keyboard | 1 | 9 Bytes |
|
|
* | Mouse | 2 | 4 Bytes |
|
|
* | Reserved | 0, 3-255 | N/A |
|
|
*/
|
|
if (param->data_ind.len == 9 && *(param->data_ind.data) == 1) {
|
|
has_report_id = true;
|
|
_usage = ESP_HID_USAGE_KEYBOARD;
|
|
} else if (param->data_ind.len == 4 && *(param->data_ind.data) == 2) {
|
|
has_report_id = true;
|
|
_usage = ESP_HID_USAGE_MOUSE;
|
|
} else {
|
|
esp_hidh_dev_unlock(dev);
|
|
ESP_LOGE(TAG, "Invalid Boot Report format, rpt_len:%d, rpt_id:%d!", param->data_ind.len,
|
|
*(param->data_ind.data));
|
|
break;
|
|
}
|
|
} else {
|
|
report = esp_hidh_dev_get_input_report_by_proto_and_data(
|
|
dev, ESP_HID_PROTOCOL_MODE_REPORT, param->data_ind.len, param->data_ind.data, &has_report_id);
|
|
if (report == NULL) {
|
|
esp_hidh_dev_unlock(dev);
|
|
ESP_LOGE(TAG, "Not find report handle: %d mode: %s", param->data_ind.handle,
|
|
param->data_ind.proto_mode == ESP_HID_PROTOCOL_MODE_REPORT ? "REPORT" : "BOOT");
|
|
break;
|
|
}
|
|
_usage = report->usage;
|
|
}
|
|
|
|
if ((p_param = (esp_hidh_event_data_t *)malloc(event_data_size)) == NULL) {
|
|
esp_hidh_dev_unlock(dev);
|
|
ESP_LOGE(TAG, "DATA_IND ERROR: malloc event data failed!");
|
|
break;
|
|
}
|
|
memset(p_param, 0, event_data_size);
|
|
p_param->input.dev = dev;
|
|
p_param->input.usage = _usage;
|
|
if (has_report_id) {
|
|
data_len = param->data_ind.len - 1;
|
|
p_data = (uint8_t *)param->data_ind.data + 1;
|
|
p_param->input.report_id = *(uint8_t *)param->data_ind.data;
|
|
} else {
|
|
data_len = param->data_ind.len;
|
|
p_data = (uint8_t *)param->data_ind.data;
|
|
p_param->input.report_id = report->report_id;
|
|
}
|
|
memcpy(((uint8_t *)p_param) + sizeof(esp_hidh_event_data_t), p_data, data_len);
|
|
p_param->input.length = data_len;
|
|
p_param->input.data = p_data;
|
|
esp_hidh_dev_unlock(dev);
|
|
esp_event_post_to(hidh_local_param.event_loop_handle, ESP_HIDH_EVENTS, ESP_HIDH_INPUT_EVENT, p_param,
|
|
event_data_size, portMAX_DELAY);
|
|
}
|
|
break;
|
|
}
|
|
case ESP_HIDH_DATA_EVT:
|
|
break;
|
|
default:
|
|
ESP_LOGV(TAG, "BTA_HH EVENT: %s", s_esp_hh_evt_names[event]);
|
|
break;
|
|
}
|
|
|
|
if (p_param) {
|
|
free(p_param);
|
|
p_param = NULL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Public Functions
|
|
* */
|
|
|
|
static esp_err_t esp_bt_hidh_dev_close(esp_hidh_dev_t *dev)
|
|
{
|
|
esp_err_t ret = ESP_OK;
|
|
do {
|
|
if (dev == NULL) {
|
|
ret = ESP_ERR_INVALID_ARG;
|
|
break;
|
|
}
|
|
if (!dev->connected) {
|
|
ESP_LOGW(TAG, "%s hdl:0x%02x not connected", __func__, dev->bt.handle);
|
|
ret = ESP_ERR_INVALID_STATE;
|
|
break;
|
|
}
|
|
ret = esp_bt_hid_host_disconnect(dev->addr.bda);
|
|
} while (0);
|
|
return ret;
|
|
}
|
|
|
|
static esp_err_t esp_bt_hidh_dev_report_write(esp_hidh_dev_t *dev, size_t map_index, size_t report_id,
|
|
int report_type, uint8_t *data, size_t len)
|
|
{
|
|
esp_err_t ret = ESP_OK;
|
|
uint8_t *p_data = NULL;
|
|
do {
|
|
esp_hidh_dev_report_t *report =
|
|
esp_hidh_dev_get_report_by_id_type_proto(dev, map_index, report_id, report_type, dev->protocol_mode);
|
|
if (!report) {
|
|
ESP_LOGE(TAG, "mode:%s report:%s id:%d not found", get_protocol_mode(dev->protocol_mode),
|
|
esp_hid_report_type_str(report_type), report_id);
|
|
ret = ESP_FAIL;
|
|
break;
|
|
}
|
|
if (len > report->value_len) {
|
|
ESP_LOGE(TAG, "%s report %d takes maximum %d bytes. you have provided %d",
|
|
esp_hid_report_type_str(report_type), report_id, report->value_len, len);
|
|
ret = ESP_FAIL;
|
|
break;
|
|
}
|
|
|
|
if (report_type != ESP_HID_REPORT_TYPE_OUTPUT) {
|
|
ESP_LOGE(TAG,
|
|
"Only OUTPUT type data can be send on interrupt channel.\n" \
|
|
"You have provided %s, try Set_Report!",
|
|
esp_hid_report_type_str(report_type));
|
|
ret = ESP_FAIL;
|
|
break;
|
|
}
|
|
|
|
if (report_id) {
|
|
if ((p_data = malloc(len + 1)) == NULL) {
|
|
ESP_LOGE(TAG, "%s malloc failed!", __func__);
|
|
ret = ESP_FAIL;
|
|
break;
|
|
}
|
|
*p_data = report_id;
|
|
memcpy(p_data + 1, data, len);
|
|
data = p_data;
|
|
len = len + 1;
|
|
}
|
|
|
|
ret = esp_bt_hid_host_send_data(dev->addr.bda, data, len);
|
|
if (p_data) {
|
|
free(p_data);
|
|
}
|
|
} while (0);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static esp_err_t esp_bt_hidh_dev_set_report(esp_hidh_dev_t *dev, size_t map_index, size_t report_id,
|
|
int report_type, uint8_t *data, size_t len)
|
|
{
|
|
esp_err_t ret = ESP_OK;
|
|
uint8_t *p_data = NULL;
|
|
esp_hidh_dev_report_t *report = NULL;
|
|
do {
|
|
if (!is_trans_done(dev)) {
|
|
ESP_LOGE(TAG, "Pending previous tansaction %s done, try later!", get_trans_type_str(dev->trans_type));
|
|
ret = ESP_FAIL;
|
|
break;
|
|
}
|
|
report = esp_hidh_dev_get_report_by_id_type_proto(dev, map_index, report_id, report_type, dev->protocol_mode);
|
|
if (!report) {
|
|
ESP_LOGE(TAG, "mode:%s report:%s id:%d not found", get_protocol_mode(dev->protocol_mode),
|
|
esp_hid_report_type_str(report_type), report_id);
|
|
ret = ESP_FAIL;
|
|
break;
|
|
}
|
|
if (len > report->value_len) {
|
|
ESP_LOGE(TAG, "%s report %d takes maximum %d bytes. you have provided %d",
|
|
esp_hid_report_type_str(report_type), report_id, report->value_len, len);
|
|
ret = ESP_FAIL;
|
|
break;
|
|
}
|
|
|
|
if (report_id) {
|
|
if ((p_data = malloc(len + 1)) == NULL) {
|
|
ESP_LOGE(TAG, "%s malloc failed!", __func__);
|
|
ret = ESP_FAIL;
|
|
break;
|
|
}
|
|
*p_data = report_id;
|
|
memcpy(p_data + 1, data, len);
|
|
data = p_data;
|
|
len = len + 1;
|
|
}
|
|
|
|
ret = esp_bt_hid_host_set_report(dev->addr.bda, report_type, data, len);
|
|
if (p_data) {
|
|
free(p_data);
|
|
}
|
|
|
|
if (ret == ESP_OK) {
|
|
set_trans(dev, ESP_HID_TRANS_SET_REPORT);
|
|
}
|
|
} while (0);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static esp_err_t esp_bt_hidh_dev_report_read(esp_hidh_dev_t *dev, size_t map_index, size_t report_id, int report_type,
|
|
size_t max_length, uint8_t *value, size_t *value_len)
|
|
{
|
|
esp_err_t ret = ESP_OK;
|
|
esp_hidh_dev_report_t *report = NULL;
|
|
do {
|
|
if (!is_trans_done(dev)) {
|
|
ESP_LOGE(TAG, "Pending previous tansaction %s done, try later!", get_trans_type_str(dev->trans_type));
|
|
ret = ESP_FAIL;
|
|
break;
|
|
}
|
|
report = esp_hidh_dev_get_report_by_id_type_proto(dev, map_index, report_id, report_type, dev->protocol_mode);
|
|
if (!report) {
|
|
ESP_LOGE(TAG, "mode:%s report:%s id:%d not found", get_protocol_mode(dev->protocol_mode),
|
|
esp_hid_report_type_str(report_type), report_id);
|
|
ret = ESP_FAIL;
|
|
break;
|
|
}
|
|
ret = esp_bt_hid_host_get_report(dev->addr.bda, report_type, report_id, max_length);
|
|
if (ret == ESP_OK) {
|
|
dev->trans_type = ESP_HID_TRANS_GET_REPORT;
|
|
dev->report_id = report_id;
|
|
dev->report_type = report_type;
|
|
}
|
|
} while (0);
|
|
return ret;
|
|
}
|
|
|
|
static esp_err_t esp_bt_hidh_dev_get_idle(esp_hidh_dev_t *dev)
|
|
{
|
|
esp_err_t ret = ESP_OK;
|
|
do {
|
|
if (!is_trans_done(dev)) {
|
|
ESP_LOGE(TAG, "Pending previous tansaction %s done, try later!", get_trans_type_str(dev->trans_type));
|
|
ret = ESP_FAIL;
|
|
break;
|
|
}
|
|
if (!dev->connected) {
|
|
ESP_LOGW(TAG, "%s hdl:0x%02x not connected", __func__, dev->bt.handle);
|
|
ret = ESP_ERR_INVALID_STATE;
|
|
break;
|
|
}
|
|
ret = esp_bt_hid_host_get_idle(dev->addr.bda);
|
|
if (ret == ESP_OK) {
|
|
set_trans(dev, ESP_HID_TRANS_GET_IDLE);
|
|
}
|
|
} while (0);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static esp_err_t esp_bt_hidh_dev_set_idle(esp_hidh_dev_t *dev, uint8_t idle_time)
|
|
{
|
|
esp_err_t ret = ESP_OK;
|
|
do {
|
|
if (!is_trans_done(dev)) {
|
|
ESP_LOGE(TAG, "Pending previous tansaction %s done, try later!", get_trans_type_str(dev->trans_type));
|
|
ret = ESP_FAIL;
|
|
break;
|
|
}
|
|
if (!dev->connected) {
|
|
ESP_LOGW(TAG, "%s hdl:0x%02x not connected", __func__, dev->bt.handle);
|
|
ret = ESP_ERR_INVALID_STATE;
|
|
break;
|
|
}
|
|
ret = esp_bt_hid_host_set_idle(dev->addr.bda, idle_time);
|
|
if (ret == ESP_OK) {
|
|
set_trans(dev, ESP_HID_TRANS_SET_IDLE);
|
|
}
|
|
} while (0);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static esp_err_t esp_bt_hidh_dev_get_protocol(esp_hidh_dev_t *dev)
|
|
{
|
|
esp_err_t ret = ESP_OK;
|
|
do {
|
|
if (!is_trans_done(dev)) {
|
|
ESP_LOGE(TAG, "Pending previous tansaction %s done, try later!", get_trans_type_str(dev->trans_type));
|
|
ret = ESP_FAIL;
|
|
break;
|
|
}
|
|
if (!dev->connected) {
|
|
ESP_LOGW(TAG, "%s hdl:0x%02x not connected", __func__, dev->bt.handle);
|
|
ret = ESP_ERR_INVALID_STATE;
|
|
break;
|
|
}
|
|
ret = esp_bt_hid_host_get_protocol(dev->addr.bda);
|
|
if (ret == ESP_OK) {
|
|
set_trans(dev, ESP_HID_TRANS_GET_PROTOCOL);
|
|
}
|
|
} while (0);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static esp_err_t esp_bt_hidh_dev_set_protocol(esp_hidh_dev_t *dev, uint8_t protocol_mode)
|
|
{
|
|
esp_err_t ret = ESP_OK;
|
|
|
|
do {
|
|
if (!is_trans_done(dev)) {
|
|
ESP_LOGE(TAG, "Pending previous tansaction %s done, try later!", get_trans_type_str(dev->trans_type));
|
|
ret = ESP_FAIL;
|
|
break;
|
|
}
|
|
if (!dev->connected) {
|
|
ESP_LOGW(TAG, "%s hdl:0x%02x not connected", __func__, dev->bt.handle);
|
|
ret = ESP_ERR_INVALID_STATE;
|
|
break;
|
|
}
|
|
ret = esp_bt_hid_host_set_protocol(dev->addr.bda, protocol_mode);
|
|
if (ret == ESP_OK) {
|
|
set_trans(dev, ESP_HID_TRANS_SET_PROTOCOL);
|
|
}
|
|
} while (0);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void esp_bt_hidh_dev_dump(esp_hidh_dev_t *dev, FILE *fp)
|
|
{
|
|
fprintf(fp, "BDA:" ESP_BD_ADDR_STR ", Status: %s, Connected: %s, Handle: %d, Usage: %s\n", ESP_BD_ADDR_HEX(dev->addr.bda), s_esp_hh_status_names[dev->status], dev->connected ? "YES" : "NO", dev->bt.handle, esp_hid_usage_str(dev->usage));
|
|
fprintf(fp, "Name: %s, Manufacturer: %s, Serial Number: %s\n", dev->config.device_name ? dev->config.device_name : "", dev->config.manufacturer_name ? dev->config.manufacturer_name : "", dev->config.serial_number ? dev->config.serial_number : "");
|
|
fprintf(fp, "PID: 0x%04x, VID: 0x%04x, VERSION: 0x%04x\n", dev->config.product_id, dev->config.vendor_id, dev->config.version);
|
|
fprintf(fp, "Report Map Length: %d\n", dev->config.report_maps[0].len);
|
|
esp_hidh_dev_report_t *report = dev->reports;
|
|
while (report) {
|
|
fprintf(fp, " %8s %7s %6s, ID: %3u, Length: %3u\n",
|
|
esp_hid_usage_str(report->usage), esp_hid_report_type_str(report->report_type), get_protocol_mode(report->protocol_mode),
|
|
report->report_id, report->value_len);
|
|
report = report->next;
|
|
}
|
|
}
|
|
|
|
esp_err_t esp_bt_hidh_init(const esp_hidh_config_t *config)
|
|
{
|
|
esp_err_t ret = ESP_OK;
|
|
ESP_RETURN_ON_FALSE(config, ESP_ERR_INVALID_ARG, TAG, "Config is NULL");
|
|
|
|
hidh_local_param.connection_queue = fixed_queue_new(QUEUE_SIZE_MAX);
|
|
ESP_RETURN_ON_FALSE(hidh_local_param.connection_queue, ESP_ERR_NO_MEM, TAG, "Alloc failed");
|
|
hidh_local_param.event_loop_handle = esp_hidh_get_event_loop();
|
|
|
|
ESP_GOTO_ON_ERROR(
|
|
esp_bt_hid_host_register_callback(esp_hh_cb),
|
|
bt_hid_fail, TAG, "BT HID register failed");
|
|
ESP_GOTO_ON_ERROR(
|
|
esp_bt_hid_host_init(),
|
|
bt_hid_fail, TAG, "BT HID register failed");
|
|
return ret;
|
|
|
|
bt_hid_fail:
|
|
free_local_param();
|
|
return ret;
|
|
}
|
|
|
|
esp_err_t esp_bt_hidh_deinit(void)
|
|
{
|
|
return esp_bt_hid_host_deinit();
|
|
}
|
|
|
|
static esp_hidh_dev_t *hidh_dev_ctor(esp_bd_addr_t bda)
|
|
{
|
|
esp_hidh_dev_t *dev = NULL;
|
|
dev = esp_hidh_dev_malloc();
|
|
if (dev == NULL) {
|
|
return NULL;
|
|
}
|
|
dev->in_use = true;
|
|
dev->transport = ESP_HID_TRANSPORT_BT;
|
|
dev->trans_type = ESP_HID_TRANS_MAX;
|
|
dev->trans_timer = NULL;
|
|
dev->protocol_mode = ESP_HID_PROTOCOL_MODE_REPORT; // device default protocol mode
|
|
dev->connected = false;
|
|
dev->opened = true;
|
|
dev->added = false;
|
|
dev->is_orig = true;
|
|
dev->reports = NULL;
|
|
dev->reports_len = 0;
|
|
dev->tmp = NULL;
|
|
dev->tmp_len = 0;
|
|
memcpy(dev->addr.bda, bda, sizeof(esp_bd_addr_t));
|
|
dev->bt.handle = 0xff;
|
|
|
|
dev->close = esp_bt_hidh_dev_close;
|
|
dev->report_write = esp_bt_hidh_dev_report_write;
|
|
dev->report_read = esp_bt_hidh_dev_report_read;
|
|
dev->set_report = esp_bt_hidh_dev_set_report;
|
|
dev->get_idle = esp_bt_hidh_dev_get_idle;
|
|
dev->set_idle = esp_bt_hidh_dev_set_idle;
|
|
dev->get_protocol = esp_bt_hidh_dev_get_protocol;
|
|
dev->set_protocol = esp_bt_hidh_dev_set_protocol;
|
|
dev->dump = esp_bt_hidh_dev_dump;
|
|
|
|
return dev;
|
|
}
|
|
|
|
esp_hidh_dev_t *esp_bt_hidh_dev_open(esp_bd_addr_t bda)
|
|
{
|
|
esp_hidh_dev_t *dev = esp_hidh_dev_get_by_bda(bda);
|
|
if (dev == NULL) {
|
|
if ((dev = hidh_dev_ctor(bda)) == NULL) {
|
|
ESP_LOGE(TAG, "%s create device failed!", __func__);
|
|
return NULL;
|
|
}
|
|
} else {
|
|
ESP_LOGW(TAG, "device has opened, connected: %d", dev->connected);
|
|
}
|
|
|
|
if (!dev->connected) {
|
|
esp_bt_hid_host_connect(dev->addr.bda);
|
|
}
|
|
return dev;
|
|
}
|
|
|
|
#endif /* CONFIG_BT_HID_HOST_ENABLED */
|