Merge branch 'for-upstream' of... (e8b47b53) · Commits · 戴 / test

drivers/bluetooth/Kconfig

+2 −2

Original line number	Diff line number	Diff line
		@@ -336,7 +336,7 @@ config BT_MRVL
		The core driver to support Marvell Bluetooth devices.

		This driver is required if you want to support
		Marvell Bluetooth devices, such as 8688/8787/8797/8887/8897/8997.
		Marvell Bluetooth devices, such as 8688/8787/8797/8887/8897/8977/8997.

		Say Y here to compile Marvell Bluetooth driver
		into the kernel or say M to compile it as module.
		@@ -350,7 +350,7 @@ config BT_MRVL_SDIO
		The driver for Marvell Bluetooth chipsets with SDIO interface.

		This driver is required if you want to use Marvell Bluetooth
		devices with SDIO interface. Currently SD8688/SD8787/SD8797/SD8887/SD8897/SD8997
		devices with SDIO interface. Currently SD8688/SD8787/SD8797/SD8887/SD8897/SD8977/SD8997
		chipsets are supported.

		Say Y here to compile support for Marvell BT-over-SDIO driver

drivers/bluetooth/btmrvl_drv.h

+0 −2

Original line number	Diff line number	Diff line
		@@ -24,11 +24,9 @@
		#include <linux/slab.h>
		#include <net/bluetooth/bluetooth.h>
		#include <linux/err.h>
		#include <linux/gpio.h>
		#include <linux/gfp.h>
		#include <linux/interrupt.h>
		#include <linux/io.h>
		#include <linux/of_gpio.h>
		#include <linux/of_platform.h>
		#include <linux/platform_device.h>
		#include <linux/pm_runtime.h>

drivers/bluetooth/btmrvl_sdio.c

+40 −3

Original line number	Diff line number	Diff line
		@@ -62,13 +62,14 @@ static const struct of_device_id btmrvl_sdio_of_match_table[] = {
		static irqreturn_t btmrvl_wake_irq_bt(int irq, void *priv)
		{
		struct btmrvl_sdio_card *card = priv;
		struct device *dev = &card->func->dev;
		struct btmrvl_plt_wake_cfg *cfg = card->plt_wake_cfg;

		pr_info("%s: wake by bt\n", __func__);
		dev_info(dev, "wake by bt\n");
		cfg->wake_by_bt = true;
		disable_irq_nosync(irq);

		pm_wakeup_event(&card->func->dev, 0);
		pm_wakeup_event(dev, 0);
		pm_system_wakeup();

		return IRQ_HANDLED;
		@@ -87,7 +88,7 @@ static int btmrvl_sdio_probe_of(struct device *dev,

		if (!dev->of_node \|\|
		!of_match_node(btmrvl_sdio_of_match_table, dev->of_node)) {
		pr_err("sdio platform data not available\n");
		dev_info(dev, "sdio device tree data not available\n");
		return -1;
		}

		@@ -211,6 +212,29 @@ static const struct btmrvl_sdio_card_reg btmrvl_reg_8897 = {
		.fw_dump_end = 0xea,
		};

		static const struct btmrvl_sdio_card_reg btmrvl_reg_8977 = {
		.cfg = 0x00,
		.host_int_mask = 0x08,
		.host_intstatus = 0x0c,
		.card_status = 0x5c,
		.sq_read_base_addr_a0 = 0xf8,
		.sq_read_base_addr_a1 = 0xf9,
		.card_revision = 0xc8,
		.card_fw_status0 = 0xe8,
		.card_fw_status1 = 0xe9,
		.card_rx_len = 0xea,
		.card_rx_unit = 0xeb,
		.io_port_0 = 0xe4,
		.io_port_1 = 0xe5,
		.io_port_2 = 0xe6,
		.int_read_to_clear = true,
		.host_int_rsr = 0x04,
		.card_misc_cfg = 0xD8,
		.fw_dump_ctrl = 0xf0,
		.fw_dump_start = 0xf1,
		.fw_dump_end = 0xf8,
		};

		static const struct btmrvl_sdio_card_reg btmrvl_reg_8997 = {
		.cfg = 0x00,
		.host_int_mask = 0x08,
		@@ -279,6 +303,15 @@ static const struct btmrvl_sdio_device btmrvl_sdio_sd8897 = {
		.supports_fw_dump = true,
		};

		static const struct btmrvl_sdio_device btmrvl_sdio_sd8977 = {
		.helper = NULL,
		.firmware = "mrvl/sd8977_uapsta.bin",
		.reg = &btmrvl_reg_8977,
		.support_pscan_win_report = true,
		.sd_blksz_fw_dl = 256,
		.supports_fw_dump = true,
		};

		static const struct btmrvl_sdio_device btmrvl_sdio_sd8997 = {
		.helper = NULL,
		.firmware = "mrvl/sd8997_uapsta.bin",
		@@ -307,6 +340,9 @@ static const struct sdio_device_id btmrvl_sdio_ids[] = {
		/* Marvell SD8897 Bluetooth device */
		{ SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, 0x912E),
		.driver_data = (unsigned long)&btmrvl_sdio_sd8897 },
		/* Marvell SD8977 Bluetooth device */
		{ SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, 0x9146),
		.driver_data = (unsigned long)&btmrvl_sdio_sd8977 },
		/* Marvell SD8997 Bluetooth device */
		{ SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, 0x9142),
		.driver_data = (unsigned long)&btmrvl_sdio_sd8997 },
		@@ -1760,4 +1796,5 @@ MODULE_FIRMWARE("mrvl/sd8787_uapsta.bin");
		MODULE_FIRMWARE("mrvl/sd8797_uapsta.bin");
		MODULE_FIRMWARE("mrvl/sd8887_uapsta.bin");
		MODULE_FIRMWARE("mrvl/sd8897_uapsta.bin");
		MODULE_FIRMWARE("mrvl/sd8977_uapsta.bin");
		MODULE_FIRMWARE("mrvl/sd8997_uapsta.bin");

drivers/bluetooth/btmtkuart.c

+234 −23

Original line number	Diff line number	Diff line
		@@ -12,6 +12,7 @@
		#include <linux/atomic.h>
		#include <linux/clk.h>
		#include <linux/firmware.h>
		#include <linux/iopoll.h>
		#include <linux/kernel.h>
		#include <linux/module.h>
		#include <linux/of.h>
		@@ -37,7 +38,17 @@
		enum {
		MTK_WMT_PATCH_DWNLD = 0x1,
		MTK_WMT_FUNC_CTRL = 0x6,
		MTK_WMT_RST = 0x7
		MTK_WMT_RST = 0x7,
		MTK_WMT_SEMAPHORE = 0x17,
		};

		enum {
		BTMTK_WMT_INVALID,
		BTMTK_WMT_PATCH_UNDONE,
		BTMTK_WMT_PATCH_DONE,
		BTMTK_WMT_ON_UNDONE,
		BTMTK_WMT_ON_DONE,
		BTMTK_WMT_ON_PROGRESS,
		};

		struct mtk_stp_hdr {
		@@ -58,6 +69,32 @@ struct mtk_hci_wmt_cmd {
		u8 data[256];
		} __packed;

		struct btmtk_hci_wmt_evt {
		struct hci_event_hdr hhdr;
		struct mtk_wmt_hdr whdr;
		} __packed;

		struct btmtk_hci_wmt_evt_funcc {
		struct btmtk_hci_wmt_evt hwhdr;
		__be16 status;
		} __packed;

		struct btmtk_tci_sleep {
		u8 mode;
		__le16 duration;
		__le16 host_duration;
		u8 host_wakeup_pin;
		u8 time_compensation;
		} __packed;

		struct btmtk_hci_wmt_params {
		u8 op;
		u8 flag;
		u16 dlen;
		const void *data;
		u32 *status;
		};

		struct btmtkuart_dev {
		struct hci_dev *hdev;
		struct serdev_device *serdev;
		@@ -68,31 +105,34 @@ struct btmtkuart_dev {
		struct sk_buff_head txq;

		struct sk_buff *rx_skb;
		struct sk_buff *evt_skb;

		u8 stp_pad[6];
		u8 stp_cursor;
		u16 stp_dlen;
		};

		static int mtk_hci_wmt_sync(struct hci_dev *hdev, u8 op, u8 flag, u16 plen,
		const void *param)
		static int mtk_hci_wmt_sync(struct hci_dev *hdev,
		struct btmtk_hci_wmt_params *wmt_params)
		{
		struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
		struct btmtk_hci_wmt_evt_funcc *wmt_evt_funcc;
		u32 hlen, status = BTMTK_WMT_INVALID;
		struct btmtk_hci_wmt_evt *wmt_evt;
		struct mtk_hci_wmt_cmd wc;
		struct mtk_wmt_hdr *hdr;
		u32 hlen;
		int err;

		hlen = sizeof(*hdr) + plen;
		hlen = sizeof(*hdr) + wmt_params->dlen;
		if (hlen > 255)
		return -EINVAL;

		hdr = (struct mtk_wmt_hdr *)&wc;
		hdr->dir = 1;
		hdr->op = op;
		hdr->dlen = cpu_to_le16(plen + 1);
		hdr->flag = flag;
		memcpy(wc.data, param, plen);
		hdr->op = wmt_params->op;
		hdr->dlen = cpu_to_le16(wmt_params->dlen + 1);
		hdr->flag = wmt_params->flag;
		memcpy(wc.data, wmt_params->data, wmt_params->dlen);

		set_bit(BTMTKUART_TX_WAIT_VND_EVT, &bdev->tx_state);

		@@ -107,7 +147,7 @@ static int mtk_hci_wmt_sync(struct hci_dev *hdev, u8 op, u8 flag, u16 plen,
		* Complete as with usual HCI command flow control.
		*
		* After sending the command, wait for BTMTKUART_TX_WAIT_VND_EVT
		* state to be cleared. The driver speicfic event receive routine
		* state to be cleared. The driver specific event receive routine
		* will clear that state and with that indicate completion of the
		* WMT command.
		*/
		@@ -115,19 +155,56 @@ static int mtk_hci_wmt_sync(struct hci_dev *hdev, u8 op, u8 flag, u16 plen,
		TASK_INTERRUPTIBLE, HCI_INIT_TIMEOUT);
		if (err == -EINTR) {
		bt_dev_err(hdev, "Execution of wmt command interrupted");
		clear_bit(BTMTKUART_TX_WAIT_VND_EVT, &bdev->tx_state);
		return err;
		}

		if (err) {
		bt_dev_err(hdev, "Execution of wmt command timed out");
		clear_bit(BTMTKUART_TX_WAIT_VND_EVT, &bdev->tx_state);
		return -ETIMEDOUT;
		}

		return 0;
		/* Parse and handle the return WMT event */
		wmt_evt = (struct btmtk_hci_wmt_evt *)bdev->evt_skb->data;
		if (wmt_evt->whdr.op != hdr->op) {
		bt_dev_err(hdev, "Wrong op received %d expected %d",
		wmt_evt->whdr.op, hdr->op);
		err = -EIO;
		goto err_free_skb;
		}

		switch (wmt_evt->whdr.op) {
		case MTK_WMT_SEMAPHORE:
		if (wmt_evt->whdr.flag == 2)
		status = BTMTK_WMT_PATCH_UNDONE;
		else
		status = BTMTK_WMT_PATCH_DONE;
		break;
		case MTK_WMT_FUNC_CTRL:
		wmt_evt_funcc = (struct btmtk_hci_wmt_evt_funcc *)wmt_evt;
		if (be16_to_cpu(wmt_evt_funcc->status) == 0x404)
		status = BTMTK_WMT_ON_DONE;
		else if (be16_to_cpu(wmt_evt_funcc->status) == 0x420)
		status = BTMTK_WMT_ON_PROGRESS;
		else
		status = BTMTK_WMT_ON_UNDONE;
		break;
		}

		if (wmt_params->status)
		*wmt_params->status = status;

		err_free_skb:
		kfree_skb(bdev->evt_skb);
		bdev->evt_skb = NULL;

		return err;
		}

		static int mtk_setup_fw(struct hci_dev *hdev)
		{
		struct btmtk_hci_wmt_params wmt_params;
		const struct firmware *fw;
		const u8 *fw_ptr;
		size_t fw_size;
		@@ -153,6 +230,9 @@ static int mtk_setup_fw(struct hci_dev *hdev)
		fw_ptr += 30;
		flag = 1;

		wmt_params.op = MTK_WMT_PATCH_DWNLD;
		wmt_params.status = NULL;

		while (fw_size > 0) {
		dlen = min_t(int, 250, fw_size);

		@@ -162,18 +242,37 @@ static int mtk_setup_fw(struct hci_dev *hdev)
		else if (fw_size < fw->size - 30)
		flag = 2;

		err = mtk_hci_wmt_sync(hdev, MTK_WMT_PATCH_DWNLD, flag, dlen,
		fw_ptr);
		wmt_params.flag = flag;
		wmt_params.dlen = dlen;
		wmt_params.data = fw_ptr;

		err = mtk_hci_wmt_sync(hdev, &wmt_params);
		if (err < 0) {
		bt_dev_err(hdev, "Failed to send wmt patch dwnld (%d)",
		err);
		break;
		goto free_fw;
		}

		fw_size -= dlen;
		fw_ptr += dlen;
		}

		wmt_params.op = MTK_WMT_RST;
		wmt_params.flag = 4;
		wmt_params.dlen = 0;
		wmt_params.data = NULL;
		wmt_params.status = NULL;

		/* Activate funciton the firmware providing to */
		err = mtk_hci_wmt_sync(hdev, &wmt_params);
		if (err < 0) {
		bt_dev_err(hdev, "Failed to send wmt rst (%d)", err);
		goto free_fw;
		}

		/* Wait a few moments for firmware activation done */
		usleep_range(10000, 12000);

		free_fw:
		release_firmware(fw);
		return err;
		@@ -192,7 +291,20 @@ static int btmtkuart_recv_event(struct hci_dev hdev, struct sk_buff skb)
		if (hdr->evt == 0xe4)
		hdr->evt = HCI_EV_VENDOR;

		/* When someone waits for the WMT event, the skb is being cloned
		* and being processed the events from there then.
		*/
		if (test_bit(BTMTKUART_TX_WAIT_VND_EVT, &bdev->tx_state)) {
		bdev->evt_skb = skb_clone(skb, GFP_KERNEL);
		if (!bdev->evt_skb) {
		err = -ENOMEM;
		goto err_out;
		}
		}

		err = hci_recv_frame(hdev, skb);
		if (err < 0)
		goto err_free_skb;

		if (hdr->evt == HCI_EV_VENDOR) {
		if (test_and_clear_bit(BTMTKUART_TX_WAIT_VND_EVT,
		@@ -203,6 +315,13 @@ static int btmtkuart_recv_event(struct hci_dev hdev, struct sk_buff skb)
		}
		}

		return 0;

		err_free_skb:
		kfree_skb(bdev->evt_skb);
		bdev->evt_skb = NULL;

		err_out:
		return err;
		}

		@@ -465,42 +584,134 @@ static int btmtkuart_flush(struct hci_dev *hdev)
		return 0;
		}

		static int btmtkuart_func_query(struct hci_dev *hdev)
		{
		struct btmtk_hci_wmt_params wmt_params;
		int status, err;
		u8 param = 0;

		/* Query whether the function is enabled */
		wmt_params.op = MTK_WMT_FUNC_CTRL;
		wmt_params.flag = 4;
		wmt_params.dlen = sizeof(param);
		wmt_params.data = &param;
		wmt_params.status = &status;

		err = mtk_hci_wmt_sync(hdev, &wmt_params);
		if (err < 0) {
		bt_dev_err(hdev, "Failed to query function status (%d)", err);
		return err;
		}

		return status;
		}

		static int btmtkuart_setup(struct hci_dev *hdev)
		{
		struct btmtk_hci_wmt_params wmt_params;
		ktime_t calltime, delta, rettime;
		struct btmtk_tci_sleep tci_sleep;
		unsigned long long duration;
		struct sk_buff *skb;
		int err, status;
		u8 param = 0x1;
		int err = 0;

		calltime = ktime_get();

		/* Query whether the firmware is already download */
		wmt_params.op = MTK_WMT_SEMAPHORE;
		wmt_params.flag = 1;
		wmt_params.dlen = 0;
		wmt_params.data = NULL;
		wmt_params.status = &status;

		err = mtk_hci_wmt_sync(hdev, &wmt_params);
		if (err < 0) {
		bt_dev_err(hdev, "Failed to query firmware status (%d)", err);
		return err;
		}

		if (status == BTMTK_WMT_PATCH_DONE) {
		bt_dev_info(hdev, "Firmware already downloaded");
		goto ignore_setup_fw;
		}

		/* Setup a firmware which the device definitely requires */
		err = mtk_setup_fw(hdev);
		if (err < 0)
		return err;

		/* Activate function the firmware providing to */
		err = mtk_hci_wmt_sync(hdev, MTK_WMT_RST, 0x4, 0, 0);
		if (err < 0) {
		bt_dev_err(hdev, "Failed to send wmt rst (%d)", err);
		ignore_setup_fw:
		/* Query whether the device is already enabled */
		err = readx_poll_timeout(btmtkuart_func_query, hdev, status,
		status < 0 \|\| status != BTMTK_WMT_ON_PROGRESS,
		2000, 5000000);
		/* -ETIMEDOUT happens */
		if (err < 0)
		return err;

		/* The other errors happen in btusb_mtk_func_query */
		if (status < 0)
		return status;

		if (status == BTMTK_WMT_ON_DONE) {
		bt_dev_info(hdev, "function already on");
		goto ignore_func_on;
		}

		/* Enable Bluetooth protocol */
		err = mtk_hci_wmt_sync(hdev, MTK_WMT_FUNC_CTRL, 0x0, sizeof(param),
		&param);
		wmt_params.op = MTK_WMT_FUNC_CTRL;
		wmt_params.flag = 0;
		wmt_params.dlen = sizeof(param);
		wmt_params.data = &param;
		wmt_params.status = NULL;

		err = mtk_hci_wmt_sync(hdev, &wmt_params);
		if (err < 0) {
		bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
		return err;
		}

		ignore_func_on:
		/* Apply the low power environment setup */
		tci_sleep.mode = 0x5;
		tci_sleep.duration = cpu_to_le16(0x640);
		tci_sleep.host_duration = cpu_to_le16(0x640);
		tci_sleep.host_wakeup_pin = 0;
		tci_sleep.time_compensation = 0;

		skb = __hci_cmd_sync(hdev, 0xfc7a, sizeof(tci_sleep), &tci_sleep,
		HCI_INIT_TIMEOUT);
		if (IS_ERR(skb)) {
		err = PTR_ERR(skb);
		bt_dev_err(hdev, "Failed to apply low power setting (%d)", err);
		return err;
		}
		kfree_skb(skb);

		rettime = ktime_get();
		delta = ktime_sub(rettime, calltime);
		duration = (unsigned long long)ktime_to_ns(delta) >> 10;

		bt_dev_info(hdev, "Device setup in %llu usecs", duration);

		return 0;
		}

		static int btmtkuart_shutdown(struct hci_dev *hdev)
		{
		struct btmtk_hci_wmt_params wmt_params;
		u8 param = 0x0;
		int err;

		/* Disable the device */
		err = mtk_hci_wmt_sync(hdev, MTK_WMT_FUNC_CTRL, 0x0, sizeof(param),
		&param);
		wmt_params.op = MTK_WMT_FUNC_CTRL;
		wmt_params.flag = 0;
		wmt_params.dlen = sizeof(param);
		wmt_params.data = &param;
		wmt_params.status = NULL;

		err = mtk_hci_wmt_sync(hdev, &wmt_params);
		if (err < 0) {
		bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
		return err;

drivers/bluetooth/btqca.c

+19 −0

Original line number	Diff line number	Diff line
		@@ -391,6 +391,25 @@ int qca_uart_setup(struct hci_dev *hdev, uint8_t baudrate,
		}
		EXPORT_SYMBOL_GPL(qca_uart_setup);

		int qca_set_bdaddr(struct hci_dev hdev, const bdaddr_t bdaddr)
		{
		struct sk_buff *skb;
		int err;

		skb = __hci_cmd_sync_ev(hdev, EDL_WRITE_BD_ADDR_OPCODE, 6, bdaddr,
		HCI_EV_VENDOR, HCI_INIT_TIMEOUT);
		if (IS_ERR(skb)) {
		err = PTR_ERR(skb);
		bt_dev_err(hdev, "QCA Change address cmd failed (%d)", err);
		return err;
		}

		kfree_skb(skb);

		return 0;
		}
		EXPORT_SYMBOL_GPL(qca_set_bdaddr);

		MODULE_AUTHOR("Ben Young Tae Kim <ytkim@qca.qualcomm.com>");
		MODULE_DESCRIPTION("Bluetooth support for Qualcomm Atheros family ver " VERSION);
		MODULE_VERSION(VERSION);

Admin message