Archipelago » qemu

/*

 * QEMU Bluetooth HCI helpers.

 *

 * Copyright (C) 2007 OpenMoko, Inc.

 * Written by Andrzej Zaborowski <andrew@openedhand.com>

 *

 * Useful definitions taken from BlueZ project's headers.

 * Copyright (C) 2000-2001  Qualcomm Incorporated

 * Copyright (C) 2002-2003  Maxim Krasnyansky <maxk@qualcomm.com>

 * Copyright (C) 2002-2006  Marcel Holtmann <marcel@holtmann.org>

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License as

 * published by the Free Software Foundation; either version 2 of

 * the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,

 * MA  02110-1301  USA

 */

/* BD Address */

typedef struct {

    uint8_t b[6];

} __attribute__((packed)) bdaddr_t;

#define BDADDR_ANY        (&(bdaddr_t) {{0, 0, 0, 0, 0, 0}})

#define BDADDR_ALL        (&(bdaddr_t) {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}})

#define BDADDR_LOCAL        (&(bdaddr_t) {{0, 0, 0, 0xff, 0xff, 0xff}})

/* Copy, swap, convert BD Address */

static inline int bacmp(const bdaddr_t *ba1, const bdaddr_t *ba2)

{

    return memcmp(ba1, ba2, sizeof(bdaddr_t));

}

static inline void bacpy(bdaddr_t *dst, const bdaddr_t *src)

{

    memcpy(dst, src, sizeof(bdaddr_t));

}

#define BAINIT(orig)        { .b = {                \

    (orig)->b[0], (orig)->b[1], (orig)->b[2],        \

    (orig)->b[3], (orig)->b[4], (orig)->b[5],        \

}, }

/* The twisted structures of a bluetooth environment */

struct bt_device_s;

struct bt_scatternet_s;

struct bt_piconet_s;

struct bt_link_s;

struct bt_scatternet_s {

    struct bt_device_s *slave;

};

struct bt_link_s {

    struct bt_device_s *slave, *host;

    uint16_t handle;                /* Master (host) side handle */

    uint16_t acl_interval;

    enum {

        acl_active,

        acl_hold,

        acl_sniff,

        acl_parked,

    } acl_mode;

};

struct bt_device_s {

    int lt_addr;

    bdaddr_t bd_addr;

    int mtu;

    int setup;

    struct bt_scatternet_s *net;

    uint8_t key[16];

    int key_present;

    uint8_t class[3];

    uint8_t reject_reason;

    uint64_t lmp_caps;

    const char *lmp_name;

    void (*lmp_connection_request)(struct bt_link_s *link);

    void (*lmp_connection_complete)(struct bt_link_s *link);

    void (*lmp_disconnect_master)(struct bt_link_s *link);

    void (*lmp_disconnect_slave)(struct bt_link_s *link);

    void (*lmp_acl_data)(struct bt_link_s *link, const uint8_t *data,

                    int start, int len);

    void (*lmp_acl_resp)(struct bt_link_s *link, const uint8_t *data,

                    int start, int len);

    void (*lmp_mode_change)(struct bt_link_s *link);

    void (*handle_destroy)(struct bt_device_s *device);

    struct bt_device_s *next;        /* Next in the piconet/scatternet */

    int inquiry_scan;

    int page_scan;

    uint16_t clkoff;        /* Note: Always little-endian */

};

/* bt.c */

void bt_device_init(struct bt_device_s *dev, struct bt_scatternet_s *net);

void bt_device_done(struct bt_device_s *dev);

/* bt-hci.c */

struct HCIInfo *bt_new_hci(struct bt_scatternet_s *net);

/* bt-host.c */

struct HCIInfo *bt_host_hci(const char *id);

/* bt-vhci.c */

void bt_vhci_init(struct HCIInfo *info);

/* bt-hci-csr.c */

enum {

    csrhci_pin_reset,

    csrhci_pin_wakeup,

    __csrhci_pins,

};

qemu_irq *csrhci_pins_get(CharDriverState *chr);

CharDriverState *uart_hci_init(qemu_irq wakeup);

/* bt-l2cap.c */

struct bt_l2cap_device_s;

struct bt_l2cap_conn_params_s;

struct bt_l2cap_psm_s;

void bt_l2cap_device_init(struct bt_l2cap_device_s *dev,

                struct bt_scatternet_s *net);

void bt_l2cap_device_done(struct bt_l2cap_device_s *dev);

void bt_l2cap_psm_register(struct bt_l2cap_device_s *dev, int psm,

                int min_mtu, int (*new_channel)(struct bt_l2cap_device_s *dev,

                        struct bt_l2cap_conn_params_s *params));

struct bt_l2cap_device_s {

    struct bt_device_s device;

    struct bt_l2cap_psm_s *first_psm;

};

struct bt_l2cap_conn_params_s {

    /* Input */

    uint8_t *(*sdu_out)(struct bt_l2cap_conn_params_s *chan, int len);

    void (*sdu_submit)(struct bt_l2cap_conn_params_s *chan);

    int remote_mtu;

    /* Output */

    void *opaque;

    void (*sdu_in)(void *opaque, const uint8_t *data, int len);

    void (*close)(void *opaque);

};

enum bt_l2cap_psm_predef {

    BT_PSM_SDP                = 0x0001,

    BT_PSM_RFCOMM        = 0x0003,

    BT_PSM_TELEPHONY        = 0x0005,

    BT_PSM_TCS                = 0x0007,

    BT_PSM_BNEP                = 0x000f,

    BT_PSM_HID_CTRL        = 0x0011,

    BT_PSM_HID_INTR        = 0x0013,

    BT_PSM_UPNP                = 0x0015,

    BT_PSM_AVCTP        = 0x0017,

    BT_PSM_AVDTP        = 0x0019,

};

/* bt-sdp.c */

void bt_l2cap_sdp_init(struct bt_l2cap_device_s *dev);

/* bt-hid.c */

struct bt_device_s *bt_mouse_init(struct bt_scatternet_s *net);

struct bt_device_s *bt_tablet_init(struct bt_scatternet_s *net);

struct bt_device_s *bt_keyboard_init(struct bt_scatternet_s *net);

/* Link Management Protocol layer defines */

#define LLID_ACLU_CONT                0x1

#define LLID_ACLU_START                0x2

#define LLID_ACLC                0x3

enum lmp_pdu_type {

    LMP_NAME_REQ                = 0x0001,

    LMP_NAME_RES                = 0x0002,

    LMP_ACCEPTED                = 0x0003,

    LMP_NOT_ACCEPTED                = 0x0004,

    LMP_CLKOFFSET_REQ                = 0x0005,

    LMP_CLKOFFSET_RES                = 0x0006,

    LMP_DETACH                        = 0x0007,

    LMP_IN_RAND                        = 0x0008,

    LMP_COMB_KEY                = 0x0009,

    LMP_UNIT_KEY                = 0x000a,

    LMP_AU_RAND                        = 0x000b,

    LMP_SRES                        = 0x000c,

    LMP_TEMP_RAND                = 0x000d,

    LMP_TEMP_KEY                = 0x000e,

    LMP_CRYPT_MODE_REQ                = 0x000f,

    LMP_CRYPT_KEY_SIZE_REQ        = 0x0010,

    LMP_START_ENCRYPT_REQ        = 0x0011,

    LMP_STOP_ENCRYPT_REQ        = 0x0012,

    LMP_SWITCH_REQ                = 0x0013,

    LMP_HOLD                        = 0x0014,

    LMP_HOLD_REQ                = 0x0015,

    LMP_SNIFF_REQ                = 0x0017,

    LMP_UNSNIFF_REQ                = 0x0018,

    LMP_LMP_PARK_REQ                = 0x0019,

    LMP_SET_BCAST_SCAN_WND        = 0x001b,

    LMP_MODIFY_BEACON                = 0x001c,

    LMP_UNPARK_BD_ADDR_REQ        = 0x001d,

    LMP_UNPARK_PM_ADDR_REQ        = 0x001e,

    LMP_INCR_POWER_REQ                = 0x001f,

    LMP_DECR_POWER_REQ                = 0x0020,

    LMP_MAX_POWER                = 0x0021,

    LMP_MIN_POWER                = 0x0022,

    LMP_AUTO_RATE                = 0x0023,

    LMP_PREFERRED_RATE                = 0x0024,

    LMP_VERSION_REQ                = 0x0025,

    LMP_VERSION_RES                = 0x0026,

    LMP_FEATURES_REQ                = 0x0027,

    LMP_FEATURES_RES                = 0x0028,

    LMP_QUALITY_OF_SERVICE        = 0x0029,

    LMP_QOS_REQ                        = 0x002a,

    LMP_RM_SCO_LINK_REQ                = 0x002b,

    LMP_SCO_LINK_REQ                = 0x002c,

    LMP_MAX_SLOT                = 0x002d,

    LMP_MAX_SLOT_REQ                = 0x002e,

    LMP_TIMING_ACCURACY_REQ        = 0x002f,

    LMP_TIMING_ACCURACY_RES        = 0x0030,

    LMP_SETUP_COMPLETE                = 0x0031,

    LMP_USE_SEMIPERM_KEY        = 0x0032,

    LMP_HOST_CONNECTION_REQ        = 0x0033,

    LMP_SLOT_OFFSET                = 0x0034,

    LMP_PAGE_MODE_REQ                = 0x0035,

    LMP_PAGE_SCAN_MODE_REQ        = 0x0036,

    LMP_SUPERVISION_TIMEOUT        = 0x0037,

    LMP_TEST_ACTIVATE                = 0x0038,

    LMP_TEST_CONTROL                = 0x0039,

    LMP_CRYPT_KEY_MASK_REQ        = 0x003a,

    LMP_CRYPT_KEY_MASK_RES        = 0x003b,

    LMP_SET_AFH                        = 0x003c,

    LMP_ACCEPTED_EXT                = 0x7f01,

    LMP_NOT_ACCEPTED_EXT        = 0x7f02,

    LMP_FEATURES_REQ_EXT        = 0x7f03,

    LMP_FEATURES_RES_EXT        = 0x7f04,

    LMP_PACKET_TYPE_TBL_REQ        = 0x7f0b,

    LMP_ESCO_LINK_REQ                = 0x7f0c,

    LMP_RM_ESCO_LINK_REQ        = 0x7f0d,

    LMP_CHANNEL_CLASS_REQ        = 0x7f10,

    LMP_CHANNEL_CLASS                = 0x7f11,

};

/* Host Controller Interface layer defines */

enum hci_packet_type {

    HCI_COMMAND_PKT                = 0x01,

    HCI_ACLDATA_PKT                = 0x02,

    HCI_SCODATA_PKT                = 0x03,

    HCI_EVENT_PKT                = 0x04,

    HCI_VENDOR_PKT                = 0xff,

};

enum bt_packet_type {

    HCI_2DH1        = 1 << 1,

    HCI_3DH1        = 1 << 2,

    HCI_DM1        = 1 << 3,

    HCI_DH1        = 1 << 4,

    HCI_2DH3        = 1 << 8,

    HCI_3DH3        = 1 << 9,

    HCI_DM3        = 1 << 10,

    HCI_DH3        = 1 << 11,

    HCI_2DH5        = 1 << 12,

    HCI_3DH5        = 1 << 13,

    HCI_DM5        = 1 << 14,

    HCI_DH5        = 1 << 15,

};

enum sco_packet_type {

    HCI_HV1        = 1 << 5,

    HCI_HV2        = 1 << 6,

    HCI_HV3        = 1 << 7,

};

enum ev_packet_type {

    HCI_EV3        = 1 << 3,

    HCI_EV4        = 1 << 4,

    HCI_EV5        = 1 << 5,

    HCI_2EV3        = 1 << 6,

    HCI_3EV3        = 1 << 7,

    HCI_2EV5        = 1 << 8,

    HCI_3EV5        = 1 << 9,

};

enum hci_error_code {

    HCI_SUCCESS                                = 0x00,

    HCI_UNKNOWN_COMMAND                        = 0x01,

    HCI_NO_CONNECTION                        = 0x02,

    HCI_HARDWARE_FAILURE                = 0x03,

    HCI_PAGE_TIMEOUT                        = 0x04,

    HCI_AUTHENTICATION_FAILURE                = 0x05,

    HCI_PIN_OR_KEY_MISSING                = 0x06,

    HCI_MEMORY_FULL                        = 0x07,

    HCI_CONNECTION_TIMEOUT                = 0x08,

    HCI_MAX_NUMBER_OF_CONNECTIONS        = 0x09,

    HCI_MAX_NUMBER_OF_SCO_CONNECTIONS        = 0x0a,

    HCI_ACL_CONNECTION_EXISTS                = 0x0b,

    HCI_COMMAND_DISALLOWED                = 0x0c,

    HCI_REJECTED_LIMITED_RESOURCES        = 0x0d,

    HCI_REJECTED_SECURITY                = 0x0e,

    HCI_REJECTED_PERSONAL                = 0x0f,

    HCI_HOST_TIMEOUT                        = 0x10,

    HCI_UNSUPPORTED_FEATURE                = 0x11,

    HCI_INVALID_PARAMETERS                = 0x12,

    HCI_OE_USER_ENDED_CONNECTION        = 0x13,

    HCI_OE_LOW_RESOURCES                = 0x14,

    HCI_OE_POWER_OFF                        = 0x15,

    HCI_CONNECTION_TERMINATED                = 0x16,

    HCI_REPEATED_ATTEMPTS                = 0x17,

    HCI_PAIRING_NOT_ALLOWED                = 0x18,

    HCI_UNKNOWN_LMP_PDU                        = 0x19,

    HCI_UNSUPPORTED_REMOTE_FEATURE        = 0x1a,

    HCI_SCO_OFFSET_REJECTED                = 0x1b,

    HCI_SCO_INTERVAL_REJECTED                = 0x1c,

    HCI_AIR_MODE_REJECTED                = 0x1d,

    HCI_INVALID_LMP_PARAMETERS                = 0x1e,

    HCI_UNSPECIFIED_ERROR                = 0x1f,

    HCI_UNSUPPORTED_LMP_PARAMETER_VALUE        = 0x20,

    HCI_ROLE_CHANGE_NOT_ALLOWED                = 0x21,

    HCI_LMP_RESPONSE_TIMEOUT                = 0x22,

    HCI_LMP_ERROR_TRANSACTION_COLLISION        = 0x23,

    HCI_LMP_PDU_NOT_ALLOWED                = 0x24,

    HCI_ENCRYPTION_MODE_NOT_ACCEPTED        = 0x25,

    HCI_UNIT_LINK_KEY_USED                = 0x26,

    HCI_QOS_NOT_SUPPORTED                = 0x27,

    HCI_INSTANT_PASSED                        = 0x28,

    HCI_PAIRING_NOT_SUPPORTED                = 0x29,

    HCI_TRANSACTION_COLLISION                = 0x2a,

    HCI_QOS_UNACCEPTABLE_PARAMETER        = 0x2c,

    HCI_QOS_REJECTED                        = 0x2d,

    HCI_CLASSIFICATION_NOT_SUPPORTED        = 0x2e,

    HCI_INSUFFICIENT_SECURITY                = 0x2f,

    HCI_PARAMETER_OUT_OF_RANGE                = 0x30,

    HCI_ROLE_SWITCH_PENDING                = 0x32,

    HCI_SLOT_VIOLATION                        = 0x34,

    HCI_ROLE_SWITCH_FAILED                = 0x35,

};

enum acl_flag_bits {

    ACL_CONT                = 1 << 0,

    ACL_START                = 1 << 1,

    ACL_ACTIVE_BCAST        = 1 << 2,

    ACL_PICO_BCAST        = 1 << 3,

};

enum baseband_link_type {

    SCO_LINK                = 0x00,

    ACL_LINK                = 0x01,

};

enum lmp_feature_bits0 {

    LMP_3SLOT                = 1 << 0,

    LMP_5SLOT                = 1 << 1,

    LMP_ENCRYPT                = 1 << 2,

    LMP_SOFFSET                = 1 << 3,

    LMP_TACCURACY        = 1 << 4,

    LMP_RSWITCH                = 1 << 5,

    LMP_HOLD_MODE        = 1 << 6,

    LMP_SNIFF_MODE        = 1 << 7,

};

enum lmp_feature_bits1 {

    LMP_PARK                = 1 << 0,

    LMP_RSSI                = 1 << 1,

    LMP_QUALITY                = 1 << 2,

    LMP_SCO                = 1 << 3,

    LMP_HV2                = 1 << 4,

    LMP_HV3                = 1 << 5,

    LMP_ULAW                = 1 << 6,

    LMP_ALAW                = 1 << 7,

};

enum lmp_feature_bits2 {

    LMP_CVSD                = 1 << 0,

    LMP_PSCHEME                = 1 << 1,

    LMP_PCONTROL        = 1 << 2,

    LMP_TRSP_SCO        = 1 << 3,

    LMP_BCAST_ENC        = 1 << 7,

};

enum lmp_feature_bits3 {

    LMP_EDR_ACL_2M        = 1 << 1,

    LMP_EDR_ACL_3M        = 1 << 2,

    LMP_ENH_ISCAN        = 1 << 3,

    LMP_ILACE_ISCAN        = 1 << 4,

    LMP_ILACE_PSCAN        = 1 << 5,

    LMP_RSSI_INQ        = 1 << 6,

    LMP_ESCO                = 1 << 7,

};

enum lmp_feature_bits4 {

    LMP_EV4                = 1 << 0,

    LMP_EV5                = 1 << 1,

    LMP_AFH_CAP_SLV        = 1 << 3,

    LMP_AFH_CLS_SLV        = 1 << 4,

    LMP_EDR_3SLOT        = 1 << 7,

};

enum lmp_feature_bits5 {

    LMP_EDR_5SLOT        = 1 << 0,

    LMP_SNIFF_SUBR        = 1 << 1,

    LMP_AFH_CAP_MST        = 1 << 3,

    LMP_AFH_CLS_MST        = 1 << 4,

    LMP_EDR_ESCO_2M        = 1 << 5,

    LMP_EDR_ESCO_3M        = 1 << 6,

    LMP_EDR_3S_ESCO        = 1 << 7,

};

enum lmp_feature_bits6 {

    LMP_EXT_INQ                = 1 << 0,

};

enum lmp_feature_bits7 {

    LMP_EXT_FEAT        = 1 << 7,

};

enum hci_link_policy {

    HCI_LP_RSWITCH        = 1 << 0,

    HCI_LP_HOLD                = 1 << 1,

    HCI_LP_SNIFF        = 1 << 2,

    HCI_LP_PARK                = 1 << 3,

};

enum hci_link_mode {

    HCI_LM_ACCEPT        = 1 << 15,

    HCI_LM_MASTER        = 1 << 0,

    HCI_LM_AUTH                = 1 << 1,

    HCI_LM_ENCRYPT        = 1 << 2,

    HCI_LM_TRUSTED        = 1 << 3,

    HCI_LM_RELIABLE        = 1 << 4,

    HCI_LM_SECURE        = 1 << 5,

};

/* HCI Commands */

/* Link Control */

#define OGF_LINK_CTL                0x01

#define OCF_INQUIRY                        0x0001

typedef struct {

    uint8_t        lap[3];

    uint8_t        length;                /* 1.28s units */

    uint8_t        num_rsp;

} __attribute__ ((packed)) inquiry_cp;

#define INQUIRY_CP_SIZE 5

typedef struct {

    uint8_t                status;

    bdaddr_t        bdaddr;

} __attribute__ ((packed)) status_bdaddr_rp;

#define STATUS_BDADDR_RP_SIZE 7

#define OCF_INQUIRY_CANCEL                0x0002

#define OCF_PERIODIC_INQUIRY                0x0003

typedef struct {

    uint16_t        max_period;        /* 1.28s units */

    uint16_t        min_period;        /* 1.28s units */

    uint8_t        lap[3];

    uint8_t        length;                /* 1.28s units */

    uint8_t        num_rsp;

} __attribute__ ((packed)) periodic_inquiry_cp;

#define PERIODIC_INQUIRY_CP_SIZE 9

#define OCF_EXIT_PERIODIC_INQUIRY        0x0004

#define OCF_CREATE_CONN                        0x0005

typedef struct {

    bdaddr_t        bdaddr;

    uint16_t        pkt_type;

    uint8_t        pscan_rep_mode;

    uint8_t        pscan_mode;

    uint16_t        clock_offset;

    uint8_t        role_switch;

} __attribute__ ((packed)) create_conn_cp;

#define CREATE_CONN_CP_SIZE 13

#define OCF_DISCONNECT                        0x0006

typedef struct {

    uint16_t        handle;

    uint8_t        reason;

} __attribute__ ((packed)) disconnect_cp;

#define DISCONNECT_CP_SIZE 3

#define OCF_ADD_SCO                        0x0007

typedef struct {

    uint16_t        handle;

    uint16_t        pkt_type;

} __attribute__ ((packed)) add_sco_cp;

#define ADD_SCO_CP_SIZE 4

#define OCF_CREATE_CONN_CANCEL                0x0008

typedef struct {

    uint8_t        status;

    bdaddr_t        bdaddr;

} __attribute__ ((packed)) create_conn_cancel_cp;

#define CREATE_CONN_CANCEL_CP_SIZE 6

typedef struct {

    uint8_t        status;

    bdaddr_t        bdaddr;

} __attribute__ ((packed)) create_conn_cancel_rp;

#define CREATE_CONN_CANCEL_RP_SIZE 7

#define OCF_ACCEPT_CONN_REQ                0x0009

typedef struct {

    bdaddr_t        bdaddr;

    uint8_t        role;

} __attribute__ ((packed)) accept_conn_req_cp;

#define ACCEPT_CONN_REQ_CP_SIZE        7

#define OCF_REJECT_CONN_REQ                0x000A

typedef struct {

    bdaddr_t        bdaddr;

    uint8_t        reason;

} __attribute__ ((packed)) reject_conn_req_cp;

#define REJECT_CONN_REQ_CP_SIZE        7

#define OCF_LINK_KEY_REPLY                0x000B

typedef struct {

    bdaddr_t        bdaddr;

    uint8_t        link_key[16];

} __attribute__ ((packed)) link_key_reply_cp;

#define LINK_KEY_REPLY_CP_SIZE 22

#define OCF_LINK_KEY_NEG_REPLY                0x000C

#define OCF_PIN_CODE_REPLY                0x000D

typedef struct {

    bdaddr_t        bdaddr;

    uint8_t        pin_len;

    uint8_t        pin_code[16];

} __attribute__ ((packed)) pin_code_reply_cp;

#define PIN_CODE_REPLY_CP_SIZE 23

#define OCF_PIN_CODE_NEG_REPLY                0x000E

#define OCF_SET_CONN_PTYPE                0x000F

typedef struct {

    uint16_t         handle;

    uint16_t         pkt_type;

} __attribute__ ((packed)) set_conn_ptype_cp;

#define SET_CONN_PTYPE_CP_SIZE 4

#define OCF_AUTH_REQUESTED                0x0011

typedef struct {

    uint16_t         handle;

} __attribute__ ((packed)) auth_requested_cp;

#define AUTH_REQUESTED_CP_SIZE 2

#define OCF_SET_CONN_ENCRYPT                0x0013

typedef struct {

    uint16_t        handle;

    uint8_t        encrypt;

} __attribute__ ((packed)) set_conn_encrypt_cp;

#define SET_CONN_ENCRYPT_CP_SIZE 3

#define OCF_CHANGE_CONN_LINK_KEY        0x0015

typedef struct {

    uint16_t        handle;

} __attribute__ ((packed)) change_conn_link_key_cp;

#define CHANGE_CONN_LINK_KEY_CP_SIZE 2

#define OCF_MASTER_LINK_KEY                0x0017

typedef struct {

    uint8_t        key_flag;

} __attribute__ ((packed)) master_link_key_cp;

#define MASTER_LINK_KEY_CP_SIZE 1

#define OCF_REMOTE_NAME_REQ                0x0019

typedef struct {

    bdaddr_t        bdaddr;

    uint8_t        pscan_rep_mode;

    uint8_t        pscan_mode;

    uint16_t        clock_offset;

} __attribute__ ((packed)) remote_name_req_cp;

#define REMOTE_NAME_REQ_CP_SIZE 10

#define OCF_REMOTE_NAME_REQ_CANCEL        0x001A

typedef struct {

    bdaddr_t        bdaddr;

} __attribute__ ((packed)) remote_name_req_cancel_cp;

#define REMOTE_NAME_REQ_CANCEL_CP_SIZE 6

typedef struct {

    uint8_t                status;

    bdaddr_t        bdaddr;

} __attribute__ ((packed)) remote_name_req_cancel_rp;

#define REMOTE_NAME_REQ_CANCEL_RP_SIZE 7

#define OCF_READ_REMOTE_FEATURES        0x001B

typedef struct {

    uint16_t        handle;

} __attribute__ ((packed)) read_remote_features_cp;

#define READ_REMOTE_FEATURES_CP_SIZE 2

#define OCF_READ_REMOTE_EXT_FEATURES        0x001C

typedef struct {

    uint16_t        handle;

    uint8_t        page_num;

} __attribute__ ((packed)) read_remote_ext_features_cp;

#define READ_REMOTE_EXT_FEATURES_CP_SIZE 3

#define OCF_READ_REMOTE_VERSION                0x001D

typedef struct {

    uint16_t        handle;

} __attribute__ ((packed)) read_remote_version_cp;

#define READ_REMOTE_VERSION_CP_SIZE 2

#define OCF_READ_CLOCK_OFFSET                0x001F

typedef struct {

    uint16_t        handle;

} __attribute__ ((packed)) read_clock_offset_cp;

#define READ_CLOCK_OFFSET_CP_SIZE 2

#define OCF_READ_LMP_HANDLE                0x0020

typedef struct {

    uint16_t        handle;

} __attribute__ ((packed)) read_lmp_handle_cp;

#define READ_LMP_HANDLE_CP_SIZE 2

typedef struct {

    uint8_t        status;

    uint16_t        handle;

    uint8_t        lmp_handle;

    uint32_t        reserved;

} __attribute__ ((packed)) read_lmp_handle_rp;

#define READ_LMP_HANDLE_RP_SIZE 8

#define OCF_SETUP_SYNC_CONN                0x0028

typedef struct {

    uint16_t        handle;

    uint32_t        tx_bandwith;

    uint32_t        rx_bandwith;

    uint16_t        max_latency;

    uint16_t        voice_setting;

    uint8_t        retrans_effort;

    uint16_t        pkt_type;

} __attribute__ ((packed)) setup_sync_conn_cp;

#define SETUP_SYNC_CONN_CP_SIZE 17

#define OCF_ACCEPT_SYNC_CONN_REQ        0x0029

typedef struct {

    bdaddr_t        bdaddr;

    uint32_t        tx_bandwith;

    uint32_t        rx_bandwith;

    uint16_t        max_latency;

    uint16_t        voice_setting;

    uint8_t        retrans_effort;

    uint16_t        pkt_type;

} __attribute__ ((packed)) accept_sync_conn_req_cp;

#define ACCEPT_SYNC_CONN_REQ_CP_SIZE 21

#define OCF_REJECT_SYNC_CONN_REQ        0x002A

typedef struct {

    bdaddr_t        bdaddr;

    uint8_t        reason;

} __attribute__ ((packed)) reject_sync_conn_req_cp;

#define REJECT_SYNC_CONN_REQ_CP_SIZE 7

/* Link Policy */

#define OGF_LINK_POLICY                0x02

#define OCF_HOLD_MODE                        0x0001

typedef struct {

    uint16_t        handle;

    uint16_t        max_interval;

    uint16_t        min_interval;

} __attribute__ ((packed)) hold_mode_cp;

#define HOLD_MODE_CP_SIZE 6

#define OCF_SNIFF_MODE                        0x0003

typedef struct {

    uint16_t        handle;

    uint16_t        max_interval;

    uint16_t        min_interval;

    uint16_t        attempt;

    uint16_t        timeout;

} __attribute__ ((packed)) sniff_mode_cp;

#define SNIFF_MODE_CP_SIZE 10

#define OCF_EXIT_SNIFF_MODE                0x0004

typedef struct {

    uint16_t        handle;

} __attribute__ ((packed)) exit_sniff_mode_cp;

#define EXIT_SNIFF_MODE_CP_SIZE 2

#define OCF_PARK_MODE                        0x0005

typedef struct {

    uint16_t        handle;

    uint16_t        max_interval;

    uint16_t        min_interval;

} __attribute__ ((packed)) park_mode_cp;

#define PARK_MODE_CP_SIZE 6

#define OCF_EXIT_PARK_MODE                0x0006

typedef struct {

    uint16_t        handle;

} __attribute__ ((packed)) exit_park_mode_cp;

#define EXIT_PARK_MODE_CP_SIZE 2

#define OCF_QOS_SETUP                        0x0007

typedef struct {

    uint8_t        service_type;                /* 1 = best effort */

    uint32_t        token_rate;                /* Byte per seconds */

    uint32_t        peak_bandwidth;                /* Byte per seconds */

    uint32_t        latency;                /* Microseconds */

    uint32_t        delay_variation;        /* Microseconds */

} __attribute__ ((packed)) hci_qos;

#define HCI_QOS_CP_SIZE 17

typedef struct {

    uint16_t         handle;

    uint8_t         flags;                        /* Reserved */

    hci_qos         qos;

} __attribute__ ((packed)) qos_setup_cp;

#define QOS_SETUP_CP_SIZE (3 + HCI_QOS_CP_SIZE)

#define OCF_ROLE_DISCOVERY                0x0009

typedef struct {

    uint16_t        handle;

} __attribute__ ((packed)) role_discovery_cp;

#define ROLE_DISCOVERY_CP_SIZE 2

typedef struct {

    uint8_t        status;

    uint16_t        handle;

    uint8_t        role;

} __attribute__ ((packed)) role_discovery_rp;

#define ROLE_DISCOVERY_RP_SIZE 4

#define OCF_SWITCH_ROLE                        0x000B

typedef struct {

    bdaddr_t        bdaddr;

    uint8_t        role;

} __attribute__ ((packed)) switch_role_cp;

#define SWITCH_ROLE_CP_SIZE 7

#define OCF_READ_LINK_POLICY                0x000C

typedef struct {

    uint16_t        handle;

} __attribute__ ((packed)) read_link_policy_cp;

#define READ_LINK_POLICY_CP_SIZE 2

typedef struct {

    uint8_t         status;

    uint16_t        handle;

    uint16_t        policy;

} __attribute__ ((packed)) read_link_policy_rp;

#define READ_LINK_POLICY_RP_SIZE 5

#define OCF_WRITE_LINK_POLICY                0x000D

typedef struct {

    uint16_t        handle;

    uint16_t        policy;

} __attribute__ ((packed)) write_link_policy_cp;

#define WRITE_LINK_POLICY_CP_SIZE 4

typedef struct {

    uint8_t         status;

    uint16_t        handle;

} __attribute__ ((packed)) write_link_policy_rp;

#define WRITE_LINK_POLICY_RP_SIZE 3

#define OCF_READ_DEFAULT_LINK_POLICY        0x000E

#define OCF_WRITE_DEFAULT_LINK_POLICY        0x000F

#define OCF_FLOW_SPECIFICATION                0x0010

#define OCF_SNIFF_SUBRATE                0x0011

typedef struct {

    uint16_t        handle;

    uint16_t        max_remote_latency;

    uint16_t        max_local_latency;

    uint16_t        min_remote_timeout;

    uint16_t        min_local_timeout;

} __attribute__ ((packed)) sniff_subrate_cp;

#define SNIFF_SUBRATE_CP_SIZE 10

/* Host Controller and Baseband */

#define OGF_HOST_CTL                0x03

#define OCF_SET_EVENT_MASK                0x0001

typedef struct {

    uint8_t        mask[8];

} __attribute__ ((packed)) set_event_mask_cp;

#define SET_EVENT_MASK_CP_SIZE 8

#define OCF_RESET                        0x0003

#define OCF_SET_EVENT_FLT                0x0005

typedef struct {

    uint8_t        flt_type;

    uint8_t        cond_type;

    uint8_t        condition[0];

} __attribute__ ((packed)) set_event_flt_cp;

#define SET_EVENT_FLT_CP_SIZE 2

enum bt_filter_type {

    FLT_CLEAR_ALL                = 0x00,

    FLT_INQ_RESULT                = 0x01,

    FLT_CONN_SETUP                = 0x02,

};

enum inq_result_cond_type {

    INQ_RESULT_RETURN_ALL        = 0x00,

    INQ_RESULT_RETURN_CLASS        = 0x01,

    INQ_RESULT_RETURN_BDADDR        = 0x02,

};

enum conn_setup_cond_type {

    CONN_SETUP_ALLOW_ALL        = 0x00,

    CONN_SETUP_ALLOW_CLASS        = 0x01,

    CONN_SETUP_ALLOW_BDADDR        = 0x02,

};

enum conn_setup_cond {

    CONN_SETUP_AUTO_OFF                = 0x01,

    CONN_SETUP_AUTO_ON                = 0x02,

};

#define OCF_FLUSH                        0x0008

typedef struct {

    uint16_t        handle;

} __attribute__ ((packed)) flush_cp;

#define FLUSH_CP_SIZE 2

typedef struct {

    uint8_t        status;

    uint16_t        handle;

} __attribute__ ((packed)) flush_rp;

#define FLUSH_RP_SIZE 3

#define OCF_READ_PIN_TYPE                0x0009

typedef struct {

    uint8_t        status;

    uint8_t        pin_type;

} __attribute__ ((packed)) read_pin_type_rp;

#define READ_PIN_TYPE_RP_SIZE 2

#define OCF_WRITE_PIN_TYPE                0x000A

typedef struct {

    uint8_t        pin_type;

} __attribute__ ((packed)) write_pin_type_cp;

#define WRITE_PIN_TYPE_CP_SIZE 1

#define OCF_CREATE_NEW_UNIT_KEY                0x000B

#define OCF_READ_STORED_LINK_KEY        0x000D

typedef struct {

    bdaddr_t        bdaddr;

    uint8_t        read_all;

} __attribute__ ((packed)) read_stored_link_key_cp;

#define READ_STORED_LINK_KEY_CP_SIZE 7

typedef struct {

    uint8_t        status;

    uint16_t        max_keys;

    uint16_t        num_keys;

} __attribute__ ((packed)) read_stored_link_key_rp;

#define READ_STORED_LINK_KEY_RP_SIZE 5

#define OCF_WRITE_STORED_LINK_KEY        0x0011

typedef struct {

    uint8_t        num_keys;

    /* variable length part */

} __attribute__ ((packed)) write_stored_link_key_cp;

#define WRITE_STORED_LINK_KEY_CP_SIZE 1

typedef struct {

    uint8_t        status;

    uint8_t        num_keys;

} __attribute__ ((packed)) write_stored_link_key_rp;

#define READ_WRITE_LINK_KEY_RP_SIZE 2

#define OCF_DELETE_STORED_LINK_KEY        0x0012

typedef struct {

    bdaddr_t        bdaddr;

    uint8_t        delete_all;

} __attribute__ ((packed)) delete_stored_link_key_cp;