AetherDroid/android_kernel_samsung_on5xelte
1
0
Fork 0
mirror of https://github.com/AetherDroid/android_kernel_samsung_on5xelte.git synced 2025-09-08 17:18:05 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Fixed MTP to work with TWRP

Browse source
This commit is contained in:
awab228 2018-06-19 23:16:04 +02:00
commit f6dfaef42e
50820 changed files with 20846062 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

3
drivers/misc/samsung/scsc_bt/Kconfig Normal file
View file

@ -0,0 +1,3 @@
config SCSC_BT
tristate "SCSC MX BT support"
depends on SCSC_CORE

18
drivers/misc/samsung/scsc_bt/Makefile Normal file
View file

@ -0,0 +1,18 @@
# Needed since this subdir is symlinked in the main Kernel tree
# without this our samsung subdir is NOT cleaned.
clean-files := *.o *.ko
#
# Maxwell BT
obj-$(CONFIG_SCSC_BT) += scsc_bt.o
scsc_bt-y += scsc_bt_module.o scsc_shm.o scsc_avdtp_detect.o scsc_bt_dump.o
ccflags-y += $(CONFIG_SAMSUNG_MAXWELL_EXTRA)
## See sibling scsc/ Makefile for an explanation of the reasons of
## the following ifeq/else
ifeq ($(CONFIG_SCSC_DEBUG), m)
ccflags-y += -DCONFIG_SCSC_PRINTK
else
ccflags-$(CONFIG_SCSC_DEBUG) += -DCONFIG_SCSC_PRINTK
endif

344
drivers/misc/samsung/scsc_bt/scsc_avdtp_detect.c Normal file
View file

@ -0,0 +1,344 @@
/****************************************************************************
*
* Copyright (c) 2015 Samsung Electronics Co., Ltd
*
****************************************************************************/
/* MX BT shared memory interface */
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/module.h>
#include <linux/firmware.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/cdev.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/uaccess.h>
#include <linux/wait.h>
#include <linux/kthread.h>
#include <asm/io.h>
#include <linux/wakelock.h>
#include <scsc/scsc_mx.h>
#include <scsc/scsc_mifram.h>
#include <scsc/api/bsmhcp.h>
#include <scsc/scsc_logring.h>
#include "scsc_bt_priv.h"
#include "scsc_shm.h"
/**
* Coex AVDTP detection.
*
* Strategy:
*
* - On the L2CAP signaling CID, look for connect requests with the AVDTP PSM
*
* - Assume the first AVDTP connection is the signaling channel.
* (AVDTP 1.3, section 5.4.6 "Transport and Signaling Channel Establishment")
*
* - If a signaling channel exists, assume the next connection is the streaming channel
*
* - If a streaming channel exists, look for AVDTP start, suspend, abort and close signals
* -- When one of these is found, signal the FW with updated acl_id and cid
*
* - If the ACL is torn down, make sure to clean up.
*
* */
/* All of the functions are duplicated for the Rx and Tx directions, since these run in separate
* threads, and might otherwise step on each other's toes by changing the "data" pointer in
* mid-inspection */
/* All four return true if the bsmhcp header should be updated */
bool scsc_avdtp_detect_connection_tx(uint16_t hci_connection_handle, const unsigned char *data, uint16_t length)
{
uint8_t code = 0;
if (length < AVDTP_DETECT_MIN_DATA_LENGTH) {
SCSC_TAG_DEBUG(BT_H4, "Ignoring L2CAP signal, length %u)\n", length);
return false;
}
code = HCI_L2CAP_CODE(data);
switch (code) {
case L2CAP_CODE_CONNECT_REQ:
{
if (HCI_L2CAP_CON_REQ_PSM(data) == L2CAP_AVDTP_PSM) {
if (bt_service.avdtp_signaling_src_cid == 0) {
bt_service.avdtp_signaling_src_cid = HCI_L2CAP_SOURCE_CID(data);
SCSC_TAG_DEBUG(BT_H4, "Signaling dst CID: 0x%04X, src CID: 0x%04X)\n",
bt_service.avdtp_signaling_dst_cid,
bt_service.avdtp_signaling_src_cid);
} else {
bt_service.avdtp_streaming_src_cid = HCI_L2CAP_SOURCE_CID(data);
SCSC_TAG_DEBUG(BT_H4, "Streaming dst CID: 0x%04X, src CID: 0x%04X)\n",
bt_service.avdtp_streaming_dst_cid,
bt_service.avdtp_streaming_src_cid);
}
}
break;
}
case L2CAP_CODE_CONNECT_RSP:
{
if (length < AVDTP_DETECT_MIN_DATA_LENGTH_CON_RSP) {
SCSC_TAG_WARNING(BT_H4, "Ignoring L2CAP CON RSP in short packet, length %u)\n",
length);
return false;
}
if (bt_service.avdtp_signaling_src_cid == HCI_L2CAP_SOURCE_CID(data) &&
HCI_L2CAP_CON_RSP_RESULT(data) == HCI_L2CAP_CON_RSP_RESULT_SUCCESS &&
bt_service.avdtp_signaling_dst_cid == 0) {
/* We're responding, so the src cid is actually the remote cid. flip them */
bt_service.avdtp_signaling_dst_cid = bt_service.avdtp_signaling_src_cid;
bt_service.avdtp_signaling_src_cid = HCI_L2CAP_RSP_DEST_CID(data);
bt_service.avdtp_hci_connection_handle = hci_connection_handle;
SCSC_TAG_DEBUG(BT_H4, "Signaling dst CID: 0x%04X, src CID: 0x%04X)\n",
bt_service.avdtp_signaling_dst_cid, bt_service.avdtp_signaling_src_cid);
} else if (bt_service.avdtp_streaming_src_cid == HCI_L2CAP_SOURCE_CID(data) &&
HCI_L2CAP_CON_RSP_RESULT(data) == HCI_L2CAP_CON_RSP_RESULT_SUCCESS &&
bt_service.avdtp_streaming_dst_cid == 0) {
/* We're responding, so the src cid is actually the remote cid. flip them */
bt_service.avdtp_streaming_dst_cid = bt_service.avdtp_streaming_src_cid;
bt_service.avdtp_streaming_src_cid = HCI_L2CAP_RSP_DEST_CID(data);
SCSC_TAG_DEBUG(BT_H4, "Streaming dst CID: 0x%04X, src CID: 0x%04X)\n",
bt_service.avdtp_streaming_dst_cid, bt_service.avdtp_streaming_src_cid);
}
break;
}
case L2CAP_CODE_DISCONNECT_REQ:
{
/* Our src cid always holds the local CID. When looking at the disconnect req in the Tx
* direction, that's also termed the src cid in the AVDTP signal */
if (bt_service.avdtp_signaling_src_cid == HCI_L2CAP_SOURCE_CID(data)) {
SCSC_TAG_DEBUG(BT_H4, "Signaling src CID disconnected: 0x%04X (dst CID: 0x%04X)\n",
bt_service.avdtp_signaling_src_cid,
bt_service.avdtp_signaling_dst_cid);
bt_service.avdtp_signaling_src_cid = bt_service.avdtp_signaling_dst_cid = 0;
bt_service.avdtp_streaming_src_cid = bt_service.avdtp_streaming_dst_cid = 0;
bt_service.avdtp_hci_connection_handle = 0;
} else if (bt_service.avdtp_streaming_src_cid == HCI_L2CAP_SOURCE_CID(data)) {
SCSC_TAG_DEBUG(BT_H4, "Streaming src CID disconnected: 0x%04X (dst CID: 0x%04X)\n",
bt_service.avdtp_streaming_src_cid,
bt_service.avdtp_streaming_dst_cid);
bt_service.avdtp_streaming_src_cid = bt_service.avdtp_streaming_dst_cid = 0;
return true;
}
break;
}
default:
break;
}
return false;
}
bool scsc_avdtp_detect_connection_rx(uint16_t hci_connection_handle, const unsigned char *data, uint16_t length)
{
uint8_t code = 0;
if (length < AVDTP_DETECT_MIN_DATA_LENGTH) {
SCSC_TAG_DEBUG(BT_H4, "Ignoring L2CAP signal, length %u)\n",
length);
return false;
}
code = HCI_L2CAP_CODE(data);
switch (code) {
case L2CAP_CODE_CONNECT_REQ:
{
if (HCI_L2CAP_CON_REQ_PSM(data) == L2CAP_AVDTP_PSM) {
if (bt_service.avdtp_signaling_src_cid == 0) {
/* In the Rx direction, the AVDTP source cid is the remote cid, but we'll save it
* as the source cid for now, and flip them when we see a response. */
bt_service.avdtp_signaling_src_cid = HCI_L2CAP_SOURCE_CID(data);
SCSC_TAG_DEBUG(BT_H4, "Signaling dst CID: 0x%04X, src CID: 0x%04X\n",
bt_service.avdtp_signaling_dst_cid,
bt_service.avdtp_signaling_src_cid);
} else {
/* In the Rx direction, the AVDTP source cid is the remote cid, but we'll save it
* as the source cid for now, and flip them when we see a response. */
bt_service.avdtp_streaming_src_cid = HCI_L2CAP_SOURCE_CID(data);
SCSC_TAG_DEBUG(BT_H4, "Streaming dst CID: 0x%04X, src CID: 0x%04X\n",
bt_service.avdtp_streaming_dst_cid,
bt_service.avdtp_streaming_src_cid);
}
}
break;
}
case L2CAP_CODE_CONNECT_RSP:
{
if (length < AVDTP_DETECT_MIN_DATA_LENGTH_CON_RSP) {
SCSC_TAG_WARNING(BT_H4, "Ignoring L2CAP CON RSP in short packet, length %u)\n",
length);
return false;
}
if (bt_service.avdtp_signaling_src_cid == HCI_L2CAP_SOURCE_CID(data) &&
HCI_L2CAP_CON_RSP_RESULT(data) == HCI_L2CAP_CON_RSP_RESULT_SUCCESS &&
bt_service.avdtp_signaling_dst_cid == 0) {
bt_service.avdtp_signaling_dst_cid = HCI_L2CAP_RSP_DEST_CID(data);
bt_service.avdtp_hci_connection_handle = hci_connection_handle;
SCSC_TAG_DEBUG(BT_H4, "Signaling dst CID: 0x%04X, src CID: 0x%04X)\n",
bt_service.avdtp_signaling_dst_cid, bt_service.avdtp_signaling_src_cid);
} else if (bt_service.avdtp_streaming_src_cid == HCI_L2CAP_SOURCE_CID(data) &&
HCI_L2CAP_CON_RSP_RESULT(data) == HCI_L2CAP_CON_RSP_RESULT_SUCCESS &&
bt_service.avdtp_streaming_dst_cid == 0){
bt_service.avdtp_streaming_dst_cid = HCI_L2CAP_RSP_DEST_CID(data);
SCSC_TAG_DEBUG(BT_H4, "Streaming dst CID: 0x%04X, src CID: 0x%04X)\n",
bt_service.avdtp_streaming_dst_cid, bt_service.avdtp_streaming_src_cid);
}
break;
}
case L2CAP_CODE_DISCONNECT_REQ:
{
/* Our "dst" variable always holds the remote CID. This may be the source or destination CID
* in the signal, depending on the direction of traffic we're snooping... */
if (bt_service.avdtp_signaling_src_cid == HCI_L2CAP_RSP_DEST_CID(data)) {
SCSC_TAG_DEBUG(BT_H4, "Signaling src CID disconnected: 0x%04X (dst CID: 0x%04X)\n",
bt_service.avdtp_signaling_src_cid,
bt_service.avdtp_signaling_dst_cid);
bt_service.avdtp_signaling_src_cid = bt_service.avdtp_signaling_dst_cid = 0;
bt_service.avdtp_streaming_src_cid = bt_service.avdtp_streaming_dst_cid = 0;
bt_service.avdtp_hci_connection_handle = 0;
} else if (bt_service.avdtp_streaming_src_cid == HCI_L2CAP_RSP_DEST_CID(data)) {
SCSC_TAG_DEBUG(BT_H4, "Streaming CID disconnected: 0x%04X (dst CID: 0x%04X)\n",
bt_service.avdtp_streaming_src_cid,
bt_service.avdtp_streaming_dst_cid);
bt_service.avdtp_streaming_src_cid = bt_service.avdtp_streaming_dst_cid = 0;
return true;
}
break;
}
default:
break;
}
return false;
}
uint8_t scsc_avdtp_detect_signaling_tx(const unsigned char *data)
{
u8 signal_id = AVDTP_SIGNAL_ID(data);
u8 message_type = AVDTP_MESSAGE_TYPE(data);
SCSC_TAG_DEBUG(BT_H4, "id: 0x%02X, type: 0x%02X)\n", signal_id, message_type);
if (message_type == AVDTP_MESSAGE_TYPE_RSP_ACCEPT) {
if (signal_id == AVDTP_SIGNAL_ID_START)
return AVDTP_DETECT_SIGNALING_ACTIVE;
else if (signal_id == AVDTP_SIGNAL_ID_CLOSE || signal_id == AVDTP_SIGNAL_ID_SUSPEND ||
signal_id == AVDTP_SIGNAL_ID_ABORT)
return AVDTP_DETECT_SIGNALING_INACTIVE;
}
return AVDTP_DETECT_SIGNALING_IGNORE;
}
uint8_t scsc_avdtp_detect_signaling_rx(const unsigned char *data)
{
u8 signal_id = AVDTP_SIGNAL_ID(data);
#ifdef CONFIG_SCSC_PRINTK
u8 message_type = AVDTP_MESSAGE_TYPE(data);
#endif
SCSC_TAG_DEBUG(BT_H4, "id: 0x%02X, type: 0x%02X)\n", signal_id, message_type);
if (AVDTP_MESSAGE_TYPE(data) == AVDTP_MESSAGE_TYPE_RSP_ACCEPT) {
if (signal_id == AVDTP_SIGNAL_ID_START)
return AVDTP_DETECT_SIGNALING_ACTIVE;
else if (signal_id == AVDTP_SIGNAL_ID_CLOSE || signal_id == AVDTP_SIGNAL_ID_SUSPEND ||
signal_id == AVDTP_SIGNAL_ID_ABORT)
return AVDTP_DETECT_SIGNALING_INACTIVE;
}
return AVDTP_DETECT_SIGNALING_IGNORE;
}
void scsc_avdtp_detect_tx(u16 hci_connection_handle, const unsigned char *data, uint16_t length)
{
/* Look for AVDTP connections */
bool avdtp_gen_bg_int = false;
uint16_t cid_to_fw = 0;
if (HCI_L2CAP_RX_CID((const unsigned char *)(data)) == L2CAP_SIGNALING_CID) {
if (scsc_avdtp_detect_connection_tx(hci_connection_handle, data, length)) {
avdtp_gen_bg_int = true;
cid_to_fw = bt_service.avdtp_streaming_dst_cid;
}
} else if (bt_service.avdtp_signaling_dst_cid != 0 &&
bt_service.avdtp_signaling_dst_cid == HCI_L2CAP_RX_CID((const unsigned char *)(data)) &&
length >= AVDTP_DETECT_MIN_AVDTP_LENGTH) {
uint8_t result = scsc_avdtp_detect_signaling_tx(data);
if (result != AVDTP_DETECT_SIGNALING_IGNORE) {
avdtp_gen_bg_int = true;
if (result != AVDTP_DETECT_SIGNALING_INACTIVE)
cid_to_fw = bt_service.avdtp_streaming_dst_cid;
}
}
if (avdtp_gen_bg_int) {
bt_service.bsmhcp_protocol->header.avdtp_detect_stream_id = cid_to_fw |
(bt_service.avdtp_hci_connection_handle << 16);
SCSC_TAG_DEBUG(BT_H4, "Found AVDTP signal. aclid: 0x%04X, cid: 0x%04X, streamid: 0x%08X\n",
bt_service.avdtp_hci_connection_handle,
cid_to_fw,
bt_service.bsmhcp_protocol->header.avdtp_detect_stream_id);
mmiowb();
scsc_service_mifintrbit_bit_set(bt_service.service,
bt_service.bsmhcp_protocol->header.ap_to_bg_int_src, SCSC_MIFINTR_TARGET_R4);
}
}
void scsc_avdtp_detect_rx(u16 hci_connection_handle, const unsigned char *data, uint16_t length)
{
bool avdtp_gen_bg_int = false;
uint16_t cid_to_fw = 0;
/* Look for AVDTP connections */
if (HCI_L2CAP_RX_CID((const unsigned char *)(data)) == L2CAP_SIGNALING_CID) {
if (scsc_avdtp_detect_connection_rx(hci_connection_handle,
(const unsigned char *)(data), length)) {
avdtp_gen_bg_int = true;
cid_to_fw = bt_service.avdtp_streaming_dst_cid;
}
} else if (bt_service.avdtp_signaling_src_cid != 0 &&
HCI_L2CAP_RX_CID((const unsigned char *)(data)) == bt_service.avdtp_signaling_src_cid &&
length >= AVDTP_DETECT_MIN_AVDTP_LENGTH) {
uint8_t result = scsc_avdtp_detect_signaling_rx((const unsigned char *)(data));
if (result != AVDTP_DETECT_SIGNALING_IGNORE) {
avdtp_gen_bg_int = true;
if (result != AVDTP_DETECT_SIGNALING_INACTIVE)
cid_to_fw = bt_service.avdtp_streaming_dst_cid;
}
}
if (avdtp_gen_bg_int) {
bt_service.bsmhcp_protocol->header.avdtp_detect_stream_id =
cid_to_fw | (bt_service.avdtp_hci_connection_handle << 16);
SCSC_TAG_DEBUG(BT_H4, "Found AVDTP signal. aclid: 0x%04X, cid: 0x%04X, streamid: 0x%08X\n",
bt_service.avdtp_hci_connection_handle,
cid_to_fw,
bt_service.bsmhcp_protocol->header.avdtp_detect_stream_id);
mmiowb();
scsc_service_mifintrbit_bit_set(bt_service.service,
bt_service.bsmhcp_protocol->header.ap_to_bg_int_src, SCSC_MIFINTR_TARGET_R4);
}
}

529
drivers/misc/samsung/scsc_bt/scsc_bt_dump.c Executable file
View file

@ -0,0 +1,529 @@
/****************************************************************************
*
* Copyright (c) 2014 - 2016 Samsung Electronics Co., Ltd. All rights reserved
*
* BT information dumper
*
****************************************************************************/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/poll.h>
#include <linux/wakelock.h>
#include "scsc_bt_priv.h"
#include "scsc_bt_hci.h"
static char scsc_hci_evt_decode_buffer[512];
const char *scsc_hci_evt_decode_command_code(u16 hci_command_code)
{
const char *ret = "NA";
switch (hci_command_code) {
HCI_CMD_DECODE(HCI_INQUIRY);
HCI_CMD_DECODE(HCI_INQUIRY_CANCEL);
HCI_CMD_DECODE(HCI_PERIODIC_INQUIRY_MODE);
HCI_CMD_DECODE(HCI_EXIT_PERIODIC_INQUIRY_MODE);
HCI_CMD_DECODE(HCI_CREATE_CONNECTION);
HCI_CMD_DECODE(HCI_DISCONNECT);
HCI_CMD_DECODE(HCI_ADD_SCO_CONNECTION);
HCI_CMD_DECODE(HCI_CREATE_CONNECTION_CANCEL);
HCI_CMD_DECODE(HCI_ACCEPT_CONNECTION_REQ);
HCI_CMD_DECODE(HCI_REJECT_CONNECTION_REQ);
HCI_CMD_DECODE(HCI_LINK_KEY_REQ_REPLY);
HCI_CMD_DECODE(HCI_LINK_KEY_REQ_NEG_REPLY);
HCI_CMD_DECODE(HCI_PIN_CODE_REQ_REPLY);
HCI_CMD_DECODE(HCI_PIN_CODE_REQ_NEG_REPLY);
HCI_CMD_DECODE(HCI_CHANGE_CONN_PKT_TYPE);
HCI_CMD_DECODE(HCI_AUTH_REQ);
HCI_CMD_DECODE(HCI_SET_CONN_ENCRYPTION);
HCI_CMD_DECODE(HCI_CHANGE_CONN_LINK_KEY);
HCI_CMD_DECODE(HCI_MASTER_LINK_KEY);
HCI_CMD_DECODE(HCI_REMOTE_NAME_REQ);
HCI_CMD_DECODE(HCI_REMOTE_NAME_REQ_CANCEL);
HCI_CMD_DECODE(HCI_READ_REMOTE_SUPP_FEATURES);
HCI_CMD_DECODE(HCI_READ_REMOTE_EXT_FEATURES);
HCI_CMD_DECODE(HCI_READ_REMOTE_VER_INFO);
HCI_CMD_DECODE(HCI_READ_CLOCK_OFFSET);
HCI_CMD_DECODE(HCI_READ_LMP_HANDLE);
HCI_CMD_DECODE(HCI_EXCHANGE_FIXED_INFO);
HCI_CMD_DECODE(HCI_EXCHANGE_ALIAS_INFO);
HCI_CMD_DECODE(HCI_PRIVATE_PAIRING_REQ_REPLY);
HCI_CMD_DECODE(HCI_PRIVATE_PAIRING_REQ_NEG_REPLY);
HCI_CMD_DECODE(HCI_GENERATED_ALIAS);
HCI_CMD_DECODE(HCI_ALIAS_ADDRESS_REQ_REPLY);
HCI_CMD_DECODE(HCI_ALIAS_ADDRESS_REQ_NEG_REPLY);
HCI_CMD_DECODE(HCI_SETUP_SYNCHRONOUS_CONN);
HCI_CMD_DECODE(HCI_ACCEPT_SYNCHRONOUS_CONN_REQ);
HCI_CMD_DECODE(HCI_REJECT_SYNCHRONOUS_CONN_REQ);
HCI_CMD_DECODE(HCI_IO_CAPABILITY_REQUEST_REPLY);
HCI_CMD_DECODE(HCI_USER_CONFIRMATION_REQUEST_REPLY);
HCI_CMD_DECODE(HCI_USER_CONFIRMATION_REQUEST_NEG_REPLY);
HCI_CMD_DECODE(HCI_USER_PASSKEY_REQUEST_REPLY);
HCI_CMD_DECODE(HCI_USER_PASSKEY_REQUEST_NEG_REPLY);
HCI_CMD_DECODE(HCI_REMOTE_OOB_DATA_REQUEST_REPLY);
HCI_CMD_DECODE(HCI_REMOTE_OOB_DATA_REQUEST_NEG_REPLY);
HCI_CMD_DECODE(HCI_IO_CAPABILITY_REQUEST_NEG_REPLY);
HCI_CMD_DECODE(HCI_ENHANCED_SETUP_SYNC_CONN);
HCI_CMD_DECODE(HCI_ENHANCED_ACCEPT_SYNC_CONN_REQ);
HCI_CMD_DECODE(HCI_TRUNCATED_PAGE);
HCI_CMD_DECODE(HCI_TRUNCATED_PAGE_CANCEL);
HCI_CMD_DECODE(HCI_SET_CSB);
HCI_CMD_DECODE(HCI_SET_CSB_RECEIVE);
HCI_CMD_DECODE(HCI_START_SYNCHRONIZATION_TRAIN);
HCI_CMD_DECODE(HCI_RECEIVE_SYNCHRONIZATION_TRAIN);
HCI_CMD_DECODE(HCI_REMOTE_OOB_EXTENDED_DATA_REQUEST_REPLY);
HCI_CMD_DECODE(HCI_HOLD_MODE);
HCI_CMD_DECODE(HCI_SNIFF_MODE);
HCI_CMD_DECODE(HCI_EXIT_SNIFF_MODE);
HCI_CMD_DECODE(HCI_PARK_MODE);
HCI_CMD_DECODE(HCI_EXIT_PARK_MODE);
HCI_CMD_DECODE(HCI_QOS_SETUP);
HCI_CMD_DECODE(HCI_ROLE_DISCOVERY);
HCI_CMD_DECODE(HCI_SWITCH_ROLE);
HCI_CMD_DECODE(HCI_READ_LINK_POLICY_SETTINGS);
HCI_CMD_DECODE(HCI_WRITE_LINK_POLICY_SETTINGS);
HCI_CMD_DECODE(HCI_READ_DEFAULT_LINK_POLICY_SETTINGS);
HCI_CMD_DECODE(HCI_WRITE_DEFAULT_LINK_POLICY_SETTINGS);
HCI_CMD_DECODE(HCI_FLOW_SPEC);
HCI_CMD_DECODE(HCI_SNIFF_SUB_RATE);
HCI_CMD_DECODE(HCI_SET_EVENT_MASK);
HCI_CMD_DECODE(HCI_RESET);
HCI_CMD_DECODE(HCI_SET_EVENT_FILTER);
HCI_CMD_DECODE(HCI_FLUSH);
HCI_CMD_DECODE(HCI_READ_PIN_TYPE);
HCI_CMD_DECODE(HCI_WRITE_PIN_TYPE);
HCI_CMD_DECODE(HCI_CREATE_NEW_UNIT_KEY);
HCI_CMD_DECODE(HCI_READ_STORED_LINK_KEY);
HCI_CMD_DECODE(HCI_WRITE_STORED_LINK_KEY);
HCI_CMD_DECODE(HCI_DELETE_STORED_LINK_KEY);
HCI_CMD_DECODE(HCI_CHANGE_LOCAL_NAME);
HCI_CMD_DECODE(HCI_READ_LOCAL_NAME);
HCI_CMD_DECODE(HCI_READ_CONN_ACCEPT_TIMEOUT);
HCI_CMD_DECODE(HCI_WRITE_CONN_ACCEPT_TIMEOUT);
HCI_CMD_DECODE(HCI_READ_PAGE_TIMEOUT);
HCI_CMD_DECODE(HCI_WRITE_PAGE_TIMEOUT);
HCI_CMD_DECODE(HCI_READ_SCAN_ENABLE);
HCI_CMD_DECODE(HCI_WRITE_SCAN_ENABLE);
HCI_CMD_DECODE(HCI_READ_PAGESCAN_ACTIVITY);
HCI_CMD_DECODE(HCI_WRITE_PAGESCAN_ACTIVITY);
HCI_CMD_DECODE(HCI_READ_INQUIRYSCAN_ACTIVITY);
HCI_CMD_DECODE(HCI_WRITE_INQUIRYSCAN_ACTIVITY);
HCI_CMD_DECODE(HCI_READ_AUTH_ENABLE);
HCI_CMD_DECODE(HCI_WRITE_AUTH_ENABLE);
HCI_CMD_DECODE(HCI_READ_ENC_MODE);
HCI_CMD_DECODE(HCI_WRITE_ENC_MODE);
HCI_CMD_DECODE(HCI_READ_CLASS_OF_DEVICE);
HCI_CMD_DECODE(HCI_WRITE_CLASS_OF_DEVICE);
HCI_CMD_DECODE(HCI_READ_VOICE_SETTING);
HCI_CMD_DECODE(HCI_WRITE_VOICE_SETTING);
HCI_CMD_DECODE(HCI_READ_AUTO_FLUSH_TIMEOUT);
HCI_CMD_DECODE(HCI_WRITE_AUTO_FLUSH_TIMEOUT);
HCI_CMD_DECODE(HCI_READ_NUM_BCAST_RETXS);
HCI_CMD_DECODE(HCI_WRITE_NUM_BCAST_RETXS);
HCI_CMD_DECODE(HCI_READ_HOLD_MODE_ACTIVITY);
HCI_CMD_DECODE(HCI_WRITE_HOLD_MODE_ACTIVITY);
HCI_CMD_DECODE(HCI_READ_TX_POWER_LEVEL);
HCI_CMD_DECODE(HCI_READ_SCO_FLOW_CON_ENABLE);
HCI_CMD_DECODE(HCI_WRITE_SCO_FLOW_CON_ENABLE);
HCI_CMD_DECODE(HCI_SET_HCTOHOST_FLOW_CONTROL);
HCI_CMD_DECODE(HCI_HOST_BUFFER_SIZE);
HCI_CMD_DECODE(HCI_HOST_NUM_COMPLETED_PACKETS);
HCI_CMD_DECODE(HCI_READ_LINK_SUPERV_TIMEOUT);
HCI_CMD_DECODE(HCI_WRITE_LINK_SUPERV_TIMEOUT);
HCI_CMD_DECODE(HCI_READ_NUM_SUPPORTED_IAC);
HCI_CMD_DECODE(HCI_READ_CURRENT_IAC_LAP);
HCI_CMD_DECODE(HCI_WRITE_CURRENT_IAC_LAP);
HCI_CMD_DECODE(HCI_READ_PAGESCAN_PERIOD_MODE);
HCI_CMD_DECODE(HCI_WRITE_PAGESCAN_PERIOD_MODE);
HCI_CMD_DECODE(HCI_READ_PAGESCAN_MODE);
HCI_CMD_DECODE(HCI_WRITE_PAGESCAN_MODE);
HCI_CMD_DECODE(HCI_SET_AFH_CHANNEL_CLASS);
HCI_CMD_DECODE(HCI_READ_INQUIRY_SCAN_TYPE);
HCI_CMD_DECODE(HCI_WRITE_INQUIRY_SCAN_TYPE);
HCI_CMD_DECODE(HCI_READ_INQUIRY_MODE);
HCI_CMD_DECODE(HCI_WRITE_INQUIRY_MODE);
HCI_CMD_DECODE(HCI_READ_PAGE_SCAN_TYPE);
HCI_CMD_DECODE(HCI_WRITE_PAGE_SCAN_TYPE);
HCI_CMD_DECODE(HCI_READ_AFH_CHANNEL_CLASS_M);
HCI_CMD_DECODE(HCI_WRITE_AFH_CHANNEL_CLASS_M);
HCI_CMD_DECODE(HCI_READ_ANON_MODE);
HCI_CMD_DECODE(HCI_WRITE_ANON_MODE);
HCI_CMD_DECODE(HCI_READ_ALIAS_AUTH_ENABLE);
HCI_CMD_DECODE(HCI_WRITE_ALIAS_AUTH_ENABLE);
HCI_CMD_DECODE(HCI_READ_ANON_ADDR_CHANGE_PARAMS);
HCI_CMD_DECODE(HCI_WRITE_ANON_ADDR_CHANGE_PARAMS);
HCI_CMD_DECODE(HCI_RESET_FIXED_ADDRESS_ATTEMPTS_COUNTER);
HCI_CMD_DECODE(HCI_READ_EXTENDED_INQUIRY_RESPONSE_DATA);
HCI_CMD_DECODE(HCI_WRITE_EXTENDED_INQUIRY_RESPONSE_DATA);
HCI_CMD_DECODE(HCI_REFRESH_ENCRYPTION_KEY);
HCI_CMD_DECODE(HCI_READ_SIMPLE_PAIRING_MODE);
HCI_CMD_DECODE(HCI_WRITE_SIMPLE_PAIRING_MODE);
HCI_CMD_DECODE(HCI_READ_LOCAL_OOB_DATA);
HCI_CMD_DECODE(HCI_READ_INQUIRY_RESPONSE_TX_POWER_LEVEL);
HCI_CMD_DECODE(HCI_WRITE_INQUIRY_TRANSMIT_POWER_LEVEL);
HCI_CMD_DECODE(HCI_ENHANCED_FLUSH);
HCI_CMD_DECODE(HCI_SEND_KEYPRESS_NOTIFICATION);
HCI_CMD_DECODE(HCI_SET_EVENT_MASK_PAGE_2);
HCI_CMD_DECODE(HCI_READ_ENH_TX_POWER_LEVEL);
HCI_CMD_DECODE(HCI_READ_LE_HOST_SUPPORT);
HCI_CMD_DECODE(HCI_WRITE_LE_HOST_SUPPORT);
HCI_CMD_DECODE(HCI_SET_RESERVED_LT_ADDR);
HCI_CMD_DECODE(HCI_DELETE_RESERVED_LT_ADDR);
HCI_CMD_DECODE(HCI_SET_CSB_DATA);
HCI_CMD_DECODE(HCI_READ_SYNCHRONIZATION_TRAIN_PARAMS);
HCI_CMD_DECODE(HCI_WRITE_SYNCHRONIZATION_TRAIN_PARAMS);
HCI_CMD_DECODE(HCI_READ_SECURE_CONNECTIONS_HOST_SUPPORT);
HCI_CMD_DECODE(HCI_WRITE_SECURE_CONNECTIONS_HOST_SUPPORT);
HCI_CMD_DECODE(HCI_READ_AUTHENTICATED_PAYLOAD_TIMEOUT);
HCI_CMD_DECODE(HCI_WRITE_AUTHENTICATED_PAYLOAD_TIMEOUT);
HCI_CMD_DECODE(HCI_READ_LOCAL_OOB_EXTENDED_DATA);
HCI_CMD_DECODE(HCI_READ_LOCAL_VER_INFO);
HCI_CMD_DECODE(HCI_READ_LOCAL_SUPP_COMMANDS);
HCI_CMD_DECODE(HCI_READ_LOCAL_SUPP_FEATURES);
HCI_CMD_DECODE(HCI_READ_LOCAL_EXT_FEATURES);
HCI_CMD_DECODE(HCI_READ_BUFFER_SIZE);
HCI_CMD_DECODE(HCI_READ_COUNTRY_CODE);
HCI_CMD_DECODE(HCI_READ_BD_ADDR);
HCI_CMD_DECODE(HCI_READ_LOCAL_SUPP_CODECS);
HCI_CMD_DECODE(HCI_READ_FAILED_CONTACT_COUNT);
HCI_CMD_DECODE(HCI_RESET_FAILED_CONTACT_COUNT);
HCI_CMD_DECODE(HCI_GET_LINK_QUALITY);
HCI_CMD_DECODE(HCI_READ_RSSI);
HCI_CMD_DECODE(HCI_READ_AFH_CHANNEL_MAP);
HCI_CMD_DECODE(HCI_READ_CLOCK);
HCI_CMD_DECODE(HCI_READ_ENCRYPTION_KEY_SIZE);
HCI_CMD_DECODE(HCI_SET_TRIGGERED_CLOCK_CAPTURE);
HCI_CMD_DECODE(HCI_READ_LOOPBACK_MODE);
HCI_CMD_DECODE(HCI_WRITE_LOOPBACK_MODE);
HCI_CMD_DECODE(HCI_ENABLE_DUT_MODE);
HCI_CMD_DECODE(HCI_WRITE_SIMPLE_PAIRING_DEBUG_MODE);
HCI_CMD_DECODE(HCI_WRITE_SECURE_CONNECTIONS_TEST_MODE);
HCI_CMD_DECODE(HCI_ULP_SET_EVENT_MASK);
HCI_CMD_DECODE(HCI_ULP_READ_BUFFER_SIZE);
HCI_CMD_DECODE(HCI_ULP_READ_LOCAL_SUPPORTED_FEATURES);
HCI_CMD_DECODE(HCI_ULP_SET_RANDOM_ADDRESS);
HCI_CMD_DECODE(HCI_ULP_SET_ADVERTISING_PARAMETERS);
HCI_CMD_DECODE(HCI_ULP_READ_ADVERTISING_CHANNEL_TX_POWER);
HCI_CMD_DECODE(HCI_ULP_SET_ADVERTISING_DATA);
HCI_CMD_DECODE(HCI_ULP_SET_SCAN_RESPONSE_DATA);
HCI_CMD_DECODE(HCI_ULP_SET_ADVERTISE_ENABLE);
HCI_CMD_DECODE(HCI_ULP_SET_SCAN_PARAMETERS);
HCI_CMD_DECODE(HCI_ULP_SET_SCAN_ENABLE);
HCI_CMD_DECODE(HCI_ULP_CREATE_CONNECTION);
HCI_CMD_DECODE(HCI_ULP_CREATE_CONNECTION_CANCEL);
HCI_CMD_DECODE(HCI_ULP_READ_WHITE_LIST_SIZE);
HCI_CMD_DECODE(HCI_ULP_CLEAR_WHITE_LIST);
HCI_CMD_DECODE(HCI_ULP_ADD_DEVICE_TO_WHITE_LIST);
HCI_CMD_DECODE(HCI_ULP_REMOVE_DEVICE_FROM_WHITE_LIST);
HCI_CMD_DECODE(HCI_ULP_CONNECTION_UPDATE);
HCI_CMD_DECODE(HCI_ULP_SET_HOST_CHANNEL_CLASSIFICATION);
HCI_CMD_DECODE(HCI_ULP_READ_CHANNEL_MAP);
HCI_CMD_DECODE(HCI_ULP_READ_REMOTE_USED_FEATURES);
HCI_CMD_DECODE(HCI_ULP_ENCRYPT);
HCI_CMD_DECODE(HCI_ULP_RAND);
HCI_CMD_DECODE(HCI_ULP_START_ENCRYPTION);
HCI_CMD_DECODE(HCI_ULP_LONG_TERM_KEY_REQUEST_REPLY);
HCI_CMD_DECODE(HCI_ULP_LONG_TERM_KEY_REQUEST_NEGATIVE_REPLY);
HCI_CMD_DECODE(HCI_ULP_READ_SUPPORTED_STATES);
HCI_CMD_DECODE(HCI_ULP_RECEIVER_TEST);
HCI_CMD_DECODE(HCI_ULP_TRANSMITTER_TEST);
HCI_CMD_DECODE(HCI_ULP_TEST_END);
HCI_CMD_DECODE(HCI_ULP_REMOTE_CONNECTION_PARAMETER_REQUEST_REPLY);
HCI_CMD_DECODE(HCI_ULP_REMOTE_CONNECTION_PARAMETER_REQUEST_NEGATIVE_REPLY);
HCI_CMD_DECODE(HCI_ULP_SET_DATA_LENGTH);
HCI_CMD_DECODE(HCI_ULP_READ_SUGGESTED_DEFAULT_DATA_LENGTH);
HCI_CMD_DECODE(HCI_ULP_WRITE_SUGGESTED_DEFAULT_DATA_LENGTH);
HCI_CMD_DECODE(HCI_ULP_READ_LOCAL_P256_PUBLIC_KEY);
HCI_CMD_DECODE(HCI_ULP_GENERATE_DHKEY);
HCI_CMD_DECODE(HCI_ULP_ADD_DEVICE_TO_RESOLVING_LIST);
HCI_CMD_DECODE(HCI_ULP_REMOVE_DEVICE_FROM_RESOLVING_LIST);
HCI_CMD_DECODE(HCI_ULP_CLEAR_RESOLVING_LIST);
HCI_CMD_DECODE(HCI_ULP_READ_RESOLVING_LIST_SIZE);
HCI_CMD_DECODE(HCI_ULP_READ_PEER_RESOLVABLE_ADDRESS);
HCI_CMD_DECODE(HCI_ULP_READ_LOCAL_RESOLVABLE_ADDRESS);
HCI_CMD_DECODE(HCI_ULP_SET_ADDRESS_RESOLUTION_ENABLE);
HCI_CMD_DECODE(HCI_ULP_SET_RANDOM_PRIVATE_ADDRESS_TIMEOUT);
HCI_CMD_DECODE(HCI_ULP_READ_MAXIMUM_DATA_LENGTH);
HCI_CMD_DECODE(HCI_ULP_READ_PHY);
HCI_CMD_DECODE(HCI_ULP_SET_DEFAULT_PHY);
HCI_CMD_DECODE(HCI_ULP_SET_PHY);
HCI_CMD_DECODE(HCI_ULP_ENHANCED_RECEIVER_TEST);
HCI_CMD_DECODE(HCI_ULP_ENHANCED_TRANSMITTER_TEST);
}
return ret;
}
static const char *scsc_bt_dump_hci_command(struct BSMHCP_TD_CONTROL *td_info)
{
return td_info->length ?
scsc_hci_evt_decode_command_code(*((u16 *) &td_info->data[0])) :
"[empty]";
}
const char *scsc_hci_evt_decode_event_code(u8 *data)
{
const char *ret = "NA";
u8 hci_event_code = data[0];
u8 hci_ulp_sub_code = data[2];
switch (hci_event_code) {
HCI_EV_DECODE(HCI_EV_INQUIRY_COMPLETE);
HCI_EV_DECODE(HCI_EV_INQUIRY_RESULT);
HCI_EV_DECODE(HCI_EV_CONN_COMPLETE);
HCI_EV_DECODE(HCI_EV_CONN_REQUEST);
HCI_EV_DECODE(HCI_EV_DISCONNECT_COMPLETE);
HCI_EV_DECODE(HCI_EV_AUTH_COMPLETE);
HCI_EV_DECODE(HCI_EV_REMOTE_NAME_REQ_COMPLETE);
HCI_EV_DECODE(HCI_EV_ENCRYPTION_CHANGE);
HCI_EV_DECODE(HCI_EV_CHANGE_CONN_LINK_KEY_COMPLETE);
HCI_EV_DECODE(HCI_EV_MASTER_LINK_KEY_COMPLETE);
HCI_EV_DECODE(HCI_EV_READ_REM_SUPP_FEATURES_COMPLETE);
HCI_EV_DECODE(HCI_EV_READ_REMOTE_VER_INFO_COMPLETE);
HCI_EV_DECODE(HCI_EV_QOS_SETUP_COMPLETE);
HCI_EV_DECODE(HCI_EV_HARDWARE_ERROR);
HCI_EV_DECODE(HCI_EV_FLUSH_OCCURRED);
HCI_EV_DECODE(HCI_EV_ROLE_CHANGE);
HCI_EV_DECODE(HCI_EV_NUMBER_COMPLETED_PKTS);
HCI_EV_DECODE(HCI_EV_MODE_CHANGE);
HCI_EV_DECODE(HCI_EV_RETURN_LINK_KEYS);
HCI_EV_DECODE(HCI_EV_PIN_CODE_REQ);
HCI_EV_DECODE(HCI_EV_LINK_KEY_REQ);
HCI_EV_DECODE(HCI_EV_LINK_KEY_NOTIFICATION);
HCI_EV_DECODE(HCI_EV_LOOPBACK_COMMAND);
HCI_EV_DECODE(HCI_EV_DATA_BUFFER_OVERFLOW);
HCI_EV_DECODE(HCI_EV_MAX_SLOTS_CHANGE);
HCI_EV_DECODE(HCI_EV_READ_CLOCK_OFFSET_COMPLETE);
HCI_EV_DECODE(HCI_EV_CONN_PACKET_TYPE_CHANGED);
HCI_EV_DECODE(HCI_EV_QOS_VIOLATION);
HCI_EV_DECODE(HCI_EV_PAGE_SCAN_MODE_CHANGE);
HCI_EV_DECODE(HCI_EV_PAGE_SCAN_REP_MODE_CHANGE);
HCI_EV_DECODE(HCI_EV_FLOW_SPEC_COMPLETE);
HCI_EV_DECODE(HCI_EV_INQUIRY_RESULT_WITH_RSSI);
HCI_EV_DECODE(HCI_EV_READ_REM_EXT_FEATURES_COMPLETE);
HCI_EV_DECODE(HCI_EV_FIXED_ADDRESS);
HCI_EV_DECODE(HCI_EV_ALIAS_ADDRESS);
HCI_EV_DECODE(HCI_EV_GENERATE_ALIAS_REQ);
HCI_EV_DECODE(HCI_EV_ACTIVE_ADDRESS);
HCI_EV_DECODE(HCI_EV_ALLOW_PRIVATE_PAIRING);
HCI_EV_DECODE(HCI_EV_ALIAS_ADDRESS_REQ);
HCI_EV_DECODE(HCI_EV_ALIAS_NOT_RECOGNISED);
HCI_EV_DECODE(HCI_EV_FIXED_ADDRESS_ATTEMPT);
HCI_EV_DECODE(HCI_EV_SYNC_CONN_COMPLETE);
HCI_EV_DECODE(HCI_EV_SYNC_CONN_CHANGED);
HCI_EV_DECODE(HCI_EV_SNIFF_SUB_RATE);
HCI_EV_DECODE(HCI_EV_EXTENDED_INQUIRY_RESULT);
HCI_EV_DECODE(HCI_EV_ENCRYPTION_KEY_REFRESH_COMPLETE);
HCI_EV_DECODE(HCI_EV_IO_CAPABILITY_REQUEST);
HCI_EV_DECODE(HCI_EV_IO_CAPABILITY_RESPONSE);
HCI_EV_DECODE(HCI_EV_USER_CONFIRMATION_REQUEST);
HCI_EV_DECODE(HCI_EV_USER_PASSKEY_REQUEST);
HCI_EV_DECODE(HCI_EV_REMOTE_OOB_DATA_REQUEST);
HCI_EV_DECODE(HCI_EV_SIMPLE_PAIRING_COMPLETE);
HCI_EV_DECODE(HCI_EV_LST_CHANGE);
HCI_EV_DECODE(HCI_EV_ENHANCED_FLUSH_COMPLETE);
HCI_EV_DECODE(HCI_EV_USER_PASSKEY_NOTIFICATION);
HCI_EV_DECODE(HCI_EV_KEYPRESS_NOTIFICATION);
HCI_EV_DECODE(HCI_EV_REM_HOST_SUPPORTED_FEATURES);
HCI_EV_DECODE(HCI_EV_TRIGGERED_CLOCK_CAPTURE);
HCI_EV_DECODE(HCI_EV_SYNCHRONIZATION_TRAIN_COMPLETE);
HCI_EV_DECODE(HCI_EV_SYNCHRONIZATION_TRAIN_RECEIVED);
HCI_EV_DECODE(HCI_EV_CSB_RECEIVE);
HCI_EV_DECODE(HCI_EV_CSB_TIMEOUT);
HCI_EV_DECODE(HCI_EV_TRUNCATED_PAGE_COMPLETE);
HCI_EV_DECODE(HCI_EV_SLAVE_PAGE_RESPONSE_TIMEOUT);
HCI_EV_DECODE(HCI_EV_CSB_CHANNEL_MAP_CHANGE);
HCI_EV_DECODE(HCI_EV_INQUIRY_RESPONSE_NOTIFICATION);
HCI_EV_DECODE(HCI_EV_AUTHENTICATED_PAYLOAD_TIMEOUT_EXPIRED);
case HCI_EV_COMMAND_COMPLETE:
{
u16 op_code = *((u16 *) &data[3]);
snprintf(scsc_hci_evt_decode_buffer,
sizeof(scsc_hci_evt_decode_buffer),
"HCI_EV_COMMAND_COMPLETE[Opcode=%s (0x%04x)]",
scsc_hci_evt_decode_command_code(op_code),
op_code);
ret = scsc_hci_evt_decode_buffer;
break;
}
case HCI_EV_COMMAND_STATUS:
{
u8 status = data[3];
u16 op_code = *((u16 *) &data[4]);
snprintf(scsc_hci_evt_decode_buffer,
sizeof(scsc_hci_evt_decode_buffer),
"HCI_EV_COMMAND_STATUS[Opcode:%s (0x%04x), Status: %u]",
scsc_hci_evt_decode_command_code(op_code),
op_code,
status);
ret = scsc_hci_evt_decode_buffer;
break;
}
case HCI_EV_ULP:
{
switch (hci_ulp_sub_code) {
HCI_EV_DECODE(HCI_EV_ULP_CONNECTION_COMPLETE);
HCI_EV_DECODE(HCI_EV_ULP_ADVERTISING_REPORT);
HCI_EV_DECODE(HCI_EV_ULP_CONNECTION_UPDATE_COMPLETE);
HCI_EV_DECODE(HCI_EV_ULP_READ_REMOTE_USED_FEATURES_COMPLETE);
HCI_EV_DECODE(HCI_EV_ULP_LONG_TERM_KEY_REQUEST);
HCI_EV_DECODE(HCI_EV_ULP_REMOTE_CONNECTION_PARAMETER_REQUEST);
HCI_EV_DECODE(HCI_EV_ULP_DATA_LENGTH_CHANGE);
HCI_EV_DECODE(HCI_EV_ULP_READ_LOCAL_P256_PUB_KEY_COMPLETE);
HCI_EV_DECODE(HCI_EV_ULP_GENERATE_DHKEY_COMPLETE);
HCI_EV_DECODE(HCI_EV_ULP_ENHANCED_CONNECTION_COMPLETE);
HCI_EV_DECODE(HCI_EV_ULP_DIRECT_ADVERTISING_REPORT);
HCI_EV_DECODE(HCI_EV_ULP_PHY_UPDATE_COMPLETE);
HCI_EV_DECODE(HCI_EV_ULP_USED_CHANNEL_SELECTION);
}
break;
}
}
return ret;
}
static const char *scsc_bt_dump_hci_event(struct BSMHCP_TD_HCI_EVT *td_info)
{
return td_info->length ?
scsc_hci_evt_decode_event_code(td_info->data) :
"[empty]";
}
void scsc_bt_dump_driver_state(void)
{
if (bt_service.bsmhcp_protocol) {
u32 index;
u32 readidx;
u32 writeidx;
pr_info("scsc_bt_dump_driver_state: Bluetooth Shared Memory Host Controller Protocol\n");
pr_info("scsc_bt_dump_driver_state: transfer ring read_idx write_idx\n");
pr_info("scsc_bt_dump_driver_state: ---------------------------------------\n");
pr_info("scsc_bt_dump_driver_state: hci_cmd %3u %3u\n",
bt_service.bsmhcp_protocol->header.mailbox_hci_cmd_read,
bt_service.bsmhcp_protocol->header.mailbox_hci_cmd_write);
pr_info("scsc_bt_dump_driver_state: hci_evt %3u %3u\n",
bt_service.bsmhcp_protocol->header.mailbox_hci_evt_read,
bt_service.bsmhcp_protocol->header.mailbox_hci_evt_write);
pr_info("scsc_bt_dump_driver_state: acl_tx %3u %3u\n",
bt_service.bsmhcp_protocol->header.mailbox_acl_tx_read,
bt_service.bsmhcp_protocol->header.mailbox_acl_tx_write);
pr_info("scsc_bt_dump_driver_state: acl_rx %3u %3u\n",
bt_service.bsmhcp_protocol->header.mailbox_acl_rx_read,
bt_service.bsmhcp_protocol->header.mailbox_acl_rx_write);
pr_info("scsc_bt_dump_driver_state: acl_free %3u %3u\n",
bt_service.bsmhcp_protocol->header.mailbox_acl_free_read,
bt_service.bsmhcp_protocol->header.mailbox_acl_free_write);
pr_info("scsc_bt_dump_driver_state: ---------------------------------------\n");
pr_info("scsc_bt_dump_driver_state: mxlog_filter = 0x%08x\n",
bt_service.bsmhcp_protocol->header.mxlog_filter);
pr_info("scsc_bt_dump_driver_state: firmware_control = 0x%08x\n",
bt_service.bsmhcp_protocol->header.firmware_control);
pr_info("scsc_bt_dump_driver_state: system_state = %s\n",
bt_service.bsmhcp_protocol->header.controller_flags == 0 ? "STOPPED" :
(bt_service.bsmhcp_protocol->header.controller_flags == 1 ? "STARTED" : "RUNNING"));
pr_info("scsc_bt_dump_driver_state: HCI commands:\n");
pr_info("scsc_bt_dump_driver_state: ptr index len details\n");
pr_info("scsc_bt_dump_driver_state: -------------------------------------------------------------\n");
readidx = bt_service.bsmhcp_protocol->header.mailbox_hci_cmd_read;
writeidx = bt_service.bsmhcp_protocol->header.mailbox_hci_cmd_write;
for (index = 0; index < BSMHCP_TRANSFER_RING_CMD_SIZE; index++) {
uint32_t write = writeidx >= index ? writeidx - index : BSMHCP_TRANSFER_RING_CMD_SIZE - index + writeidx;
struct BSMHCP_TD_CONTROL *td_info =
&bt_service.bsmhcp_protocol->hci_cmd_transfer_ring[write];
pr_info("scsc_bt_dump_driver_state: %c %c %3u %3u %s\n",
write == writeidx ? 'W' : ' ',
write == readidx ? 'R' : ' ',
write,
td_info->length,
scsc_bt_dump_hci_command(td_info));
}
pr_info("scsc_bt_dump_driver_state: -------------------------------------------------------------\n");
pr_info("scsc_bt_dump_driver_state: HCI events:\n");
pr_info("scsc_bt_dump_driver_state: ptr index len hci_handle event details\n");
pr_info("scsc_bt_dump_driver_state: -------------------------------------------------------------\n");
readidx = bt_service.bsmhcp_protocol->header.mailbox_hci_evt_read;
writeidx = bt_service.bsmhcp_protocol->header.mailbox_hci_evt_write;
for (index = 0; index < BSMHCP_TRANSFER_RING_EVT_SIZE; index++) {
uint32_t write = writeidx >= index ? writeidx - index : BSMHCP_TRANSFER_RING_EVT_SIZE - index + writeidx;
struct BSMHCP_TD_HCI_EVT *td_info =
&bt_service.bsmhcp_protocol->hci_evt_transfer_ring[write];
pr_info("scsc_bt_dump_driver_state: %c %c %3u %3u 0x%03x %2u %s\n",
write == writeidx ? 'W' : ' ',
write == readidx ? 'R' : ' ',
write,
td_info->length,
td_info->hci_connection_handle,
td_info->event_type,
scsc_bt_dump_hci_event(td_info));
}
pr_info("scsc_bt_dump_driver_state: -------------------------------------------------------------\n");
pr_info("scsc_bt_dump_driver_state: ACL to AIR:\n");
pr_info("scsc_bt_dump_driver_state: ptr index len idx start flush broadcast hci_handle cid\n");
pr_info("scsc_bt_dump_driver_state: -----------------------------------------------------------------\n");
readidx = bt_service.bsmhcp_protocol->header.mailbox_acl_tx_read;
writeidx = bt_service.bsmhcp_protocol->header.mailbox_acl_tx_write;
for (index = 0; index < BSMHCP_TRANSFER_RING_ACL_SIZE; index++) {
uint32_t write = writeidx >= index ? writeidx - index : BSMHCP_TRANSFER_RING_ACL_SIZE - index + writeidx;
struct BSMHCP_TD_ACL_TX_DATA *td_info =
&bt_service.bsmhcp_protocol->acl_tx_data_transfer_ring[write];
u8 pb = td_info->flags & BSMHCP_ACL_PB_FLAG_MASK;
u8 bc = td_info->flags & BSMHCP_ACL_BC_FLAG_BCAST_MASK;
pr_info("scsc_bt_dump_driver_state: %c %c %3u %3u %3u %c %c %c 0x%03x 0x%04x\n",
write == writeidx ? 'W' : ' ',
write == readidx ? 'R' : ' ',
write,
td_info->length,
td_info->buffer_index,
pb == BSMHCP_ACL_PB_FLAG_CONT ? 'N' : 'Y',
pb == BSMHCP_ACL_PB_FLAG_START_FLUSH ? 'Y' : 'N',
bc == BSMHCP_ACL_BC_FLAG_BCAST_NON ? 'N' : 'Y',
td_info->hci_connection_handle,
td_info->l2cap_cid);
}
pr_info("scsc_bt_dump_driver_state: -----------------------------------------------------------------\n");
pr_info("scsc_bt_dump_driver_state: ACL from AIR:\n");
pr_info("scsc_bt_dump_driver_state: ptr index len start flush hci_handle dis\n");
pr_info("scsc_bt_dump_driver_state: ----------------------------------------------\n");
readidx = bt_service.bsmhcp_protocol->header.mailbox_acl_rx_read;
writeidx = bt_service.bsmhcp_protocol->header.mailbox_acl_rx_write;
for (index = 0; index < BSMHCP_TRANSFER_RING_ACL_SIZE; index++) {
uint32_t write = writeidx >= index ? writeidx - index : BSMHCP_TRANSFER_RING_ACL_SIZE - index + writeidx;
struct BSMHCP_TD_ACL_RX *td_info =
&bt_service.bsmhcp_protocol->acl_rx_transfer_ring[write];
u8 pb = (td_info->packet_boundary << 4) & BSMHCP_ACL_PB_FLAG_MASK;
pr_info("scsc_bt_dump_driver_state: %c %c %3u %3u %c %c 0x%03x %c\n",
write == writeidx ? 'W' : ' ',
write == readidx ? 'R' : ' ',
write,
td_info->length,
pb == BSMHCP_ACL_PB_FLAG_CONT ? 'N' : 'Y',
td_info->broadcast_flag ? 'Y' : 'N',
td_info->hci_connection_handle,
td_info->disconnected ? 'Y' : 'N');
}
pr_info("scsc_bt_dump_driver_state: ----------------------------------------------\n");
}
}

352
drivers/misc/samsung/scsc_bt/scsc_bt_hci.h Normal file
View file

@ -0,0 +1,352 @@
/****************************************************************************
*
* Internal BT driver HCI decoder
*
* Copyright (c) 2015 Samsung Electronics Co., Ltd
*
****************************************************************************/
#ifndef __SCSC_BT_HCI_H
#define __SCSC_BT_HCI_H
#define HCI_EVENT_HEADER_LENGTH (2)
#define HCI_LINK ((u16)0x0400)
#define HCI_POLICY ((u16)0x0800)
#define HCI_HOST_BB ((u16)0x0C00)
#define HCI_INFO ((u16)0x1000)
#define HCI_STATUS ((u16)0x1400)
#define HCI_TEST ((u16)0x1800)
#define HCI_ULP ((u16)0x2000)
#define HCI_INQUIRY ((u16)HCI_LINK | 0x0001)
#define HCI_INQUIRY_CANCEL ((u16)HCI_LINK | 0x0002)
#define HCI_PERIODIC_INQUIRY_MODE ((u16)HCI_LINK | 0x0003)
#define HCI_EXIT_PERIODIC_INQUIRY_MODE ((u16)HCI_LINK | 0x0004)
#define HCI_CREATE_CONNECTION ((u16)HCI_LINK | 0x0005)
#define HCI_DISCONNECT ((u16)HCI_LINK | 0x0006)
#define HCI_ADD_SCO_CONNECTION ((u16)HCI_LINK | 0x0007)
#define HCI_CREATE_CONNECTION_CANCEL ((u16)HCI_LINK | 0x0008)
#define HCI_ACCEPT_CONNECTION_REQ ((u16)HCI_LINK | 0x0009)
#define HCI_REJECT_CONNECTION_REQ ((u16)HCI_LINK | 0x000A)
#define HCI_LINK_KEY_REQ_REPLY ((u16)HCI_LINK | 0x000B)
#define HCI_LINK_KEY_REQ_NEG_REPLY ((u16)HCI_LINK | 0x000C)
#define HCI_PIN_CODE_REQ_REPLY ((u16)HCI_LINK | 0x000D)
#define HCI_PIN_CODE_REQ_NEG_REPLY ((u16)HCI_LINK | 0x000E)
#define HCI_CHANGE_CONN_PKT_TYPE ((u16)HCI_LINK | 0x000F)
#define HCI_AUTH_REQ ((u16)HCI_LINK | 0x0011)
#define HCI_SET_CONN_ENCRYPTION ((u16)HCI_LINK | 0x0013)
#define HCI_CHANGE_CONN_LINK_KEY ((u16)HCI_LINK | 0x0015)
#define HCI_MASTER_LINK_KEY ((u16)HCI_LINK | 0x0017)
#define HCI_REMOTE_NAME_REQ ((u16)HCI_LINK | 0x0019)
#define HCI_REMOTE_NAME_REQ_CANCEL ((u16)HCI_LINK | 0x001A)
#define HCI_READ_REMOTE_SUPP_FEATURES ((u16)HCI_LINK | 0x001B)
#define HCI_READ_REMOTE_EXT_FEATURES ((u16)HCI_LINK | 0x001C)
#define HCI_READ_REMOTE_VER_INFO ((u16)HCI_LINK | 0x001D)
#define HCI_READ_CLOCK_OFFSET ((u16)HCI_LINK | 0x001F)
#define HCI_READ_LMP_HANDLE ((u16)HCI_LINK | 0x0020)
#define HCI_EXCHANGE_FIXED_INFO ((u16)HCI_LINK | 0x0021)
#define HCI_EXCHANGE_ALIAS_INFO ((u16)HCI_LINK | 0x0022)
#define HCI_PRIVATE_PAIRING_REQ_REPLY ((u16)HCI_LINK | 0x0023)
#define HCI_PRIVATE_PAIRING_REQ_NEG_REPLY ((u16)HCI_LINK | 0x0024)
#define HCI_GENERATED_ALIAS ((u16)HCI_LINK | 0x0025)
#define HCI_ALIAS_ADDRESS_REQ_REPLY ((u16)HCI_LINK | 0x0026)
#define HCI_ALIAS_ADDRESS_REQ_NEG_REPLY ((u16)HCI_LINK | 0x0027)
#define HCI_SETUP_SYNCHRONOUS_CONN ((u16)HCI_LINK | 0x0028)
#define HCI_ACCEPT_SYNCHRONOUS_CONN_REQ ((u16)HCI_LINK | 0x0029)
#define HCI_REJECT_SYNCHRONOUS_CONN_REQ ((u16)HCI_LINK | 0x002A)
#define HCI_IO_CAPABILITY_REQUEST_REPLY ((u16)HCI_LINK | 0x002B)
#define HCI_USER_CONFIRMATION_REQUEST_REPLY ((u16)HCI_LINK | 0x002C)
#define HCI_USER_CONFIRMATION_REQUEST_NEG_REPLY ((u16)HCI_LINK | 0x002D)
#define HCI_USER_PASSKEY_REQUEST_REPLY ((u16)HCI_LINK | 0x002E)
#define HCI_USER_PASSKEY_REQUEST_NEG_REPLY ((u16)HCI_LINK | 0x002F)
#define HCI_REMOTE_OOB_DATA_REQUEST_REPLY ((u16)HCI_LINK | 0x0030)
#define HCI_REMOTE_OOB_DATA_REQUEST_NEG_REPLY ((u16)HCI_LINK | 0x0033)
#define HCI_IO_CAPABILITY_REQUEST_NEG_REPLY ((u16)HCI_LINK | 0x0034)
#define HCI_ENHANCED_SETUP_SYNC_CONN ((u16)HCI_LINK | 0x003D)
#define HCI_ENHANCED_ACCEPT_SYNC_CONN_REQ ((u16)HCI_LINK | 0x003E)
#define HCI_TRUNCATED_PAGE ((u16)HCI_LINK | 0x003F)
#define HCI_TRUNCATED_PAGE_CANCEL ((u16)HCI_LINK | 0x0040)
#define HCI_SET_CSB ((u16)HCI_LINK | 0x0041)
#define HCI_SET_CSB_RECEIVE ((u16)HCI_LINK | 0x0042)
#define HCI_START_SYNCHRONIZATION_TRAIN ((u16)HCI_LINK | 0x0043)
#define HCI_RECEIVE_SYNCHRONIZATION_TRAIN ((u16)HCI_LINK | 0x0044)
#define HCI_REMOTE_OOB_EXTENDED_DATA_REQUEST_REPLY ((u16)HCI_LINK | 0x0045)
#define HCI_HOLD_MODE ((u16)HCI_POLICY | 0x0001)
#define HCI_SNIFF_MODE ((u16)HCI_POLICY | 0x0003)
#define HCI_EXIT_SNIFF_MODE ((u16)HCI_POLICY | 0x0004)
#define HCI_PARK_MODE ((u16)HCI_POLICY | 0x0005)
#define HCI_EXIT_PARK_MODE ((u16)HCI_POLICY | 0x0006)
#define HCI_QOS_SETUP ((u16)HCI_POLICY | 0x0007)
#define HCI_ROLE_DISCOVERY ((u16)HCI_POLICY | 0x0009)
#define HCI_SWITCH_ROLE ((u16)HCI_POLICY | 0x000B)
#define HCI_READ_LINK_POLICY_SETTINGS ((u16)HCI_POLICY | 0x000C)
#define HCI_WRITE_LINK_POLICY_SETTINGS ((u16)HCI_POLICY | 0x000D)
#define HCI_READ_DEFAULT_LINK_POLICY_SETTINGS ((u16)HCI_POLICY | 0x000E)
#define HCI_WRITE_DEFAULT_LINK_POLICY_SETTINGS ((u16)HCI_POLICY | 0x000F)
#define HCI_FLOW_SPEC ((u16)HCI_POLICY | 0x0010)
#define HCI_SNIFF_SUB_RATE ((u16)HCI_POLICY | 0x0011)
#define HCI_SET_EVENT_MASK ((u16)HCI_HOST_BB | 0x0001)
#define HCI_RESET ((u16)HCI_HOST_BB | 0x0003)
#define HCI_SET_EVENT_FILTER ((u16)HCI_HOST_BB | 0x0005)
#define HCI_FLUSH ((u16)HCI_HOST_BB | 0x0008)
#define HCI_READ_PIN_TYPE ((u16)HCI_HOST_BB | 0x0009)
#define HCI_WRITE_PIN_TYPE ((u16)HCI_HOST_BB | 0x000A)
#define HCI_CREATE_NEW_UNIT_KEY ((u16)HCI_HOST_BB | 0x000B)
#define HCI_READ_STORED_LINK_KEY ((u16)HCI_HOST_BB | 0x000D)
#define HCI_WRITE_STORED_LINK_KEY ((u16)HCI_HOST_BB | 0x0011)
#define HCI_DELETE_STORED_LINK_KEY ((u16)HCI_HOST_BB | 0x0012)
#define HCI_CHANGE_LOCAL_NAME ((u16)HCI_HOST_BB | 0x0013)
#define HCI_READ_LOCAL_NAME ((u16)HCI_HOST_BB | 0x0014)
#define HCI_READ_CONN_ACCEPT_TIMEOUT ((u16)HCI_HOST_BB | 0x0015)
#define HCI_WRITE_CONN_ACCEPT_TIMEOUT ((u16)HCI_HOST_BB | 0x0016)
#define HCI_READ_PAGE_TIMEOUT ((u16)HCI_HOST_BB | 0x0017)
#define HCI_WRITE_PAGE_TIMEOUT ((u16)HCI_HOST_BB | 0x0018)
#define HCI_READ_SCAN_ENABLE ((u16)HCI_HOST_BB | 0x0019)
#define HCI_WRITE_SCAN_ENABLE ((u16)HCI_HOST_BB | 0x001A)
#define HCI_READ_PAGESCAN_ACTIVITY ((u16)HCI_HOST_BB | 0x001B)
#define HCI_WRITE_PAGESCAN_ACTIVITY ((u16)HCI_HOST_BB | 0x001C)
#define HCI_READ_INQUIRYSCAN_ACTIVITY ((u16)HCI_HOST_BB | 0x001D)
#define HCI_WRITE_INQUIRYSCAN_ACTIVITY ((u16)HCI_HOST_BB | 0x001E)
#define HCI_READ_AUTH_ENABLE ((u16)HCI_HOST_BB | 0x001F)
#define HCI_WRITE_AUTH_ENABLE ((u16)HCI_HOST_BB | 0x0020)
#define HCI_READ_ENC_MODE ((u16)HCI_HOST_BB | 0x0021)
#define HCI_WRITE_ENC_MODE ((u16)HCI_HOST_BB | 0x0022)
#define HCI_READ_CLASS_OF_DEVICE ((u16)HCI_HOST_BB | 0x0023)
#define HCI_WRITE_CLASS_OF_DEVICE ((u16)HCI_HOST_BB | 0x0024)
#define HCI_READ_VOICE_SETTING ((u16)HCI_HOST_BB | 0x0025)
#define HCI_WRITE_VOICE_SETTING ((u16)HCI_HOST_BB | 0x0026)
#define HCI_READ_AUTO_FLUSH_TIMEOUT ((u16)HCI_HOST_BB | 0x0027)
#define HCI_WRITE_AUTO_FLUSH_TIMEOUT ((u16)HCI_HOST_BB | 0x0028)
#define HCI_READ_NUM_BCAST_RETXS ((u16)HCI_HOST_BB | 0x0029)
#define HCI_WRITE_NUM_BCAST_RETXS ((u16)HCI_HOST_BB | 0x002A)
#define HCI_READ_HOLD_MODE_ACTIVITY ((u16)HCI_HOST_BB | 0x002B)
#define HCI_WRITE_HOLD_MODE_ACTIVITY ((u16)HCI_HOST_BB | 0x002C)
#define HCI_READ_TX_POWER_LEVEL ((u16)HCI_HOST_BB | 0x002D)
#define HCI_READ_SCO_FLOW_CON_ENABLE ((u16)HCI_HOST_BB | 0x002E)
#define HCI_WRITE_SCO_FLOW_CON_ENABLE ((u16)HCI_HOST_BB | 0x002F)
#define HCI_SET_HCTOHOST_FLOW_CONTROL ((u16)HCI_HOST_BB | 0x0031)
#define HCI_HOST_BUFFER_SIZE ((u16)HCI_HOST_BB | 0x0033)
#define HCI_HOST_NUM_COMPLETED_PACKETS ((u16)HCI_HOST_BB | 0x0035)
#define HCI_READ_LINK_SUPERV_TIMEOUT ((u16)HCI_HOST_BB | 0x0036)
#define HCI_WRITE_LINK_SUPERV_TIMEOUT ((u16)HCI_HOST_BB | 0x0037)
#define HCI_READ_NUM_SUPPORTED_IAC ((u16)HCI_HOST_BB | 0x0038)
#define HCI_READ_CURRENT_IAC_LAP ((u16)HCI_HOST_BB | 0x0039)
#define HCI_WRITE_CURRENT_IAC_LAP ((u16)HCI_HOST_BB | 0x003A)
#define HCI_READ_PAGESCAN_PERIOD_MODE ((u16)HCI_HOST_BB | 0x003B)
#define HCI_WRITE_PAGESCAN_PERIOD_MODE ((u16)HCI_HOST_BB | 0x003C)
#define HCI_READ_PAGESCAN_MODE ((u16)HCI_HOST_BB | 0x003D)
#define HCI_WRITE_PAGESCAN_MODE ((u16)HCI_HOST_BB | 0x003E)
#define HCI_SET_AFH_CHANNEL_CLASS ((u16)HCI_HOST_BB | 0x003F)
#define HCI_READ_INQUIRY_SCAN_TYPE ((u16)HCI_HOST_BB | 0x0042)
#define HCI_WRITE_INQUIRY_SCAN_TYPE ((u16)HCI_HOST_BB | 0x0043)
#define HCI_READ_INQUIRY_MODE ((u16)HCI_HOST_BB | 0x0044)
#define HCI_WRITE_INQUIRY_MODE ((u16)HCI_HOST_BB | 0x0045)
#define HCI_READ_PAGE_SCAN_TYPE ((u16)HCI_HOST_BB | 0x0046)
#define HCI_WRITE_PAGE_SCAN_TYPE ((u16)HCI_HOST_BB | 0x0047)
#define HCI_READ_AFH_CHANNEL_CLASS_M ((u16)HCI_HOST_BB | 0x0048)
#define HCI_WRITE_AFH_CHANNEL_CLASS_M ((u16)HCI_HOST_BB | 0x0049)
#define HCI_READ_ANON_MODE ((u16)HCI_HOST_BB | 0x004A)
#define HCI_WRITE_ANON_MODE ((u16)HCI_HOST_BB | 0x004B)
#define HCI_READ_ALIAS_AUTH_ENABLE ((u16)HCI_HOST_BB | 0x004C)
#define HCI_WRITE_ALIAS_AUTH_ENABLE ((u16)HCI_HOST_BB | 0x004D)
#define HCI_READ_ANON_ADDR_CHANGE_PARAMS ((u16)HCI_HOST_BB | 0x004E)
#define HCI_WRITE_ANON_ADDR_CHANGE_PARAMS ((u16)HCI_HOST_BB | 0x004F)
#define HCI_RESET_FIXED_ADDRESS_ATTEMPTS_COUNTER ((u16)HCI_HOST_BB | 0x0050)
#define HCI_READ_EXTENDED_INQUIRY_RESPONSE_DATA ((u16)HCI_HOST_BB | 0x0051)
#define HCI_WRITE_EXTENDED_INQUIRY_RESPONSE_DATA ((u16)HCI_HOST_BB | 0x0052)
#define HCI_REFRESH_ENCRYPTION_KEY ((u16)HCI_HOST_BB | 0x0053)
#define HCI_READ_SIMPLE_PAIRING_MODE ((u16)HCI_HOST_BB | 0x0055)
#define HCI_WRITE_SIMPLE_PAIRING_MODE ((u16)HCI_HOST_BB | 0x0056)
#define HCI_READ_LOCAL_OOB_DATA ((u16)HCI_HOST_BB | 0x0057)
#define HCI_READ_INQUIRY_RESPONSE_TX_POWER_LEVEL ((u16)HCI_HOST_BB | 0x0058)
#define HCI_WRITE_INQUIRY_TRANSMIT_POWER_LEVEL ((u16)HCI_HOST_BB | 0x0059)
#define HCI_ENHANCED_FLUSH ((u16)HCI_HOST_BB | 0x005F)
#define HCI_SEND_KEYPRESS_NOTIFICATION ((u16)HCI_HOST_BB | 0x0060)
#define HCI_SET_EVENT_MASK_PAGE_2 ((u16)HCI_HOST_BB | 0x0063)
#define HCI_READ_ENH_TX_POWER_LEVEL ((u16)HCI_HOST_BB | 0x0068)
#define HCI_READ_LE_HOST_SUPPORT ((u16)HCI_HOST_BB | 0x006C)
#define HCI_WRITE_LE_HOST_SUPPORT ((u16)HCI_HOST_BB | 0x006D)
#define HCI_SET_RESERVED_LT_ADDR ((u16)HCI_HOST_BB | 0x0074)
#define HCI_DELETE_RESERVED_LT_ADDR ((u16)HCI_HOST_BB | 0x0075)
#define HCI_SET_CSB_DATA ((u16)HCI_HOST_BB | 0x0076)
#define HCI_READ_SYNCHRONIZATION_TRAIN_PARAMS ((u16)HCI_HOST_BB | 0x0077)
#define HCI_WRITE_SYNCHRONIZATION_TRAIN_PARAMS ((u16)HCI_HOST_BB | 0x0078)
#define HCI_READ_SECURE_CONNECTIONS_HOST_SUPPORT ((u16)HCI_HOST_BB | 0x0079)
#define HCI_WRITE_SECURE_CONNECTIONS_HOST_SUPPORT ((u16)HCI_HOST_BB | 0x007A)
#define HCI_READ_AUTHENTICATED_PAYLOAD_TIMEOUT ((u16)HCI_HOST_BB | 0x007B)
#define HCI_WRITE_AUTHENTICATED_PAYLOAD_TIMEOUT ((u16)HCI_HOST_BB | 0x007C)
#define HCI_READ_LOCAL_OOB_EXTENDED_DATA ((u16)HCI_HOST_BB | 0x007D)
#define HCI_READ_LOCAL_VER_INFO ((u16)HCI_INFO | 0x0001)
#define HCI_READ_LOCAL_SUPP_COMMANDS ((u16)HCI_INFO | 0x0002)
#define HCI_READ_LOCAL_SUPP_FEATURES ((u16)HCI_INFO | 0x0003)
#define HCI_READ_LOCAL_EXT_FEATURES ((u16)HCI_INFO | 0x0004)
#define HCI_READ_BUFFER_SIZE ((u16)HCI_INFO | 0x0005)
#define HCI_READ_COUNTRY_CODE ((u16)HCI_INFO | 0x0007)
#define HCI_READ_BD_ADDR ((u16)HCI_INFO | 0x0009)
#define HCI_READ_LOCAL_SUPP_CODECS ((u16)HCI_INFO | 0x000B)
#define HCI_READ_FAILED_CONTACT_COUNT ((u16)HCI_STATUS | 0x0001)
#define HCI_RESET_FAILED_CONTACT_COUNT ((u16)HCI_STATUS | 0x0002)
#define HCI_GET_LINK_QUALITY ((u16)HCI_STATUS | 0x0003)
#define HCI_READ_RSSI ((u16)HCI_STATUS | 0x0005)
#define HCI_READ_AFH_CHANNEL_MAP ((u16)HCI_STATUS | 0x0006)
#define HCI_READ_CLOCK ((u16)HCI_STATUS | 0x0007)
#define HCI_READ_ENCRYPTION_KEY_SIZE ((u16)HCI_STATUS | 0x0008)
#define HCI_SET_TRIGGERED_CLOCK_CAPTURE ((u16)HCI_STATUS | 0x000D)
#define HCI_READ_LOOPBACK_MODE ((u16)HCI_TEST | 0x0001)
#define HCI_WRITE_LOOPBACK_MODE ((u16)HCI_TEST | 0x0002)
#define HCI_ENABLE_DUT_MODE ((u16)HCI_TEST | 0x0003)
#define HCI_WRITE_SIMPLE_PAIRING_DEBUG_MODE ((u16)HCI_TEST | 0x0004)
#define HCI_WRITE_SECURE_CONNECTIONS_TEST_MODE ((u16)HCI_TEST | 0x000A)
#define HCI_ULP_SET_EVENT_MASK ((u16)HCI_ULP | 0x0001)
#define HCI_ULP_READ_BUFFER_SIZE ((u16)HCI_ULP | 0x0002)
#define HCI_ULP_READ_LOCAL_SUPPORTED_FEATURES ((u16)HCI_ULP | 0x0003)
#define HCI_ULP_SET_RANDOM_ADDRESS ((u16)HCI_ULP | 0x0005)
#define HCI_ULP_SET_ADVERTISING_PARAMETERS ((u16)HCI_ULP | 0x0006)
#define HCI_ULP_READ_ADVERTISING_CHANNEL_TX_POWER ((u16)HCI_ULP | 0x0007)
#define HCI_ULP_SET_ADVERTISING_DATA ((u16)HCI_ULP | 0x0008)
#define HCI_ULP_SET_SCAN_RESPONSE_DATA ((u16)HCI_ULP | 0x0009)
#define HCI_ULP_SET_ADVERTISE_ENABLE ((u16)HCI_ULP | 0x000A)
#define HCI_ULP_SET_SCAN_PARAMETERS ((u16)HCI_ULP | 0x000B)
#define HCI_ULP_SET_SCAN_ENABLE ((u16)HCI_ULP | 0x000C)
#define HCI_ULP_CREATE_CONNECTION ((u16)HCI_ULP | 0x000D)
#define HCI_ULP_CREATE_CONNECTION_CANCEL ((u16)HCI_ULP | 0x000E)
#define HCI_ULP_READ_WHITE_LIST_SIZE ((u16)HCI_ULP | 0x000F)
#define HCI_ULP_CLEAR_WHITE_LIST ((u16)HCI_ULP | 0x0010)
#define HCI_ULP_ADD_DEVICE_TO_WHITE_LIST ((u16)HCI_ULP | 0x0011)
#define HCI_ULP_REMOVE_DEVICE_FROM_WHITE_LIST ((u16)HCI_ULP | 0x0012)
#define HCI_ULP_CONNECTION_UPDATE ((u16)HCI_ULP | 0x0013)
#define HCI_ULP_SET_HOST_CHANNEL_CLASSIFICATION ((u16)HCI_ULP | 0x0014)
#define HCI_ULP_READ_CHANNEL_MAP ((u16)HCI_ULP | 0x0015)
#define HCI_ULP_READ_REMOTE_USED_FEATURES ((u16)HCI_ULP | 0x0016)
#define HCI_ULP_ENCRYPT ((u16)HCI_ULP | 0x0017)
#define HCI_ULP_RAND ((u16)HCI_ULP | 0x0018)
#define HCI_ULP_START_ENCRYPTION ((u16)HCI_ULP | 0x0019)
#define HCI_ULP_LONG_TERM_KEY_REQUEST_REPLY ((u16)HCI_ULP | 0x001A)
#define HCI_ULP_LONG_TERM_KEY_REQUEST_NEGATIVE_REPLY ((u16)HCI_ULP | 0x001B)
#define HCI_ULP_READ_SUPPORTED_STATES ((u16)HCI_ULP | 0x001C)
#define HCI_ULP_RECEIVER_TEST ((u16)HCI_ULP | 0x001D)
#define HCI_ULP_TRANSMITTER_TEST ((u16)HCI_ULP | 0x001E)
#define HCI_ULP_TEST_END ((u16)HCI_ULP | 0x001F)
#define HCI_ULP_REMOTE_CONNECTION_PARAMETER_REQUEST_REPLY ((u16)HCI_ULP | 0x0020)
#define HCI_ULP_REMOTE_CONNECTION_PARAMETER_REQUEST_NEGATIVE_REPLY ((u16)HCI_ULP | 0x0021)
#define HCI_ULP_SET_DATA_LENGTH ((u16)HCI_ULP | 0x0022)
#define HCI_ULP_READ_SUGGESTED_DEFAULT_DATA_LENGTH ((u16)HCI_ULP | 0x0023)
#define HCI_ULP_WRITE_SUGGESTED_DEFAULT_DATA_LENGTH ((u16)HCI_ULP | 0x0024)
#define HCI_ULP_READ_LOCAL_P256_PUBLIC_KEY ((u16)HCI_ULP | 0x0025)
#define HCI_ULP_GENERATE_DHKEY ((u16)HCI_ULP | 0x0026)
#define HCI_ULP_ADD_DEVICE_TO_RESOLVING_LIST ((u16)HCI_ULP | 0x0027)
#define HCI_ULP_REMOVE_DEVICE_FROM_RESOLVING_LIST ((u16)HCI_ULP | 0x0028)
#define HCI_ULP_CLEAR_RESOLVING_LIST ((u16)HCI_ULP | 0x0029)
#define HCI_ULP_READ_RESOLVING_LIST_SIZE ((u16)HCI_ULP | 0x002A)
#define HCI_ULP_READ_PEER_RESOLVABLE_ADDRESS ((u16)HCI_ULP | 0x002B)
#define HCI_ULP_READ_LOCAL_RESOLVABLE_ADDRESS ((u16)HCI_ULP | 0x002C)
#define HCI_ULP_SET_ADDRESS_RESOLUTION_ENABLE ((u16)HCI_ULP | 0x002D)
#define HCI_ULP_SET_RANDOM_PRIVATE_ADDRESS_TIMEOUT ((u16)HCI_ULP | 0x002E)
#define HCI_ULP_READ_MAXIMUM_DATA_LENGTH ((u16)HCI_ULP | 0x002F)
#define HCI_ULP_READ_PHY ((u16)HCI_ULP | 0x0030)
#define HCI_ULP_SET_DEFAULT_PHY ((u16)HCI_ULP | 0x0031)
#define HCI_ULP_SET_PHY ((u16)HCI_ULP | 0x0032)
#define HCI_ULP_ENHANCED_RECEIVER_TEST ((u16)HCI_ULP | 0x0033)
#define HCI_ULP_ENHANCED_TRANSMITTER_TEST ((u16)HCI_ULP | 0x0034)
#define HCI_EV_INQUIRY_COMPLETE ((u8)0x01)
#define HCI_EV_INQUIRY_RESULT ((u8)0x02)
#define HCI_EV_CONN_COMPLETE ((u8)0x03)
#define HCI_EV_CONN_REQUEST ((u8)0x04)
#define HCI_EV_DISCONNECT_COMPLETE ((u8)0x05)
#define HCI_EV_AUTH_COMPLETE ((u8)0x06)
#define HCI_EV_REMOTE_NAME_REQ_COMPLETE ((u8)0x07)
#define HCI_EV_ENCRYPTION_CHANGE ((u8)0x08)
#define HCI_EV_CHANGE_CONN_LINK_KEY_COMPLETE ((u8)0x09)
#define HCI_EV_MASTER_LINK_KEY_COMPLETE ((u8)0x0A)
#define HCI_EV_READ_REM_SUPP_FEATURES_COMPLETE ((u8)0x0B)
#define HCI_EV_READ_REMOTE_VER_INFO_COMPLETE ((u8)0x0C)
#define HCI_EV_QOS_SETUP_COMPLETE ((u8)0x0D)
#define HCI_EV_COMMAND_COMPLETE ((u8)0x0E)
#define HCI_EV_COMMAND_STATUS ((u8)0x0F)
#define HCI_EV_HARDWARE_ERROR ((u8)0x10)
#define HCI_EV_FLUSH_OCCURRED ((u8)0x11)
#define HCI_EV_ROLE_CHANGE ((u8)0x12)
#define HCI_EV_NUMBER_COMPLETED_PKTS ((u8)0x13)
#define HCI_EV_MODE_CHANGE ((u8)0x14)
#define HCI_EV_RETURN_LINK_KEYS ((u8)0x15)
#define HCI_EV_PIN_CODE_REQ ((u8)0x16)
#define HCI_EV_LINK_KEY_REQ ((u8)0x17)
#define HCI_EV_LINK_KEY_NOTIFICATION ((u8)0x18)
#define HCI_EV_LOOPBACK_COMMAND ((u8)0x19)
#define HCI_EV_DATA_BUFFER_OVERFLOW ((u8)0x1A)
#define HCI_EV_MAX_SLOTS_CHANGE ((u8)0x1B)
#define HCI_EV_READ_CLOCK_OFFSET_COMPLETE ((u8)0x1C)
#define HCI_EV_CONN_PACKET_TYPE_CHANGED ((u8)0x1D)
#define HCI_EV_QOS_VIOLATION ((u8)0x1E)
#define HCI_EV_PAGE_SCAN_MODE_CHANGE ((u8)0x1F)
#define HCI_EV_PAGE_SCAN_REP_MODE_CHANGE ((u8)0x20)
/* 1.2 Events */
#define HCI_EV_FLOW_SPEC_COMPLETE ((u8)0x21)
#define HCI_EV_INQUIRY_RESULT_WITH_RSSI ((u8)0x22)
#define HCI_EV_READ_REM_EXT_FEATURES_COMPLETE ((u8)0x23)
#define HCI_EV_FIXED_ADDRESS ((u8)0x24)
#define HCI_EV_ALIAS_ADDRESS ((u8)0x25)
#define HCI_EV_GENERATE_ALIAS_REQ ((u8)0x26)
#define HCI_EV_ACTIVE_ADDRESS ((u8)0x27)
#define HCI_EV_ALLOW_PRIVATE_PAIRING ((u8)0x28)
#define HCI_EV_ALIAS_ADDRESS_REQ ((u8)0x29)
#define HCI_EV_ALIAS_NOT_RECOGNISED ((u8)0x2A)
#define HCI_EV_FIXED_ADDRESS_ATTEMPT ((u8)0x2B)
#define HCI_EV_SYNC_CONN_COMPLETE ((u8)0x2C)
#define HCI_EV_SYNC_CONN_CHANGED ((u8)0x2D)
/* 2.1 Events */
#define HCI_EV_SNIFF_SUB_RATE ((u8)0x2E)
#define HCI_EV_EXTENDED_INQUIRY_RESULT ((u8)0x2F)
#define HCI_EV_ENCRYPTION_KEY_REFRESH_COMPLETE ((u8)0x30)
#define HCI_EV_IO_CAPABILITY_REQUEST ((u8)0x31)
#define HCI_EV_IO_CAPABILITY_RESPONSE ((u8)0x32)
#define HCI_EV_USER_CONFIRMATION_REQUEST ((u8)0x33)
#define HCI_EV_USER_PASSKEY_REQUEST ((u8)0x34)
#define HCI_EV_REMOTE_OOB_DATA_REQUEST ((u8)0x35)
#define HCI_EV_SIMPLE_PAIRING_COMPLETE ((u8)0x36)
#define HCI_EV_LST_CHANGE ((u8)0x38)
#define HCI_EV_ENHANCED_FLUSH_COMPLETE ((u8)0x39)
#define HCI_EV_USER_PASSKEY_NOTIFICATION ((u8)0x3B)
#define HCI_EV_KEYPRESS_NOTIFICATION ((u8)0x3C)
#define HCI_EV_REM_HOST_SUPPORTED_FEATURES ((u8)0x3D)
#define HCI_EV_ULP ((u8)0x3E)
/* TCC + CSB Events */
#define HCI_EV_TRIGGERED_CLOCK_CAPTURE ((u8)0x4E)
#define HCI_EV_SYNCHRONIZATION_TRAIN_COMPLETE ((u8)0x4F)
#define HCI_EV_SYNCHRONIZATION_TRAIN_RECEIVED ((u8)0x50)
#define HCI_EV_CSB_RECEIVE ((u8)0x51)
#define HCI_EV_CSB_TIMEOUT ((u8)0x52)
#define HCI_EV_TRUNCATED_PAGE_COMPLETE ((u8)0x53)
#define HCI_EV_SLAVE_PAGE_RESPONSE_TIMEOUT ((u8)0x54)
#define HCI_EV_CSB_CHANNEL_MAP_CHANGE ((u8)0x55)
#define HCI_EV_INQUIRY_RESPONSE_NOTIFICATION ((u8)0x56)
/* 4.1 Events */
#define HCI_EV_AUTHENTICATED_PAYLOAD_TIMEOUT_EXPIRED ((u8)0x57)
/* ULP Sub-opcodes */
#define HCI_EV_ULP_CONNECTION_COMPLETE ((u8)0x01)
#define HCI_EV_ULP_ADVERTISING_REPORT ((u8)0x02)
#define HCI_EV_ULP_CONNECTION_UPDATE_COMPLETE ((u8)0x03)
#define HCI_EV_ULP_READ_REMOTE_USED_FEATURES_COMPLETE ((u8)0x04)
#define HCI_EV_ULP_LONG_TERM_KEY_REQUEST ((u8)0x05)
#define HCI_EV_ULP_REMOTE_CONNECTION_PARAMETER_REQUEST ((u8)0x06)
#define HCI_EV_ULP_DATA_LENGTH_CHANGE ((u8)0x07)
#define HCI_EV_ULP_READ_LOCAL_P256_PUB_KEY_COMPLETE ((u8)0x08)
#define HCI_EV_ULP_GENERATE_DHKEY_COMPLETE ((u8)0x09)
#define HCI_EV_ULP_ENHANCED_CONNECTION_COMPLETE ((u8)0x0A)
#define HCI_EV_ULP_DIRECT_ADVERTISING_REPORT ((u8)0x0B)
#define HCI_EV_ULP_PHY_UPDATE_COMPLETE ((u8)0x0C)
/* The subevent code of ULP_USED_CHANNEL_SELECTION_EVENT shall be updated
when it is defined in the spec.
Assign it as 0x0D temporarily. */
#define HCI_EV_ULP_USED_CHANNEL_SELECTION ((u8)0x0D)
#define HCI_CMD_DECODE(entry) case entry: ret = #entry; break
#define HCI_EV_DECODE(entry) case entry: ret = #entry; break
#endif /* __SCSC_BT_HCI_H */

1123
drivers/misc/samsung/scsc_bt/scsc_bt_module.c Normal file
View file

File diff suppressed because it is too large Load diff

240
drivers/misc/samsung/scsc_bt/scsc_bt_priv.h Normal file
View file

@ -0,0 +1,240 @@
/****************************************************************************
*
* Internal BT driver definitions
*
* Copyright (c) 2015 Samsung Electronics Co., Ltd
*
****************************************************************************/
#ifndef __SCSC_BT_PRIV_H
#define __SCSC_BT_PRIV_H
#include <scsc/scsc_mx.h>
#include <scsc/api/bsmhcp.h>
#include <scsc/api/bhcs.h>
#include "scsc_shm.h"
#ifndef UNUSED
#define UNUSED(x) ((void)(x))
#endif
/**
* Size of temporary buffer (on stack) for peeking at HCI/H4
* packet header held in FIFO.
*
* Must be big enough to decode the
* length of any HCI packet type.
*
* For ACL that is 1 h4 header + 2 ACL handle + 2 ACL data size
*/
#define H4DMUX_HEADER_HCI (1 + 3) /* CMD, SCO */
#define H4DMUX_HEADER_ACL (1 + 4) /* ACL */
#define HCI_COMMAND_PKT (1)
#define HCI_ACLDATA_PKT (2)
#define HCI_EVENT_PKT (4)
#define ACLDATA_HEADER_SIZE (4)
#define L2CAP_HEADER_SIZE (4)
#define HCI_ACL_DATA_FLAGS(data) ((*(data + 1)) & 0xf0)
#define HCI_ACL_DATA_CON_HDL(data) ((u16)(*(data + 0) | ((*(data + 1)) & 0x0f) << 8))
#define HCI_ACL_DATA_LENGTH(data) ((u16)(*(data + 2) | (*(data + 3)) << 8))
#define HCI_L2CAP_LENGTH(data) ((u16)(*(data + 4) | (*(data + 5)) << 8))
#define HCI_L2CAP_CID(data) ((u16)(*(data + 6) | (*(data + 7)) << 8))
#define HCI_EVENT_NUMBER_OF_COMPLETED_PACKETS_EVENT (0x13)
#define HCI_EVENT_HARDWARE_ERROR_EVENT (0x10)
#define SCSC_BT_CONF "bluetooth/bt.hcf"
#define SCSC_BT_ADDR "/efs/bluetooth/bt_addr"
#define SCSC_BT_ADDR_LEN (6)
#define SCSC_H4_DEVICE_NAME "scsc_h4_0"
#define SCSC_BT_CONNECTION_INFO_MAX (0x1000)
#define SCSC_TTY_MINORS (8)
enum scsc_bt_shm_thread_flags;
enum scsc_bt_read_op {
BT_READ_OP_NONE,
BT_READ_OP_HCI_EVT,
BT_READ_OP_HCI_EVT_ERROR,
BT_READ_OP_ACL_DATA,
BT_READ_OP_ACL_CREDIT,
BT_READ_OP_STOP
};
struct scsc_bt_connection_info {
u8 state;
u16 length;
u16 l2cap_cid;
};
#define CONNECTION_NONE (0)
#define CONNECTION_ACTIVE (1)
#define CONNECTION_DISCONNECTED (2)
enum bt_link_type_enum {
BT_LINK_TYPE_SCO = 0,
BT_LINK_TYPE_ACL = 1,
BT_LINK_TYPE_SETUP_ID = 2,
BT_LINK_TYPE_SETUP_FHS = 3,
BT_LINK_TYPE_ESCO = 4,
BT_LINK_TYPE_ACL_23 = 5,
BT_LINK_TYPE_ESCO_23 = 6,
BT_LINK_TYPE_ANTPLUS = 7,
MAX_BT_LINK_TYPE = 7
};
struct scsc_bt_service {
dev_t device;
struct class *class;
struct scsc_mx *maxwell_core;
struct scsc_service *service;
struct device *dev;
struct cdev h4_cdev;
struct device *h4_device;
struct file *h4_file;
bool h4_users;
atomic_t h4_readers;
atomic_t h4_writers;
size_t h4_write_offset;
atomic_t error_count;
atomic_t service_users;
u8 *debug_ptr;
wait_queue_head_t debug_wait;
struct task_struct *debug_thread;
scsc_mifram_ref debug_output_ref; /* Bluetooth debug output reference */
struct completion debug_thread_complete;
bool debug_terminate;
scsc_mifram_ref bhcs_ref; /* Bluetooth host configuration service reference */
scsc_mifram_ref bsmhcp_ref; /* Bluetooth shared memory host controller protocol reference */
scsc_mifram_ref config_ref; /* Bluetooth configuration reference */
struct BSMHCP_PROTOCOL *bsmhcp_protocol; /* Bluetooth shared memory host controller protocol pointer */
size_t read_offset;
enum scsc_bt_read_op read_operation;
u32 read_index;
wait_queue_head_t read_wait;
wait_queue_head_t info_wait;
int last_alloc; /* Cached previous alloc index to aid search */
u8 allocated[BSMHCP_DATA_BUFFER_TX_ACL_SIZE];
u32 allocated_count;
u32 freed_count;
bool processed[BSMHCP_TRANSFER_RING_EVT_SIZE];
struct scsc_bt_connection_info connection_handle_list[SCSC_BT_CONNECTION_INFO_MAX];
bool hci_event_paused;
bool acldata_paused;
struct wake_lock read_wake_lock;
struct wake_lock write_wake_lock;
struct wake_lock service_wake_lock;
size_t write_wake_lock_count;
size_t write_wake_unlock_count;
size_t interrupt_count;
size_t interrupt_read_count;
size_t interrupt_write_count;
size_t interrupt_debug_count;
u32 mailbox_hci_evt_read;
u32 mailbox_hci_evt_write;
u32 mailbox_acl_rx_read;
u32 mailbox_acl_rx_write;
u32 mailbox_acl_free_read;
u32 mailbox_acl_free_read_scan;
u32 mailbox_acl_free_write;
u32 mailbox_debug_read;
u32 mailbox_debug_write;
/* NOTE! The naming takes the perspective of the local device (==src), as opposed to the L2CAP
* spec, which names the sender of the current signal as the src. */
u16 avdtp_signaling_src_cid;
u16 avdtp_signaling_dst_cid;
u16 avdtp_streaming_src_cid;
u16 avdtp_streaming_dst_cid;
u16 avdtp_hci_connection_handle;
struct completion recovery_release_complete;
struct completion recovery_probe_complete;
};
extern struct scsc_bt_service bt_service;
void scsc_bt_shm_debug(void);
/* Coex avdtp detection */
/* The buffers passed for inspection begin at the L2CAP basic header, as does the length
* passed in the function calls */
#define AVDTP_DETECT_MIN_DATA_LENGTH (12) /* We always want to look for the SRC CID */
#define AVDTP_DETECT_MIN_DATA_LENGTH_CON_RSP (16) /* For CON RSP, we want the result, too */
#define AVDTP_DETECT_MIN_AVDTP_LENGTH (6) /* Basic L2CAP header + 2 AVDTP octets as min */
#define HCI_ACL_PACKET_BOUNDARY_START_FLUSH (2)
/* Can't use HCI_L2CAP_CID(data), since that assumes 4 bytes of HCI header, which has been stripped
* for the calls to the avdtp detection functions */
#define HCI_L2CAP_RX_CID(data) ((u16)(*(data + 2) | (*(data + 3)) << 8))
#define HCI_L2CAP_CODE(data) ((u8)(*(data + 4)))
#define HCI_L2CAP_CON_REQ_PSM(data) ((u16)(*(data + 8) | (*(data + 9)) << 8))
/* Valid for at least connection request/response and disconnection request */
#define HCI_L2CAP_SOURCE_CID(data) ((u16)(*(data + 10) | (*(data + 11)) << 8))
/* Valid for at least connection and disconnection responses */
#define HCI_L2CAP_RSP_DEST_CID(data) ((u16)(*(data + 8) | (*(data + 9)) << 8))
#define HCI_L2CAP_CON_RSP_RESULT(data) ((u16)(*(data + 12) | (*(data + 13)) << 8))
#define HCI_L2CAP_CON_RSP_RESULT_SUCCESS (0)
#define L2CAP_AVDTP_PSM 0x0019
#define L2CAP_SIGNALING_CID 0x0001
#define L2CAP_CODE_CONNECT_REQ 0x02
#define L2CAP_CODE_CONNECT_RSP 0x03
#define L2CAP_CODE_DISCONNECT_REQ 0x06
#define L2CAP_CODE_DISCONNECT_RSP 0x07
#define AVDTP_MESSAGE_TYPE_OFFSET 4 /* Assuming only single packet type */
#define AVDTP_MESSAGE_TYPE_MASK 0x03
#define AVDTP_MESSAGE_TYPE(data) ((u8)(*(data + AVDTP_MESSAGE_TYPE_OFFSET)) & AVDTP_MESSAGE_TYPE_MASK)
#define AVDTP_MESSAGE_TYPE_RSP_ACCEPT 0x02
#define AVDTP_SIGNAL_ID_OFFSET 5 /* Assuming only single packet type */
#define AVDTP_SIGNAL_ID_MASK 0x1F
#define AVDTP_SIGNAL_ID(data) ((u8)(*(data + AVDTP_SIGNAL_ID_OFFSET)) & AVDTP_SIGNAL_ID_MASK)
#define AVDTP_SIGNAL_ID_START 0x07
#define AVDTP_SIGNAL_ID_CLOSE 0x08
#define AVDTP_SIGNAL_ID_SUSPEND 0x09
#define AVDTP_SIGNAL_ID_ABORT 0x0A
extern uint16_t avdtp_signaling_src_cid;
extern uint16_t avdtp_signaling_dst_cid;
extern uint16_t avdtp_streaming_src_cid;
extern uint16_t avdtp_streaming_dst_cid;
extern uint16_t avdtp_hci_connection_handle;
#define AVDTP_DETECT_SIGNALING_IGNORE 0
#define AVDTP_DETECT_SIGNALING_ACTIVE 1
#define AVDTP_DETECT_SIGNALING_INACTIVE 2
bool scsc_avdtp_detect_connection_tx(uint16_t hci_connection_handle, const unsigned char *data, uint16_t length);
bool scsc_avdtp_detect_connection_rx(uint16_t hci_connection_handle, const unsigned char *data, uint16_t length);
uint8_t scsc_avdtp_detect_signaling_tx(const unsigned char *data);
uint8_t scsc_avdtp_detect_signaling_rx(const unsigned char *data);
void scsc_avdtp_detect_tx(u16 hci_connection_handle, const unsigned char *data, uint16_t length);
void scsc_avdtp_detect_rx(u16 hci_connection_handle, const unsigned char *data, uint16_t length);
void scsc_bt_dump_driver_state(void);
const char *scsc_hci_evt_decode_event_code(u8 *data);
#endif /* __SCSC_BT_PRIV_H */

1529
drivers/misc/samsung/scsc_bt/scsc_shm.c Normal file
View file

File diff suppressed because it is too large Load diff

27
drivers/misc/samsung/scsc_bt/scsc_shm.h Normal file
View file

@ -0,0 +1,27 @@
/****************************************************************************
*
* Copyright (c) 2015 Samsung Electronics Co., Ltd
*
****************************************************************************/
/* Shared memory interface API */
#ifndef __SCSC_SHM_H__
#define __SCSC_SHM_H__
#include <scsc/api/bsmhcp.h>
int scsc_bt_shm_init(u32 filter);
void scsc_bt_shm_stop_thread(void);
void scsc_bt_shm_exit(void);
ssize_t scsc_bt_shm_h4_read(struct file *file,
char __user *buf,
size_t len,
loff_t *offset);
ssize_t scsc_bt_shm_h4_write(struct file *file,
const char __user *buf,
size_t len, loff_t *offset);
unsigned scsc_bt_shm_h4_poll(struct file *file, poll_table *wait);
#endif