Bluetooth: hci_qca: Add support for Qualcomm Bluetooth chip wcn3990 (fa9ad876) · Commits · e / devices / android_kernel_teracube_emerald

drivers/bluetooth/btqca.h

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -37,6 +37,9 @@
	#define EDL_TAG_ID_HCI (17)		#define EDL_TAG_ID_HCI (17)
	#define EDL_TAG_ID_DEEP_SLEEP (27)		#define EDL_TAG_ID_DEEP_SLEEP (27)

			#define QCA_WCN3990_POWERON_PULSE 0xFC
			#define QCA_WCN3990_POWEROFF_PULSE 0xC0

	enum qca_bardrate {		enum qca_bardrate {
	QCA_BAUDRATE_115200 = 0,		QCA_BAUDRATE_115200 = 0,
	QCA_BAUDRATE_57600,		QCA_BAUDRATE_57600,

drivers/bluetooth/hci_qca.c

+360 −47

Original line number	Original line	Diff line number	Diff line
	@@ -5,7 +5,7 @@
	* protocol extension to H4.		* protocol extension to H4.
	*		*
	* Copyright (C) 2007 Texas Instruments, Inc.		* Copyright (C) 2007 Texas Instruments, Inc.
	* Copyright (c) 2010, 2012 The Linux Foundation. All rights reserved.		* Copyright (c) 2010, 2012, 2018 The Linux Foundation. All rights reserved.
	*		*
	* Acknowledgements:		* Acknowledgements:
	* This file is based on hci_ll.c, which was...		* This file is based on hci_ll.c, which was...
	@@ -31,9 +31,14 @@
	#include <linux/kernel.h>		#include <linux/kernel.h>
	#include <linux/clk.h>		#include <linux/clk.h>
	#include <linux/debugfs.h>		#include <linux/debugfs.h>
			#include <linux/delay.h>
			#include <linux/device.h>
	#include <linux/gpio/consumer.h>		#include <linux/gpio/consumer.h>
	#include <linux/mod_devicetable.h>		#include <linux/mod_devicetable.h>
	#include <linux/module.h>		#include <linux/module.h>
			#include <linux/of_device.h>
			#include <linux/platform_device.h>
			#include <linux/regulator/consumer.h>
	#include <linux/serdev.h>		#include <linux/serdev.h>

	#include <net/bluetooth/bluetooth.h>		#include <net/bluetooth/bluetooth.h>
	@@ -124,12 +129,46 @@ enum qca_speed_type {
	QCA_OPER_SPEED		QCA_OPER_SPEED
	};		};

			/*
			* Voltage regulator information required for configuring the
			* QCA Bluetooth chipset
			*/
			struct qca_vreg {
			const char *name;
			unsigned int min_uV;
			unsigned int max_uV;
			unsigned int load_uA;
			};

			struct qca_vreg_data {
			enum qca_btsoc_type soc_type;
			struct qca_vreg *vregs;
			size_t num_vregs;
			};

			/*
			* Platform data for the QCA Bluetooth power driver.
			*/
			struct qca_power {
			struct device *dev;
			const struct qca_vreg_data *vreg_data;
			struct regulator_bulk_data *vreg_bulk;
			bool vregs_on;
			};

	struct qca_serdev {		struct qca_serdev {
	struct hci_uart serdev_hu;		struct hci_uart serdev_hu;
	struct gpio_desc *bt_en;		struct gpio_desc *bt_en;
	struct clk *susclk;		struct clk *susclk;
			enum qca_btsoc_type btsoc_type;
			struct qca_power *bt_power;
			u32 init_speed;
			u32 oper_speed;
	};		};

			static int qca_power_setup(struct hci_uart *hu, bool on);
			static void qca_power_shutdown(struct hci_dev *hdev);

	static void __serial_clock_on(struct tty_struct *tty)		static void __serial_clock_on(struct tty_struct *tty)
	{		{
	/* TODO: Some chipset requires to enable UART clock on client		/* TODO: Some chipset requires to enable UART clock on client
	@@ -407,6 +446,7 @@ static int qca_open(struct hci_uart *hu)
	{		{
	struct qca_serdev *qcadev;		struct qca_serdev *qcadev;
	struct qca_data *qca;		struct qca_data *qca;
			int ret;

	BT_DBG("hu %p qca_open", hu);		BT_DBG("hu %p qca_open", hu);

	@@ -458,19 +498,32 @@ static int qca_open(struct hci_uart *hu)

	hu->priv = qca;		hu->priv = qca;

	timer_setup(&qca->wake_retrans_timer, hci_ibs_wake_retrans_timeout, 0);
	qca->wake_retrans = IBS_WAKE_RETRANS_TIMEOUT_MS;

	timer_setup(&qca->tx_idle_timer, hci_ibs_tx_idle_timeout, 0);
	qca->tx_idle_delay = IBS_TX_IDLE_TIMEOUT_MS;

	if (hu->serdev) {		if (hu->serdev) {
	serdev_device_open(hu->serdev);		serdev_device_open(hu->serdev);

	qcadev = serdev_device_get_drvdata(hu->serdev);		qcadev = serdev_device_get_drvdata(hu->serdev);
			if (qcadev->btsoc_type != QCA_WCN3990) {
	gpiod_set_value_cansleep(qcadev->bt_en, 1);		gpiod_set_value_cansleep(qcadev->bt_en, 1);
			} else {
			hu->init_speed = qcadev->init_speed;
			hu->oper_speed = qcadev->oper_speed;
			ret = qca_power_setup(hu, true);
			if (ret) {
			destroy_workqueue(qca->workqueue);
			kfree_skb(qca->rx_skb);
			hu->priv = NULL;
			kfree(qca);
			return ret;
			}
			}
	}		}

			timer_setup(&qca->wake_retrans_timer, hci_ibs_wake_retrans_timeout, 0);
			qca->wake_retrans = IBS_WAKE_RETRANS_TIMEOUT_MS;

			timer_setup(&qca->tx_idle_timer, hci_ibs_tx_idle_timeout, 0);
			qca->tx_idle_delay = IBS_TX_IDLE_TIMEOUT_MS;

	BT_DBG("HCI_UART_QCA open, tx_idle_delay=%u, wake_retrans=%u",		BT_DBG("HCI_UART_QCA open, tx_idle_delay=%u, wake_retrans=%u",
	qca->tx_idle_delay, qca->wake_retrans);		qca->tx_idle_delay, qca->wake_retrans);

	@@ -554,10 +607,13 @@ static int qca_close(struct hci_uart *hu)
	qca->hu = NULL;		qca->hu = NULL;

	if (hu->serdev) {		if (hu->serdev) {
	serdev_device_close(hu->serdev);

	qcadev = serdev_device_get_drvdata(hu->serdev);		qcadev = serdev_device_get_drvdata(hu->serdev);
			if (qcadev->btsoc_type == QCA_WCN3990)
			qca_power_shutdown(hu->hdev);
			else
	gpiod_set_value_cansleep(qcadev->bt_en, 0);		gpiod_set_value_cansleep(qcadev->bt_en, 0);

			serdev_device_close(hu->serdev);
	}		}

	kfree_skb(qca->rx_skb);		kfree_skb(qca->rx_skb);
	@@ -891,6 +947,7 @@ static int qca_set_baudrate(struct hci_dev *hdev, uint8_t baudrate)
	struct hci_uart *hu = hci_get_drvdata(hdev);		struct hci_uart *hu = hci_get_drvdata(hdev);
	struct qca_data *qca = hu->priv;		struct qca_data *qca = hu->priv;
	struct sk_buff *skb;		struct sk_buff *skb;
			struct qca_serdev *qcadev;
	u8 cmd[] = { 0x01, 0x48, 0xFC, 0x01, 0x00 };		u8 cmd[] = { 0x01, 0x48, 0xFC, 0x01, 0x00 };

	if (baudrate > QCA_BAUDRATE_3200000)		if (baudrate > QCA_BAUDRATE_3200000)
	@@ -904,6 +961,13 @@ static int qca_set_baudrate(struct hci_dev *hdev, uint8_t baudrate)
	return -ENOMEM;		return -ENOMEM;
	}		}

			/* Disabling hardware flow control is mandatory while
			* sending change baudrate request to wcn3990 SoC.
			*/
			qcadev = serdev_device_get_drvdata(hu->serdev);
			if (qcadev->btsoc_type == QCA_WCN3990)
			hci_uart_set_flow_control(hu, true);

	/* Assign commands to change baudrate and packet type. */		/* Assign commands to change baudrate and packet type. */
	skb_put_data(skb, cmd, sizeof(cmd));		skb_put_data(skb, cmd, sizeof(cmd));
	hci_skb_pkt_type(skb) = HCI_COMMAND_PKT;		hci_skb_pkt_type(skb) = HCI_COMMAND_PKT;
	@@ -919,6 +983,9 @@ static int qca_set_baudrate(struct hci_dev *hdev, uint8_t baudrate)
	schedule_timeout(msecs_to_jiffies(BAUDRATE_SETTLE_TIMEOUT_MS));		schedule_timeout(msecs_to_jiffies(BAUDRATE_SETTLE_TIMEOUT_MS));
	set_current_state(TASK_RUNNING);		set_current_state(TASK_RUNNING);

			if (qcadev->btsoc_type == QCA_WCN3990)
			hci_uart_set_flow_control(hu, false);

	return 0;		return 0;
	}		}

	@@ -930,6 +997,43 @@ static inline void host_set_baudrate(struct hci_uart *hu, unsigned int speed)
	hci_uart_set_baudrate(hu, speed);		hci_uart_set_baudrate(hu, speed);
	}		}

			static int qca_send_power_pulse(struct hci_dev *hdev, u8 cmd)
			{
			struct hci_uart *hu = hci_get_drvdata(hdev);
			struct qca_data *qca = hu->priv;
			struct sk_buff *skb;

			/* These power pulses are single byte command which are sent
			* at required baudrate to wcn3990. On wcn3990, we have an external
			* circuit at Tx pin which decodes the pulse sent at specific baudrate.
			* For example, wcn3990 supports RF COEX antenna for both Wi-Fi/BT
			* and also we use the same power inputs to turn on and off for
			* Wi-Fi/BT. Powering up the power sources will not enable BT, until
			* we send a power on pulse at 115200 bps. This algorithm will help to
			* save power. Disabling hardware flow control is mandatory while
			* sending power pulses to SoC.
			*/
			bt_dev_dbg(hdev, "sending power pulse %02x to SoC", cmd);

			skb = bt_skb_alloc(sizeof(cmd), GFP_KERNEL);
			if (!skb)
			return -ENOMEM;

			hci_uart_set_flow_control(hu, true);

			skb_put_u8(skb, cmd);
			hci_skb_pkt_type(skb) = HCI_COMMAND_PKT;

			skb_queue_tail(&qca->txq, skb);
			hci_uart_tx_wakeup(hu);

			/* Wait for 100 uS for SoC to settle down */
			usleep_range(100, 200);
			hci_uart_set_flow_control(hu, false);

			return 0;
			}

	static unsigned int qca_get_speed(struct hci_uart *hu,		static unsigned int qca_get_speed(struct hci_uart *hu,
	enum qca_speed_type speed_type)		enum qca_speed_type speed_type)
	{		{
	@@ -952,9 +1056,18 @@ static unsigned int qca_get_speed(struct hci_uart *hu,

	static int qca_check_speeds(struct hci_uart *hu)		static int qca_check_speeds(struct hci_uart *hu)
	{		{
			struct qca_serdev *qcadev;

			qcadev = serdev_device_get_drvdata(hu->serdev);
			if (qcadev->btsoc_type == QCA_WCN3990) {
			if (!qca_get_speed(hu, QCA_INIT_SPEED) &&
			!qca_get_speed(hu, QCA_OPER_SPEED))
			return -EINVAL;
			} else {
	if (!qca_get_speed(hu, QCA_INIT_SPEED) \|\|		if (!qca_get_speed(hu, QCA_INIT_SPEED) \|\|
	!qca_get_speed(hu, QCA_OPER_SPEED))		!qca_get_speed(hu, QCA_OPER_SPEED))
	return -EINVAL;		return -EINVAL;
			}

	return 0;		return 0;
	}		}
	@@ -974,7 +1087,7 @@ static int qca_set_speed(struct hci_uart *hu, enum qca_speed_type speed_type)
	return 0;		return 0;

	qca_baudrate = qca_get_baudrate_value(speed);		qca_baudrate = qca_get_baudrate_value(speed);
	bt_dev_info(hu->hdev, "Set UART speed to %d", speed);		bt_dev_dbg(hu->hdev, "Set UART speed to %d", speed);
	ret = qca_set_baudrate(hu->hdev, qca_baudrate);		ret = qca_set_baudrate(hu->hdev, qca_baudrate);
	if (ret)		if (ret)
	return ret;		return ret;
	@@ -985,15 +1098,52 @@ static int qca_set_speed(struct hci_uart *hu, enum qca_speed_type speed_type)
	return 0;		return 0;
	}		}

			static int qca_wcn3990_init(struct hci_uart *hu)
			{
			struct hci_dev *hdev = hu->hdev;
			int ret;

			/* Forcefully enable wcn3990 to enter in to boot mode. */
			host_set_baudrate(hu, 2400);
			ret = qca_send_power_pulse(hdev, QCA_WCN3990_POWEROFF_PULSE);
			if (ret)
			return ret;

			qca_set_speed(hu, QCA_INIT_SPEED);
			ret = qca_send_power_pulse(hdev, QCA_WCN3990_POWERON_PULSE);
			if (ret)
			return ret;

			/* Wait for 100 ms for SoC to boot */
			msleep(100);

			/* Now the device is in ready state to communicate with host.
			* To sync host with device we need to reopen port.
			* Without this, we will have RTS and CTS synchronization
			* issues.
			*/
			serdev_device_close(hu->serdev);
			ret = serdev_device_open(hu->serdev);
			if (ret) {
			bt_dev_err(hu->hdev, "failed to open port");
			return ret;
			}

			hci_uart_set_flow_control(hu, false);

			return 0;
			}

	static int qca_setup(struct hci_uart *hu)		static int qca_setup(struct hci_uart *hu)
	{		{
	struct hci_dev *hdev = hu->hdev;		struct hci_dev *hdev = hu->hdev;
	struct qca_data *qca = hu->priv;		struct qca_data *qca = hu->priv;
	unsigned int speed, qca_baudrate = QCA_BAUDRATE_115200;		unsigned int speed, qca_baudrate = QCA_BAUDRATE_115200;
			struct qca_serdev *qcadev;
	int ret;		int ret;
	int soc_ver = 0;		int soc_ver = 0;

	bt_dev_info(hdev, "ROME setup");		qcadev = serdev_device_get_drvdata(hu->serdev);

	ret = qca_check_speeds(hu);		ret = qca_check_speeds(hu);
	if (ret)		if (ret)
	@@ -1002,8 +1152,19 @@ static int qca_setup(struct hci_uart *hu)
	/* Patch downloading has to be done without IBS mode */		/* Patch downloading has to be done without IBS mode */
	clear_bit(STATE_IN_BAND_SLEEP_ENABLED, &qca->flags);		clear_bit(STATE_IN_BAND_SLEEP_ENABLED, &qca->flags);

	/* Setup initial baudrate */		if (qcadev->btsoc_type == QCA_WCN3990) {
			bt_dev_info(hdev, "setting up wcn3990");
			ret = qca_wcn3990_init(hu);
			if (ret)
			return ret;

			ret = qca_read_soc_version(hdev, &soc_ver);
			if (ret)
			return ret;
			} else {
			bt_dev_info(hdev, "ROME setup");
	qca_set_speed(hu, QCA_INIT_SPEED);		qca_set_speed(hu, QCA_INIT_SPEED);
			}

	/* Setup user speed if needed */		/* Setup user speed if needed */
	speed = qca_get_speed(hu, QCA_OPER_SPEED);		speed = qca_get_speed(hu, QCA_OPER_SPEED);
	@@ -1015,15 +1176,16 @@ static int qca_setup(struct hci_uart *hu)
	qca_baudrate = qca_get_baudrate_value(speed);		qca_baudrate = qca_get_baudrate_value(speed);
	}		}

			if (qcadev->btsoc_type != QCA_WCN3990) {
	/* Get QCA version information */		/* Get QCA version information */
	ret = qca_read_soc_version(hdev, &soc_ver);		ret = qca_read_soc_version(hdev, &soc_ver);
	if (ret)		if (ret)
	return ret;		return ret;
			}

	bt_dev_info(hdev, "QCA controller version 0x%08x", soc_ver);		bt_dev_info(hdev, "QCA controller version 0x%08x", soc_ver);

	/* Setup patch / NVM configurations */		/* Setup patch / NVM configurations */
	ret = qca_uart_setup(hdev, qca_baudrate, QCA_ROME, soc_ver);		ret = qca_uart_setup(hdev, qca_baudrate, qcadev->btsoc_type, soc_ver);
	if (!ret) {		if (!ret) {
	set_bit(STATE_IN_BAND_SLEEP_ENABLED, &qca->flags);		set_bit(STATE_IN_BAND_SLEEP_ENABLED, &qca->flags);
	qca_debugfs_init(hdev);		qca_debugfs_init(hdev);
	@@ -1059,9 +1221,123 @@ static struct hci_uart_proto qca_proto = {
	.dequeue = qca_dequeue,		.dequeue = qca_dequeue,
	};		};

			static const struct qca_vreg_data qca_soc_data = {
			.soc_type = QCA_WCN3990,
			.vregs = (struct qca_vreg []) {
			{ "vddio", 1800000, 1900000, 15000 },
			{ "vddxo", 1800000, 1900000, 80000 },
			{ "vddrf", 1300000, 1350000, 300000 },
			{ "vddch0", 3300000, 3400000, 450000 },
			},
			.num_vregs = 4,
			};

			static void qca_power_shutdown(struct hci_dev *hdev)
			{
			struct hci_uart *hu = hci_get_drvdata(hdev);

			host_set_baudrate(hu, 2400);
			qca_send_power_pulse(hdev, QCA_WCN3990_POWEROFF_PULSE);
			qca_power_setup(hu, false);
			}

			static int qca_enable_regulator(struct qca_vreg vregs,
			struct regulator *regulator)
			{
			int ret;

			ret = regulator_set_voltage(regulator, vregs.min_uV,
			vregs.max_uV);
			if (ret)
			return ret;

			if (vregs.load_uA)
			ret = regulator_set_load(regulator,
			vregs.load_uA);

			if (ret)
			return ret;

			return regulator_enable(regulator);

			}

			static void qca_disable_regulator(struct qca_vreg vregs,
			struct regulator *regulator)
			{
			regulator_disable(regulator);
			regulator_set_voltage(regulator, 0, vregs.max_uV);
			if (vregs.load_uA)
			regulator_set_load(regulator, 0);

			}

			static int qca_power_setup(struct hci_uart *hu, bool on)
			{
			struct qca_vreg *vregs;
			struct regulator_bulk_data *vreg_bulk;
			struct qca_serdev *qcadev;
			int i, num_vregs, ret = 0;

			qcadev = serdev_device_get_drvdata(hu->serdev);
			if (!qcadev \|\| !qcadev->bt_power \|\| !qcadev->bt_power->vreg_data \|\|
			!qcadev->bt_power->vreg_bulk)
			return -EINVAL;

			vregs = qcadev->bt_power->vreg_data->vregs;
			vreg_bulk = qcadev->bt_power->vreg_bulk;
			num_vregs = qcadev->bt_power->vreg_data->num_vregs;
			BT_DBG("on: %d", on);
			if (on && !qcadev->bt_power->vregs_on) {
			for (i = 0; i < num_vregs; i++) {
			ret = qca_enable_regulator(vregs[i],
			vreg_bulk[i].consumer);
			if (ret)
			break;
			}

			if (ret) {
			BT_ERR("failed to enable regulator:%s", vregs[i].name);
			/* turn off regulators which are enabled */
			for (i = i - 1; i >= 0; i--)
			qca_disable_regulator(vregs[i],
			vreg_bulk[i].consumer);
			} else {
			qcadev->bt_power->vregs_on = true;
			}
			} else if (!on && qcadev->bt_power->vregs_on) {
			/* turn off regulator in reverse order */
			i = qcadev->bt_power->vreg_data->num_vregs - 1;
			for ( ; i >= 0; i--)
			qca_disable_regulator(vregs[i], vreg_bulk[i].consumer);

			qcadev->bt_power->vregs_on = false;
			}

			return ret;
			}

			static int qca_init_regulators(struct qca_power *qca,
			const struct qca_vreg *vregs, size_t num_vregs)
			{
			int i;

			qca->vreg_bulk = devm_kzalloc(qca->dev, num_vregs *
			sizeof(struct regulator_bulk_data),
			GFP_KERNEL);
			if (!qca->vreg_bulk)
			return -ENOMEM;

			for (i = 0; i < num_vregs; i++)
			qca->vreg_bulk[i].supply = vregs[i].name;

			return devm_regulator_bulk_get(qca->dev, num_vregs, qca->vreg_bulk);
			}

	static int qca_serdev_probe(struct serdev_device *serdev)		static int qca_serdev_probe(struct serdev_device *serdev)
	{		{
	struct qca_serdev *qcadev;		struct qca_serdev *qcadev;
			const struct qca_vreg_data *data;
	int err;		int err;

	qcadev = devm_kzalloc(&serdev->dev, sizeof(*qcadev), GFP_KERNEL);		qcadev = devm_kzalloc(&serdev->dev, sizeof(*qcadev), GFP_KERNEL);
	@@ -1069,8 +1345,39 @@ static int qca_serdev_probe(struct serdev_device *serdev)
	return -ENOMEM;		return -ENOMEM;

	qcadev->serdev_hu.serdev = serdev;		qcadev->serdev_hu.serdev = serdev;
			data = of_device_get_match_data(&serdev->dev);
	serdev_device_set_drvdata(serdev, qcadev);		serdev_device_set_drvdata(serdev, qcadev);
			if (data && data->soc_type == QCA_WCN3990) {
			qcadev->btsoc_type = QCA_WCN3990;
			qcadev->bt_power = devm_kzalloc(&serdev->dev,
			sizeof(struct qca_power),
			GFP_KERNEL);
			if (!qcadev->bt_power)
			return -ENOMEM;

			qcadev->bt_power->dev = &serdev->dev;
			qcadev->bt_power->vreg_data = data;
			err = qca_init_regulators(qcadev->bt_power, data->vregs,
			data->num_vregs);
			if (err) {
			BT_ERR("Failed to init regulators:%d", err);
			goto out;
			}

			qcadev->bt_power->vregs_on = false;

			device_property_read_u32(&serdev->dev, "max-speed",
			&qcadev->oper_speed);
			if (!qcadev->oper_speed)
			BT_DBG("UART will pick default operating speed");

			err = hci_uart_register_device(&qcadev->serdev_hu, &qca_proto);
			if (err) {
			BT_ERR("wcn3990 serdev registration failed");
			goto out;
			}
			} else {
			qcadev->btsoc_type = QCA_ROME;
	qcadev->bt_en = devm_gpiod_get(&serdev->dev, "enable",		qcadev->bt_en = devm_gpiod_get(&serdev->dev, "enable",
	GPIOD_OUT_LOW);		GPIOD_OUT_LOW);
	if (IS_ERR(qcadev->bt_en)) {		if (IS_ERR(qcadev->bt_en)) {
	@@ -1095,21 +1402,27 @@ static int qca_serdev_probe(struct serdev_device *serdev)
	err = hci_uart_register_device(&qcadev->serdev_hu, &qca_proto);		err = hci_uart_register_device(&qcadev->serdev_hu, &qca_proto);
	if (err)		if (err)
	clk_disable_unprepare(qcadev->susclk);		clk_disable_unprepare(qcadev->susclk);
			}

			out: return err;

	return err;
	}		}

	static void qca_serdev_remove(struct serdev_device *serdev)		static void qca_serdev_remove(struct serdev_device *serdev)
	{		{
	struct qca_serdev *qcadev = serdev_device_get_drvdata(serdev);		struct qca_serdev *qcadev = serdev_device_get_drvdata(serdev);

	hci_uart_unregister_device(&qcadev->serdev_hu);		if (qcadev->btsoc_type == QCA_WCN3990)
			qca_power_shutdown(qcadev->serdev_hu.hdev);
			else
	clk_disable_unprepare(qcadev->susclk);		clk_disable_unprepare(qcadev->susclk);

			hci_uart_unregister_device(&qcadev->serdev_hu);
	}		}

	static const struct of_device_id qca_bluetooth_of_match[] = {		static const struct of_device_id qca_bluetooth_of_match[] = {
	{ .compatible = "qcom,qca6174-bt" },		{ .compatible = "qcom,qca6174-bt" },
			{ .compatible = "qcom,wcn3990-bt", .data = &qca_soc_data},
	{ /* sentinel */ }		{ /* sentinel */ }
	};		};
	MODULE_DEVICE_TABLE(of, qca_bluetooth_of_match);		MODULE_DEVICE_TABLE(of, qca_bluetooth_of_match);