[esp-hosted.git] / esp_hosted_fg / host / linux / host_driver / esp32 / esp_bt.c

/*
 * Espressif Systems Wireless LAN device driver
 *
 * Copyright (C) 2015-2021 Espressif Systems (Shanghai) PTE LTD
 *
 * This software file (the "File") is distributed by Espressif Systems (Shanghai)
 * PTE LTD under the terms of the GNU General Public License Version 2, June 1991
 * (the "License").  You may use, redistribute and/or modify this File in
 * accordance with the terms and conditions of the License, a copy of which
 * is available by writing to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
 * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
 *
 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
 * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
 * this warranty disclaimer.
 */
#include "esp_bt_api.h"
#include "esp_api.h"
#include "esp_kernel_port.h"

#define INVALID_HDEV_BUS (0xff)


static ESP_BT_SEND_FRAME_PROTOTYPE();

void esp_hci_update_tx_counter(struct hci_dev *hdev, u8 pkt_type, size_t len)
{
	if (hdev) {
		if (pkt_type == HCI_COMMAND_PKT) {
			hdev->stat.cmd_tx++;
		} else if (pkt_type == HCI_ACLDATA_PKT) {
			hdev->stat.acl_tx++;
		} else if (pkt_type == HCI_SCODATA_PKT) {
			hdev->stat.sco_tx++;
		}

		hdev->stat.byte_tx += len;
	}
}

void esp_hci_update_rx_counter(struct hci_dev *hdev, u8 pkt_type, size_t len)
{
	if (hdev) {
		if (pkt_type == HCI_EVENT_PKT) {
			hdev->stat.evt_rx++;
		} else if (pkt_type == HCI_ACLDATA_PKT) {
			hdev->stat.acl_rx++;
		} else if (pkt_type == HCI_SCODATA_PKT) {
			hdev->stat.sco_rx++;
		}

		hdev->stat.byte_rx += len;
	}
}

static int esp_bt_open(struct hci_dev *hdev)
{
	return 0;
}

static int esp_bt_close(struct hci_dev *hdev)
{
	return 0;
}

static int esp_bt_flush(struct hci_dev *hdev)
{
	return 0;
}

static ESP_BT_SEND_FRAME_PROTOTYPE()
{
	struct esp_payload_header *hdr;
	size_t total_len, len = skb->len;
	int ret = 0;
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 13, 0))
    struct hci_dev * hdev = (struct hci_dev *)(skb->dev);
#endif
	struct esp_adapter *adapter = hci_get_drvdata(hdev);
	struct sk_buff *new_skb;
	u8 pad_len = 0, realloc_skb = 0;
	u8 *pos = NULL;
	u8 pkt_type;

	if (!adapter) {
		printk(KERN_ERR "%s: invalid args", __func__);
		return -EINVAL;
	}
	//print_hex_dump(KERN_INFO, "bt_tx: ", DUMP_PREFIX_ADDRESS, 16, 1, skb->data, len, 1  );

	/* Create space for payload header */
	pad_len = sizeof(struct esp_payload_header);
	total_len = len + sizeof(struct esp_payload_header);

	/* Align buffer len */
	pad_len += SKB_DATA_ADDR_ALIGNMENT - (total_len % SKB_DATA_ADDR_ALIGNMENT);

	pkt_type = hci_skb_pkt_type(skb);

	if (skb_headroom(skb) < pad_len) {
		/* Headroom is not sufficient */
		realloc_skb = 1;
	}

	if (realloc_skb || !IS_ALIGNED((unsigned long) skb->data, SKB_DATA_ADDR_ALIGNMENT)) {
		/* Realloc SKB */
		if (skb_linearize(skb)) {
			hdev->stat.err_tx++;
			return -EINVAL;
		}

		new_skb = esp_alloc_skb(skb->len + pad_len);

		if (!new_skb) {
			printk(KERN_ERR "%s: Failed to allocate SKB", __func__);
			hdev->stat.err_tx++;
			return -ENOMEM;
		}

		pos = new_skb->data;

		pos += pad_len;

		/* Populate new SKB */
		skb_copy_from_linear_data(skb, pos, skb->len);
		skb_put(new_skb, skb->len);

		/* Replace old SKB */
		dev_kfree_skb_any(skb);
		skb = new_skb;
	} else {
		/* Realloc is not needed, Make space for interface header */
		skb_push(skb, pad_len);
	}

	hdr = (struct esp_payload_header *) skb->data;

	memset (hdr, 0, sizeof(struct esp_payload_header));

	hdr->if_type = ESP_HCI_IF;
	hdr->if_num = 0;
	hdr->len = cpu_to_le16(len);
	hdr->offset = cpu_to_le16(pad_len);
	pos = skb->data;

	/* set HCI packet type */
	*(pos + pad_len - 1) = pkt_type;

	hdr->checksum = cpu_to_le16(compute_checksum(skb->data, (len + pad_len)));

	ret = esp_send_packet(adapter, skb);

	if (ret) {
		hdev->stat.err_tx++;
		return ret;
	} else {
		esp_hci_update_tx_counter(hdev, hdr->hci_pkt_type, skb->len);
	}

	return 0;
}

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0))
static int esp_bt_setup(struct hci_dev *hdev)
{
	return 0;
}
#endif

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 17, 0))
static int esp_bt_set_bdaddr(struct hci_dev *hdev, const bdaddr_t *bdaddr)
{
	return 0;
}
#endif

int esp_deinit_bt(struct esp_adapter *adapter)
{
	struct hci_dev *hdev = NULL;

	if (!adapter || !adapter->hcidev)
		return 0;

	hdev = adapter->hcidev;

	hci_unregister_dev(hdev);
	hci_free_dev(hdev);

	adapter->hcidev = NULL;

	return 0;
}

int esp_init_bt(struct esp_adapter *adapter)
{
	int ret = 0;
	struct hci_dev *hdev = NULL;

	if (!adapter) {
		return -EINVAL;
	}

	if (adapter->hcidev) {
		return -EEXIST;
	}

	hdev = hci_alloc_dev();

	if (!hdev) {
		BT_ERR("Can not allocate HCI device");
		return -ENOMEM;
	}

	adapter->hcidev = hdev;
	hci_set_drvdata(hdev, adapter);

	hdev->bus = INVALID_HDEV_BUS;

	if (adapter->if_type == ESP_IF_TYPE_SDIO)
		hdev->bus   = HCI_SDIO;
    #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 7, 0))
	else if (adapter->if_type == ESP_IF_TYPE_SPI)
		hdev->bus   = HCI_SPI;
    #endif

	if (hdev->bus == INVALID_HDEV_BUS) {

		if (adapter->if_type == ESP_IF_TYPE_SDIO) {
			printk(KERN_ERR "%s: Kernel version does not support HCI over SDIO BUS\n",__func__);
		} else if (adapter->if_type == ESP_IF_TYPE_SPI) {
			printk(KERN_ERR "%s: Kernel version does not support HCI over SPI BUS\n",__func__);
		} else {
			printk(KERN_ERR "%s: HCI over expected BUS[%u] is not supported\n",__func__, adapter->if_type);
		}
		hci_free_dev(hdev);
		adapter->hcidev = NULL;
		return -EINVAL;
	}

	hdev->open  = esp_bt_open;
	hdev->close = esp_bt_close;
	hdev->flush = esp_bt_flush;
	hdev->send  = esp_bt_send_frame;

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0))
	hdev->setup = esp_bt_setup;
#endif

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 17, 0))
	hdev->set_bdaddr = esp_bt_set_bdaddr;
#endif

	hdev->dev_type = HCI_PRIMARY;

	ret = hci_register_dev(hdev);
	if (ret < 0) {
		BT_ERR("Can not register HCI device");
		hci_free_dev(hdev);
		return -ENOMEM;
	}

	return 0;
}
Commit	Line	Data
71d37aa1 MM	1	/*
	2	* Espressif Systems Wireless LAN device driver
	3	*
683f0529	4	* Copyright (C) 2015-2021 Espressif Systems (Shanghai) PTE LTD
71d37aa1 MM	5	*
	6	* This software file (the "File") is distributed by Espressif Systems (Shanghai)
	7	* PTE LTD under the terms of the GNU General Public License Version 2, June 1991
	8	* (the "License"). You may use, redistribute and/or modify this File in
	9	* accordance with the terms and conditions of the License, a copy of which
	10	* is available by writing to the Free Software Foundation, Inc.,
	11	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
	12	* worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
	13	*
	14	* THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
	15	* IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
	16	* ARE EXPRESSLY DISCLAIMED. The License provides additional details about
	17	* this warranty disclaimer.
	18	*/
	19	#include "esp_bt_api.h"
	20	#include "esp_api.h"
aad2ae2e	21	#include "esp_kernel_port.h"
71d37aa1	22
d718e190 YM	23	#define INVALID_HDEV_BUS (0xff)
d718e190 YM	24
85c5e78a	25
aad2ae2e	26	static ESP_BT_SEND_FRAME_PROTOTYPE();
85c5e78a	27
c6a5eef9 MM	28	void esp_hci_update_tx_counter(struct hci_dev *hdev, u8 pkt_type, size_t len)
	29	{
	30	if (hdev) {
	31	if (pkt_type == HCI_COMMAND_PKT) {
	32	hdev->stat.cmd_tx++;
	33	} else if (pkt_type == HCI_ACLDATA_PKT) {
	34	hdev->stat.acl_tx++;
	35	} else if (pkt_type == HCI_SCODATA_PKT) {
	36	hdev->stat.sco_tx++;
	37	}
	38
	39	hdev->stat.byte_tx += len;
	40	}
	41	}
	42
	43	void esp_hci_update_rx_counter(struct hci_dev *hdev, u8 pkt_type, size_t len)
	44	{
	45	if (hdev) {
	46	if (pkt_type == HCI_EVENT_PKT) {
	47	hdev->stat.evt_rx++;
	48	} else if (pkt_type == HCI_ACLDATA_PKT) {
	49	hdev->stat.acl_rx++;
	50	} else if (pkt_type == HCI_SCODATA_PKT) {
	51	hdev->stat.sco_rx++;
	52	}
	53
	54	hdev->stat.byte_rx += len;
	55	}
	56	}
	57
71d37aa1 MM	58	static int esp_bt_open(struct hci_dev *hdev)
	59	{
	60	return 0;
	61	}
	62
	63	static int esp_bt_close(struct hci_dev *hdev)
	64	{
	65	return 0;
	66	}
	67
	68	static int esp_bt_flush(struct hci_dev *hdev)
	69	{
	70	return 0;
	71	}
	72
aad2ae2e	73	static ESP_BT_SEND_FRAME_PROTOTYPE()
71d37aa1 MM	74	{
	75	struct esp_payload_header *hdr;
	76	size_t total_len, len = skb->len;
	77	int ret = 0;
85c5e78a	78	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 13, 0))
	79	struct hci_dev * hdev = (struct hci_dev *)(skb->dev);
	80	#endif
71d37aa1 MM	81	struct esp_adapter *adapter = hci_get_drvdata(hdev);
71d37aa1 MM	82	struct sk_buff *new_skb;
5bd53032 MM	83	u8 pad_len = 0, realloc_skb = 0;
	84	u8 *pos = NULL;
	85	u8 pkt_type;
71d37aa1 MM	86
	87	if (!adapter) {
	88	printk(KERN_ERR "%s: invalid args", __func__);
	89	return -EINVAL;
	90	}
d53a8a4a	91	//print_hex_dump(KERN_INFO, "bt_tx: ", DUMP_PREFIX_ADDRESS, 16, 1, skb->data, len, 1 );
71d37aa1	92
5bd53032 MM	93	/* Create space for payload header */
5bd53032 MM	94	pad_len = sizeof(struct esp_payload_header);
71d37aa1 MM	95	total_len = len + sizeof(struct esp_payload_header);
71d37aa1 MM	96
5bd53032 MM	97	/* Align buffer len */
5bd53032 MM	98	pad_len += SKB_DATA_ADDR_ALIGNMENT - (total_len % SKB_DATA_ADDR_ALIGNMENT);
71d37aa1	99
5bd53032 MM	100	pkt_type = hci_skb_pkt_type(skb);
	101
	102	if (skb_headroom(skb) < pad_len) {
	103	/* Headroom is not sufficient */
	104	realloc_skb = 1;
	105	}
	106
	107	if (realloc_skb \|\| !IS_ALIGNED((unsigned long) skb->data, SKB_DATA_ADDR_ALIGNMENT)) {
	108	/* Realloc SKB */
	109	if (skb_linearize(skb)) {
	110	hdev->stat.err_tx++;
	111	return -EINVAL;
	112	}
	113
	114	new_skb = esp_alloc_skb(skb->len + pad_len);
	115
	116	if (!new_skb) {
71d37aa1	117	printk(KERN_ERR "%s: Failed to allocate SKB", __func__);
c6a5eef9	118	hdev->stat.err_tx++;
71d37aa1 MM	119	return -ENOMEM;
	120	}
	121
5bd53032 MM	122	pos = new_skb->data;
	123
	124	pos += pad_len;
	125
	126	/* Populate new SKB */
	127	skb_copy_from_linear_data(skb, pos, skb->len);
	128	skb_put(new_skb, skb->len);
71d37aa1	129
5bd53032 MM	130	/* Replace old SKB */
5bd53032 MM	131	dev_kfree_skb_any(skb);
71d37aa1	132	skb = new_skb;
5bd53032 MM	133	} else {
	134	/* Realloc is not needed, Make space for interface header */
	135	skb_push(skb, pad_len);
71d37aa1 MM	136	}
71d37aa1 MM	137
71d37aa1 MM	138	hdr = (struct esp_payload_header *) skb->data;
	139
	140	memset (hdr, 0, sizeof(struct esp_payload_header));
	141
	142	hdr->if_type = ESP_HCI_IF;
	143	hdr->if_num = 0;
	144	hdr->len = cpu_to_le16(len);
5bd53032 MM	145	hdr->offset = cpu_to_le16(pad_len);
	146	pos = skb->data;
	147
	148	/* set HCI packet type */
	149	*(pos + pad_len - 1) = pkt_type;
71d37aa1	150
54f5d2e4 MM	151	hdr->checksum = cpu_to_le16(compute_checksum(skb->data, (len + pad_len)));
54f5d2e4 MM	152
03e9f879	153	ret = esp_send_packet(adapter, skb);
71d37aa1	154
c6a5eef9 MM	155	if (ret) {
c6a5eef9 MM	156	hdev->stat.err_tx++;
5bd53032	157	return ret;
c6a5eef9 MM	158	} else {
	159	esp_hci_update_tx_counter(hdev, hdr->hci_pkt_type, skb->len);
	160	}
	161
71d37aa1 MM	162	return 0;
	163	}
	164
85c5e78a	165	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0))
71d37aa1 MM	166	static int esp_bt_setup(struct hci_dev *hdev)
	167	{
	168	return 0;
	169	}
85c5e78a	170	#endif
71d37aa1	171
85c5e78a	172	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 17, 0))
71d37aa1 MM	173	static int esp_bt_set_bdaddr(struct hci_dev hdev, const bdaddr_t bdaddr)
	174	{
	175	return 0;
	176	}
85c5e78a	177	#endif
71d37aa1 MM	178
	179	int esp_deinit_bt(struct esp_adapter *adapter)
	180	{
	181	struct hci_dev *hdev = NULL;
	182
062be972 MM	183	if (!adapter \|\| !adapter->hcidev)
	184	return 0;
	185
71d37aa1 MM	186	hdev = adapter->hcidev;
	187
	188	hci_unregister_dev(hdev);
	189	hci_free_dev(hdev);
	190
	191	adapter->hcidev = NULL;
	192
	193	return 0;
	194	}
	195
	196	int esp_init_bt(struct esp_adapter *adapter)
	197	{
	198	int ret = 0;
	199	struct hci_dev *hdev = NULL;
	200
	201	if (!adapter) {
	202	return -EINVAL;
	203	}
	204
	205	if (adapter->hcidev) {
	206	return -EEXIST;
	207	}
	208
	209	hdev = hci_alloc_dev();
	210
	211	if (!hdev) {
	212	BT_ERR("Can not allocate HCI device");
	213	return -ENOMEM;
	214	}
	215
	216	adapter->hcidev = hdev;
	217	hci_set_drvdata(hdev, adapter);
	218
d718e190 YM	219	hdev->bus = INVALID_HDEV_BUS;
d718e190 YM	220
062be972 MM	221	if (adapter->if_type == ESP_IF_TYPE_SDIO)
062be972 MM	222	hdev->bus = HCI_SDIO;
85c5e78a	223	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 7, 0))
062be972 MM	224	else if (adapter->if_type == ESP_IF_TYPE_SPI)
062be972 MM	225	hdev->bus = HCI_SPI;
85c5e78a	226	#endif
d718e190 YM	227
	228	if (hdev->bus == INVALID_HDEV_BUS) {
	229
	230	if (adapter->if_type == ESP_IF_TYPE_SDIO) {
	231	printk(KERN_ERR "%s: Kernel version does not support HCI over SDIO BUS\n",__func__);
	232	} else if (adapter->if_type == ESP_IF_TYPE_SPI) {
	233	printk(KERN_ERR "%s: Kernel version does not support HCI over SPI BUS\n",__func__);
	234	} else {
	235	printk(KERN_ERR "%s: HCI over expected BUS[%u] is not supported\n",__func__, adapter->if_type);
	236	}
	237	hci_free_dev(hdev);
	238	adapter->hcidev = NULL;
	239	return -EINVAL;
	240	}
062be972	241
71d37aa1 MM	242	hdev->open = esp_bt_open;
	243	hdev->close = esp_bt_close;
	244	hdev->flush = esp_bt_flush;
	245	hdev->send = esp_bt_send_frame;
85c5e78a	246
85c5e78a	247	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0))
71d37aa1	248	hdev->setup = esp_bt_setup;
85c5e78a	249	#endif
	250
	251	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 17, 0))
71d37aa1	252	hdev->set_bdaddr = esp_bt_set_bdaddr;
85c5e78a	253	#endif
71d37aa1 MM	254
	255	hdev->dev_type = HCI_PRIMARY;
	256
	257	ret = hci_register_dev(hdev);
	258	if (ret < 0) {
	259	BT_ERR("Can not register HCI device");
	260	hci_free_dev(hdev);
	261	return -ENOMEM;
	262	}
	263
	264	return 0;
	265	}