/*

 * 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