HID 人机交互应用框架

/*message type*/   /*hex*/  /*sent by*/
#define HID_HANDSHAKE       0x00     /*Device*/
#define HID_CONTROL         0x10     /*Device&host*/
/**0x20,0x30 Reserved*/
#define HID_GET_REPORT      0x40     /*host*/
#define HID_SET_REPORT      0x50     /*host*/
#define HID_GET_PROTOCOL    0x60     /*host*/
#define HID_SET_PROTOCOL    0x70     /*host*/
#define HID_GET_IDLE        0x80     /*host DEPRECATED*/
#define HID_SET_IDLE        0x90     /*host DEPRECATED*/
#define HID_DATA            0xA0     /*Device&host*/
#define HID_DATC            0xB0     /*Device&host  DEPRECATED*/
/*C-F  Reserved*/

/*DATA*/
#define DATA_OTHER       0x00
#define DATA_INPUT       0x01
#define DATA_OUTPUT      0x02
#define DATA_FEATURE     0x03

static  u8 *report_map;
static  u16 report_map_size;
#define HID_REPORT_MAP_DATA    report_map
#define HID_REPORT_MAP_SIZE    report_map_size

static void (*user_hid_send_wakeup)(void) = NULL;
static u16 hid_channel;//inter_channel
static u16 hid_ctrl_channel;//ctrl_channel
static volatile u8 hid_run = 0;
static volatile u8 is_hid_active = 0;
static volatile u8 hid_s_step = 0;
int hid_timer_id = 0;

#define HID_SEND_MAX_SIZE   (16) //描述符数据包的长度
static volatile u8  bt_send_busy = 0;
void (*user_led_status_callback)(u8 *buffer, u16 size) = NULL;

#define HID_TMP_BUFSIZE  (64*2)
#define cbuf_get_space(a) (a)->total_len
static cbuffer_t user_send_cbuf;
static u8 hid_tmp_buffer[HID_TMP_BUFSIZE];

static void edr_bt_evnet_post(u32 arg_type, u8 priv_event, u8 *args, u32 value)
{
    struct sys_event e;
    e.type = SYS_BT_EVENT;
    e.arg  = (void *)arg_type;
    e.u.bt.event = priv_event;
    if (args) {
        memcpy(e.u.bt.args, args, 7);
    }
    e.u.bt.value = value;
    sys_event_notify(&e);
}

void sdp_callback_remote_type(u8 remote_type)
{
    log_info("edr_hid:remote_type= %d\n", remote_type);
    edr_bt_evnet_post(SYS_BT_EVENT_FORM_COMMON, COMMON_EVENT_EDR_REMOTE_TYPE, NULL, remote_type);
    //to do
}

static u16 user_data_read_sub(u8 *buf, u16 buf_size)
{
    u16 ret_len;
    if (0 == cbuf_get_data_size(&user_send_cbuf)) {
        return 0;
    }

    OS_ENTER_CRITICAL();
    cbuf_read(&user_send_cbuf, &ret_len, 2);
    if (ret_len && ret_len <= buf_size) {
        cbuf_read(&user_send_cbuf, buf, ret_len);
    }
    OS_EXIT_CRITICAL();

    return ret_len;
}

static void user_data_try_send(void)
{
    u16 send_len;

    if (bt_send_busy) {
        return;
    }
    bt_send_busy = 1;//hold

    u8 tmp_send_buf[HID_SEND_MAX_SIZE];

    send_len = user_data_read_sub(tmp_send_buf, HID_SEND_MAX_SIZE);

    if (send_len) {
        if (user_hid_send_data(tmp_send_buf, send_len)) {
            bt_send_busy = 0;
        }
    } else {
        //not send
        bt_send_busy = 0;
    }
}

static u32 user_data_write_sub(u8 *data, u16 len)
{
    u16 wlen = 0;

    u16 buf_space = cbuf_get_space(&user_send_cbuf) - cbuf_get_data_size(&user_send_cbuf);
    if (len + 2 > buf_space) {
        return 0;
    }

    OS_ENTER_CRITICAL();
    wlen = cbuf_write(&user_send_cbuf, &len, 2);
    wlen += cbuf_write(&user_send_cbuf, data, len);
    OS_EXIT_CRITICAL();

    user_data_try_send();
    return wlen;
}

int edr_hid_data_send(u8 report_id, u8 *data, u16 len);
int edr_hid_data_send_ext(u8 report_type, u8 report_id, u8 *data, u16 len);

typedef struct {
    u8 report_type;
    u8 report_id;
    u8 data[HID_SEND_MAX_SIZE - 2];
} hid_data_info_t;

enum {
    HID_USER_ERR_NONE = 0x0,
    HID_USER_ERR_DONE,
    HID_USER_ERR_SEND_FAIL,
};

void user_hid_init(void (*user_hid_output_handler)(u8 *packet, u16 size, u16 channel));
void user_hid_exit(void);
void user_hid_enable(u8 en);
int  user_hid_send_data(u8 *buf, u32 len);
void user_hid_disconnect(void);
void user_hid_set_icon(u32 class_type);
void user_hid_set_ReportMap(u8 *map, u16 size);
int edr_hid_data_send(u8 report_id, u8 *data, u16 len);
int edr_hid_data_send_ext(u8 report_type, u8 report_id, u8 *data, u16 len);
void edr_hid_key_deal_test(u16 key_msg);
int edr_hid_is_connected(void);
int edr_hid_tx_buff_is_ok(void);

static const u8 sHIDDescriptor[] = {
    //InterfaceDeszcriptor:
    USB_DT_INTERFACE_SIZE,     // Length
    USB_DT_INTERFACE,          // DescriptorType
    0x00,                      // bInterface number
    0x00,                      // AlternateSetting
    0x02,                      // NumEndpoint
    USB_CLASS_HID,             // Class = Human Interface Device
    0x00,                      // Subclass, 0 No subclass, 1 Boot Interface subclass
    0x00,                      // Procotol, 0 None, 1 Keyboard, 2 Mouse
    0x00,                      // Interface Name

    //HIDDescriptor:
    0x09,                      // bLength
    USB_HID_DT_HID,            // bDescriptorType, HID Descriptor
    0x01, 0x02,                // bcdHID, HID Class Specification release NO.
    0x00,                      // bCuntryCode, Country localization (=none)
    0x01,                      // bNumDescriptors, Number of descriptors to follow
    0x22,                      // bDescriptorType, Report Desc. 0x22, Physical Desc. 0x23
    0,                         // LOW(ReportLength)
    0,                         // HIGH(ReportLength)

    //EndpointDescriptor:
    USB_DT_ENDPOINT_SIZE,      // bLength
    USB_DT_ENDPOINT,           // bDescriptorType, Type
    USB_DIR_IN | HID_EP_IN,    // bEndpointAddress
    USB_ENDPOINT_XFER_INT,     // Interrupt
    LOBYTE(MAXP_SIZE_HIDIN), HIBYTE(MAXP_SIZE_HIDIN), // Maximum packet size
    0x01,                      // Poll every 10msec seconds

    //Endpoint Descriptor:
    USB_DT_ENDPOINT_SIZE,      // bLength
    USB_DT_ENDPOINT,           // bDescriptorType, Type
    USB_DIR_OUT | HID_EP_OUT,  // bEndpointAddress
    USB_ENDPOINT_XFER_INT,     // Interrupt
    LOBYTE(MAXP_SIZE_HIDOUT), HIBYTE(MAXP_SIZE_HIDOUT), // Maximum packet size
    0x01,                      // bInterval
};

static const u8 *hid_report_map;
static int hid_report_map_size = 0;
void usb_hid_set_repport_map(const u8 *map, int size)
{
    hid_report_map_size = size;
    hid_report_map = map;
}

static void (*usb_hid_state_ck)(u8 state) = NULL;
static void hid_state_callback(u8 state)
{
    if (usb_hid_state_ck) {
        usb_hid_state_ck(state);
    }
}

void usb_hid_register_state_callback(void *callback)
{
    usb_hid_state_ck = callback;
}

static void (*usb_hid_output_callback)(u8 *buffer, u16 size) = NULL;
void usb_hid_set_output_callback(void *cb)
{
    usb_hid_output_callback = cb;
}

#define HID_UUID_16                                 0x1812
#define HID_INFORMATION_UUID_16                     0x2A4A
#define HID_REPORT_MAP_UUID_16                      0x2A4B
#define HID_CONTROL_POINT_UUID_16                   0x2A4C
#define HID_REPORT_UUID_16                          0x2A4D
#define PROTOCOL_MODE_UUID_16       				0x2A4E
#define HID_REPORT_REFERENCE_UUID_16                0x2908

// 初始化 HID，注册主机下发数据的输出回调
user_hid_init(user_hid_output_handler);
// 注入 HID Report Descriptor（SDP 与协议栈使用）
user_hid_set_ReportMap(hid_report_map, hid_report_map_size);
// 使能 HID
user_hid_enable(1);

// 上报 Input 报告（report_id = 1，数据为按键码数组）
u8 key_data[6] = {0, 0, 0, 0, 0, 0};
edr_hid_data_send(1, key_data, sizeof(key_data));

// 显式指定报告类型上报
edr_hid_data_send_ext(DATA_INPUT, 1, key_data, sizeof(key_data));

void usb_hid_set_repport_map(const u8 *map, int size);
void usb_hid_register_state_callback(void *callback);
void usb_hid_set_output_callback(void *cb);