mirror of
https://github.com/FEX-Emu/linux.git
synced 2024-12-23 09:56:00 +00:00
Bluetooth: hci_qca: Add support for Qualcomm Bluetooth chip wcn3990
Add support to set voltage/current of various regulators to power up/down Bluetooth chip wcn3990. Signed-off-by: Balakrishna Godavarthi <bgodavar@codeaurora.org> Reviewed-by: Matthias Kaehlcke <mka@chromium.org> Signed-off-by: Marcel Holtmann <marcel@holtmann.org>
This commit is contained in:
Balakrishna Godavarthi
Marcel Holtmann
parent
4219d46868
commit
fa9ad876b8
@ -37,6 +37,9 @@
|
||||
#define EDL_TAG_ID_HCI (17)
|
||||
#define EDL_TAG_ID_DEEP_SLEEP (27)
|
||||
|
||||
#define QCA_WCN3990_POWERON_PULSE 0xFC
|
||||
#define QCA_WCN3990_POWEROFF_PULSE 0xC0
|
||||
|
||||
enum qca_bardrate {
|
||||
QCA_BAUDRATE_115200 = 0,
|
||||
QCA_BAUDRATE_57600,
|
||||
|
||||
@ -5,7 +5,7 @@
|
||||
* protocol extension to H4.
|
||||
*
|
||||
* 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:
|
||||
* This file is based on hci_ll.c, which was...
|
||||
@ -31,9 +31,14 @@
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/clk.h>
|
||||
#include <linux/debugfs.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/gpio/consumer.h>
|
||||
#include <linux/mod_devicetable.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 <net/bluetooth/bluetooth.h>
|
||||
@ -124,12 +129,46 @@ enum qca_speed_type {
|
||||
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 hci_uart serdev_hu;
|
||||
struct gpio_desc *bt_en;
|
||||
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)
|
||||
{
|
||||
/* 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_data *qca;
|
||||
int ret;
|
||||
|
||||
BT_DBG("hu %p qca_open", hu);
|
||||
|
||||
@ -458,19 +498,32 @@ static int qca_open(struct hci_uart *hu)
|
||||
|
||||
hu->priv = qca;
|
||||
|
||||
if (hu->serdev) {
|
||||
serdev_device_open(hu->serdev);
|
||||
|
||||
qcadev = serdev_device_get_drvdata(hu->serdev);
|
||||
if (qcadev->btsoc_type != QCA_WCN3990) {
|
||||
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;
|
||||
|
||||
if (hu->serdev) {
|
||||
serdev_device_open(hu->serdev);
|
||||
|
||||
qcadev = serdev_device_get_drvdata(hu->serdev);
|
||||
gpiod_set_value_cansleep(qcadev->bt_en, 1);
|
||||
}
|
||||
|
||||
BT_DBG("HCI_UART_QCA open, tx_idle_delay=%u, wake_retrans=%u",
|
||||
qca->tx_idle_delay, qca->wake_retrans);
|
||||
|
||||
@ -554,10 +607,13 @@ static int qca_close(struct hci_uart *hu)
|
||||
qca->hu = NULL;
|
||||
|
||||
if (hu->serdev) {
|
||||
serdev_device_close(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);
|
||||
|
||||
serdev_device_close(hu->serdev);
|
||||
}
|
||||
|
||||
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 qca_data *qca = hu->priv;
|
||||
struct sk_buff *skb;
|
||||
struct qca_serdev *qcadev;
|
||||
u8 cmd[] = { 0x01, 0x48, 0xFC, 0x01, 0x00 };
|
||||
|
||||
if (baudrate > QCA_BAUDRATE_3200000)
|
||||
@ -904,6 +961,13 @@ static int qca_set_baudrate(struct hci_dev *hdev, uint8_t baudrate)
|
||||
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. */
|
||||
skb_put_data(skb, cmd, sizeof(cmd));
|
||||
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));
|
||||
set_current_state(TASK_RUNNING);
|
||||
|
||||
if (qcadev->btsoc_type == QCA_WCN3990)
|
||||
hci_uart_set_flow_control(hu, false);
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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,
|
||||
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)
|
||||
{
|
||||
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) ||
|
||||
!qca_get_speed(hu, QCA_OPER_SPEED))
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -974,7 +1087,7 @@ static int qca_set_speed(struct hci_uart *hu, enum qca_speed_type speed_type)
|
||||
return 0;
|
||||
|
||||
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);
|
||||
if (ret)
|
||||
return ret;
|
||||
@ -985,15 +1098,52 @@ static int qca_set_speed(struct hci_uart *hu, enum qca_speed_type speed_type)
|
||||
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)
|
||||
{
|
||||
struct hci_dev *hdev = hu->hdev;
|
||||
struct qca_data *qca = hu->priv;
|
||||
unsigned int speed, qca_baudrate = QCA_BAUDRATE_115200;
|
||||
struct qca_serdev *qcadev;
|
||||
int ret;
|
||||
int soc_ver = 0;
|
||||
|
||||
bt_dev_info(hdev, "ROME setup");
|
||||
qcadev = serdev_device_get_drvdata(hu->serdev);
|
||||
|
||||
ret = qca_check_speeds(hu);
|
||||
if (ret)
|
||||
@ -1002,8 +1152,19 @@ static int qca_setup(struct hci_uart *hu)
|
||||
/* Patch downloading has to be done without IBS mode */
|
||||
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);
|
||||
}
|
||||
|
||||
/* Setup user speed if needed */
|
||||
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);
|
||||
}
|
||||
|
||||
if (qcadev->btsoc_type != QCA_WCN3990) {
|
||||
/* Get QCA version information */
|
||||
ret = qca_read_soc_version(hdev, &soc_ver);
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
|
||||
bt_dev_info(hdev, "QCA controller version 0x%08x", soc_ver);
|
||||
|
||||
/* 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) {
|
||||
set_bit(STATE_IN_BAND_SLEEP_ENABLED, &qca->flags);
|
||||
qca_debugfs_init(hdev);
|
||||
@ -1059,9 +1221,123 @@ static struct hci_uart_proto qca_proto = {
|
||||
.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)
|
||||
{
|
||||
struct qca_serdev *qcadev;
|
||||
const struct qca_vreg_data *data;
|
||||
int err;
|
||||
|
||||
qcadev = devm_kzalloc(&serdev->dev, sizeof(*qcadev), GFP_KERNEL);
|
||||
@ -1069,8 +1345,39 @@ static int qca_serdev_probe(struct serdev_device *serdev)
|
||||
return -ENOMEM;
|
||||
|
||||
qcadev->serdev_hu.serdev = serdev;
|
||||
data = of_device_get_match_data(&serdev->dev);
|
||||
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",
|
||||
GPIOD_OUT_LOW);
|
||||
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);
|
||||
if (err)
|
||||
clk_disable_unprepare(qcadev->susclk);
|
||||
}
|
||||
|
||||
out: return err;
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static void qca_serdev_remove(struct serdev_device *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);
|
||||
|
||||
hci_uart_unregister_device(&qcadev->serdev_hu);
|
||||
}
|
||||
|
||||
static const struct of_device_id qca_bluetooth_of_match[] = {
|
||||
{ .compatible = "qcom,qca6174-bt" },
|
||||
{ .compatible = "qcom,wcn3990-bt", .data = &qca_soc_data},
|
||||
{ /* sentinel */ }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(of, qca_bluetooth_of_match);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user