* [PATCH v1 08/12] nfc: Unify style of of_device_id arrays
From: Uwe Kleine-König (The Capable Hub) @ 2026-07-03 15:46 UTC (permalink / raw)
To: David Heidelberg, Krzysztof Kozlowski, Mark Greer, Carl Lee,
Jakub Kicinski, Ian Ray, Paolo Abeni, Pengpeng Hou, Kees Cook,
Simon Horman, Tomasz Unger
Cc: oe-linux-nfc, linux-kernel, linux-wireless
In-Reply-To: <cover.1783091699.git.u.kleine-koenig@baylibre.com>
The most common style treewide is:
- A single space in the list terminator and no trailing ,
- No comma after a named initializers iff the closing } is on the same
line
Adapt the of_device_id arrays accordingly.
Signed-off-by: Uwe Kleine-König (The Capable Hub) <u.kleine-koenig@baylibre.com>
---
drivers/nfc/nfcmrvl/i2c.c | 4 ++--
drivers/nfc/nfcmrvl/spi.c | 4 ++--
drivers/nfc/nxp-nci/i2c.c | 4 ++--
drivers/nfc/pn533/i2c.c | 8 ++++----
drivers/nfc/pn533/uart.c | 4 ++--
drivers/nfc/pn544/i2c.c | 4 ++--
drivers/nfc/s3fwrn5/i2c.c | 4 ++--
drivers/nfc/s3fwrn5/uart.c | 4 ++--
drivers/nfc/st-nci/i2c.c | 8 ++++----
drivers/nfc/st-nci/spi.c | 4 ++--
drivers/nfc/st21nfca/i2c.c | 6 +++---
drivers/nfc/st95hf/core.c | 2 +-
drivers/nfc/trf7970a.c | 5 ++---
13 files changed, 30 insertions(+), 31 deletions(-)
diff --git a/drivers/nfc/nfcmrvl/i2c.c b/drivers/nfc/nfcmrvl/i2c.c
index 687d2979b881..068c5d278a35 100644
--- a/drivers/nfc/nfcmrvl/i2c.c
+++ b/drivers/nfc/nfcmrvl/i2c.c
@@ -246,8 +246,8 @@ static void nfcmrvl_i2c_remove(struct i2c_client *client)
static const struct of_device_id of_nfcmrvl_i2c_match[] = {
- { .compatible = "marvell,nfc-i2c", },
- {},
+ { .compatible = "marvell,nfc-i2c" },
+ { }
};
MODULE_DEVICE_TABLE(of, of_nfcmrvl_i2c_match);
diff --git a/drivers/nfc/nfcmrvl/spi.c b/drivers/nfc/nfcmrvl/spi.c
index 8dd71fed8493..34842ecc4a05 100644
--- a/drivers/nfc/nfcmrvl/spi.c
+++ b/drivers/nfc/nfcmrvl/spi.c
@@ -182,8 +182,8 @@ static void nfcmrvl_spi_remove(struct spi_device *spi)
}
static const struct of_device_id of_nfcmrvl_spi_match[] = {
- { .compatible = "marvell,nfc-spi", },
- {},
+ { .compatible = "marvell,nfc-spi" },
+ { }
};
MODULE_DEVICE_TABLE(of, of_nfcmrvl_spi_match);
diff --git a/drivers/nfc/nxp-nci/i2c.c b/drivers/nfc/nxp-nci/i2c.c
index 39b43f8f3bf0..d424452934ec 100644
--- a/drivers/nfc/nxp-nci/i2c.c
+++ b/drivers/nfc/nxp-nci/i2c.c
@@ -355,8 +355,8 @@ static const struct i2c_device_id nxp_nci_i2c_id_table[] = {
MODULE_DEVICE_TABLE(i2c, nxp_nci_i2c_id_table);
static const struct of_device_id of_nxp_nci_i2c_match[] = {
- { .compatible = "nxp,nxp-nci-i2c", },
- {}
+ { .compatible = "nxp,nxp-nci-i2c" },
+ { }
};
MODULE_DEVICE_TABLE(of, of_nxp_nci_i2c_match);
diff --git a/drivers/nfc/pn533/i2c.c b/drivers/nfc/pn533/i2c.c
index 2128083f0297..66d201c14a40 100644
--- a/drivers/nfc/pn533/i2c.c
+++ b/drivers/nfc/pn533/i2c.c
@@ -237,14 +237,14 @@ static void pn533_i2c_remove(struct i2c_client *client)
}
static const struct of_device_id of_pn533_i2c_match[] = {
- { .compatible = "nxp,pn532", },
+ { .compatible = "nxp,pn532" },
/*
* NOTE: The use of the compatibles with the trailing "...-i2c" is
* deprecated and will be removed.
*/
- { .compatible = "nxp,pn533-i2c", },
- { .compatible = "nxp,pn532-i2c", },
- {},
+ { .compatible = "nxp,pn533-i2c" },
+ { .compatible = "nxp,pn532-i2c" },
+ { }
};
MODULE_DEVICE_TABLE(of, of_pn533_i2c_match);
diff --git a/drivers/nfc/pn533/uart.c b/drivers/nfc/pn533/uart.c
index e0d67cd2ac9b..83c1ccda0af6 100644
--- a/drivers/nfc/pn533/uart.c
+++ b/drivers/nfc/pn533/uart.c
@@ -238,8 +238,8 @@ static const struct serdev_device_ops pn532_serdev_ops = {
};
static const struct of_device_id pn532_uart_of_match[] = {
- { .compatible = "nxp,pn532", },
- {},
+ { .compatible = "nxp,pn532" },
+ { }
};
MODULE_DEVICE_TABLE(of, pn532_uart_of_match);
diff --git a/drivers/nfc/pn544/i2c.c b/drivers/nfc/pn544/i2c.c
index 50907a1974cd..7fde3aefae70 100644
--- a/drivers/nfc/pn544/i2c.c
+++ b/drivers/nfc/pn544/i2c.c
@@ -938,8 +938,8 @@ static void pn544_hci_i2c_remove(struct i2c_client *client)
}
static const struct of_device_id of_pn544_i2c_match[] = {
- { .compatible = "nxp,pn544-i2c", },
- {},
+ { .compatible = "nxp,pn544-i2c" },
+ { }
};
MODULE_DEVICE_TABLE(of, of_pn544_i2c_match);
diff --git a/drivers/nfc/s3fwrn5/i2c.c b/drivers/nfc/s3fwrn5/i2c.c
index 499301a6fa3f..4ba762611711 100644
--- a/drivers/nfc/s3fwrn5/i2c.c
+++ b/drivers/nfc/s3fwrn5/i2c.c
@@ -211,8 +211,8 @@ static const struct i2c_device_id s3fwrn5_i2c_id_table[] = {
MODULE_DEVICE_TABLE(i2c, s3fwrn5_i2c_id_table);
static const struct of_device_id of_s3fwrn5_i2c_match[] = {
- { .compatible = "samsung,s3fwrn5-i2c", },
- {}
+ { .compatible = "samsung,s3fwrn5-i2c" },
+ { }
};
MODULE_DEVICE_TABLE(of, of_s3fwrn5_i2c_match);
diff --git a/drivers/nfc/s3fwrn5/uart.c b/drivers/nfc/s3fwrn5/uart.c
index e17c599a2da5..8f142a255101 100644
--- a/drivers/nfc/s3fwrn5/uart.c
+++ b/drivers/nfc/s3fwrn5/uart.c
@@ -85,8 +85,8 @@ static const struct serdev_device_ops s3fwrn82_serdev_ops = {
};
static const struct of_device_id s3fwrn82_uart_of_match[] = {
- { .compatible = "samsung,s3fwrn82", },
- {},
+ { .compatible = "samsung,s3fwrn82" },
+ { }
};
MODULE_DEVICE_TABLE(of, s3fwrn82_uart_of_match);
diff --git a/drivers/nfc/st-nci/i2c.c b/drivers/nfc/st-nci/i2c.c
index ceb7d7450e47..152c20b6bb01 100644
--- a/drivers/nfc/st-nci/i2c.c
+++ b/drivers/nfc/st-nci/i2c.c
@@ -270,10 +270,10 @@ static const struct acpi_device_id st_nci_i2c_acpi_match[] = {
MODULE_DEVICE_TABLE(acpi, st_nci_i2c_acpi_match);
static const struct of_device_id of_st_nci_i2c_match[] = {
- { .compatible = "st,st21nfcb-i2c", },
- { .compatible = "st,st21nfcb_i2c", },
- { .compatible = "st,st21nfcc-i2c", },
- {}
+ { .compatible = "st,st21nfcb-i2c" },
+ { .compatible = "st,st21nfcb_i2c" },
+ { .compatible = "st,st21nfcc-i2c" },
+ { }
};
MODULE_DEVICE_TABLE(of, of_st_nci_i2c_match);
diff --git a/drivers/nfc/st-nci/spi.c b/drivers/nfc/st-nci/spi.c
index 8632cc0cb305..5e0b94050f90 100644
--- a/drivers/nfc/st-nci/spi.c
+++ b/drivers/nfc/st-nci/spi.c
@@ -284,8 +284,8 @@ static const struct acpi_device_id st_nci_spi_acpi_match[] = {
MODULE_DEVICE_TABLE(acpi, st_nci_spi_acpi_match);
static const struct of_device_id of_st_nci_spi_match[] = {
- { .compatible = "st,st21nfcb-spi", },
- {}
+ { .compatible = "st,st21nfcb-spi" },
+ { }
};
MODULE_DEVICE_TABLE(of, of_st_nci_spi_match);
diff --git a/drivers/nfc/st21nfca/i2c.c b/drivers/nfc/st21nfca/i2c.c
index 4e70f591af55..a4c93ff7c5b0 100644
--- a/drivers/nfc/st21nfca/i2c.c
+++ b/drivers/nfc/st21nfca/i2c.c
@@ -584,9 +584,9 @@ static const struct acpi_device_id st21nfca_hci_i2c_acpi_match[] = {
MODULE_DEVICE_TABLE(acpi, st21nfca_hci_i2c_acpi_match);
static const struct of_device_id of_st21nfca_i2c_match[] = {
- { .compatible = "st,st21nfca-i2c", },
- { .compatible = "st,st21nfca_i2c", },
- {}
+ { .compatible = "st,st21nfca-i2c" },
+ { .compatible = "st,st21nfca_i2c" },
+ { }
};
MODULE_DEVICE_TABLE(of, of_st21nfca_i2c_match);
diff --git a/drivers/nfc/st95hf/core.c b/drivers/nfc/st95hf/core.c
index 1ecd47c6518e..265ab10bbb61 100644
--- a/drivers/nfc/st95hf/core.c
+++ b/drivers/nfc/st95hf/core.c
@@ -1056,7 +1056,7 @@ MODULE_DEVICE_TABLE(spi, st95hf_id);
static const struct of_device_id st95hf_spi_of_match[] = {
{ .compatible = "st,st95hf" },
- {},
+ { }
};
MODULE_DEVICE_TABLE(of, st95hf_spi_of_match);
diff --git a/drivers/nfc/trf7970a.c b/drivers/nfc/trf7970a.c
index bc01b46f461c..3802081fb8ee 100644
--- a/drivers/nfc/trf7970a.c
+++ b/drivers/nfc/trf7970a.c
@@ -2304,10 +2304,9 @@ static const struct dev_pm_ops trf7970a_pm_ops = {
};
static const struct of_device_id trf7970a_of_match[] = {
- {.compatible = "ti,trf7970a",},
- {},
+ { .compatible = "ti,trf7970a" },
+ { }
};
-
MODULE_DEVICE_TABLE(of, trf7970a_of_match);
static const struct spi_device_id trf7970a_id_table[] = {
--
2.55.0.11.g153666a7d9bb
^ permalink raw reply related
* [PATCH v1 07/12] nfc: Drop __maybe_unused from of_device_id tables
From: Uwe Kleine-König (The Capable Hub) @ 2026-07-03 15:46 UTC (permalink / raw)
To: David Heidelberg, Krzysztof Kozlowski, Mark Greer, Simon Horman,
Tomasz Unger
Cc: oe-linux-nfc, linux-kernel, linux-wireless
In-Reply-To: <cover.1783091699.git.u.kleine-koenig@baylibre.com>
Referencing these arrays in MODULE_DEVICE_TABLE() is enough to convince
the compiler that they are used even if the drivers are built-in (since
5ab23c7923a1 ("modpost: Create modalias for builtin modules"). So the
__maybe_unused marking can be removed without introducing a compiler
warning.
Signed-off-by: Uwe Kleine-König (The Capable Hub) <u.kleine-koenig@baylibre.com>
---
drivers/nfc/nfcmrvl/i2c.c | 2 +-
drivers/nfc/nfcmrvl/spi.c | 2 +-
drivers/nfc/pn533/i2c.c | 2 +-
drivers/nfc/pn544/i2c.c | 2 +-
drivers/nfc/s3fwrn5/i2c.c | 2 +-
drivers/nfc/st-nci/i2c.c | 2 +-
drivers/nfc/st-nci/spi.c | 2 +-
drivers/nfc/st21nfca/i2c.c | 2 +-
drivers/nfc/st95hf/core.c | 2 +-
drivers/nfc/trf7970a.c | 2 +-
10 files changed, 10 insertions(+), 10 deletions(-)
diff --git a/drivers/nfc/nfcmrvl/i2c.c b/drivers/nfc/nfcmrvl/i2c.c
index 66877a7d03f2..687d2979b881 100644
--- a/drivers/nfc/nfcmrvl/i2c.c
+++ b/drivers/nfc/nfcmrvl/i2c.c
@@ -245,7 +245,7 @@ static void nfcmrvl_i2c_remove(struct i2c_client *client)
}
-static const struct of_device_id of_nfcmrvl_i2c_match[] __maybe_unused = {
+static const struct of_device_id of_nfcmrvl_i2c_match[] = {
{ .compatible = "marvell,nfc-i2c", },
{},
};
diff --git a/drivers/nfc/nfcmrvl/spi.c b/drivers/nfc/nfcmrvl/spi.c
index 9c8cde1250fb..8dd71fed8493 100644
--- a/drivers/nfc/nfcmrvl/spi.c
+++ b/drivers/nfc/nfcmrvl/spi.c
@@ -181,7 +181,7 @@ static void nfcmrvl_spi_remove(struct spi_device *spi)
nfcmrvl_nci_unregister_dev(drv_data->priv);
}
-static const struct of_device_id of_nfcmrvl_spi_match[] __maybe_unused = {
+static const struct of_device_id of_nfcmrvl_spi_match[] = {
{ .compatible = "marvell,nfc-spi", },
{},
};
diff --git a/drivers/nfc/pn533/i2c.c b/drivers/nfc/pn533/i2c.c
index 94aca9119f0f..2128083f0297 100644
--- a/drivers/nfc/pn533/i2c.c
+++ b/drivers/nfc/pn533/i2c.c
@@ -236,7 +236,7 @@ static void pn533_i2c_remove(struct i2c_client *client)
pn53x_common_clean(phy->priv);
}
-static const struct of_device_id of_pn533_i2c_match[] __maybe_unused = {
+static const struct of_device_id of_pn533_i2c_match[] = {
{ .compatible = "nxp,pn532", },
/*
* NOTE: The use of the compatibles with the trailing "...-i2c" is
diff --git a/drivers/nfc/pn544/i2c.c b/drivers/nfc/pn544/i2c.c
index b731d0b02f52..50907a1974cd 100644
--- a/drivers/nfc/pn544/i2c.c
+++ b/drivers/nfc/pn544/i2c.c
@@ -937,7 +937,7 @@ static void pn544_hci_i2c_remove(struct i2c_client *client)
pn544_hci_i2c_disable(phy);
}
-static const struct of_device_id of_pn544_i2c_match[] __maybe_unused = {
+static const struct of_device_id of_pn544_i2c_match[] = {
{ .compatible = "nxp,pn544-i2c", },
{},
};
diff --git a/drivers/nfc/s3fwrn5/i2c.c b/drivers/nfc/s3fwrn5/i2c.c
index e9a34d27a369..499301a6fa3f 100644
--- a/drivers/nfc/s3fwrn5/i2c.c
+++ b/drivers/nfc/s3fwrn5/i2c.c
@@ -210,7 +210,7 @@ static const struct i2c_device_id s3fwrn5_i2c_id_table[] = {
};
MODULE_DEVICE_TABLE(i2c, s3fwrn5_i2c_id_table);
-static const struct of_device_id of_s3fwrn5_i2c_match[] __maybe_unused = {
+static const struct of_device_id of_s3fwrn5_i2c_match[] = {
{ .compatible = "samsung,s3fwrn5-i2c", },
{}
};
diff --git a/drivers/nfc/st-nci/i2c.c b/drivers/nfc/st-nci/i2c.c
index f43ae8e92070..ceb7d7450e47 100644
--- a/drivers/nfc/st-nci/i2c.c
+++ b/drivers/nfc/st-nci/i2c.c
@@ -269,7 +269,7 @@ static const struct acpi_device_id st_nci_i2c_acpi_match[] = {
};
MODULE_DEVICE_TABLE(acpi, st_nci_i2c_acpi_match);
-static const struct of_device_id of_st_nci_i2c_match[] __maybe_unused = {
+static const struct of_device_id of_st_nci_i2c_match[] = {
{ .compatible = "st,st21nfcb-i2c", },
{ .compatible = "st,st21nfcb_i2c", },
{ .compatible = "st,st21nfcc-i2c", },
diff --git a/drivers/nfc/st-nci/spi.c b/drivers/nfc/st-nci/spi.c
index 9303217acd7b..8632cc0cb305 100644
--- a/drivers/nfc/st-nci/spi.c
+++ b/drivers/nfc/st-nci/spi.c
@@ -283,7 +283,7 @@ static const struct acpi_device_id st_nci_spi_acpi_match[] = {
};
MODULE_DEVICE_TABLE(acpi, st_nci_spi_acpi_match);
-static const struct of_device_id of_st_nci_spi_match[] __maybe_unused = {
+static const struct of_device_id of_st_nci_spi_match[] = {
{ .compatible = "st,st21nfcb-spi", },
{}
};
diff --git a/drivers/nfc/st21nfca/i2c.c b/drivers/nfc/st21nfca/i2c.c
index 13fb6f5533e0..4e70f591af55 100644
--- a/drivers/nfc/st21nfca/i2c.c
+++ b/drivers/nfc/st21nfca/i2c.c
@@ -583,7 +583,7 @@ static const struct acpi_device_id st21nfca_hci_i2c_acpi_match[] = {
};
MODULE_DEVICE_TABLE(acpi, st21nfca_hci_i2c_acpi_match);
-static const struct of_device_id of_st21nfca_i2c_match[] __maybe_unused = {
+static const struct of_device_id of_st21nfca_i2c_match[] = {
{ .compatible = "st,st21nfca-i2c", },
{ .compatible = "st,st21nfca_i2c", },
{}
diff --git a/drivers/nfc/st95hf/core.c b/drivers/nfc/st95hf/core.c
index ffe5b4eab457..1ecd47c6518e 100644
--- a/drivers/nfc/st95hf/core.c
+++ b/drivers/nfc/st95hf/core.c
@@ -1054,7 +1054,7 @@ static const struct spi_device_id st95hf_id[] = {
};
MODULE_DEVICE_TABLE(spi, st95hf_id);
-static const struct of_device_id st95hf_spi_of_match[] __maybe_unused = {
+static const struct of_device_id st95hf_spi_of_match[] = {
{ .compatible = "st,st95hf" },
{},
};
diff --git a/drivers/nfc/trf7970a.c b/drivers/nfc/trf7970a.c
index f22e091019de..bc01b46f461c 100644
--- a/drivers/nfc/trf7970a.c
+++ b/drivers/nfc/trf7970a.c
@@ -2303,7 +2303,7 @@ static const struct dev_pm_ops trf7970a_pm_ops = {
trf7970a_pm_runtime_resume, NULL)
};
-static const struct of_device_id trf7970a_of_match[] __maybe_unused = {
+static const struct of_device_id trf7970a_of_match[] = {
{.compatible = "ti,trf7970a",},
{},
};
--
2.55.0.11.g153666a7d9bb
^ permalink raw reply related
* [PATCH v1 00/12] nfc: Various cleanups around device_id arrays
From: Uwe Kleine-König (The Capable Hub) @ 2026-07-03 15:46 UTC (permalink / raw)
To: David Heidelberg, Krzysztof Kozlowski, Simon Horman,
Jakub Kicinski, Tomasz Unger, Carl Lee, Ian Ray, Takashi Sakamoto,
Bjorn Helgaas, Danilo Krummrich, Krzysztof Kozlowski, Mark Greer,
Paolo Abeni, Pengpeng Hou, Kees Cook, Bartosz Golaszewski,
Linus Walleij, Johan Hovold, Jialu Xu
Cc: oe-linux-nfc, linux-kernel, linux-wireless
Hello,
this series's objective is to convert device_id arrays of various
different device types to named initialisation. It contains a few
cleanups left and right that I spotted while working on these changes.
The follow up change is to replace .driver_data by an anonymous union,
see
https://lore.kernel.org/all/cover.1780048925.git.u.kleine-koenig@baylibre.com/
for the idea.
The changes here are not strictly necessary for my quest, but they align
the device_id structures to how they look and will look for other
subsystems.
Best regards
Uwe
Uwe Kleine-König (The Capable Hub) (12):
nfc: Drop __maybe_unused from acpi_device_id tables
nfc: Drop unused assignment of acpi_device_id driver data
nfc: Initialize acpi_device_id arrays using member names
nfc: Unify style of acpi_device_id arrays
nfc: pn544: Drop empty line between i2c_device_id array and
MODULE_DEVICE_TABLE()
nfc: Initialize mei_cl_device_idarrays using member names
nfc: Drop __maybe_unused from of_device_id tables
nfc: Unify style of of_device_id arrays
nfc: Drop unused assignment of spi_device_id driver data
nfc: Initialize spi_device_idarrays using member names
nfc: Unify style of spi_device_id arrays
nfc: Unify style of usb_device_id arrays
drivers/nfc/fdp/i2c.c | 4 ++--
drivers/nfc/microread/mei.c | 10 ++++++----
drivers/nfc/nfcmrvl/i2c.c | 6 +++---
drivers/nfc/nfcmrvl/spi.c | 8 ++++----
drivers/nfc/nfcmrvl/usb.c | 1 -
drivers/nfc/nxp-nci/i2c.c | 10 +++++-----
drivers/nfc/pn533/i2c.c | 10 +++++-----
drivers/nfc/pn533/uart.c | 4 ++--
drivers/nfc/pn544/i2c.c | 14 ++++++--------
drivers/nfc/pn544/mei.c | 10 ++++++----
drivers/nfc/port100.c | 4 ++--
drivers/nfc/s3fwrn5/i2c.c | 6 +++---
drivers/nfc/s3fwrn5/uart.c | 4 ++--
drivers/nfc/st-nci/i2c.c | 18 +++++++++---------
drivers/nfc/st-nci/spi.c | 18 +++++++++---------
drivers/nfc/st21nfca/i2c.c | 14 +++++++-------
drivers/nfc/st95hf/core.c | 8 ++++----
drivers/nfc/trf7970a.c | 12 +++++-------
18 files changed, 80 insertions(+), 81 deletions(-)
base-commit: 6eb8711ece2ce27e52e327a5b7a628ed39b97f45
--
2.55.0.11.g153666a7d9bb
^ permalink raw reply
* Re: [PATCH v9 01/14] firmware: qcom: Add a generic PAS service
From: Konrad Dybcio @ 2026-07-03 15:06 UTC (permalink / raw)
To: Sumit Garg, andersson, konradybcio
Cc: linux-arm-msm, devicetree, dri-devel, freedreno, linux-media,
netdev, linux-wireless, ath12k, linux-remoteproc, robh, krzk+dt,
conor+dt, robin.clark, sean, akhilpo, lumag, abhinav.kumar,
jesszhan0024, marijn.suijten, airlied, simona, vikash.garodia,
bod, mchehab, elder, andrew+netdev, davem, edumazet, kuba, pabeni,
jjohnson, mathieu.poirier, trilokkumar.soni, mukesh.ojha,
pavan.kondeti, jorge.ramirez, tonyh, vignesh.viswanathan,
srinivas.kandagatla, amirreza.zarrabi, jenswi, op-tee, apurupa,
skare, linux-kernel, Sumit Garg, Harshal Dev
In-Reply-To: <20260702115835.167602-2-sumit.garg@kernel.org>
On 7/2/26 1:58 PM, Sumit Garg wrote:
> From: Sumit Garg <sumit.garg@oss.qualcomm.com>
>
> Qcom platforms has the legacy of using non-standard SCM calls
> splintered over the various kernel drivers. These SCM calls aren't
> compliant with the standard SMC calling conventions which is a
> prerequisite to enable migration to the FF-A specifications from Arm.
>
> OP-TEE as an alternative trusted OS to Qualcomm TEE (QTEE) can't
> support these non-standard SCM calls. And even for newer architectures
> using S-EL2 with Hafnium support, QTEE won't be able to support SCM
> calls either with FF-A requirements coming in. And with both OP-TEE
> and QTEE drivers well integrated in the TEE subsystem, it makes further
> sense to reuse the TEE bus client drivers infrastructure.
>
> The added benefit of TEE bus infrastructure is that there is support
> for discoverable/enumerable services. With that client drivers don't
> have to manually invoke a special SCM call to know the service status.
>
> So enable the generic Peripheral Authentication Service (PAS) provided
> by the firmware. It acts as the common layer with different TZ
> backends plugged in whether it's an SCM implementation or a proper
> TEE bus based PAS service implementation.
>
> Reviewed-by: Mukesh Ojha <mukesh.ojha@oss.qualcomm.com>
> Tested-by: Mukesh Ojha <mukesh.ojha@oss.qualcomm.com> # Lemans
> Reviewed-by: Harshal Dev <harshal.dev@oss.qualcomm.com>
> Tested-by: Vignesh Viswanathan <vignesh.viswanathan@oss.qualcomm.com> # IPQ9650
> Signed-off-by: Sumit Garg <sumit.garg@oss.qualcomm.com>
> ---
Reviewed-by: Konrad Dybcio <konrad.dybcio@oss.qualcomm.com>
Konrad
^ permalink raw reply
* [PATCH] wifi: iwlwifi: fw: Fix spelling typo in error-dump.h
From: Praveen Rajendran @ 2026-07-03 14:07 UTC (permalink / raw)
To: miriam.rachel.korenblit, johannes.berg
Cc: linux-wireless, linux-kernel, Praveen Rajendran
Correct a minor grammatical error inside the kernel-doc comments
of error-dump.h where "configuration" was misspelled as "configuraiton".
Signed-off-by: Praveen Rajendran <praveenrajendran2009@gmail.com>
---
drivers/net/wireless/intel/iwlwifi/fw/error-dump.h | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/drivers/net/wireless/intel/iwlwifi/fw/error-dump.h b/drivers/net/wireless/intel/iwlwifi/fw/error-dump.h
index 07f1240df866..692bb17dfc33 100644
--- a/drivers/net/wireless/intel/iwlwifi/fw/error-dump.h
+++ b/drivers/net/wireless/intel/iwlwifi/fw/error-dump.h
@@ -352,7 +352,7 @@ struct iwl_fw_ini_error_dump_register {
* struct iwl_fw_ini_dump_cfg_name - configuration name
* @image_type: image type the configuration is related to
* @cfg_name_len: length of the configuration name
- * @cfg_name: name of the configuraiton
+ * @cfg_name: name of the configuration
*/
struct iwl_fw_ini_dump_cfg_name {
__le32 image_type;
--
2.50.1
^ permalink raw reply related
* [PATCH] net: wireless: ralink: RT2X00: init EEPROM properly
From: Corentin Labbe @ 2026-07-03 13:49 UTC (permalink / raw)
To: stf_xl; +Cc: linux-kernel, linux-wireless, Corentin Labbe
I have an hostapd setup with a
01:00.0 Network controller: Ralink corp. RT2790 Wireless 802.11n 1T/2R PCIe
The setup work fine on 6.18.26-gentoo
It breaks on 6.18.33-gentoo (and still broken on 6.18.37)
I found an hint in dmesg:
On 6.18.26-gentoo I see:
May 31 15:48:45 trash01 kernel: ieee80211 phy0: rt2x00_set_rf: Info - RF chipset 0003 detected
On 6.18.33-gentoo I see:
May 31 15:22:57 trash01 kernel: ieee80211 phy0: rt2x00_set_rf: Info - RF chipset 0006 detected
The RF chipset seems badly detected.
The problem was the EEPROM which was badly initialized.
Probably the origin was in some PCI change but unfortunately I couldn't play
to bisect/reboot often the board with this card to do it.
Signed-off-by: Corentin Labbe <clabbe@baylibre.com>
---
drivers/net/wireless/ralink/rt2x00/rt2400pci.c | 2 +-
drivers/net/wireless/ralink/rt2x00/rt2500pci.c | 2 +-
drivers/net/wireless/ralink/rt2x00/rt2800pci.c | 2 +-
drivers/net/wireless/ralink/rt2x00/rt61pci.c | 2 +-
4 files changed, 4 insertions(+), 4 deletions(-)
diff --git a/drivers/net/wireless/ralink/rt2x00/rt2400pci.c b/drivers/net/wireless/ralink/rt2x00/rt2400pci.c
index 42e21e9f303b..15073b856adf 100644
--- a/drivers/net/wireless/ralink/rt2x00/rt2400pci.c
+++ b/drivers/net/wireless/ralink/rt2x00/rt2400pci.c
@@ -1429,7 +1429,7 @@ static irqreturn_t rt2400pci_interrupt(int irq, void *dev_instance)
*/
static int rt2400pci_validate_eeprom(struct rt2x00_dev *rt2x00dev)
{
- struct eeprom_93cx6 eeprom;
+ struct eeprom_93cx6 eeprom = {};
u32 reg;
u16 word;
u8 *mac;
diff --git a/drivers/net/wireless/ralink/rt2x00/rt2500pci.c b/drivers/net/wireless/ralink/rt2x00/rt2500pci.c
index 36ddc5a69fa4..3536a0f31117 100644
--- a/drivers/net/wireless/ralink/rt2x00/rt2500pci.c
+++ b/drivers/net/wireless/ralink/rt2x00/rt2500pci.c
@@ -1555,7 +1555,7 @@ static irqreturn_t rt2500pci_interrupt(int irq, void *dev_instance)
*/
static int rt2500pci_validate_eeprom(struct rt2x00_dev *rt2x00dev)
{
- struct eeprom_93cx6 eeprom;
+ struct eeprom_93cx6 eeprom = {};
u32 reg;
u16 word;
u8 *mac;
diff --git a/drivers/net/wireless/ralink/rt2x00/rt2800pci.c b/drivers/net/wireless/ralink/rt2x00/rt2800pci.c
index 14c45aba836f..853fd31d1362 100644
--- a/drivers/net/wireless/ralink/rt2x00/rt2800pci.c
+++ b/drivers/net/wireless/ralink/rt2x00/rt2800pci.c
@@ -108,7 +108,7 @@ static void rt2800pci_eepromregister_write(struct eeprom_93cx6 *eeprom)
static int rt2800pci_read_eeprom_pci(struct rt2x00_dev *rt2x00dev)
{
- struct eeprom_93cx6 eeprom;
+ struct eeprom_93cx6 eeprom = {};
u32 reg;
reg = rt2x00mmio_register_read(rt2x00dev, E2PROM_CSR);
diff --git a/drivers/net/wireless/ralink/rt2x00/rt61pci.c b/drivers/net/wireless/ralink/rt2x00/rt61pci.c
index d1cd5694e3c7..5dca2afb4b96 100644
--- a/drivers/net/wireless/ralink/rt2x00/rt61pci.c
+++ b/drivers/net/wireless/ralink/rt2x00/rt61pci.c
@@ -2298,7 +2298,7 @@ static irqreturn_t rt61pci_interrupt(int irq, void *dev_instance)
*/
static int rt61pci_validate_eeprom(struct rt2x00_dev *rt2x00dev)
{
- struct eeprom_93cx6 eeprom;
+ struct eeprom_93cx6 eeprom = {};
u32 reg;
u16 word;
u8 *mac;
--
2.53.0
^ permalink raw reply related
* [PATCH v8 9/9] arm64: dts: qcom: arduino-imola: Describe NVMEM layout for WiFi/BT addresses
From: Loic Poulain @ 2026-07-03 13:45 UTC (permalink / raw)
To: Ulf Hansson, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Bjorn Andersson, Konrad Dybcio, Jens Axboe, Johannes Berg,
Jeff Johnson, Bartosz Golaszewski, Marcel Holtmann,
Luiz Augusto von Dentz, Balakrishna Godavarthi, Rocky Liao,
David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman, Srinivas Kandagatla, Andrew Lunn, Heiner Kallweit,
Russell King, Saravana Kannan, Christian Marangi
Cc: linux-mmc, devicetree, linux-kernel, linux-arm-msm, linux-block,
linux-wireless, ath10k, linux-bluetooth, netdev, daniel,
Loic Poulain, Konrad Dybcio, Bartosz Golaszewski
In-Reply-To: <20260703-block-as-nvmem-v8-0-98ae32bfc49a@oss.qualcomm.com>
On Arduino Uno-Q, the eMMC boot1 partition is factory provisioned
with device-specific information such as the WiFi MAC address
and the Bluetooth BD address. This partition can serve as an
alternative to additional non-volatile memory, such as a
dedicated EEPROM.
The eMMC boot partitions are typically good candidates, as they
are relatively small, read-only by default (and can be enforced
as hardware read-only), and are not affected by board reflashing
procedures, which generally target the eMMC user or GP partitions.
Describe the corresponding nvmem-layout for the WiFi and Bluetooth
addresses, and point the WiFi and Bluetooth nodes to the appropriate
NVMEM cells to retrieve them.
Reviewed-by: Konrad Dybcio <konrad.dybcio@oss.qualcomm.com>
Reviewed-by: Bartosz Golaszewski <bartosz.golaszewski@oss.qualcomm.com>
Signed-off-by: Loic Poulain <loic.poulain@oss.qualcomm.com>
---
arch/arm64/boot/dts/qcom/qrb2210-arduino-imola.dts | 32 ++++++++++++++++++++++
1 file changed, 32 insertions(+)
diff --git a/arch/arm64/boot/dts/qcom/qrb2210-arduino-imola.dts b/arch/arm64/boot/dts/qcom/qrb2210-arduino-imola.dts
index bf088fa9807f040f0c8f405f9111b01790b09377..38839b8a361e76f6c1989924b16095b9d8815f66 100644
--- a/arch/arm64/boot/dts/qcom/qrb2210-arduino-imola.dts
+++ b/arch/arm64/boot/dts/qcom/qrb2210-arduino-imola.dts
@@ -409,7 +409,33 @@ &sdhc_1 {
no-sdio;
no-sd;
+ #address-cells = <1>;
+ #size-cells = <0>;
+
status = "okay";
+
+ card@0 {
+ compatible = "mmc-card";
+ reg = <0>;
+
+ partitions-boot1 {
+ compatible = "fixed-layout";
+ #address-cells = <1>;
+ #size-cells = <1>;
+
+ wifi_mac_addr: mac-addr@4400 {
+ compatible = "mac-base";
+ reg = <0x4400 0x6>;
+ #nvmem-cell-cells = <1>;
+ };
+
+ bd_addr: bd-addr@5400 {
+ compatible = "mac-base";
+ reg = <0x5400 0x6>;
+ #nvmem-cell-cells = <1>;
+ };
+ };
+ };
};
&spi5 {
@@ -512,6 +538,9 @@ bluetooth {
vddch0-supply = <&pm4125_l22>;
enable-gpios = <&tlmm 87 GPIO_ACTIVE_HIGH>;
max-speed = <3000000>;
+
+ nvmem-cells = <&bd_addr 0>;
+ nvmem-cell-names = "local-bd-address";
};
};
@@ -557,6 +586,9 @@ &wifi {
qcom,ath10k-calibration-variant = "ArduinoImola";
firmware-name = "qcm2290";
+ nvmem-cells = <&wifi_mac_addr 0>;
+ nvmem-cell-names = "mac-address";
+
status = "okay";
};
--
2.34.1
^ permalink raw reply related
* [PATCH v8 8/9] Bluetooth: qca: Set NVMEM BD address quirks when address is invalid
From: Loic Poulain @ 2026-07-03 13:45 UTC (permalink / raw)
To: Ulf Hansson, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Bjorn Andersson, Konrad Dybcio, Jens Axboe, Johannes Berg,
Jeff Johnson, Bartosz Golaszewski, Marcel Holtmann,
Luiz Augusto von Dentz, Balakrishna Godavarthi, Rocky Liao,
David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman, Srinivas Kandagatla, Andrew Lunn, Heiner Kallweit,
Russell King, Saravana Kannan, Christian Marangi
Cc: linux-mmc, devicetree, linux-kernel, linux-arm-msm, linux-block,
linux-wireless, ath10k, linux-bluetooth, netdev, daniel,
Loic Poulain, Bartosz Golaszewski
In-Reply-To: <20260703-block-as-nvmem-v8-0-98ae32bfc49a@oss.qualcomm.com>
When the controller BD address is invalid (zero or default),
set the NVMEM quirks to allow retrieving the address from a
'local-bd-address' NVMEM cell. The BD address is often stored
alongside the WiFi MAC address in big-endian format, so also
set the big-endian quirk.
Reviewed-by: Bartosz Golaszewski <bartosz.golaszewski@oss.qualcomm.com>
Signed-off-by: Loic Poulain <loic.poulain@oss.qualcomm.com>
---
drivers/bluetooth/btqca.c | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
diff --git a/drivers/bluetooth/btqca.c b/drivers/bluetooth/btqca.c
index dda76365726f0bfe0e80e05fe04859fa4f0592e1..df33eacfd29fa680f393f90215150743e6001d5b 100644
--- a/drivers/bluetooth/btqca.c
+++ b/drivers/bluetooth/btqca.c
@@ -721,8 +721,11 @@ static int qca_check_bdaddr(struct hci_dev *hdev, const struct qca_fw_config *co
}
bda = (struct hci_rp_read_bd_addr *)skb->data;
- if (!bacmp(&bda->bdaddr, &config->bdaddr))
+ if (!bacmp(&bda->bdaddr, &config->bdaddr)) {
hci_set_quirk(hdev, HCI_QUIRK_USE_BDADDR_PROPERTY);
+ hci_set_quirk(hdev, HCI_QUIRK_USE_BDADDR_NVMEM);
+ hci_set_quirk(hdev, HCI_QUIRK_BDADDR_NVMEM_BE);
+ }
kfree_skb(skb);
--
2.34.1
^ permalink raw reply related
* [PATCH v8 7/9] Bluetooth: hci_sync: Add NVMEM-backed BD address retrieval
From: Loic Poulain @ 2026-07-03 13:45 UTC (permalink / raw)
To: Ulf Hansson, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Bjorn Andersson, Konrad Dybcio, Jens Axboe, Johannes Berg,
Jeff Johnson, Bartosz Golaszewski, Marcel Holtmann,
Luiz Augusto von Dentz, Balakrishna Godavarthi, Rocky Liao,
David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman, Srinivas Kandagatla, Andrew Lunn, Heiner Kallweit,
Russell King, Saravana Kannan, Christian Marangi
Cc: linux-mmc, devicetree, linux-kernel, linux-arm-msm, linux-block,
linux-wireless, ath10k, linux-bluetooth, netdev, daniel,
Loic Poulain, Bartosz Golaszewski, Piotr Kwapulinski
In-Reply-To: <20260703-block-as-nvmem-v8-0-98ae32bfc49a@oss.qualcomm.com>
Some devices store the Bluetooth BD address in non-volatile
memory, which can be accessed through the NVMEM framework.
Similar to Ethernet or WiFi MAC addresses, add support for
reading the BD address from a 'local-bd-address' NVMEM cell.
As with the device-tree provided BD address, add a quirk to
indicate whether a device or platform should attempt to read
the address from NVMEM when no valid in-chip address is present.
Also add a quirk to indicate if the address is stored in
big-endian byte order.
Reviewed-by: Bartosz Golaszewski <bartosz.golaszewski@oss.qualcomm.com>
Reviewed-by: Piotr Kwapulinski <piotr.kwapulinski@intel.com>
Signed-off-by: Loic Poulain <loic.poulain@oss.qualcomm.com>
---
include/net/bluetooth/hci.h | 18 ++++++++++++++++++
net/bluetooth/hci_sync.c | 41 ++++++++++++++++++++++++++++++++++++++++-
net/bluetooth/mgmt.c | 6 ++++--
3 files changed, 62 insertions(+), 3 deletions(-)
diff --git a/include/net/bluetooth/hci.h b/include/net/bluetooth/hci.h
index 572b1c620c5d653a1fe10b26c1b0ba33e8f4968f..7686466d1109253b0d75edeb5f6a99fb98ce4cc6 100644
--- a/include/net/bluetooth/hci.h
+++ b/include/net/bluetooth/hci.h
@@ -164,6 +164,24 @@ enum {
*/
HCI_QUIRK_BDADDR_PROPERTY_BROKEN,
+ /* When this quirk is set, the public Bluetooth address
+ * initially reported by HCI Read BD Address command
+ * is considered invalid. The public BD Address can be
+ * retrieved via a 'local-bd-address' NVMEM cell.
+ *
+ * This quirk can be set before hci_register_dev is called or
+ * during the hdev->setup vendor callback.
+ */
+ HCI_QUIRK_USE_BDADDR_NVMEM,
+
+ /* When this quirk is set, the Bluetooth Device Address provided by
+ * the 'local-bd-address' NVMEM is stored in big-endian order.
+ *
+ * This quirk can be set before hci_register_dev is called or
+ * during the hdev->setup vendor callback.
+ */
+ HCI_QUIRK_BDADDR_NVMEM_BE,
+
/* When this quirk is set, the duplicate filtering during
* scanning is based on Bluetooth devices addresses. To allow
* RSSI based updates, restart scanning if needed.
diff --git a/net/bluetooth/hci_sync.c b/net/bluetooth/hci_sync.c
index fd3aacdea512a37c22b9a2be90c89ddca4b4d99f..56248d4abcb5b1d9993962a9f6bf60bf865b8d7b 100644
--- a/net/bluetooth/hci_sync.c
+++ b/net/bluetooth/hci_sync.c
@@ -7,6 +7,7 @@
*/
#include <linux/property.h>
+#include <linux/of_net.h>
#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>
@@ -3588,6 +3589,39 @@ int hci_powered_update_sync(struct hci_dev *hdev)
return 0;
}
+/**
+ * hci_dev_get_bd_addr_from_nvmem - Get the Bluetooth Device Address
+ * (BD_ADDR) for a HCI device from
+ * an NVMEM cell.
+ * @hdev: The HCI device
+ *
+ * Search for 'local-bd-address' NVMEM cell in the device firmware node.
+ *
+ * All-zero BD addresses are rejected (unprovisioned).
+ *
+ * Return: 0 on success, or a negative error code on failure.
+ */
+static int hci_dev_get_bd_addr_from_nvmem(struct hci_dev *hdev)
+{
+ struct device_node *np = dev_of_node(hdev->dev.parent);
+ u8 ba[sizeof(bdaddr_t)];
+ int err;
+
+ if (!np)
+ return -ENODEV;
+
+ err = of_get_nvmem_eui48(np, "local-bd-address", ba);
+ if (err)
+ return err;
+
+ if (hci_test_quirk(hdev, HCI_QUIRK_BDADDR_NVMEM_BE))
+ baswap(&hdev->public_addr, (bdaddr_t *)ba);
+ else
+ bacpy(&hdev->public_addr, (bdaddr_t *)ba);
+
+ return 0;
+}
+
/**
* hci_dev_get_bd_addr_from_property - Get the Bluetooth Device Address
* (BD_ADDR) for a HCI device from
@@ -5042,12 +5076,17 @@ static int hci_dev_setup_sync(struct hci_dev *hdev)
* its setup callback.
*/
invalid_bdaddr = hci_test_quirk(hdev, HCI_QUIRK_INVALID_BDADDR) ||
- hci_test_quirk(hdev, HCI_QUIRK_USE_BDADDR_PROPERTY);
+ hci_test_quirk(hdev, HCI_QUIRK_USE_BDADDR_PROPERTY) ||
+ hci_test_quirk(hdev, HCI_QUIRK_USE_BDADDR_NVMEM);
if (!ret) {
if (hci_test_quirk(hdev, HCI_QUIRK_USE_BDADDR_PROPERTY) &&
!bacmp(&hdev->public_addr, BDADDR_ANY))
hci_dev_get_bd_addr_from_property(hdev);
+ if (hci_test_quirk(hdev, HCI_QUIRK_USE_BDADDR_NVMEM) &&
+ !bacmp(&hdev->public_addr, BDADDR_ANY))
+ hci_dev_get_bd_addr_from_nvmem(hdev);
+
if (invalid_bdaddr && bacmp(&hdev->public_addr, BDADDR_ANY) &&
hdev->set_bdaddr) {
ret = hdev->set_bdaddr(hdev, &hdev->public_addr);
diff --git a/net/bluetooth/mgmt.c b/net/bluetooth/mgmt.c
index b05bb380e5f87715e2a4ac38aa7e7eb77c48549f..8f2a2d0f76adc3dd9cbe235d5ad0ed5e1667fcb6 100644
--- a/net/bluetooth/mgmt.c
+++ b/net/bluetooth/mgmt.c
@@ -617,7 +617,8 @@ static bool is_configured(struct hci_dev *hdev)
return false;
if ((hci_test_quirk(hdev, HCI_QUIRK_INVALID_BDADDR) ||
- hci_test_quirk(hdev, HCI_QUIRK_USE_BDADDR_PROPERTY)) &&
+ hci_test_quirk(hdev, HCI_QUIRK_USE_BDADDR_PROPERTY) ||
+ hci_test_quirk(hdev, HCI_QUIRK_USE_BDADDR_NVMEM)) &&
!bacmp(&hdev->public_addr, BDADDR_ANY))
return false;
@@ -633,7 +634,8 @@ static __le32 get_missing_options(struct hci_dev *hdev)
options |= MGMT_OPTION_EXTERNAL_CONFIG;
if ((hci_test_quirk(hdev, HCI_QUIRK_INVALID_BDADDR) ||
- hci_test_quirk(hdev, HCI_QUIRK_USE_BDADDR_PROPERTY)) &&
+ hci_test_quirk(hdev, HCI_QUIRK_USE_BDADDR_PROPERTY) ||
+ hci_test_quirk(hdev, HCI_QUIRK_USE_BDADDR_NVMEM)) &&
!bacmp(&hdev->public_addr, BDADDR_ANY))
options |= MGMT_OPTION_PUBLIC_ADDRESS;
--
2.34.1
^ permalink raw reply related
* [PATCH v8 6/9] net: of_net: Add of_get_nvmem_eui48() helper for EUI-48 lookup
From: Loic Poulain @ 2026-07-03 13:45 UTC (permalink / raw)
To: Ulf Hansson, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Bjorn Andersson, Konrad Dybcio, Jens Axboe, Johannes Berg,
Jeff Johnson, Bartosz Golaszewski, Marcel Holtmann,
Luiz Augusto von Dentz, Balakrishna Godavarthi, Rocky Liao,
David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman, Srinivas Kandagatla, Andrew Lunn, Heiner Kallweit,
Russell King, Saravana Kannan, Christian Marangi
Cc: linux-mmc, devicetree, linux-kernel, linux-arm-msm, linux-block,
linux-wireless, ath10k, linux-bluetooth, netdev, daniel,
Loic Poulain, Bartosz Golaszewski
In-Reply-To: <20260703-block-as-nvmem-v8-0-98ae32bfc49a@oss.qualcomm.com>
Factor out the common NVMEM EUI-48 retrieval logic from
of_get_mac_address_nvmem() into a new of_get_nvmem_eui48() helper that
accepts the NVMEM cell name as a parameter. This allows other subsystems
(e.g. Bluetooth) to reuse the same lookup-validate-copy pattern with a
different cell name, without duplicating code.
of_get_mac_address_nvmem() is updated to call of_get_nvmem_eui48() with
"mac-address", preserving its existing behavior.
Reviewed-by: Bartosz Golaszewski <bartosz.golaszewski@oss.qualcomm.com>
Signed-off-by: Loic Poulain <loic.poulain@oss.qualcomm.com>
---
include/linux/of_net.h | 7 +++++++
net/core/of_net.c | 52 ++++++++++++++++++++++++++++++++++++++------------
2 files changed, 47 insertions(+), 12 deletions(-)
diff --git a/include/linux/of_net.h b/include/linux/of_net.h
index d88715a0b3a52f87af23d47791bea3baf5be5200..7854ba555d9a55f3d020a37fe00a27ae52e0e5dc 100644
--- a/include/linux/of_net.h
+++ b/include/linux/of_net.h
@@ -15,6 +15,7 @@ struct net_device;
extern int of_get_phy_mode(struct device_node *np, phy_interface_t *interface);
extern int of_get_mac_address(struct device_node *np, u8 *mac);
extern int of_get_mac_address_nvmem(struct device_node *np, u8 *mac);
+int of_get_nvmem_eui48(struct device_node *np, const char *cell_name, u8 *addr);
int of_get_ethdev_address(struct device_node *np, struct net_device *dev);
extern struct net_device *of_find_net_device_by_node(struct device_node *np);
#else
@@ -34,6 +35,12 @@ static inline int of_get_mac_address_nvmem(struct device_node *np, u8 *mac)
return -ENODEV;
}
+static inline int of_get_nvmem_eui48(struct device_node *np,
+ const char *cell_name, u8 *addr)
+{
+ return -ENODEV;
+}
+
static inline int of_get_ethdev_address(struct device_node *np, struct net_device *dev)
{
return -ENODEV;
diff --git a/net/core/of_net.c b/net/core/of_net.c
index 93ea425b9248a23f4f95a336e9cdbf0053248e32..999ca0e9258c41580823b80e0ef6db26617bc968 100644
--- a/net/core/of_net.c
+++ b/net/core/of_net.c
@@ -61,9 +61,7 @@ static int of_get_mac_addr(struct device_node *np, const char *name, u8 *addr)
int of_get_mac_address_nvmem(struct device_node *np, u8 *addr)
{
struct platform_device *pdev = of_find_device_by_node(np);
- struct nvmem_cell *cell;
- const void *mac;
- size_t len;
+ u8 mac[ETH_ALEN] __aligned(sizeof(u16));
int ret;
/* Try lookup by device first, there might be a nvmem_cell_lookup
@@ -75,27 +73,57 @@ int of_get_mac_address_nvmem(struct device_node *np, u8 *addr)
return ret;
}
- cell = of_nvmem_cell_get(np, "mac-address");
+ ret = of_get_nvmem_eui48(np, "mac-address", mac);
+ if (ret)
+ return ret;
+
+ if (!is_valid_ether_addr(mac))
+ return -EINVAL;
+
+ memcpy(addr, mac, ETH_ALEN);
+ return 0;
+}
+EXPORT_SYMBOL(of_get_mac_address_nvmem);
+
+/**
+ * of_get_nvmem_eui48 - Read a 6-byte EUI-48 address from a named NVMEM cell.
+ * @np: Device node to look up the NVMEM cell from.
+ * @cell_name: Name of the NVMEM cell (e.g. "mac-address", "local-bd-address").
+ * @addr: Output buffer for the 6-byte address.
+ *
+ * Reads the named NVMEM cell and validates that it contains a non-zero 6-byte
+ * address. Returns 0 on success, negative errno on failure.
+ */
+int of_get_nvmem_eui48(struct device_node *np, const char *cell_name, u8 *addr)
+{
+ struct nvmem_cell *cell;
+ const void *eui48;
+ size_t len;
+
+ cell = of_nvmem_cell_get(np, cell_name);
if (IS_ERR(cell))
return PTR_ERR(cell);
- mac = nvmem_cell_read(cell, &len);
+ eui48 = nvmem_cell_read(cell, &len);
nvmem_cell_put(cell);
- if (IS_ERR(mac))
- return PTR_ERR(mac);
+ if (IS_ERR(eui48))
+ return PTR_ERR(eui48);
- if (len != ETH_ALEN || !is_valid_ether_addr(mac)) {
- kfree(mac);
+ /* Reject unprogrammed cells that read as all-zeroes or all-ones */
+ if (len != ETH_ALEN ||
+ !memchr_inv(eui48, 0x00, ETH_ALEN) ||
+ !memchr_inv(eui48, 0xff, ETH_ALEN)) {
+ kfree(eui48);
return -EINVAL;
}
- memcpy(addr, mac, ETH_ALEN);
- kfree(mac);
+ memcpy(addr, eui48, ETH_ALEN);
+ kfree(eui48);
return 0;
}
-EXPORT_SYMBOL(of_get_mac_address_nvmem);
+EXPORT_SYMBOL_GPL(of_get_nvmem_eui48);
/**
* of_get_mac_address()
--
2.34.1
^ permalink raw reply related
* [PATCH v8 3/9] dt-bindings: bluetooth: qcom: Add NVMEM BD address cell
From: Loic Poulain @ 2026-07-03 13:45 UTC (permalink / raw)
To: Ulf Hansson, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Bjorn Andersson, Konrad Dybcio, Jens Axboe, Johannes Berg,
Jeff Johnson, Bartosz Golaszewski, Marcel Holtmann,
Luiz Augusto von Dentz, Balakrishna Godavarthi, Rocky Liao,
David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman, Srinivas Kandagatla, Andrew Lunn, Heiner Kallweit,
Russell King, Saravana Kannan, Christian Marangi
Cc: linux-mmc, devicetree, linux-kernel, linux-arm-msm, linux-block,
linux-wireless, ath10k, linux-bluetooth, netdev, daniel,
Loic Poulain, Bartosz Golaszewski
In-Reply-To: <20260703-block-as-nvmem-v8-0-98ae32bfc49a@oss.qualcomm.com>
Add support for an NVMEM cell provider for "local-bd-address",
allowing the Bluetooth stack to retrieve controller's BD address
from non-volatile storage such as an EEPROM or an eMMC partition.
Reviewed-by: Rob Herring (Arm) <robh@kernel.org>
Reviewed-by: Bartosz Golaszewski <bartosz.golaszewski@oss.qualcomm.com>
Signed-off-by: Loic Poulain <loic.poulain@oss.qualcomm.com>
---
.../devicetree/bindings/net/bluetooth/qcom,bluetooth-common.yaml | 9 +++++++++
1 file changed, 9 insertions(+)
diff --git a/Documentation/devicetree/bindings/net/bluetooth/qcom,bluetooth-common.yaml b/Documentation/devicetree/bindings/net/bluetooth/qcom,bluetooth-common.yaml
index c8e9c55c1afb4c8e05ba2dae41ce2db4194b4a0f..7cb28f30c9af032082f23311f2fc89a32f266f17 100644
--- a/Documentation/devicetree/bindings/net/bluetooth/qcom,bluetooth-common.yaml
+++ b/Documentation/devicetree/bindings/net/bluetooth/qcom,bluetooth-common.yaml
@@ -22,4 +22,13 @@ properties:
description:
boot firmware is incorrectly passing the address in big-endian order
+ nvmem-cells:
+ maxItems: 1
+ description:
+ Nvmem data cell that contains a 6 byte BD address with the most
+ significant byte first (big-endian).
+
+ nvmem-cell-names:
+ const: local-bd-address
+
additionalProperties: true
--
2.34.1
^ permalink raw reply related
* [PATCH v8 5/9] block: implement NVMEM provider
From: Loic Poulain @ 2026-07-03 13:45 UTC (permalink / raw)
To: Ulf Hansson, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Bjorn Andersson, Konrad Dybcio, Jens Axboe, Johannes Berg,
Jeff Johnson, Bartosz Golaszewski, Marcel Holtmann,
Luiz Augusto von Dentz, Balakrishna Godavarthi, Rocky Liao,
David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman, Srinivas Kandagatla, Andrew Lunn, Heiner Kallweit,
Russell King, Saravana Kannan, Christian Marangi
Cc: linux-mmc, devicetree, linux-kernel, linux-arm-msm, linux-block,
linux-wireless, ath10k, linux-bluetooth, netdev, daniel,
Loic Poulain, Bartosz Golaszewski
In-Reply-To: <20260703-block-as-nvmem-v8-0-98ae32bfc49a@oss.qualcomm.com>
From: Daniel Golle <daniel@makrotopia.org>
On embedded devices using an eMMC it is common that one or more partitions
on the eMMC are used to store MAC addresses and Wi-Fi calibration EEPROM
data. Allow referencing the partition in device tree for the kernel and
Wi-Fi drivers accessing it via the NVMEM layer.
NVMEM is registered for a block device whose OF node describes an NVMEM
layout, either via an "nvmem-layout" child or by being a "fixed-layout"
node itself (e.g. an eMMC boot partition associated through its mmc-card
node).
Signed-off-by: Daniel Golle <daniel@makrotopia.org>
Co-developed-by: Loic Poulain <loic.poulain@oss.qualcomm.com>
Signed-off-by: Loic Poulain <loic.poulain@oss.qualcomm.com>
Reviewed-by: Bartosz Golaszewski <bartosz.golaszewski@oss.qualcomm.com>
---
block/Kconfig | 11 +++++
block/Makefile | 1 +
block/blk-nvmem.c | 110 ++++++++++++++++++++++++++++++++++++++++++++++
block/blk.h | 8 ++++
block/genhd.c | 4 ++
include/linux/blk_types.h | 4 ++
6 files changed, 138 insertions(+)
diff --git a/block/Kconfig b/block/Kconfig
index 15027963472d7b40e27b9097a5993c457b5b3054..69370ea2e268b9e5320477c747db4aab15abe3ff 100644
--- a/block/Kconfig
+++ b/block/Kconfig
@@ -209,6 +209,17 @@ config BLK_INLINE_ENCRYPTION_FALLBACK
by falling back to the kernel crypto API when inline
encryption hardware is not present.
+config BLK_NVMEM
+ bool "Block device NVMEM provider"
+ depends on OF
+ depends on NVMEM
+ help
+ Allow block devices (or partitions) to act as NVMEM providers,
+ exposing factory-provisioned data such as MAC addresses or Wi-Fi
+ calibration blobs to the drivers that consume them. This is
+ typically used on embedded devices where such data is stored in a
+ dedicated area of an eMMC, instead of a separate EEPROM or OTP.
+
source "block/partitions/Kconfig"
config BLK_PM
diff --git a/block/Makefile b/block/Makefile
index 7dce2e44276c4274c11a0a61121c83d9c43d6e0c..d7ac389e71902bc091a8800ea266190a43b3e63d 100644
--- a/block/Makefile
+++ b/block/Makefile
@@ -36,3 +36,4 @@ obj-$(CONFIG_BLK_INLINE_ENCRYPTION) += blk-crypto.o blk-crypto-profile.o \
blk-crypto-sysfs.o
obj-$(CONFIG_BLK_INLINE_ENCRYPTION_FALLBACK) += blk-crypto-fallback.o
obj-$(CONFIG_BLOCK_HOLDER_DEPRECATED) += holder.o
+obj-$(CONFIG_BLK_NVMEM) += blk-nvmem.o
diff --git a/block/blk-nvmem.c b/block/blk-nvmem.c
new file mode 100644
index 0000000000000000000000000000000000000000..642a12f8a8b1c88e25baa1b684adef48c8c91c84
--- /dev/null
+++ b/block/blk-nvmem.c
@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * block device NVMEM provider
+ *
+ * Copyright (c) 2024 Daniel Golle <daniel@makrotopia.org>
+ * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+ *
+ * Useful on devices using a partition on an eMMC for MAC addresses or
+ * Wi-Fi calibration EEPROM data.
+ */
+
+#include <linux/cleanup.h>
+#include <linux/device.h>
+#include <linux/file.h>
+#include <linux/nvmem-provider.h>
+#include <linux/nvmem-consumer.h>
+#include <linux/of.h>
+#include <linux/pagemap.h>
+#include <linux/property.h>
+
+#include "blk.h"
+
+static int blk_nvmem_reg_read(void *priv, unsigned int from, void *val, size_t bytes)
+{
+ dev_t devt = (dev_t)(uintptr_t)priv;
+ size_t bytes_left = bytes;
+ loff_t pos = from;
+ int ret = 0;
+
+ struct file *bdev_file __free(fput) =
+ bdev_file_open_by_dev(devt, BLK_OPEN_READ, NULL, NULL);
+ if (IS_ERR(bdev_file))
+ return PTR_ERR(bdev_file);
+
+ while (bytes_left) {
+ pgoff_t f_index = pos >> PAGE_SHIFT;
+ struct folio *folio;
+ size_t folio_off;
+ size_t to_read;
+
+ folio = read_mapping_folio(bdev_file->f_mapping, f_index, NULL);
+ if (IS_ERR(folio)) {
+ ret = PTR_ERR(folio);
+ break;
+ }
+
+ folio_off = offset_in_folio(folio, pos);
+ to_read = min(bytes_left, folio_size(folio) - folio_off);
+ memcpy_from_folio(val, folio, folio_off, to_read);
+ pos += to_read;
+ bytes_left -= to_read;
+ val += to_read;
+ folio_put(folio);
+ }
+
+ return ret;
+}
+
+int blk_nvmem_add(struct block_device *bdev)
+{
+ struct device *dev = &bdev->bd_device;
+ struct nvmem_config config = {};
+ struct nvmem_device *nvmem;
+
+ /* skip devices which do not have a device tree node */
+ if (!dev_of_node(dev))
+ return 0;
+
+ /* skip devices without an nvmem layout defined */
+ struct device_node *child __free(device_node) =
+ of_get_child_by_name(dev_of_node(dev), "nvmem-layout");
+ if (!child && !of_device_is_compatible(dev_of_node(dev), "fixed-layout"))
+ return 0;
+
+ /*
+ * skip block device too large to be represented as NVMEM devices,
+ * nvmem_config.size is a signed int
+ */
+ if (bdev_nr_bytes(bdev) > INT_MAX) {
+ dev_warn(dev, "block device too large to be an NVMEM provider\n");
+ return 0;
+ }
+
+ config.id = NVMEM_DEVID_NONE;
+ config.dev = dev;
+ config.name = dev_name(dev);
+ config.owner = THIS_MODULE;
+ config.priv = (void *)(uintptr_t)dev->devt;
+ config.reg_read = blk_nvmem_reg_read;
+ config.size = bdev_nr_bytes(bdev);
+ config.word_size = 1;
+ config.stride = 1;
+ config.read_only = true;
+ config.root_only = true;
+ config.ignore_wp = true;
+ config.of_node = to_of_node(dev->fwnode);
+
+ nvmem = nvmem_register(&config);
+ if (IS_ERR(nvmem))
+ return dev_err_probe(dev, PTR_ERR(nvmem), "Failed to register NVMEM device\n");
+
+ bdev->bd_nvmem = nvmem;
+ return 0;
+}
+
+void blk_nvmem_del(struct block_device *bdev)
+{
+ nvmem_unregister(bdev->bd_nvmem);
+ bdev->bd_nvmem = NULL;
+}
diff --git a/block/blk.h b/block/blk.h
index ec4674cdf2ead4fd259ff5fc42401f591e684ee9..ed0c10168ba7be10855509637f824a9cea2b9ccb 100644
--- a/block/blk.h
+++ b/block/blk.h
@@ -757,4 +757,12 @@ static inline void blk_debugfs_unlock(struct request_queue *q,
memalloc_noio_restore(memflags);
}
+#ifdef CONFIG_BLK_NVMEM
+int blk_nvmem_add(struct block_device *bdev);
+void blk_nvmem_del(struct block_device *bdev);
+#else
+static inline int blk_nvmem_add(struct block_device *bdev) { return 0; }
+static inline void blk_nvmem_del(struct block_device *bdev) {}
+#endif
+
#endif /* BLK_INTERNAL_H */
diff --git a/block/genhd.c b/block/genhd.c
index 7d6854fd28e95ae9134309679a7c6a937f5b7db8..1b2382de6fb30c1e5f60f45c04dc03ed3bf5d5f2 100644
--- a/block/genhd.c
+++ b/block/genhd.c
@@ -421,6 +421,8 @@ static void add_disk_final(struct gendisk *disk)
*/
dev_set_uevent_suppress(ddev, 0);
disk_uevent(disk, KOBJ_ADD);
+
+ blk_nvmem_add(disk->part0);
}
blk_apply_bdi_limits(disk->bdi, &disk->queue->limits);
@@ -704,6 +706,8 @@ static void __del_gendisk(struct gendisk *disk)
disk_del_events(disk);
+ blk_nvmem_del(disk->part0);
+
/*
* Prevent new openers by unlinked the bdev inode.
*/
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index 8808ee76e73c09e0ceaac41ba59e86fb0c4efc64..6ed173c649025b95cce9253b27f68f2c7dbab8eb 100644
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -15,6 +15,7 @@
struct bio_set;
struct bio;
struct bio_integrity_payload;
+struct nvmem_device;
struct page;
struct io_context;
struct cgroup_subsys_state;
@@ -73,6 +74,9 @@ struct block_device {
int bd_writers;
#ifdef CONFIG_SECURITY
void *bd_security;
+#endif
+#ifdef CONFIG_BLK_NVMEM
+ struct nvmem_device *bd_nvmem;
#endif
/*
* keep this out-of-line as it's both big and not needed in the fast
--
2.34.1
^ permalink raw reply related
* [PATCH v8 4/9] nvmem: layouts: Support fixed-layout as the nvmem device node itself
From: Loic Poulain @ 2026-07-03 13:45 UTC (permalink / raw)
To: Ulf Hansson, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Bjorn Andersson, Konrad Dybcio, Jens Axboe, Johannes Berg,
Jeff Johnson, Bartosz Golaszewski, Marcel Holtmann,
Luiz Augusto von Dentz, Balakrishna Godavarthi, Rocky Liao,
David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman, Srinivas Kandagatla, Andrew Lunn, Heiner Kallweit,
Russell King, Saravana Kannan, Christian Marangi
Cc: linux-mmc, devicetree, linux-kernel, linux-arm-msm, linux-block,
linux-wireless, ath10k, linux-bluetooth, netdev, daniel,
Loic Poulain
In-Reply-To: <20260703-block-as-nvmem-v8-0-98ae32bfc49a@oss.qualcomm.com>
of_nvmem_layout_get_container() only looks for a child node named
"nvmem-layout" to locate the cell definitions. This does not cover
providers whose device tree node is itself the fixed-layout container,
such as an eMMC boot partition block device whose fwnode points directly
at a "fixed-layout" compatible partitions node.
When no "nvmem-layout" child is present, fall back to returning the nvmem
device node itself if it is compatible with "fixed-layout", so that its
cells are parsed by nvmem_add_cells_from_fixed_layout().
Signed-off-by: Loic Poulain <loic.poulain@oss.qualcomm.com>
---
drivers/nvmem/layouts.c | 13 ++++++++++++-
1 file changed, 12 insertions(+), 1 deletion(-)
diff --git a/drivers/nvmem/layouts.c b/drivers/nvmem/layouts.c
index b90584e1b99eab4217cbe7ec48373e18a7caf0dc..efa631ce7283bdd6c8ecda75915911b5e3a33c99 100644
--- a/drivers/nvmem/layouts.c
+++ b/drivers/nvmem/layouts.c
@@ -167,7 +167,18 @@ static int nvmem_layout_bus_populate(struct nvmem_device *nvmem,
struct device_node *of_nvmem_layout_get_container(struct nvmem_device *nvmem)
{
- return of_get_child_by_name(nvmem->dev.of_node, "nvmem-layout");
+ struct device_node *np;
+
+ /* Search for nvmem-layout child */
+ np = of_get_child_by_name(nvmem->dev.of_node, "nvmem-layout");
+ if (np)
+ return np;
+
+ /* The nvmem of_node is itself a fixed-layout node */
+ if (of_device_is_compatible(nvmem->dev.of_node, "fixed-layout"))
+ return of_node_get(nvmem->dev.of_node);
+
+ return NULL;
}
EXPORT_SYMBOL_GPL(of_nvmem_layout_get_container);
--
2.34.1
^ permalink raw reply related
* [PATCH v8 2/9] dt-bindings: net: wireless: qcom,ath10k: Document NVMEM cells
From: Loic Poulain @ 2026-07-03 13:45 UTC (permalink / raw)
To: Ulf Hansson, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Bjorn Andersson, Konrad Dybcio, Jens Axboe, Johannes Berg,
Jeff Johnson, Bartosz Golaszewski, Marcel Holtmann,
Luiz Augusto von Dentz, Balakrishna Godavarthi, Rocky Liao,
David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman, Srinivas Kandagatla, Andrew Lunn, Heiner Kallweit,
Russell King, Saravana Kannan, Christian Marangi
Cc: linux-mmc, devicetree, linux-kernel, linux-arm-msm, linux-block,
linux-wireless, ath10k, linux-bluetooth, netdev, daniel,
Loic Poulain, Bartosz Golaszewski, Krzysztof Kozlowski
In-Reply-To: <20260703-block-as-nvmem-v8-0-98ae32bfc49a@oss.qualcomm.com>
Document the NVMEM cells supported by the ath10k driver, the
mac-address, pre-calibration data, and calibration data.
Since such data may also originate from chipset OTP or be supplied
via other device tree structures. All of these cells are optional
and can be provided independently, in any combination.
Reviewed-by: Bartosz Golaszewski <bartosz.golaszewski@oss.qualcomm.com>
Reviewed-by: Krzysztof Kozlowski <krzysztof.kozlowski@oss.qualcomm.com>
Signed-off-by: Loic Poulain <loic.poulain@oss.qualcomm.com>
---
.../devicetree/bindings/net/wireless/qcom,ath10k.yaml | 16 ++++++++++++++++
1 file changed, 16 insertions(+)
diff --git a/Documentation/devicetree/bindings/net/wireless/qcom,ath10k.yaml b/Documentation/devicetree/bindings/net/wireless/qcom,ath10k.yaml
index c21d66c7cd558ab792524be9afec8b79272d1c87..878c5d833a9cb073520c256c1b72d0f1489e7f4a 100644
--- a/Documentation/devicetree/bindings/net/wireless/qcom,ath10k.yaml
+++ b/Documentation/devicetree/bindings/net/wireless/qcom,ath10k.yaml
@@ -92,6 +92,22 @@ properties:
ieee80211-freq-limit: true
+ nvmem-cells:
+ minItems: 1
+ maxItems: 3
+ description:
+ References to nvmem cells for MAC address and/or calibration data.
+ Supported cell names are mac-address, calibration, and pre-calibration.
+
+ nvmem-cell-names:
+ minItems: 1
+ maxItems: 3
+ items:
+ enum:
+ - mac-address
+ - calibration
+ - pre-calibration
+
qcom,calibration-data:
$ref: /schemas/types.yaml#/definitions/uint8-array
description:
--
2.34.1
^ permalink raw reply related
* [PATCH v8 1/9] dt-bindings: mmc: Document fixed-layout NVMEM provider support
From: Loic Poulain @ 2026-07-03 13:45 UTC (permalink / raw)
To: Ulf Hansson, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Bjorn Andersson, Konrad Dybcio, Jens Axboe, Johannes Berg,
Jeff Johnson, Bartosz Golaszewski, Marcel Holtmann,
Luiz Augusto von Dentz, Balakrishna Godavarthi, Rocky Liao,
David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman, Srinivas Kandagatla, Andrew Lunn, Heiner Kallweit,
Russell King, Saravana Kannan, Christian Marangi
Cc: linux-mmc, devicetree, linux-kernel, linux-arm-msm, linux-block,
linux-wireless, ath10k, linux-bluetooth, netdev, daniel,
Loic Poulain
In-Reply-To: <20260703-block-as-nvmem-v8-0-98ae32bfc49a@oss.qualcomm.com>
Allow an eMMC hardware partition node to describe an NVMEM layout so the
partition can be exposed as an NVMEM provider. This lets a partition
(e.g. an eMMC boot partition) store device-specific information such as a
WiFi MAC address or a Bluetooth BD address and reference it through NVMEM
cells.
Accept "fixed-layout" as the partition node compatible, in addition to
"fixed-partitions", so the layout can be described directly on the
partition node.
Signed-off-by: Loic Poulain <loic.poulain@oss.qualcomm.com>
---
.../devicetree/bindings/mmc/mmc-card.yaml | 23 +++++++++++++++++++++-
1 file changed, 22 insertions(+), 1 deletion(-)
diff --git a/Documentation/devicetree/bindings/mmc/mmc-card.yaml b/Documentation/devicetree/bindings/mmc/mmc-card.yaml
index a61d6c96df759102f9c1fbfd548b026a77921cae..0422894508478c8d0ca68292b58a5fdbee218358 100644
--- a/Documentation/devicetree/bindings/mmc/mmc-card.yaml
+++ b/Documentation/devicetree/bindings/mmc/mmc-card.yaml
@@ -38,7 +38,9 @@ patternProperties:
properties:
compatible:
contains:
- const: fixed-partitions
+ enum:
+ - fixed-partitions
+ - fixed-layout
required:
- compatible
@@ -86,6 +88,25 @@ examples:
read-only;
};
};
+
+ partitions-boot2 {
+ compatible = "fixed-layout";
+
+ #address-cells = <1>;
+ #size-cells = <1>;
+
+ mac-addr@4400 {
+ compatible = "mac-base";
+ reg = <0x4400 0x6>;
+ #nvmem-cell-cells = <1>;
+ };
+
+ bd-addr@5400 {
+ compatible = "mac-base";
+ reg = <0x5400 0x6>;
+ #nvmem-cell-cells = <1>;
+ };
+ };
};
};
--
2.34.1
^ permalink raw reply related
* [PATCH v8 0/9] Support for block device NVMEM providers
From: Loic Poulain @ 2026-07-03 13:45 UTC (permalink / raw)
To: Ulf Hansson, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Bjorn Andersson, Konrad Dybcio, Jens Axboe, Johannes Berg,
Jeff Johnson, Bartosz Golaszewski, Marcel Holtmann,
Luiz Augusto von Dentz, Balakrishna Godavarthi, Rocky Liao,
David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman, Srinivas Kandagatla, Andrew Lunn, Heiner Kallweit,
Russell King, Saravana Kannan, Christian Marangi
Cc: linux-mmc, devicetree, linux-kernel, linux-arm-msm, linux-block,
linux-wireless, ath10k, linux-bluetooth, netdev, daniel,
Loic Poulain, Bartosz Golaszewski, Krzysztof Kozlowski,
Piotr Kwapulinski, Konrad Dybcio
On embedded devices, it is common for factory provisioning to store
device-specific information, such as Ethernet or WiFi MAC addresses,
in a dedicated area of an eMMC partition. This avoids the need for
and additional EEPROM/OTP and leverages the persistence of eMMC.
One example is the Arduino UNO-Q, where the WiFi MAC address and the
Bluetooth Device address are stored in the eMMC Boot1 partition.
Until now, accessing this information required a custom bootloader
to read the data and inject it into the Device Tree before handing
control over to the kernel. This approach is fragile and leads to
device-specific workarounds.
Rather than adding a new NVMEM provider specifically to the eMMC
subsystem, the new support operates at the block layer, allowing any
block device to behave like other non-volatile memories such as EEPROM
or OTP.
This series builds on earlier work by Daniel Golle that enables block
devices to act as NVMEM providers:
https://lore.kernel.org/all/6061aa4201030b9bb2f8d03ef32a564fdb786ed1.1709667858.git.daniel@makrotopia.org/
It also introduces an NVMEM layout description for the Arduino UNO-Q,
allowing device-specific data stored in the eMMC Boot1 partition to
be accessed in a standard way.
WiFi and Ethernet already support retrieving MAC addresses from NVMEM.
Bluetooth requires similar support, which is also addressed.
Note that this is currently limited to MMC-backed block devices, as
only the MMC core associates a firmware node with the block device
(add_disk_fwnode). This can be easily extended in the future to
support additional block drivers.
Signed-off-by: Loic Poulain <loic.poulain@oss.qualcomm.com>
---
Changes in v8:
- block: Fix bdev->bd_nvmem on registering failure (sashiko)
- net: of_net: of_get_nvmem_eui48() now also rejects all-ones cells (sashiko)
- Bluetooth: mgmt: account for HCI_QUIRK_USE_BDADDR_NVMEM in
is_configured() and get_missing_options() (sashiko)
- Reword blk-nvmem KCONFIG help text to satisfy checkpatch
- Link to v7: https://lore.kernel.org/r/20260701-block-as-nvmem-v7-0-3fe8205ef0a8@oss.qualcomm.com
Changes in v7:
- Rework bindings/dts so that the eMMC boot partition can be a nvmem fixed-layout
and not a child of fixed-partition. (Rob)
- Add Support for fixed-layout as the nvmem device node itself
- Remove "block: partitions: of: Skip child nodes without reg property"
This is no more required in this series and will be submitted separately (Rob)
- Add missing linux/cleanup.h and linux/device.h includes (Bartosz)
- simplify nvmem_register() error path using dev_err_probe() (Bartosz)
- nvmem_device forward declaration to blk_types.h (Bartosz)
- Add hci_dev_get_bd_addr_from_nvmem() kernel-doc for return value (Piotr)
- Link to v6: https://lore.kernel.org/r/20260629-block-as-nvmem-v6-0-f02513dcd46d@oss.qualcomm.com
Changes in v6:
- blk_nvmem_add() returns int, error properly propagated (Bartosz)
- Redundant if (bdev->bd_nvmem) guard removed in blk_nvmem_del() (Bartosz)
- Size guard changed from UINT_MAX → INT_MAX to avoid signed overflow in config.size (sashiko)
- BLK_OPEN_RESTRICT_WRITES removed from blk_nvmem_reg_read() (sashiko)
- Link to v5: https://lore.kernel.org/r/20260612-block-as-nvmem-v5-0-95e0b30fff90@oss.qualcomm.com
Changes in v5:
- Fixed ath10k binding issue + extended commit message (Krzysztof)
- Moved blk-nvmem handling to block core instead of a class_interface
This allows correct/robust integration with block device life cycle (Bartosz).
- block: partitions: of: Skip child nodes without reg property (sashiko)
- Link to v4: https://lore.kernel.org/r/20260609-block-as-nvmem-v4-0-45712e6b22c6@oss.qualcomm.com
Changes in v4:
- Fix squash issue (dts commit incorrectly squashed) (Konrad)
- Use devres for nvmem resources (Bartosz)
- use __free() destructor helper when possible (Bartosz)
- Fix value return checking for bdev_file_open_by_dev
- Link to v3: https://lore.kernel.org/r/20260608-block-as-nvmem-v3-0-82681f50aa35@oss.qualcomm.com
Changes in v3:
- Fixed missing 'fixed-partitions' compatible in partition (Rob)
- Fixed clashing nvmem cells, document calibration along mac (Sashiko)
- Remove workaround to handle dangling nvmem references after
unregistering, this is a generic nvmem framework issue handled
in Bartosz's series:
https://lore.kernel.org/all/20260429-nvmem-unbind-v3-0-2a694f95395b@oss.qualcomm.com/
- Validate mac (is_valid_ether_addr) before copying to output buffer
- Link to v2: https://lore.kernel.org/r/20260507-block-as-nvmem-v2-0-bf17edd5134e@oss.qualcomm.com
Changes in v2:
- Fix example nvmem-layout cells to use compatible = "mac-base"
- Squash WiFi MAC and Bluetooth BD address consumer patches into the nvmem layout patch
- Fix possible use-after-free in blk-nvmem: bnv (nvmem priv) linked to nvmem lifetime
- Simplify nvmem-cell-names from items: - const: to plain const:
- Factor out common NVMEM EUI-48 retrieval logic
- Reorder changes
- Link to v1: https://lore.kernel.org/r/20260428-block-as-nvmem-v1-0-6ad23e75190a@oss.qualcomm.com
---
Daniel Golle (1):
block: implement NVMEM provider
Loic Poulain (8):
dt-bindings: mmc: Document fixed-layout NVMEM provider support
dt-bindings: net: wireless: qcom,ath10k: Document NVMEM cells
dt-bindings: bluetooth: qcom: Add NVMEM BD address cell
nvmem: layouts: Support fixed-layout as the nvmem device node itself
net: of_net: Add of_get_nvmem_eui48() helper for EUI-48 lookup
Bluetooth: hci_sync: Add NVMEM-backed BD address retrieval
Bluetooth: qca: Set NVMEM BD address quirks when address is invalid
arm64: dts: qcom: arduino-imola: Describe NVMEM layout for WiFi/BT addresses
.../devicetree/bindings/mmc/mmc-card.yaml | 23 ++++-
.../net/bluetooth/qcom,bluetooth-common.yaml | 9 ++
.../bindings/net/wireless/qcom,ath10k.yaml | 16 +++
arch/arm64/boot/dts/qcom/qrb2210-arduino-imola.dts | 32 ++++++
block/Kconfig | 11 +++
block/Makefile | 1 +
block/blk-nvmem.c | 110 +++++++++++++++++++++
block/blk.h | 8 ++
block/genhd.c | 4 +
drivers/bluetooth/btqca.c | 5 +-
drivers/nvmem/layouts.c | 13 ++-
include/linux/blk_types.h | 4 +
include/linux/of_net.h | 7 ++
include/net/bluetooth/hci.h | 18 ++++
net/bluetooth/hci_sync.c | 41 +++++++-
net/bluetooth/mgmt.c | 6 +-
net/core/of_net.c | 52 +++++++---
17 files changed, 342 insertions(+), 18 deletions(-)
---
base-commit: dffcfe75c722be66aa2669fb335528edb0590671
change-id: 20260428-block-as-nvmem-4b308e8bda9a
Best regards,
--
Loic Poulain <loic.poulain@oss.qualcomm.com>
^ permalink raw reply
* [PATCH rtw-next 9/9] wifi: rtw89: coex: Add Co-RX logic
From: Ping-Ke Shih @ 2026-07-03 11:43 UTC (permalink / raw)
To: linux-wireless; +Cc: ku920601
In-Reply-To: <20260703114311.2609942-1-pkshih@realtek.com>
From: Ching-Te Ku <ku920601@realtek.com>
Co-RX means Wi-Fi & Bluetooth can be able to RX in the same time. This
patch is for judging the Wi-Fi/Bluetooth condition could be Co-RX or not,
and how to set the gain and power.
Signed-off-by: Ching-Te Ku <ku920601@realtek.com>
Signed-off-by: Ping-Ke Shih <pkshih@realtek.com>
---
drivers/net/wireless/realtek/rtw89/coex.c | 69 +++++++++++++++++++++++
drivers/net/wireless/realtek/rtw89/core.h | 1 +
2 files changed, 70 insertions(+)
diff --git a/drivers/net/wireless/realtek/rtw89/coex.c b/drivers/net/wireless/realtek/rtw89/coex.c
index d45fab32ab46..129b6b7cb634 100644
--- a/drivers/net/wireless/realtek/rtw89/coex.c
+++ b/drivers/net/wireless/realtek/rtw89/coex.c
@@ -3319,7 +3319,74 @@ static void _set_bt_rx_gain(struct rtw89_dev *rtwdev, bool force_exec, u8 bid,
_write_scbd(rtwdev, bid, scbd_bit, state);
}
+}
+
+static void _set_bt_corx_table(struct rtw89_dev *rtwdev, bool en)
+{
+ struct rtw89_btc *btc = &rtwdev->btc;
+ struct rtw89_btc_cx *cx = &btc->cx;
+ struct rtw89_btc_bt_info *bt = &cx->bt0;
+ struct rtw89_btc_dm *dm = &btc->dm;
+ u8 is_24g, is_56g, i;
+ u32 scbd_bit;
+
+ /*
+ * true: bt use Hi-LNA rx gain table (f/e/3/2) in -3x~-9xdBm for co-rx
+ * false: bt use original rx gain table (f/b/7/3/2)
+ */
+
+ if (btc->dm.fdd_bind.bt_sel == BIT(BTC_BT_EXT))
+ return;
+
+ for (i = BTC_BT_1ST; i <= BTC_BT_2ND; i++) {
+ scbd_bit = 0;
+ if (i == BTC_BT_2ND) {
+ if (!(rtwdev->chip->para_ver & BTC_FEAT_DUAL_BT))
+ continue;
+ bt = &cx->bt1;
+ }
+ is_24g = (dm->corx_map[BTC_RF_S0][i] ||
+ dm->corx_map[BTC_RF_S1][i]) & BIT(RTW89_BAND_2G);
+ is_56g = (dm->corx_map[BTC_RF_S0][i] ||
+ dm->corx_map[BTC_RF_S1][i]) & BIT(RTW89_BAND_5G);
+ if (is_24g)
+ scbd_bit |= BTC_WSCB_BT_HILNA;
+ if (is_56g)
+ scbd_bit |= BTC_WSCB_BT_HILNA_56G;
+
+ if ((is_24g && (en != (!!bt->hi_lna_rx))) ||
+ (is_56g && (en != (!!bt->hi_lna_rx_6g))))
+ _write_scbd(rtwdev, i, scbd_bit, en);
+ }
+}
+
+static void _set_rf_trx_para_v9(struct rtw89_dev *rtwdev)
+{
+ struct rtw89_btc *btc = &rtwdev->btc;
+ struct rtw89_btc_cx *cx = &btc->cx;
+ struct rtw89_btc_wl_smap *wl_smap = &cx->wl.status.map;
+ struct rtw89_btc_dm *dm = &btc->dm;
+ bool bt_2r = false;
+ u8 wl_stb_chg = 0;
+
+ if (wl_smap->rf_off || wl_smap->lps == BTC_LPS_RF_OFF)
+ return;
+
+ /* must call after _set_halbb_btg_ctrl() */
+ if (dm->tdd_bind.wl_link_mode != BTC_WLINK_NOLINK) {
+ wl_stb_chg = 1;
+ if (dm->wl_btg_rx)
+ bt_2r = true;
+ }
+
+ _set_bt_corx_table(rtwdev, bt_2r);
+
+ if (wl_stb_chg != dm->wl_stb_chg) {
+ dm->wl_stb_chg = wl_stb_chg;
+ dm->ost_info.wl_btg_standby_chg = wl_stb_chg;
+ rtwdev->chip->ops->btc_wl_s1_standby(rtwdev, dm->wl_stb_chg);
+ }
}
static void _set_rf_trx_para(struct rtw89_dev *rtwdev)
@@ -3356,6 +3423,8 @@ static void _set_rf_trx_para(struct rtw89_dev *rtwdev)
if (ver->fcxtrx == 9 && chip->rf_para_ulink_v9) {
ul_para_num = chip->rf_para_ulink_num_v9;
dl_para_num = chip->rf_para_dlink_num_v9;
+ _set_rf_trx_para_v9(rtwdev);
+ return;
} else if (ver->fcxtrx == 0 && chip->rf_para_ulink_v0) {
ul_para_num = chip->rf_para_ulink_num_v0;
dl_para_num = chip->rf_para_dlink_num_v0;
diff --git a/drivers/net/wireless/realtek/rtw89/core.h b/drivers/net/wireless/realtek/rtw89/core.h
index 8646a13bfd79..524b4974040c 100644
--- a/drivers/net/wireless/realtek/rtw89/core.h
+++ b/drivers/net/wireless/realtek/rtw89/core.h
@@ -3278,6 +3278,7 @@ struct rtw89_btc_fbtc_outsrc_set_info {
u8 pta_req_hw_band;
u8 rf_gbt_source;
u8 bt_enable_state;
+ u8 wl_btg_standby_chg;
} __packed;
union rtw89_btc_fbtc_slot_u {
--
2.25.1
^ permalink raw reply related
* [PATCH rtw-next 8/9] wifi: rtw89: coex: Update scoreboard related logic for dual Bluetooth
From: Ping-Ke Shih @ 2026-07-03 11:43 UTC (permalink / raw)
To: linux-wireless; +Cc: ku920601
In-Reply-To: <20260703114311.2609942-1-pkshih@realtek.com>
From: Ching-Te Ku <ku920601@realtek.com>
Update WiFi status to each Bluetooth & collect status from the two
Bluetooth adapter by non-stop power zone register. To correct the meaning
of variable, redefine the naming for the variables.
Signed-off-by: Ching-Te Ku <ku920601@realtek.com>
Signed-off-by: Ping-Ke Shih <pkshih@realtek.com>
---
drivers/net/wireless/realtek/rtw89/coex.c | 525 ++++++++++++++--------
drivers/net/wireless/realtek/rtw89/coex.h | 9 +
drivers/net/wireless/realtek/rtw89/core.c | 4 +-
drivers/net/wireless/realtek/rtw89/core.h | 33 +-
4 files changed, 370 insertions(+), 201 deletions(-)
diff --git a/drivers/net/wireless/realtek/rtw89/coex.c b/drivers/net/wireless/realtek/rtw89/coex.c
index 86833b0cd47c..d45fab32ab46 100644
--- a/drivers/net/wireless/realtek/rtw89/coex.c
+++ b/drivers/net/wireless/realtek/rtw89/coex.c
@@ -461,7 +461,14 @@ enum btc_b2w_scoreboard {
BTC_BSCB_BT_LNAB1 = BIT(10),
BTC_BSCB_WLRFK = BIT(11),
BTC_BSCB_BT_HILNA = BIT(13),
+ BTC_BSCB_BT_HILNA_56G = BIT(14),
+ BTC_BSCB_CTCODE = BIT(15),
BTC_BSCB_BT_CONNECT = BIT(16),
+ BTC_BSCB_BT_CONNECT_56G = BIT(17),
+ BTC_BSCB_BT_LNAB0_56G = BIT(18),
+ BTC_BSCB_BT_LNAB1_56G = BIT(19),
+ BTC_BSCB_BT_15DOT4 = BIT(24),
+ BTC_BSCB_BT_PROTECT = BIT(27),
BTC_BSCB_PAN_ACT = BIT(28),
BTC_BSCB_HFP_ACT = BIT(29),
BTC_BSCB_PATCH_CODE = BIT(30),
@@ -808,6 +815,8 @@ enum btc_reset_module {
BTC_RESET_CXDM = BIT(0) | BIT(1),
BTC_RESET_BTINFO = BIT(3),
BTC_RESET_MDINFO = BIT(4),
+ BTC_RESET_BT_PSD_DM = BIT(5),
+ BTC_RESET_BTINFO2 = BIT(6),
BTC_RESET_ALL = GENMASK(7, 0),
};
@@ -905,8 +914,9 @@ enum btc_reason_and_action {
static void _run_coex(struct rtw89_dev *rtwdev,
enum btc_reason_and_action reason);
-static void _write_scbd(struct rtw89_dev *rtwdev, u32 val, bool state);
-static void _update_bt_scbd(struct rtw89_dev *rtwdev, bool only_update);
+static void _write_scbd(struct rtw89_dev *rtwdev, u8 bid, u32 val, bool state);
+static u8 _sned_h2c_w2bscbd(struct rtw89_dev *rtwdev, bool force_exec, u8 bid);
+static void _update_bt_scbd(struct rtw89_dev *rtwdev, u8 bid);
static int _send_fw_cmd(struct rtw89_dev *rtwdev, u8 h2c_class, u8 h2c_func,
void *param, u16 len)
@@ -1272,11 +1282,6 @@ static void _chk_btc_err(struct rtw89_dev *rtwdev, u8 type, u32 cnt)
dm->cnt_dm[BTC_DCNT_BTCNT_HANG]++;
else
dm->cnt_dm[BTC_DCNT_BTCNT_HANG] = 0;
-
- if ((dm->cnt_dm[BTC_DCNT_BTCNT_HANG] >= BTC_CHK_HANG_MAX &&
- bt->enable.now) || (!dm->cnt_dm[BTC_DCNT_BTCNT_HANG] &&
- !bt->enable.now))
- _update_bt_scbd(rtwdev, false);
break;
case BTC_DCNT_WL_SLOT_DRIFT:
if (cnt >= BTC_CHK_WLSLOT_DRIFT_MAX)
@@ -1755,7 +1760,7 @@ static u32 _chk_btc_report(struct rtw89_dev *rtwdev,
rtwdev->chip->ops->btc_update_bt_cnt(rtwdev);
_chk_btc_err(rtwdev, BTC_DCNT_BTCNT_HANG, 0);
- bt->bcnt[BTC_BCNT_POLUT] =
+ bt->bcnt[BTC_BCNT_POLLUTED] =
rtw89_mac_get_plt_cnt(rtwdev,
RTW89_MAC_0);
}
@@ -1778,7 +1783,7 @@ static u32 _chk_btc_report(struct rtw89_dev *rtwdev,
le32_to_cpu(prpt->v4.bt_cnt[BTC_BCNT_LO_TX]);
bt->bcnt[BTC_BCNT_LOPRI_RX] =
le32_to_cpu(prpt->v4.bt_cnt[BTC_BCNT_LO_RX]);
- bt->bcnt[BTC_BCNT_POLUT] =
+ bt->bcnt[BTC_BCNT_POLLUTED] =
le32_to_cpu(prpt->v4.bt_cnt[BTC_BCNT_POLLUTED]);
_chk_btc_err(rtwdev, BTC_DCNT_BTCNT_HANG, 0);
@@ -1810,7 +1815,7 @@ static u32 _chk_btc_report(struct rtw89_dev *rtwdev,
le16_to_cpu(prpt->v5.bt_cnt[BTC_BCNT_LO_TX]);
bt->bcnt[BTC_BCNT_LOPRI_RX] =
le16_to_cpu(prpt->v5.bt_cnt[BTC_BCNT_LO_RX]);
- bt->bcnt[BTC_BCNT_POLUT] =
+ bt->bcnt[BTC_BCNT_POLLUTED] =
le16_to_cpu(prpt->v5.bt_cnt[BTC_BCNT_POLLUTED]);
_chk_btc_err(rtwdev, BTC_DCNT_BTCNT_HANG, 0);
@@ -1837,7 +1842,7 @@ static u32 _chk_btc_report(struct rtw89_dev *rtwdev,
le16_to_cpu(prpt->v105.bt_cnt[BTC_BCNT_LO_TX_V105]);
bt->bcnt[BTC_BCNT_LOPRI_RX] =
le16_to_cpu(prpt->v105.bt_cnt[BTC_BCNT_LO_RX_V105]);
- bt->bcnt[BTC_BCNT_POLUT] =
+ bt->bcnt[BTC_BCNT_POLLUTED] =
le16_to_cpu(prpt->v105.bt_cnt[BTC_BCNT_POLLUTED_V105]);
_chk_btc_err(rtwdev, BTC_DCNT_BTCNT_HANG, 0);
@@ -2791,14 +2796,14 @@ static void _fw_set_policy(struct rtw89_dev *rtwdev, u16 policy_type,
if (dm->tdma.rxflctrl == CXFLC_NULLP ||
dm->tdma.rxflctrl == CXFLC_QOSNULL)
- btc->lps = 1;
+ btc->btc_ctrl_lps = 1;
else
- btc->lps = dm->lps_ctrl_scbd;
+ btc->btc_ctrl_lps = dm->lps_ctrl_scbd;
dm->lps_ctrl_scbd_last = dm->lps_ctrl_scbd;
- if (btc->lps == 1)
- rtw89_set_coex_ctrl_lps(rtwdev, btc->lps);
+ if (btc->btc_ctrl_lps == 1)
+ rtw89_set_coex_ctrl_lps(rtwdev, btc->btc_ctrl_lps);
ret = _send_fw_cmd(rtwdev, BTFC_SET, SET_CX_POLICY,
btc->policy, btc->policy_len);
@@ -2813,8 +2818,8 @@ static void _fw_set_policy(struct rtw89_dev *rtwdev, u16 policy_type,
if (btc->update_policy_force)
btc->update_policy_force = false;
- if (btc->lps == 0)
- rtw89_set_coex_ctrl_lps(rtwdev, btc->lps);
+ if (btc->btc_ctrl_lps == 0)
+ rtw89_set_coex_ctrl_lps(rtwdev, btc->btc_ctrl_lps);
}
static void _fw_set_drv_info(struct rtw89_dev *rtwdev, u8 index)
@@ -2913,21 +2918,35 @@ void btc_fw_event(struct rtw89_dev *rtwdev, u8 evt_id, void *data, u32 len)
{
struct rtw89_btc *btc = &rtwdev->btc;
struct rtw89_btc_btf_fwinfo *pfwinfo = &btc->fwinfo;
+ struct rtw89_btc_bt_info *bt = &btc->cx.bt0;
+ u8 i;
- rtw89_debug(rtwdev, RTW89_DBG_BTC,
- "[BTC], %s(): evt_id:%d len:%d\n",
- __func__, evt_id, len);
+ _parse_btc_report(rtwdev, pfwinfo, data, len);
- if (!len || !data)
+ if (!rtwdev->chip->scbd)
return;
- switch (evt_id) {
- case BTF_EVNT_RPT:
- _parse_btc_report(rtwdev, pfwinfo, data, len);
- break;
- default:
- break;
+ if (!btc->dm.scbd_b2w_update)
+ return; /* skip if init or no-update */
+
+ for (i = BTC_BT_1ST; i <= BTC_BT_2ND; i++) {
+ bt = (i == BTC_BT_1ST) ? &btc->cx.bt0 : &btc->cx.bt1;
+
+ if (bt->scbd_c2h != bt->scbd_rb) {
+ /* if btx b2w scbd non-sync */
+ rtw89_debug(rtwdev, RTW89_DBG_BTC,
+ "[BTC], %s() bt%d:c2h->0x%08x, rb->0x%08x\n",
+ __func__, i, bt->scbd_c2h, bt->scbd_rb);
+ bt->scbd_c2h = bt->scbd_rb;
+ _update_bt_scbd(rtwdev, i);
+ btc->dm.scbd_b2w_update = false;
+ }
}
+
+ if (!btc->dm.scbd_b2w_update)
+ _run_coex(rtwdev, BTC_RSN_UPDATE_BT_SCBD);
+ else
+ btc->dm.scbd_b2w_update = 0;
}
static void _set_gnt(struct rtw89_dev *rtwdev, u8 phy_map, u8 wl_state, u8 bt_state)
@@ -3298,7 +3317,7 @@ static void _set_bt_rx_gain(struct rtw89_dev *rtwdev, bool force_exec, u8 bid,
if (buf[0] != BTC_BT_RX_NORMAL_LVL)
state = true;
- _write_scbd(rtwdev, scbd_bit, state);
+ _write_scbd(rtwdev, bid, scbd_bit, state);
}
}
@@ -3406,7 +3425,7 @@ static void _set_rf_trx_para(struct rtw89_dev *rtwdev)
if (dm->fddt_train) {
_set_wl_rx_gain(rtwdev, 1, RTW89_PHY_0);
- _write_scbd(rtwdev, BTC_WSCB_RXGAIN, true);
+ _write_scbd(rtwdev, bid, BTC_WSCB_RXGAIN, true);
} else {
_set_wl_tx_power(rtwdev, para.wl_tx_power[RTW89_PHY_0], RTW89_PHY_0);
_set_wl_rx_gain(rtwdev, para.wl_rx_gain[RTW89_PHY_0], RTW89_PHY_0);
@@ -3899,14 +3918,22 @@ static void _set_tdma_bind(struct rtw89_dev *rtwdev, bool tdma_on)
struct rtw89_btc_dm *dm = &rtwdev->btc.dm;
struct rtw89_btc_bind_info *bind;
u8 null_role = RTW89_WIFI_ROLE_STATION;
+ u8 bt_sel;
if (dm->tdd_en)
bind = &dm->tdd_bind; /* tdd = 1 && fdd = 0 or 1 */
else
bind = &dm->fdd_bind; /* tdd = 0 && fdd = 1 */
+ if (bind->bt_sel >= (BIT(BTC_BT_1ST) | BIT(BTC_BT_2ND)))
+ bt_sel = BTC_ALL_BT;
+ else if (bind->bt_sel == BIT(BTC_BT_2ND))
+ bt_sel = BTC_BT_2ND;
+ else
+ bt_sel = BTC_BT_1ST;
+
/* notify BT TDMA on/off by scoreboard for ACL/Scan schedule */
- _write_scbd(rtwdev, BTC_WSCB_TDMA, tdma_on);
+ _write_scbd(rtwdev, bt_sel, BTC_WSCB_TDMA, tdma_on);
/*
* set hwb/bt bind to TDMA policy parameter
@@ -5849,7 +5876,7 @@ static void _set_bt_rx_agc(struct rtw89_dev *rtwdev)
if (bt_hi_lna_rx == bt->hi_lna_rx)
return;
- _write_scbd(rtwdev, BTC_WSCB_BT_HILNA, bt_hi_lna_rx);
+ _write_scbd(rtwdev, BTC_BT_1ST, BTC_WSCB_BT_HILNA, bt_hi_lna_rx);
}
static void _set_bt_rx_scan_pri(struct rtw89_dev *rtwdev)
@@ -5857,7 +5884,8 @@ static void _set_bt_rx_scan_pri(struct rtw89_dev *rtwdev)
struct rtw89_btc *btc = &rtwdev->btc;
struct rtw89_btc_bt_info *bt = &btc->cx.bt0;
- _write_scbd(rtwdev, BTC_WSCB_RXSCAN_PRI, (bool)(!!bt->scan_rx_low_pri));
+ _write_scbd(rtwdev, BTC_ALL_BT, BTC_WSCB_RXSCAN_PRI,
+ (bool)(!!bt->scan_rx_low_pri));
}
static void _wl_req_mac(struct rtw89_dev *rtwdev, u8 mac)
@@ -5897,6 +5925,7 @@ static void _action_common(struct rtw89_dev *rtwdev)
struct rtw89_btc_bt_info *bt = &btc->cx.bt0;
struct rtw89_btc_dm *dm = &btc->dm;
u32 bt_rom_code_id, bt_fw_ver;
+ u8 i;
if (btc->ver->fwlrole == 8)
_wl_req_mac(rtwdev, rinfo_v8->pta_req_band);
@@ -5929,13 +5958,8 @@ static void _action_common(struct rtw89_dev *rtwdev)
rtw89_btc_fw_en_rpt(rtwdev, RPT_EN_MREG, 1);
}
- if (wl->scbd_change) {
- rtw89_mac_cfg_sb(rtwdev, wl->scbd);
- rtw89_debug(rtwdev, RTW89_DBG_BTC, "[BTC], write scbd: 0x%08x\n",
- wl->scbd);
- wl->scbd_change = false;
- wl->wcnt[BTC_WCNT_SCBDUPDATE]++;
- }
+ for (i = BTC_BT_1ST; i <= BTC_BT_2ND; i++)
+ _sned_h2c_w2bscbd(rtwdev, false, i);
if (btc->ver->fcxosi) {
if (memcmp(&dm->ost_info_last, &dm->ost_info,
@@ -6187,42 +6211,97 @@ static void _action_wl_2g_nan(struct rtw89_dev *rtwdev)
}
}
-static u32 _read_scbd(struct rtw89_dev *rtwdev)
+static u8 _sned_h2c_w2bscbd(struct rtw89_dev *rtwdev, bool force_exec, u8 bid)
{
- const struct rtw89_chip_info *chip = rtwdev->chip;
struct rtw89_btc *btc = &rtwdev->btc;
- u32 scbd_val = 0;
+ struct rtw89_btc_cx *cx = &btc->cx;
+ struct rtw89_btc_wl_info *wl = &cx->wl;
+ u8 cnt_idx = BTC_WCNT_SCBDUPDATE;
+ u8 h2c_func = SET_IOFLD_SCBD;
+ u8 buf[4];
- if (!chip->scbd)
- return 0;
+ if (bid == BTC_BT_2ND) {
+ if (!(rtwdev->chip->para_ver & BTC_FEAT_DUAL_BT))
+ return 0;
+
+ h2c_func |= BT_H2C_FUNC_BT2ND;
+ cnt_idx = BTC_WCNT_SCBDUPDATE2;
+ }
- scbd_val = rtw89_mac_get_sb(rtwdev);
- rtw89_debug(rtwdev, RTW89_DBG_BTC, "[BTC], read scbd: 0x%08x\n",
- scbd_val);
+ if (wl->scbd_chg[bid] || force_exec) {
+ /* Add delay to avoid BT FW loss information */
- btc->cx.bt0.bcnt[BTC_BCNT_SCBDREAD]++;
- return scbd_val;
+ btc_dw2b(buf, 0, (wl->scbd[bid] | BIT(31))); /* trig */
+ if (rtwdev->chip->para_ver & BTC_FEAT_H2C_MACRO) {
+ if (!_send_fw_cmd(rtwdev, BTFC_SET,
+ h2c_func, buf, sizeof(buf)))
+ return 0;
+ } else {
+ rtw89_mac_cfg_sb(rtwdev, wl->scbd[bid]);
+ }
+ wl->scbd_chg[bid] = 0;
+ wl->wcnt[cnt_idx]++;
+ rtw89_debug(rtwdev, RTW89_DBG_BTC,
+ "[BTC], %s() write BT%d scbd:0x%08x\n",
+ __func__, bid, wl->scbd[bid]);
+ }
+ return 1;
}
-static void _write_scbd(struct rtw89_dev *rtwdev, u32 val, bool state)
+static void _write_scbd(struct rtw89_dev *rtwdev, u8 bid, u32 val, bool state)
{
const struct rtw89_chip_info *chip = rtwdev->chip;
struct rtw89_btc *btc = &rtwdev->btc;
struct rtw89_btc_wl_info *wl = &btc->cx.wl;
- u32 scbd_val = 0;
- u8 force_exec = false;
+ struct rtw89_btc_dm *dm = &btc->dm;
+ u8 force_exec, id, id_start, id_stop;
+ u32 scbd = 0;
if (!chip->scbd)
return;
- scbd_val = state ? wl->scbd | val : wl->scbd & ~val;
+ if (bid == BTC_ALL_BT) {
+ id_start = BTC_BT_1ST;
+ id_stop = BTC_BT_2ND;
+ } else {
+ id_start = bid;
+ id_stop = bid;
+ }
- if (val & BTC_WSCB_ACTIVE || val & BTC_WSCB_ON)
- force_exec = true;
+ for (id = id_start; id <= id_stop; id++) {
+ force_exec = false;
+ if (!(rtwdev->chip->para_ver & BTC_FEAT_DUAL_BT) &&
+ id == BTC_BT_2ND)
+ continue;
- if (scbd_val != wl->scbd || force_exec) {
- wl->scbd = scbd_val;
- wl->scbd_change = true;
+ if (state)
+ scbd = wl->scbd[id] | val;
+ else
+ scbd = wl->scbd[id] & (~val);
+
+ if (val & BTC_WSCB_CTCODE ||
+ val & BTC_WSCB_RXGAIN ||
+ val & BTC_WSCB_RXGAIN_56G) { /* instant exec */
+ force_exec = true;
+ wl->scbd[id] = scbd;
+ dm->scbd_write_instant = 1;
+ if (rtwdev->chip->para_ver & BTC_FEAT_H2C_MACRO)
+ _sned_h2c_w2bscbd(rtwdev, force_exec, id);
+ else
+ rtw89_mac_cfg_sb(rtwdev, wl->scbd[id]);
+ dm->scbd_write_instant = 0;
+ } else if ((val & BTC_WSCB_ACTIVE ||
+ val & BTC_WSCB_ON ||
+ val & BTC_WSCB_WLRFK) ||
+ scbd != wl->scbd[id]) {
+ /*
+ * Just update wl->scbd[] and set wl->scbd_chg[],
+ * moved "Write scoreboard I/O" to _action_common()
+ * _write_scbd will be executed if run_coex()
+ */
+ wl->scbd[id] = scbd;
+ wl->scbd_chg[id] = 1;
+ }
}
}
@@ -7522,34 +7601,27 @@ void rtw89_coex_rfk_chk_work(struct wiphy *wiphy, struct wiphy_work *work)
wl->wcnt[BTC_WCNT_RFK_TIMEOUT]++;
dm->error.map.wl_rfk_timeout = true;
wl->rfk_info.state = BTC_WRFK_STOP;
- _write_scbd(rtwdev, BTC_WSCB_WLRFK, false);
+ _write_scbd(rtwdev, BTC_ALL_BT, BTC_WSCB_WLRFK, false);
_run_coex(rtwdev, BTC_RSN_RFK_CHK_WORK);
}
}
-static void _update_bt_scbd(struct rtw89_dev *rtwdev, bool only_update)
+static void _update_bt_scbd(struct rtw89_dev *rtwdev, u8 bid)
{
+ struct rtw89_btc_bt_link_info *bt_2g, *bt_56g;
struct rtw89_btc *btc = &rtwdev->btc;
- struct rtw89_btc_bt_info *bt = &btc->cx.bt0;
const struct rtw89_btc_ver *ver = btc->ver;
- struct rtw89_btc_wl_info *wl = &btc->cx.wl;
- struct rtw89_btc_dm *dm = &rtwdev->btc.dm;
- bool bt_link_change = false, lps_ctrl = false;
- u32 val, any_bt_connect;
- u8 mode;
-
- if (rtwdev->chip->scbd)
- return;
-
- rtw89_debug(rtwdev, RTW89_DBG_BTC, "[BTC], %s\n", __func__);
+ struct rtw89_btc_cx *cx = &btc->cx;
+ struct rtw89_btc_wl_info *wl = &cx->wl;
+ struct rtw89_btc_dm *dm = &btc->dm;
+ struct rtw89_btc_bt_info *bt;
+ u32 val, any_bt_connect, any_bt_6g_connect = 0;
+ u8 id, id_start, id_stop, mode;
+ bool bt_link_change = false;
+ bool lps_ctrl = false;
- val = _read_scbd(rtwdev);
- if (val == BTC_SCB_INV_VALUE) {
- rtw89_debug(rtwdev, RTW89_DBG_BTC,
- "[BTC], %s(): return by invalid scbd value\n",
- __func__);
+ if (!rtwdev->chip->scbd || bid > BTC_ALL_BT)
return;
- }
if (ver->fwlrole == 0)
mode = wl->role_info.link_mode;
@@ -7564,66 +7636,112 @@ static void _update_bt_scbd(struct rtw89_dev *rtwdev, bool only_update)
else
return;
- if (!(val & BTC_BSCB_ON))
- bt->enable.now = 0;
- else
- bt->enable.now = 1;
+ if (bid == BTC_ALL_BT) {
+ id_start = BTC_BT_1ST;
+ id_stop = BTC_BT_2ND;
+ } else {
+ id_start = bid;
+ id_stop = bid;
+ }
+
+ dm->lps_ctrl_change = false;
+ rtw89_debug(rtwdev, RTW89_DBG_BTC, "[BTC], %s()\n", __func__);
- if (bt->enable.now != bt->enable.last)
- bt_link_change = true;
+ for (id = id_start; id <= id_stop; id++) {
+ bt = (id == BTC_BT_1ST) ? &cx->bt0 : &cx->bt1;
+ bt_2g = &bt->link_info;
+ bt_56g = &bt->link_info_56g;
- /* reset bt info if bt re-enable */
- if (bt->enable.now && !bt->enable.last) {
- _reset_btc_var(rtwdev, BTC_RESET_BTINFO);
- bt->bcnt[BTC_BCNT_REENABLE]++;
- bt->enable.now = 1;
- }
+ if (!(rtwdev->chip->para_ver & BTC_FEAT_DUAL_BT) && id == BTC_BT_2ND)
+ break;
+
+ val = bt->scbd_c2h;
- bt->enable.last = bt->enable.now;
- bt->scbd = val;
- bt->mbx_avl = !!(val & BTC_BSCB_ACT);
+ if (val == 0xffffffff) {
+ rtw89_debug(rtwdev, RTW89_DBG_BTC,
+ "[BTC], %s return by invalid scbd value\n",
+ __func__);
+ return;
+ }
- if (bt->whql_test != !!(val & BTC_BSCB_WHQL))
- bt_link_change = true;
+ if (!(val & BTC_BSCB_ON))
+ bt->enable.now = 0;
+ else
+ bt->enable.now = 1;
- bt->whql_test = !!(val & BTC_BSCB_WHQL);
- bt->btg_type = val & BTC_BSCB_BT_S1 ? BTC_BT_BTG : BTC_BT_ALONE;
- bt->link_info.a2dp_desc.exist = !!(val & BTC_BSCB_A2DP_ACT);
- bt->link_info.pan_desc.exist = !!(val & BTC_BSCB_PAN_ACT);
- bt->link_info.hfp_desc.exist = !!(val & BTC_BSCB_HFP_ACT);
+ if (bt->enable.now != bt->enable.last)
+ bt_link_change = true;
- bt->lna_constrain = !!(val & BTC_BSCB_BT_LNAB0) +
- !!(val & BTC_BSCB_BT_LNAB1) * 2 + 4;
+ /* reset bt info if bt re-enable */
+ if (bt->enable.now && !bt->enable.last) {
+ if (id == BTC_BT_1ST)
+ _reset_btc_var(rtwdev, BTC_RESET_BTINFO);
+ else
+ _reset_btc_var(rtwdev, BTC_RESET_BTINFO2);
- /* if rfk run 1->0 */
- if (bt->rfk_info.map.run && !(val & BTC_BSCB_RFK_RUN))
- bt_link_change = true;
+ bt->bcnt[BTC_BCNT_REENABLE]++;
+ bt->enable.now = 1;
+ bt->rf_band_map = BIT(RTW89_BAND_2G);
+ bt->link_weight[BTC_BT_B2G] = 5; /* no-profile */
+ }
+ bt->enable.last = bt->enable.now;
- bt->rfk_info.map.run = !!(val & BTC_BSCB_RFK_RUN);
- bt->rfk_info.map.req = !!(val & BTC_BSCB_RFK_REQ);
- bt->hi_lna_rx = !!(val & BTC_BSCB_BT_HILNA);
- any_bt_connect = !!(val & BTC_BSCB_BT_CONNECT);
+ /* if BT will disconnect and adopt protect plan */
+ if ((val & BTC_BSCB_BT_PROTECT) &&
+ !(bt->scbd & BTC_BSCB_BT_PROTECT))
+ bt->bcnt[BTC_BCNT_PROTECT]++;
- /* if connect change */
- if (bt->link_info.status.map.connect != any_bt_connect)
- bt_link_change = true;
+ bt->mbx_avl = !!(val & BTC_BSCB_ACT);
+ if (bt->whql_test != !!(val & BTC_BSCB_WHQL))
+ bt_link_change = true;
- /* if specific profile exist */
- if (((bt->link_info.a2dp_desc.exist || bt->link_info.pan_desc.exist ||
- bt->link_info.hfp_desc.exist) && mode == BTC_WLINK_2G_STA) ||
- bt->whql_test)
- lps_ctrl = true;
+ bt->whql_test = !!(val & BTC_BSCB_WHQL);
+ bt->btg_type = (val & BTC_BSCB_BT_S1 ? BTC_BT_BTG : BTC_BT_ALONE);
- if (dm->lps_ctrl_scbd != lps_ctrl) {
- dm->lps_ctrl_scbd = lps_ctrl;
- bt_link_change = true;
- dm->lps_ctrl_change = true;
- } else {
- dm->lps_ctrl_change = false;
- }
+ bt_2g->a2dp_desc.exist = !!(val & BTC_BSCB_A2DP_ACT);
+ bt_2g->pan_desc.exist = !!(val & BTC_BSCB_PAN_ACT);
+ bt_2g->hfp_desc.exist = !!(val & BTC_BSCB_HFP_ACT);
- bt->link_info.status.map.connect = any_bt_connect;
- bt->run_patch_code = !!(val & BTC_BSCB_PATCH_CODE);
+ bt->lna_constrain = 4 + !!(val & BTC_BSCB_BT_LNAB0) +
+ !!(val & BTC_BSCB_BT_LNAB1) * 2;
+
+ if (rtwdev->chip->para_ver & BTC_FEAT_DUAL_BT) {
+ if (val & BTC_BSCB_BT_15DOT4)
+ bt->func_type |= (BTC_BTF_THREAD | BTC_BTF_ZB);
+ else
+ bt->func_type &= ~(BTC_BTF_THREAD | BTC_BTF_ZB);
+ }
+
+ bt->hi_lna_rx = !!(val & BTC_BSCB_BT_HILNA);
+ any_bt_connect = !!(val & BTC_BSCB_BT_CONNECT);
+
+ /* if connect change */
+ if (bt_2g->status.map.connect != any_bt_connect ||
+ bt_56g->status.map.connect != any_bt_6g_connect) {
+ bt_link_change = true;
+ bt_2g->status.map.connect = any_bt_connect;
+ bt_56g->status.map.connect = any_bt_6g_connect;
+ }
+
+ /* if specific profile exist */
+ if (((bt->link_info.a2dp_desc.exist ||
+ bt->link_info.pan_desc.exist ||
+ bt->link_info.hfp_desc.exist) &&
+ mode == BTC_WLINK_2G_STA) ||
+ bt->whql_test)
+ lps_ctrl = true;
+
+ if (dm->lps_ctrl_scbd != lps_ctrl) {
+ dm->lps_ctrl_scbd = lps_ctrl;
+ bt_link_change = true;
+ dm->lps_ctrl_change = true;
+ } else {
+ dm->lps_ctrl_change = false;
+ }
+
+ bt->run_patch_code = !!(val & BTC_BSCB_PATCH_CODE);
+ bt->scbd = val;
+ }
if (bt_link_change) {
rtw89_debug(rtwdev, RTW89_DBG_BTC,
@@ -7651,26 +7769,6 @@ static void _update_bt_txpwr_info(struct rtw89_dev *rtwdev, u8 *buf, u32 len)
memcpy(&b->bt_txpwr_desc, &buf[2], sizeof(b->bt_txpwr_desc));
}
-static bool _chk_wl_rfk_request(struct rtw89_dev *rtwdev)
-{
- struct rtw89_btc *btc = &rtwdev->btc;
- struct rtw89_btc_cx *cx = &btc->cx;
- struct rtw89_btc_bt_info *bt = &cx->bt0;
-
- _update_bt_scbd(rtwdev, true);
-
- cx->wl.wcnt[BTC_WCNT_RFK_REQ]++;
-
- if ((bt->rfk_info.map.run || bt->rfk_info.map.req) &&
- !bt->rfk_info.map.timeout) {
- cx->wl.wcnt[BTC_WCNT_RFK_REJECT]++;
- } else {
- cx->wl.wcnt[BTC_WCNT_RFK_GO]++;
- return true;
- }
- return false;
-}
-
static void _set_bind_info(struct rtw89_btc *btc, u8 type)
{
struct rtw89_btc_cx *cx = &btc->cx;
@@ -8181,7 +8279,7 @@ void rtw89_btc_ntfy_poweroff(struct rtw89_dev *rtwdev)
btc->cx.wl.status.map.busy = 0;
wl->status.map.lps = BTC_LPS_OFF;
- _write_scbd(rtwdev, BTC_WSCB_ALL, false);
+ _write_scbd(rtwdev, BTC_ALL_BT, BTC_WSCB_ALL, false);
_run_coex(rtwdev, BTC_RSN_NTFY_POWEROFF);
rtw89_btc_fw_en_rpt(rtwdev, RPT_EN_ALL, 0);
@@ -8266,24 +8364,22 @@ void rtw89_btc_ntfy_init(struct rtw89_dev *rtwdev, u8 mode)
return;
}
+ btc->cx.bt0.enable.now = 1;
+ btc->cx.bt0.run_patch_code = 1;
if (rtwdev->chip->para_ver & BTC_FEAT_DUAL_BT) {
btc->cx.bt1.enable.now = 1;
btc->cx.bt1.run_patch_code = 1;
}
- if (rtwdev->chip->para_ver & BTC_FEAT_H2C_MACRO) {
- btc->cx.bt0.enable.now = 1;
- btc->cx.bt0.run_patch_code = 1;
+ if (rtwdev->chip->para_ver & BTC_FEAT_H2C_MACRO)
btc->io_oflld_type = BTC_IO_OFLD_BTC_H2C;
- } else {
+ else
btc->io_oflld_type = BTC_IO_OFLD_NO_SUPPORT;
- _update_bt_scbd(rtwdev, true);
- }
chip->ops->btc_set_rfe(rtwdev);
chip->ops->btc_init_cfg(rtwdev);
- _write_scbd(rtwdev,
+ _write_scbd(rtwdev, BTC_ALL_BT,
BTC_WSCB_ACTIVE | BTC_WSCB_ON | BTC_WSCB_BTLOG, true);
if (rtw89_mac_get_ctrl_path(rtwdev)) {
@@ -8842,16 +8938,16 @@ void rtw89_btc_ntfy_radio_state(struct rtw89_dev *rtwdev, enum btc_rfctrl rf_sta
if (rf_state == BTC_RFCTRL_WL_ON) {
rtw89_btc_fw_en_rpt(rtwdev, RPT_EN_MREG, true);
val = BTC_WSCB_ACTIVE | BTC_WSCB_ON | BTC_WSCB_BTLOG;
- _write_scbd(rtwdev, val, true);
+ _write_scbd(rtwdev, BTC_ALL_BT, val, true);
chip->ops->btc_init_cfg(rtwdev);
} else {
rtw89_btc_fw_en_rpt(rtwdev, RPT_EN_ALL, false);
if (rf_state == BTC_RFCTRL_FW_CTRL)
- _write_scbd(rtwdev, BTC_WSCB_ACTIVE, false);
+ _write_scbd(rtwdev, BTC_ALL_BT, BTC_WSCB_ACTIVE, false);
else if (rf_state == BTC_RFCTRL_WL_OFF)
- _write_scbd(rtwdev, BTC_WSCB_ALL, false);
+ _write_scbd(rtwdev, BTC_ALL_BT, BTC_WSCB_ALL, false);
else
- _write_scbd(rtwdev, BTC_WSCB_ACTIVE, false);
+ _write_scbd(rtwdev, BTC_ALL_BT, BTC_WSCB_ACTIVE, false);
}
btc->dm.cnt_dm[BTC_DCNT_BTCNT_HANG] = 0;
@@ -8883,27 +8979,26 @@ static bool _ntfy_wl_rfk(struct rtw89_dev *rtwdev, u8 phy_path,
switch (state) {
case BTC_WRFK_START:
- result = _chk_wl_rfk_request(rtwdev);
- wl->rfk_info.state = result ? BTC_WRFK_START : BTC_WRFK_STOP;
-
- _write_scbd(rtwdev, BTC_WSCB_WLRFK, result);
+ result = BTC_WRFK_ALLOW;
+ wl->rfk_info.state = BTC_WRFK_START;
+ btc->cx.wl.wcnt[BTC_WCNT_RFK_REQ]++;
+ btc->cx.wl.wcnt[BTC_WCNT_RFK_GO]++;
btc->dm.cnt_notify[BTC_NCNT_WL_RFK]++;
+
+ _write_scbd(rtwdev, BTC_ALL_BT, BTC_WSCB_WLRFK, true);
break;
case BTC_WRFK_ONESHOT_START:
case BTC_WRFK_ONESHOT_STOP:
- if (wl->rfk_info.state == BTC_WRFK_STOP) {
- result = BTC_WRFK_REJECT;
- } else {
- result = BTC_WRFK_ALLOW;
- wl->rfk_info.state = state;
- }
+ wl->rfk_info.state = state;
+ if (type != BTC_WRFKT_RXDCK)
+ return BTC_WRFK_ALLOW;
break;
case BTC_WRFK_STOP:
result = BTC_WRFK_ALLOW;
wl->rfk_info.state = BTC_WRFK_STOP;
- _write_scbd(rtwdev, BTC_WSCB_WLRFK, false);
+ _write_scbd(rtwdev, BTC_ALL_BT, BTC_WSCB_WLRFK, false);
wiphy_delayed_work_cancel(rtwdev->hw->wiphy, &rtwdev->coex_rfk_chk_work);
break;
default:
@@ -8927,7 +9022,7 @@ static bool _ntfy_wl_rfk(struct rtw89_dev *rtwdev, u8 phy_path,
"[BTC], %s()_finish: rfk_cnt=%d, result=%d\n",
__func__, btc->dm.cnt_notify[BTC_NCNT_WL_RFK], result);
- return result == BTC_WRFK_ALLOW;
+ return result;
}
void rtw89_btc_ntfy_wl_rfk(struct rtw89_dev *rtwdev, u8 phy_map,
@@ -9160,7 +9255,7 @@ void rtw89_btc_ntfy_wl_sta(struct rtw89_dev *rtwdev)
rtw89_debug(rtwdev, RTW89_DBG_BTC, "[BTC], %s(): busy=%d\n",
__func__, !!wl->status.map.busy);
- _write_scbd(rtwdev, BTC_WSCB_WLBUSY, (!!wl->status.map.busy));
+ _write_scbd(rtwdev, BTC_ALL_BT, BTC_WSCB_WLBUSY, (!!wl->status.map.busy));
if (data.is_traffic_change)
_fw_set_drv_info(rtwdev, CXDRVINFO_ROLE);
@@ -9251,6 +9346,7 @@ void rtw89_btc_c2h_handle(struct rtw89_dev *rtwdev, struct sk_buff *skb,
struct rtw89_btc_bt_info *bt = &rtwdev->btc.cx.bt0;
struct rtw89_btc_btf_fwinfo *pfwinfo = &btc->fwinfo;
u8 *buf = &skb->data[RTW89_C2H_HEADER_LEN];
+ u8 bid = BTC_BT_1ST;
len -= RTW89_C2H_HEADER_LEN;
@@ -9261,6 +9357,12 @@ void rtw89_btc_c2h_handle(struct rtw89_dev *rtwdev, struct sk_buff *skb,
if (class != BTFC_FW_EVENT)
return;
+ if (func & BT_C2H_FUNC_BT2ND) {
+ bid = BTC_BT_2ND;
+ func &= ~BT_C2H_FUNC_BT2ND;
+ bt = &btc->cx.bt1;
+ }
+
func = rtw89_btc_c2h_get_index_by_ver(rtwdev, func);
pfwinfo->cnt_c2h++;
@@ -9280,10 +9382,15 @@ void rtw89_btc_c2h_handle(struct rtw89_dev *rtwdev, struct sk_buff *skb,
_update_bt_info(rtwdev, buf, len);
break;
case BTF_EVNT_BT_SCBD:
- rtw89_debug(rtwdev, RTW89_DBG_BTC,
- "[BTC], handle C2H BT SCBD with data %8ph\n", buf);
bt->bcnt[BTC_BCNT_SCBDUPDATE]++;
- _update_bt_scbd(rtwdev, false);
+ bt->scbd_c2h = ((buf[3] << 24) | (buf[2] << 16) |
+ (buf[1] << 8) | (buf[0]));
+ bt->scbd_rb = bt->scbd_c2h;
+ rtw89_debug(rtwdev, RTW89_DBG_BTC,
+ "[BTC], handle C2H BT%d SCBD with data 0x%08x\n",
+ bid, bt->scbd_c2h);
+ _update_bt_scbd(rtwdev, bid);
+ _run_coex(rtwdev, BTC_RSN_UPDATE_BT_SCBD);
break;
case BTF_EVNT_BT_PSD:
break;
@@ -9300,7 +9407,7 @@ void rtw89_btc_c2h_handle(struct rtw89_dev *rtwdev, struct sk_buff *skb,
btc->dm.cnt_dm[BTC_DCNT_CX_RUNINFO]++;
break;
case BTF_EVNT_BT_QUERY_TXPWR:
- bt->bcnt[BTC_BCNT_BTTXPWR_UPDATE]++;
+ bt->bcnt[BTC_BCNT_TXPWR_UPDATE]++;
_update_bt_txpwr_info(rtwdev, buf, len);
}
}
@@ -9680,7 +9787,7 @@ static int _show_bt_info(struct rtw89_dev *rtwdev, char *buf, size_t bufsz)
bt->bcnt[BTC_BCNT_HIPRI_TX],
bt->bcnt[BTC_BCNT_LOPRI_RX],
bt->bcnt[BTC_BCNT_LOPRI_TX],
- bt->bcnt[BTC_BCNT_POLUT]);
+ bt->bcnt[BTC_BCNT_POLLUTED]);
if (!bt->scan_info_update) {
rtw89_btc_fw_en_rpt(rtwdev, RPT_EN_BT_SCAN_INFO, true);
@@ -9716,7 +9823,7 @@ static int _show_bt_info(struct rtw89_dev *rtwdev, char *buf, size_t bufsz)
else
rtw89_btc_fw_en_rpt(rtwdev, RPT_EN_BT_TX_PWR_LVL, false);
- if (bt->bcnt[BTC_BCNT_BTTXPWR_UPDATE]) {
+ if (bt->bcnt[BTC_BCNT_TXPWR_UPDATE]) {
p += scnprintf(p, end - p,
" %-15s : br_index:0x%x, le_index:0x%x",
"[bt_txpwr_lvl]",
@@ -10127,7 +10234,7 @@ static int _show_dm_info(struct rtw89_dev *rtwdev, char *buf, size_t bufsz)
p += scnprintf(p, end - p,
" %-15s : wl_only:%d, bt_only:%d, igno_bt:%d, free_run:%d, wl_ps_ctrl:%d, wl_mimo_ps:%d, ",
"[dm_flag]", dm->wl_only, dm->bt_only, igno_bt,
- dm->freerun, btc->lps, dm->wl_mimo_ps);
+ dm->freerun, btc->btc_ctrl_lps, dm->wl_mimo_ps);
p += scnprintf(p, end - p, "leak_ap:%d, fw_offload:%s%s\n",
dm->leak_ap,
@@ -11353,10 +11460,11 @@ static int _show_mreg_v1(struct rtw89_dev *rtwdev, char *buf, size_t bufsz)
const struct rtw89_chip_info *chip = rtwdev->chip;
struct rtw89_btc *btc = &rtwdev->btc;
struct rtw89_btc_btf_fwinfo *pfwinfo = &btc->fwinfo;
- struct rtw89_btc_rpt_cmn_info *pcinfo = NULL;
struct rtw89_btc_fbtc_mreg_val_v1 *pmreg = NULL;
+ struct rtw89_btc_bt_info *bt0 = &btc->cx.bt0;
+ struct rtw89_btc_bt_info *bt1 = &btc->cx.bt1;
+ struct rtw89_btc_rpt_cmn_info *pcinfo = NULL;
struct rtw89_btc_wl_info *wl = &btc->cx.wl;
- struct rtw89_btc_bt_info *bt = &btc->cx.bt0;
struct rtw89_mac_ax_coex_gnt gnt_cfg = {};
struct rtw89_mac_ax_gnt gnt;
char *p = buf, *end = buf + bufsz;
@@ -11369,11 +11477,20 @@ static int _show_mreg_v1(struct rtw89_dev *rtwdev, char *buf, size_t bufsz)
p += scnprintf(p, end - p, "========== [HW Status] ==========\n");
p += scnprintf(p, end - p,
- " %-15s : WL->BT:0x%08x(cnt:%d), BT->WL:0x%08x(total:%d, bt_update:%d)\n",
- "[scoreboard]", wl->scbd,
+ " %-15s : WL->BT0:0x%08x(cnt:%d), BT0->WL:0x%08x(total:%d, bt_update:%d)\n",
+ "[scoreboard]", wl->scbd[BTC_BT_1ST],
wl->wcnt[BTC_WCNT_SCBDUPDATE],
- bt->scbd, bt->bcnt[BTC_BCNT_SCBDREAD],
- bt->bcnt[BTC_BCNT_SCBDUPDATE]);
+ bt0->scbd, bt0->bcnt[BTC_BCNT_SCBDREAD],
+ bt0->bcnt[BTC_BCNT_SCBDUPDATE]);
+
+ if (rtwdev->chip->para_ver & BTC_FEAT_DUAL_BT) {
+ p += scnprintf(p, end - p,
+ " %-15s : WL->BT1:0x%08x(cnt:%d), BT1->WL:0x%08x(total:%d, bt_update:%d)\n",
+ "[scoreboard]", wl->scbd[BTC_BT_2ND],
+ wl->wcnt[BTC_WCNT_SCBDUPDATE2],
+ bt1->scbd, bt1->bcnt[BTC_BCNT_SCBDREAD],
+ bt1->bcnt[BTC_BCNT_SCBDUPDATE]);
+ }
btc->dm.pta_owner = rtw89_mac_get_ctrl_path(rtwdev);
_get_gnt(rtwdev, &gnt_cfg);
@@ -11437,10 +11554,11 @@ static int _show_mreg_v2(struct rtw89_dev *rtwdev, char *buf, size_t bufsz)
const struct rtw89_chip_info *chip = rtwdev->chip;
struct rtw89_btc *btc = &rtwdev->btc;
struct rtw89_btc_btf_fwinfo *pfwinfo = &btc->fwinfo;
- struct rtw89_btc_rpt_cmn_info *pcinfo = NULL;
struct rtw89_btc_fbtc_mreg_val_v2 *pmreg = NULL;
+ struct rtw89_btc_bt_info *bt0 = &btc->cx.bt0;
+ struct rtw89_btc_bt_info *bt1 = &btc->cx.bt1;
+ struct rtw89_btc_rpt_cmn_info *pcinfo = NULL;
struct rtw89_btc_wl_info *wl = &btc->cx.wl;
- struct rtw89_btc_bt_info *bt = &btc->cx.bt0;
struct rtw89_mac_ax_coex_gnt gnt_cfg = {};
struct rtw89_mac_ax_gnt gnt;
char *p = buf, *end = buf + bufsz;
@@ -11453,11 +11571,20 @@ static int _show_mreg_v2(struct rtw89_dev *rtwdev, char *buf, size_t bufsz)
p += scnprintf(p, end - p, "========== [HW Status] ==========\n");
p += scnprintf(p, end - p,
- " %-15s : WL->BT:0x%08x(cnt:%d), BT->WL:0x%08x(total:%d, bt_update:%d)\n",
- "[scoreboard]", wl->scbd,
+ " %-15s : WL->BT0:0x%08x(cnt:%d), BT0->WL:0x%08x(total:%d, bt_update:%d)\n",
+ "[scoreboard]", wl->scbd[BTC_BT_1ST],
wl->wcnt[BTC_WCNT_SCBDUPDATE],
- bt->scbd, bt->bcnt[BTC_BCNT_SCBDREAD],
- bt->bcnt[BTC_BCNT_SCBDUPDATE]);
+ bt0->scbd, bt0->bcnt[BTC_BCNT_SCBDREAD],
+ bt0->bcnt[BTC_BCNT_SCBDUPDATE]);
+
+ if (rtwdev->chip->para_ver & BTC_FEAT_DUAL_BT) {
+ p += scnprintf(p, end - p,
+ " %-15s : WL->BT1:0x%08x(cnt:%d), BT1->WL:0x%08x(total:%d, bt_update:%d)\n",
+ "[scoreboard]", wl->scbd[BTC_BT_2ND],
+ wl->wcnt[BTC_WCNT_SCBDUPDATE2],
+ bt1->scbd, bt1->bcnt[BTC_BCNT_SCBDREAD],
+ bt1->bcnt[BTC_BCNT_SCBDUPDATE]);
+ }
btc->dm.pta_owner = rtw89_mac_get_ctrl_path(rtwdev);
_get_gnt(rtwdev, &gnt_cfg);
@@ -11524,8 +11651,9 @@ static int _show_mreg_v7(struct rtw89_dev *rtwdev, char *buf, size_t bufsz)
struct rtw89_btc_fbtc_mreg_val_v7 *pmreg = NULL;
struct rtw89_btc_rpt_cmn_info *pcinfo = NULL;
struct rtw89_btc_cx *cx = &btc->cx;
+ struct rtw89_btc_bt_info *bt0 = &cx->bt0;
+ struct rtw89_btc_bt_info *bt1 = &cx->bt1;
struct rtw89_btc_wl_info *wl = &cx->wl;
- struct rtw89_btc_bt_info *bt = &cx->bt0;
struct rtw89_mac_ax_gnt *gnt = NULL;
struct rtw89_btc_dm *dm = &btc->dm;
char *p = buf, *end = buf + bufsz;
@@ -11538,11 +11666,20 @@ static int _show_mreg_v7(struct rtw89_dev *rtwdev, char *buf, size_t bufsz)
p += scnprintf(p, end - p, "\n\r========== [HW Status] ==========");
p += scnprintf(p, end - p,
- "\n\r %-15s : WL->BT:0x%08x(cnt:%d), BT->WL:0x%08x(total:%d, bt_update:%d)",
- "[scoreboard]", wl->scbd,
+ " %-15s : WL->BT0:0x%08x(cnt:%d), BT0->WL:0x%08x(total:%d, bt_update:%d)\n",
+ "[scoreboard]", wl->scbd[BTC_BT_1ST],
wl->wcnt[BTC_WCNT_SCBDUPDATE],
- bt->scbd, bt->bcnt[BTC_BCNT_SCBDREAD],
- bt->bcnt[BTC_BCNT_SCBDUPDATE]);
+ bt0->scbd, bt0->bcnt[BTC_BCNT_SCBDREAD],
+ bt0->bcnt[BTC_BCNT_SCBDUPDATE]);
+
+ if (rtwdev->chip->para_ver & BTC_FEAT_DUAL_BT) {
+ p += scnprintf(p, end - p,
+ " %-15s : WL->BT1:0x%08x(cnt:%d), BT1->WL:0x%08x(total:%d, bt_update:%d)\n",
+ "[scoreboard]", wl->scbd[BTC_BT_2ND],
+ wl->wcnt[BTC_WCNT_SCBDUPDATE2],
+ bt1->scbd, bt1->bcnt[BTC_BCNT_SCBDREAD],
+ bt1->bcnt[BTC_BCNT_SCBDUPDATE]);
+ }
/* To avoid I/O if WL LPS or power-off */
dm->pta_owner = rtw89_mac_get_ctrl_path(rtwdev);
diff --git a/drivers/net/wireless/realtek/rtw89/coex.h b/drivers/net/wireless/realtek/rtw89/coex.h
index fb151f68eb64..74027ca4eccc 100644
--- a/drivers/net/wireless/realtek/rtw89/coex.h
+++ b/drivers/net/wireless/realtek/rtw89/coex.h
@@ -391,4 +391,13 @@ void _slot_set_tbl(struct rtw89_btc *btc, u8 sid, u32 tbl)
btc->dm.slot.v7[sid].cxtbl = cpu_to_le32(tbl);
}
+static inline
+void btc_dw2b(u8 *buf, size_t idx, u32 val)
+{
+ buf[idx] = u32_get_bits(val, MASKBYTE0);
+ buf[idx + 1] = u32_get_bits(val, MASKBYTE1);
+ buf[idx + 2] = u32_get_bits(val, MASKBYTE2);
+ buf[idx + 3] = u32_get_bits(val, MASKBYTE3);
+}
+
#endif
diff --git a/drivers/net/wireless/realtek/rtw89/core.c b/drivers/net/wireless/realtek/rtw89/core.c
index 85aeb9e90812..b3376fadf593 100644
--- a/drivers/net/wireless/realtek/rtw89/core.c
+++ b/drivers/net/wireless/realtek/rtw89/core.c
@@ -5417,7 +5417,7 @@ static void rtw89_track_ps_work(struct wiphy *wiphy, struct wiphy_work *work)
if (rtwdev->scanning)
return;
- if (rtwdev->lps_enabled && !rtwdev->btc.lps)
+ if (rtwdev->lps_enabled && !rtwdev->btc.btc_ctrl_lps)
rtw89_enter_lps_track(rtwdev, RTW89_TFC_INTERVAL_100MS);
}
@@ -5465,7 +5465,7 @@ static void rtw89_track_work(struct wiphy *wiphy, struct wiphy_work *work)
rtw89_core_rfkill_poll(rtwdev, false);
rtw89_core_mlo_track(rtwdev);
- if (rtwdev->lps_enabled && !rtwdev->btc.lps)
+ if (rtwdev->lps_enabled && !rtwdev->btc.btc_ctrl_lps)
rtw89_enter_lps_track(rtwdev, RTW89_TFC_INTERVAL_2SEC);
}
diff --git a/drivers/net/wireless/realtek/rtw89/core.h b/drivers/net/wireless/realtek/rtw89/core.h
index eb814425f536..8646a13bfd79 100644
--- a/drivers/net/wireless/realtek/rtw89/core.h
+++ b/drivers/net/wireless/realtek/rtw89/core.h
@@ -1415,6 +1415,7 @@ enum rtw89_btc_wl_state_cnt {
BTC_WCNT_RX_ERR_LAST,
BTC_WCNT_RX_ERR_LAST2S,
BTC_WCNT_RX_LAST,
+ BTC_WCNT_SCBDUPDATE2,
BTC_WCNT_NUM
};
@@ -1431,17 +1432,25 @@ enum rtw89_btc_bt_state_cnt {
BTC_BCNT_ROLESW,
BTC_BCNT_AFH,
BTC_BCNT_INFOUPDATE,
+ BTC_BCNT_LEAUDIO_INFOUPDATE,
BTC_BCNT_INFOSAME,
+ BTC_BCNT_LEAUDIO_INFOSAME,
BTC_BCNT_SCBDUPDATE,
BTC_BCNT_HIPRI_TX,
BTC_BCNT_HIPRI_RX,
BTC_BCNT_LOPRI_TX,
BTC_BCNT_LOPRI_RX,
- BTC_BCNT_POLUT,
BTC_BCNT_POLUT_NOW,
BTC_BCNT_POLUT_DIFF,
BTC_BCNT_RATECHG,
- BTC_BCNT_BTTXPWR_UPDATE,
+ BTC_BCNT_AFH_CONFLICT,
+ BTC_BCNT_AFH_LE_CONFLICT,
+ BTC_BCNT_AFH_UPDATE,
+ BTC_BCNT_AFH_LE_UPDATE,
+ BTC_BCNT_AFH_CHN,
+ BTC_BCNT_AFH_LE_CHN,
+ BTC_BCNT_TXPWR_UPDATE,
+ BTC_BCNT_PROTECT,
BTC_BCNT_NUM,
};
@@ -2188,12 +2197,13 @@ struct rtw89_btc_wl_info {
bool pta_reg_mac_chg;
bool bg_mode;
bool he_mode;
- bool scbd_change;
+ bool scbd_chg[BTC_ALL_BT];
bool fw_ver_mismatch;
bool client_cnt_inc_2g;
bool link_mode_chg;
bool dbcc_chg;
- u32 scbd;
+ u32 scbd[BTC_ALL_BT];
+ u32 scbd_rb[BTC_ALL_BT];
u32 wcnt[BTC_WCNT_NUM];
};
@@ -2323,6 +2333,15 @@ enum rtw89_btc_ble_scan_type {
CXSCAN_MAX
};
+enum rtw89_btc_bt_func_type {
+ BTC_BTF_NONE = 0,
+ BTC_BTF_BT = BIT(0),
+ BTC_BTF_ZB = BIT(1),
+ BTC_BTF_THREAD = BIT(2),
+ BTC_BTF_24GPRO = BIT(3), /* 2.4GHz Proprietary */
+ BTC_BTF_ULL = BIT(4),
+};
+
#define RTW89_BTC_BTC_SCAN_V1_FLAG_ENABLE BIT(0)
#define RTW89_BTC_BTC_SCAN_V1_FLAG_INTERLACE BIT(1)
@@ -2394,6 +2413,8 @@ struct rtw89_btc_bt_info {
u8 rsvd: 6;
u32 scbd;
+ u32 scbd_rb;
+ u32 scbd_c2h;
u32 feature;
u32 mbx_avl: 1;
@@ -3338,6 +3359,8 @@ struct rtw89_btc_dm {
u8 lps_ctrl_scbd: 1;
u8 lps_ctrl_scbd_last: 1;
u8 lps_ctrl_change: 1;
+ u8 scbd_write_instant;
+ bool scbd_b2w_update;
};
struct rtw89_btc_ctrl {
@@ -3585,7 +3608,7 @@ struct rtw89_btc {
u32 hubmsg_cnt;
bool bt_req_en;
bool update_policy_force;
- bool lps;
+ bool btc_ctrl_lps;
bool manual_ctrl;
bool cli_h2c_cmd;
};
--
2.25.1
^ permalink raw reply related
* [PATCH rtw-next 7/9] wifi: rtw89: coex: Add TDMA binding for dual MAC
From: Ping-Ke Shih @ 2026-07-03 11:43 UTC (permalink / raw)
To: linux-wireless; +Cc: ku920601
In-Reply-To: <20260703114311.2609942-1-pkshih@realtek.com>
From: Ching-Te Ku <ku920601@realtek.com>
Because the two MAC should have their own individual using, they will
need different TDMA mechanism. This patch will bind TDMA with MAC index,
and also the corresponding antenna, hardware grant signal setting.
Signed-off-by: Ching-Te Ku <ku920601@realtek.com>
Signed-off-by: Ping-Ke Shih <pkshih@realtek.com>
---
drivers/net/wireless/realtek/rtw89/coex.c | 381 +++++++++-------------
drivers/net/wireless/realtek/rtw89/core.h | 11 +-
2 files changed, 158 insertions(+), 234 deletions(-)
diff --git a/drivers/net/wireless/realtek/rtw89/coex.c b/drivers/net/wireless/realtek/rtw89/coex.c
index 435a4a5d2c2d..86833b0cd47c 100644
--- a/drivers/net/wireless/realtek/rtw89/coex.c
+++ b/drivers/net/wireless/realtek/rtw89/coex.c
@@ -494,7 +494,7 @@ enum btc_ant_phase {
BTC_ANT_FREERUN,
BTC_ANT_WRFK,
BTC_ANT_WRFK2,
- BTC_ANT_BRFK,
+ BTC_ANT_PTA, /* for Multi-PTA, each hw-band has its own PTA */
BTC_ANT_MAX
};
@@ -3894,6 +3894,41 @@ static void _set_policy(struct rtw89_dev *rtwdev, u16 policy_type,
_fw_set_policy(rtwdev, policy_type, action);
}
+static void _set_tdma_bind(struct rtw89_dev *rtwdev, bool tdma_on)
+{
+ struct rtw89_btc_dm *dm = &rtwdev->btc.dm;
+ struct rtw89_btc_bind_info *bind;
+ u8 null_role = RTW89_WIFI_ROLE_STATION;
+
+ if (dm->tdd_en)
+ bind = &dm->tdd_bind; /* tdd = 1 && fdd = 0 or 1 */
+ else
+ bind = &dm->fdd_bind; /* tdd = 0 && fdd = 1 */
+
+ /* notify BT TDMA on/off by scoreboard for ACL/Scan schedule */
+ _write_scbd(rtwdev, BTC_WSCB_TDMA, tdma_on);
+
+ /*
+ * set hwb/bt bind to TDMA policy parameter
+ * FW-BTC will setup related hwbx vs. BTx coex tables by slot toggle
+ * ex: HWb0 + BT0 + BT1, HWB0-BT0/HWB0-BT1 coex by WL/BT slot toggle
+ */
+ dm->tdma.bind = ((bind->bt_sel & 0xf) << 4) + (bind->wl_hwb_sel & 0x3);
+ if (dm->tdd_en)
+ dm->tdma.bind |= BIT(2);
+ if (dm->fdd_en)
+ dm->tdma.bind |= BIT(3);
+ if (rtwdev->btc.ver->fcxtdma != 8)
+ dm->tdma.bind |= 0;
+
+ /* set Null-tx role for 2 HW-BAND TDMA (MLMR) */
+ if (!dm->eslot_ctrl.en && dm->tdma.rxflctrl &&
+ (bind->wl_hwb_sel == (BIT(RTW89_PHY_1) | BIT(RTW89_PHY_0)))) {
+ null_role = (null_role << 4) + null_role;
+ _tdma_set_flctrl_role(&rtwdev->btc, null_role);
+ }
+}
+
#define BTC_B1_MAX 250 /* unit ms */
void rtw89_btc_set_policy(struct rtw89_dev *rtwdev, u16 policy_type)
{
@@ -3903,6 +3938,7 @@ void rtw89_btc_set_policy(struct rtw89_dev *rtwdev, u16 policy_type)
struct rtw89_btc_fbtc_slot *s = dm->slot.v1;
u8 type;
u32 tbl_w1, tbl_b1, tbl_b4;
+ bool tdma_on = false;
if (btc->ant_type == BTC_ANT_SHARED) {
if (btc->cx.wl.status.map._4way)
@@ -3928,7 +3964,7 @@ void rtw89_btc_set_policy(struct rtw89_dev *rtwdev, u16 policy_type)
btc->update_policy_force = true;
break;
case BTC_CXP_OFF: /* TDMA off */
- _write_scbd(rtwdev, BTC_WSCB_TDMA, false);
+ tdma_on = false;
*t = t_def[CXTD_OFF];
s[CXST_OFF] = s_def[CXST_OFF];
@@ -3963,7 +3999,7 @@ void rtw89_btc_set_policy(struct rtw89_dev *rtwdev, u16 policy_type)
}
break;
case BTC_CXP_OFFB: /* TDMA off + beacon protect */
- _write_scbd(rtwdev, BTC_WSCB_TDMA, false);
+ tdma_on = false;
*t = t_def[CXTD_OFF_B2];
s[CXST_OFF] = s_def[CXST_OFF];
switch (policy_type) {
@@ -3974,7 +4010,7 @@ void rtw89_btc_set_policy(struct rtw89_dev *rtwdev, u16 policy_type)
break;
case BTC_CXP_OFFE: /* TDMA off + beacon protect + Ext_control */
btc->bt_req_en = true;
- _write_scbd(rtwdev, BTC_WSCB_TDMA, true);
+ tdma_on = true;
*t = t_def[CXTD_OFF_EXT];
switch (policy_type) {
case BTC_CXP_OFFE_DEF:
@@ -3992,7 +4028,7 @@ void rtw89_btc_set_policy(struct rtw89_dev *rtwdev, u16 policy_type)
}
break;
case BTC_CXP_FIX: /* TDMA Fix-Slot */
- _write_scbd(rtwdev, BTC_WSCB_TDMA, true);
+ tdma_on = true;
*t = t_def[CXTD_FIX];
switch (policy_type) {
case BTC_CXP_FIX_TD3030:
@@ -4048,7 +4084,7 @@ void rtw89_btc_set_policy(struct rtw89_dev *rtwdev, u16 policy_type)
}
break;
case BTC_CXP_PFIX: /* PS-TDMA Fix-Slot */
- _write_scbd(rtwdev, BTC_WSCB_TDMA, true);
+ tdma_on = true;
*t = t_def[CXTD_PFIX];
if (btc->cx.wl.role_info.role_map.role.ap)
_tdma_set_flctrl(btc, CXFLC_QOSNULL);
@@ -4081,7 +4117,7 @@ void rtw89_btc_set_policy(struct rtw89_dev *rtwdev, u16 policy_type)
}
break;
case BTC_CXP_AUTO: /* TDMA Auto-Slot */
- _write_scbd(rtwdev, BTC_WSCB_TDMA, true);
+ tdma_on = true;
*t = t_def[CXTD_AUTO];
switch (policy_type) {
case BTC_CXP_AUTO_TD50B1:
@@ -4105,7 +4141,7 @@ void rtw89_btc_set_policy(struct rtw89_dev *rtwdev, u16 policy_type)
}
break;
case BTC_CXP_PAUTO: /* PS-TDMA Auto-Slot */
- _write_scbd(rtwdev, BTC_WSCB_TDMA, true);
+ tdma_on = true;
*t = t_def[CXTD_PAUTO];
switch (policy_type) {
case BTC_CXP_PAUTO_TD50B1:
@@ -4129,7 +4165,7 @@ void rtw89_btc_set_policy(struct rtw89_dev *rtwdev, u16 policy_type)
}
break;
case BTC_CXP_AUTO2: /* TDMA Auto-Slot2 */
- _write_scbd(rtwdev, BTC_WSCB_TDMA, true);
+ tdma_on = true;
*t = t_def[CXTD_AUTO2];
switch (policy_type) {
case BTC_CXP_AUTO2_TD3050:
@@ -4166,7 +4202,7 @@ void rtw89_btc_set_policy(struct rtw89_dev *rtwdev, u16 policy_type)
}
break;
case BTC_CXP_PAUTO2: /* PS-TDMA Auto-Slot2 */
- _write_scbd(rtwdev, BTC_WSCB_TDMA, true);
+ tdma_on = true;
*t = t_def[CXTD_PAUTO2];
switch (policy_type) {
case BTC_CXP_PAUTO2_TD3050:
@@ -4203,6 +4239,7 @@ void rtw89_btc_set_policy(struct rtw89_dev *rtwdev, u16 policy_type)
}
break;
}
+ _set_tdma_bind(rtwdev, tdma_on);
}
EXPORT_SYMBOL(rtw89_btc_set_policy);
@@ -4211,14 +4248,14 @@ void rtw89_btc_set_policy_v1(struct rtw89_dev *rtwdev, u16 policy_type)
struct rtw89_btc *btc = &rtwdev->btc;
struct rtw89_btc_dm *dm = &btc->dm;
struct rtw89_btc_fbtc_tdma *t = &dm->tdma;
- struct rtw89_btc_wl_role_info_v1 *wl_rinfo = &btc->cx.wl.role_info_v1;
struct rtw89_btc_bt_a2dp_desc *a2dp = &btc->cx.bt0.link_info.a2dp_desc;
struct rtw89_btc_bt_hid_desc *hid = &btc->cx.bt0.link_info.hid_desc;
struct rtw89_btc_bt_hfp_desc *hfp = &btc->cx.bt0.link_info.hfp_desc;
struct rtw89_btc_wl_info *wl = &btc->cx.wl;
u8 type, null_role;
u32 tbl_w1, tbl_b1, tbl_b4;
- u16 dur_2;
+ bool tdma_on = false;
+ u16 dur_1 = 0, dur_2;
if (wl->status.map.lps) {
_slot_set_le(btc, CXST_E2G, s_def[CXST_E2G].dur,
@@ -4272,7 +4309,7 @@ void rtw89_btc_set_policy_v1(struct rtw89_dev *rtwdev, u16 policy_type)
_slot_set_tbl(btc, CXST_OFF, cxtbl[2]);
break;
case BTC_CXP_OFF: /* TDMA off */
- _write_scbd(rtwdev, BTC_WSCB_TDMA, false);
+ tdma_on = false;
*t = t_def[CXTD_OFF];
_slot_set_le(btc, CXST_OFF, s_def[CXST_OFF].dur,
s_def[CXST_OFF].cxtbl, s_def[CXST_OFF].cxtype);
@@ -4324,7 +4361,7 @@ void rtw89_btc_set_policy_v1(struct rtw89_dev *rtwdev, u16 policy_type)
}
break;
case BTC_CXP_OFFB: /* TDMA off + beacon protect */
- _write_scbd(rtwdev, BTC_WSCB_TDMA, false);
+ tdma_on = false;
*t = t_def[CXTD_OFF_B2];
_slot_set_le(btc, CXST_OFF, s_def[CXST_OFF].dur,
s_def[CXST_OFF].cxtbl, s_def[CXST_OFF].cxtype);
@@ -4338,24 +4375,35 @@ void rtw89_btc_set_policy_v1(struct rtw89_dev *rtwdev, u16 policy_type)
}
break;
case BTC_CXP_OFFE: /* TDMA off + beacon protect + Ext_control */
- _write_scbd(rtwdev, BTC_WSCB_TDMA, true);
+ tdma_on = true;
*t = t_def[CXTD_OFF_EXT];
/* To avoid wl-s0 tx break by hid/hfp tx */
if (hid->exist || hfp->exist)
tbl_w1 = cxtbl[16];
+ if (dm->eslot_ctrl.en) {
+ null_role = u8_encode_bits(dm->eslot_ctrl.nulltx_role1, 0x0f) |
+ u8_encode_bits(dm->eslot_ctrl.nulltx_role2, 0xf0);
+ _tdma_set_flctrl_role(btc, null_role);
+ _tdma_set_rxflctrl(btc, 1);
+ _tdma_set_txflctrl(btc, 1);
+ /* Set Null-Tx time-tick by E2G duration */
+ dm->eslot_ctrl.nulltx_pre_time = 5; /* TODO: BIS COEX */
+ dur_1 = dm->eslot_ctrl.nulltx_pre_time;
+ }
+
dur_2 = dm->e2g_slot_limit;
switch (policy_type) {
case BTC_CXP_OFFE_2GBWISOB: /* for normal-case */
- _slot_set(btc, CXST_E2G, 5, tbl_w1, SLOT_ISO);
+ _slot_set(btc, CXST_E2G, dur_1, tbl_w1, SLOT_ISO);
_slot_set_le(btc, CXST_EBT, s_def[CXST_EBT].dur,
s_def[CXST_EBT].cxtbl, s_def[CXST_EBT].cxtype);
_slot_set_dur(btc, CXST_EBT, dur_2);
break;
case BTC_CXP_OFFE_2GISOB: /* for bt no-link */
- _slot_set(btc, CXST_E2G, 5, cxtbl[1], SLOT_ISO);
+ _slot_set(btc, CXST_E2G, dur_1, cxtbl[1], SLOT_ISO);
_slot_set_le(btc, CXST_EBT, s_def[CXST_EBT].dur,
s_def[CXST_EBT].cxtbl, s_def[CXST_EBT].cxtype);
_slot_set_dur(btc, CXST_EBT, dur_2);
@@ -4383,16 +4431,16 @@ void rtw89_btc_set_policy_v1(struct rtw89_dev *rtwdev, u16 policy_type)
break;
case BTC_CXP_OFFE_2GBWMIXB:
if (a2dp->exist)
- _slot_set(btc, CXST_E2G, 5, cxtbl[2], SLOT_MIX);
+ _slot_set(btc, CXST_E2G, dur_1, cxtbl[2], SLOT_MIX);
else
- _slot_set(btc, CXST_E2G, 5, tbl_w1, SLOT_MIX);
+ _slot_set(btc, CXST_E2G, dur_1, tbl_w1, SLOT_MIX);
_slot_set_le(btc, CXST_EBT, cpu_to_le16(40),
s_def[CXST_EBT].cxtbl, s_def[CXST_EBT].cxtype);
_slot_set_dur(btc, CXST_EBT, dur_2);
break;
case BTC_CXP_OFFE_WL: /* for 4-way */
- _slot_set(btc, CXST_E2G, 5, cxtbl[1], SLOT_MIX);
- _slot_set(btc, CXST_EBT, 5, cxtbl[1], SLOT_MIX);
+ _slot_set(btc, CXST_E2G, dur_1, cxtbl[1], SLOT_MIX);
+ _slot_set(btc, CXST_EBT, dur_1, cxtbl[1], SLOT_MIX);
break;
default:
break;
@@ -4403,7 +4451,7 @@ void rtw89_btc_set_policy_v1(struct rtw89_dev *rtwdev, u16 policy_type)
s_def[CXST_OFF].cxtbl, s_def[CXST_OFF].cxtype);
break;
case BTC_CXP_FIX: /* TDMA Fix-Slot */
- _write_scbd(rtwdev, BTC_WSCB_TDMA, true);
+ tdma_on = true;
*t = t_def[CXTD_FIX];
switch (policy_type) {
@@ -4462,7 +4510,7 @@ void rtw89_btc_set_policy_v1(struct rtw89_dev *rtwdev, u16 policy_type)
}
break;
case BTC_CXP_PFIX: /* PS-TDMA Fix-Slot */
- _write_scbd(rtwdev, BTC_WSCB_TDMA, true);
+ tdma_on = true;
*t = t_def[CXTD_PFIX];
switch (policy_type) {
@@ -4501,7 +4549,7 @@ void rtw89_btc_set_policy_v1(struct rtw89_dev *rtwdev, u16 policy_type)
}
break;
case BTC_CXP_AUTO: /* TDMA Auto-Slot */
- _write_scbd(rtwdev, BTC_WSCB_TDMA, true);
+ tdma_on = true;
*t = t_def[CXTD_AUTO];
switch (policy_type) {
@@ -4528,7 +4576,7 @@ void rtw89_btc_set_policy_v1(struct rtw89_dev *rtwdev, u16 policy_type)
}
break;
case BTC_CXP_PAUTO: /* PS-TDMA Auto-Slot */
- _write_scbd(rtwdev, BTC_WSCB_TDMA, true);
+ tdma_on = true;
*t = t_def[CXTD_PAUTO];
switch (policy_type) {
@@ -4555,7 +4603,7 @@ void rtw89_btc_set_policy_v1(struct rtw89_dev *rtwdev, u16 policy_type)
}
break;
case BTC_CXP_AUTO2: /* TDMA Auto-Slot2 */
- _write_scbd(rtwdev, BTC_WSCB_TDMA, true);
+ tdma_on = true;
*t = t_def[CXTD_AUTO2];
switch (policy_type) {
@@ -4597,7 +4645,7 @@ void rtw89_btc_set_policy_v1(struct rtw89_dev *rtwdev, u16 policy_type)
}
break;
case BTC_CXP_PAUTO2: /* PS-TDMA Auto-Slot2 */
- _write_scbd(rtwdev, BTC_WSCB_TDMA, true);
+ tdma_on = true;
*t = t_def[CXTD_PAUTO2];
switch (policy_type) {
@@ -4640,20 +4688,22 @@ void rtw89_btc_set_policy_v1(struct rtw89_dev *rtwdev, u16 policy_type)
break;
}
- if (wl_rinfo->link_mode == BTC_WLINK_2G_SCC && dm->tdma.rxflctrl) {
- null_role = FIELD_PREP(0x0f, dm->wl_scc.null_role1) |
- FIELD_PREP(0xf0, dm->wl_scc.null_role2);
- _tdma_set_flctrl_role(btc, null_role);
- }
-
/* enter leak_slot after each null-1 */
if (dm->leak_ap && dm->tdma.leak_n > 1)
_tdma_set_lek(btc, 1);
- if (dm->tdma_instant_excute || dm->lps_ctrl_change) {
+ if (dm->tdma_instant_excute ||
+ dm->error.map.tdma_no_sync ||
+ dm->error.map.slot_no_sync ||
+ dm->lps_ctrl_change) {
btc->dm.tdma.option_ctrl |= BIT(0);
btc->update_policy_force = true;
}
+
+ if (btc->cli_h2c_cmd)
+ btc->update_policy_force = true;
+
+ _set_tdma_bind(rtwdev, tdma_on);
}
EXPORT_SYMBOL(rtw89_btc_set_policy_v1);
@@ -4697,20 +4747,29 @@ static void _set_ant_v0(struct rtw89_dev *rtwdev, bool force_exec,
struct rtw89_btc_wl_info *wl = &btc->cx.wl;
struct rtw89_btc_bt_info *bt = &cx->bt0;
struct rtw89_btc_wl_dbcc_info *wl_dinfo = &wl->dbcc_info;
- u8 gnt_wl_ctrl, gnt_bt_ctrl, plt_ctrl, i, b2g = 0;
- bool dbcc_chg = false;
+ u8 gwl, gwl0, gwl1, gbt, plt_ctrl, i, dbcc_2g_phy, b2g = 0;
+ bool dbcc_chg = false, dbcc_en = false;
u32 ant_path_type;
ant_path_type = ((phy_map << 8) + type);
- if (btc->ver->fwlrole == 1)
+ if (btc->ver->fwlrole == 1) {
dbcc_chg = wl->role_info_v1.dbcc_chg;
- else if (btc->ver->fwlrole == 2)
+ dbcc_en = wl->role_info_v1.dbcc_en;
+ dbcc_2g_phy = wl->role_info_v1.dbcc_2g_phy;
+ } else if (btc->ver->fwlrole == 2) {
dbcc_chg = wl->role_info_v2.dbcc_chg;
- else if (btc->ver->fwlrole == 7)
+ dbcc_en = wl->role_info_v2.dbcc_en;
+ dbcc_2g_phy = wl->role_info_v2.dbcc_2g_phy;
+ } else if (btc->ver->fwlrole == 7) {
dbcc_chg = wl->role_info_v7.dbcc_chg;
- else if (btc->ver->fwlrole == 8)
+ dbcc_en = wl->role_info_v7.dbcc_en;
+ dbcc_2g_phy = wl->role_info_v7.dbcc_2g_phy;
+ } else if (btc->ver->fwlrole == 8) {
dbcc_chg = wl->role_info_v8.dbcc_chg;
+ dbcc_en = wl->role_info_v8.dbcc_en;
+ dbcc_2g_phy = wl->role_info_v8.dbcc_2g_phy;
+ }
if (btc->dm.run_reason == BTC_RSN_NTFY_POWEROFF ||
btc->dm.run_reason == BTC_RSN_NTFY_RADIO_STATE ||
@@ -4768,14 +4827,14 @@ static void _set_ant_v0(struct rtw89_dev *rtwdev, bool force_exec,
for (i = 0; i < RTW89_PHY_NUM; i++) {
b2g = (wl_dinfo->real_band[i] == RTW89_BAND_2G);
- gnt_wl_ctrl = b2g ? BTC_GNT_HW : BTC_GNT_SW_HI;
- gnt_bt_ctrl = b2g ? BTC_GNT_HW : BTC_GNT_SW_HI;
+ gwl = b2g ? BTC_GNT_HW : BTC_GNT_SW_HI;
+ gbt = b2g ? BTC_GNT_HW : BTC_GNT_SW_HI;
/* BT should control by GNT_BT if WL_2G at S0 */
if (i == 1 &&
wl_dinfo->real_band[0] == RTW89_BAND_2G &&
wl_dinfo->real_band[1] == RTW89_BAND_5G)
- gnt_bt_ctrl = BTC_GNT_HW;
- _set_gnt(rtwdev, BIT(i), gnt_wl_ctrl, gnt_bt_ctrl);
+ gbt = BTC_GNT_HW;
+ _set_gnt(rtwdev, BIT(i), gwl, gbt);
plt_ctrl = b2g ? BTC_PLT_BT : BTC_PLT_NONE;
_set_bt_plut(rtwdev, BIT(i),
plt_ctrl, plt_ctrl);
@@ -4808,12 +4867,27 @@ static void _set_ant_v0(struct rtw89_dev *rtwdev, bool force_exec,
_set_gnt(rtwdev, phy_map, BTC_GNT_SW_HI, BTC_GNT_SW_LO);
_set_bt_plut(rtwdev, phy_map, BTC_PLT_NONE, BTC_PLT_NONE);
break;
- case BTC_ANT_BRFK:
- rtw89_chip_cfg_ctrl_path(rtwdev, BTC_CTRL_BY_BT);
- _set_gnt(rtwdev, phy_map, BTC_GNT_SW_LO, BTC_GNT_SW_HI);
- _set_bt_plut(rtwdev, phy_map, BTC_PLT_NONE, BTC_PLT_NONE);
- break;
+ case BTC_ANT_PTA:
default:
+ gbt = BTC_GNT_HW;
+ if ((rtwdev->chip->para_ver & BTC_FEAT_MULTI_PTA) ||
+ !dbcc_en) {
+ gwl = BTC_GNT_HW;
+ _set_gnt(rtwdev, BTC_PHY_ALL, gwl, gbt);
+ } else {
+ /* for DBCC Only-1-PTA */
+ if (dbcc_2g_phy == RTW89_PHY_0) {
+ gwl0 = BTC_GNT_HW;
+ gwl1 = BTC_GNT_SW_HI;
+ } else {
+ gwl0 = BTC_GNT_SW_HI;
+ gwl1 = BTC_GNT_HW;
+ }
+ _set_gnt(rtwdev, BTC_PHY_0, gwl0, gbt);
+ _set_gnt(rtwdev, BTC_PHY_1, gwl1, gbt);
+ }
+ rtw89_chip_cfg_ctrl_path(rtwdev, BTC_CTRL_BY_WL);
+ _set_bt_plut(rtwdev, phy_map, BTC_PLT_NONE, BTC_PLT_NONE);
break;
}
}
@@ -4828,7 +4902,7 @@ static void _set_ant_v1(struct rtw89_dev *rtwdev, bool force_exec,
u32 ant_path_type = rtw89_get_antpath_type(phy_map, type);
struct rtw89_btc_wl_dbcc_info *wl_dinfo = &wl->dbcc_info;
struct rtw89_btc_dm *dm = &btc->dm;
- u8 gwl = BTC_GNT_HW;
+ u8 gwl = BTC_GNT_HW, gwl0, gwl1, gbt;
if (btc->dm.run_reason == BTC_RSN_NTFY_POWEROFF ||
btc->dm.run_reason == BTC_RSN_NTFY_RADIO_STATE ||
@@ -4913,8 +4987,26 @@ static void _set_ant_v1(struct rtw89_dev *rtwdev, bool force_exec,
_set_gnt_v1(rtwdev, phy_map, BTC_GNT_SW_HI, BTC_GNT_SW_LO,
BTC_WLACT_SW_HI); /* no BT-Tx */
break;
+ case BTC_ANT_PTA:
default:
- return;
+ gbt = BTC_GNT_HW;
+ if ((rtwdev->chip->para_ver & BTC_FEAT_MULTI_PTA) ||
+ !wl_rinfo->dbcc_en) {
+ gwl = BTC_GNT_HW;
+ _set_gnt_v1(rtwdev, BTC_PHY_ALL, gwl, gbt, BTC_WLACT_HW);
+ } else {
+ /* for DBCC Only-1-PTA */
+ if (wl_rinfo->dbcc_2g_phy == RTW89_PHY_0) {
+ gwl0 = BTC_GNT_HW;
+ gwl1 = BTC_GNT_SW_HI;
+ } else {
+ gwl0 = BTC_GNT_SW_HI;
+ gwl1 = BTC_GNT_HW;
+ }
+ _set_gnt_v1(rtwdev, BTC_PHY_0, gwl0, gbt, BTC_WLACT_HW);
+ _set_gnt_v1(rtwdev, BTC_PHY_1, gwl1, gbt, BTC_WLACT_HW);
+ }
+ break;
}
_set_bt_plut(rtwdev, phy_map, BTC_PLT_GNT_WL, BTC_PLT_GNT_WL);
@@ -6017,178 +6109,15 @@ static void _action_wl_2g_mcc(struct rtw89_dev *rtwdev)
static void _action_wl_2g_scc(struct rtw89_dev *rtwdev)
{
struct rtw89_btc *btc = &rtwdev->btc;
-
- _set_ant(rtwdev, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
-
- if (btc->ant_type == BTC_ANT_SHARED) { /* shared-antenna */
- if (btc->cx.bt0.link_info.link_cnt.now == 0)
- _set_policy(rtwdev,
- BTC_CXP_OFFE_DEF2, BTC_ACT_WL_2G_SCC);
- else
- _set_policy(rtwdev,
- BTC_CXP_OFFE_DEF, BTC_ACT_WL_2G_SCC);
- } else { /* dedicated-antenna */
- _set_policy(rtwdev, BTC_CXP_OFF_EQ0, BTC_ACT_WL_2G_SCC);
- }
-}
-
-static void _action_wl_2g_scc_v1(struct rtw89_dev *rtwdev)
-{
- struct rtw89_btc *btc = &rtwdev->btc;
- struct rtw89_btc_wl_info *wl = &btc->cx.wl;
- struct rtw89_btc_bt_info *bt = &btc->cx.bt0;
struct rtw89_btc_dm *dm = &btc->dm;
- struct rtw89_btc_wl_role_info_v1 *wl_rinfo = &wl->role_info_v1;
- u16 policy_type = BTC_CXP_OFF_BT;
- u32 dur;
+ u16 policy_type;
- if (btc->ant_type == BTC_ANT_DEDICATED) {
- policy_type = BTC_CXP_OFF_EQ0;
- } else {
- /* shared-antenna */
- switch (wl_rinfo->mrole_type) {
- case BTC_WLMROLE_STA_GC:
- dm->wl_scc.null_role1 = RTW89_WIFI_ROLE_STATION;
- dm->wl_scc.null_role2 = RTW89_WIFI_ROLE_P2P_CLIENT;
- dm->wl_scc.ebt_null = 0; /* no ext-slot-control */
- _action_by_bt(rtwdev);
- return;
- case BTC_WLMROLE_STA_STA:
- dm->wl_scc.null_role1 = RTW89_WIFI_ROLE_STATION;
- dm->wl_scc.null_role2 = RTW89_WIFI_ROLE_STATION;
- dm->wl_scc.ebt_null = 0; /* no ext-slot-control */
- _action_by_bt(rtwdev);
- return;
- case BTC_WLMROLE_STA_GC_NOA:
- case BTC_WLMROLE_STA_GO:
- case BTC_WLMROLE_STA_GO_NOA:
- dm->wl_scc.null_role1 = RTW89_WIFI_ROLE_STATION;
- dm->wl_scc.null_role2 = RTW89_WIFI_ROLE_NONE;
- dur = wl_rinfo->mrole_noa_duration;
-
- if (wl->status.map._4way) {
- dm->wl_scc.ebt_null = 0;
- policy_type = BTC_CXP_OFFE_WL;
- } else if (bt->link_info.status.map.connect == 0) {
- dm->wl_scc.ebt_null = 0;
- policy_type = BTC_CXP_OFFE_2GISOB;
- } else if (bt->link_info.a2dp_desc.exist &&
- dur < btc->bt_req_len[RTW89_PHY_0]) {
- dm->wl_scc.ebt_null = 1; /* tx null at EBT */
- policy_type = BTC_CXP_OFFE_2GBWMIXB2;
- } else if (bt->link_info.a2dp_desc.exist ||
- bt->link_info.pan_desc.exist) {
- dm->wl_scc.ebt_null = 1; /* tx null at EBT */
- policy_type = BTC_CXP_OFFE_2GBWISOB;
- } else {
- dm->wl_scc.ebt_null = 0;
- policy_type = BTC_CXP_OFFE_2GBWISOB;
- }
- break;
- default:
- break;
- }
- }
-
- _set_ant(rtwdev, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
- _set_policy(rtwdev, policy_type, BTC_ACT_WL_2G_SCC);
-}
-
-static void _action_wl_2g_scc_v2(struct rtw89_dev *rtwdev)
-{
- struct rtw89_btc *btc = &rtwdev->btc;
- struct rtw89_btc_wl_info *wl = &btc->cx.wl;
- struct rtw89_btc_bt_info *bt = &btc->cx.bt0;
- struct rtw89_btc_dm *dm = &btc->dm;
- struct rtw89_btc_wl_role_info_v2 *rinfo_v2 = &wl->role_info_v2;
- struct rtw89_btc_wl_role_info_v7 *rinfo_v7 = &wl->role_info_v7;
- u32 dur, mrole_type, mrole_noa_duration;
- u16 policy_type = BTC_CXP_OFF_BT;
-
- if (btc->ver->fwlrole == 2) {
- mrole_type = rinfo_v2->mrole_type;
- mrole_noa_duration = rinfo_v2->mrole_noa_duration;
- } else if (btc->ver->fwlrole == 7) {
- mrole_type = rinfo_v7->mrole_type;
- mrole_noa_duration = rinfo_v7->mrole_noa_duration;
- } else {
- return;
- }
-
- if (btc->ant_type == BTC_ANT_DEDICATED) {
- policy_type = BTC_CXP_OFF_EQ0;
- } else {
- /* shared-antenna */
- switch (mrole_type) {
- case BTC_WLMROLE_STA_GC:
- dm->wl_scc.null_role1 = RTW89_WIFI_ROLE_STATION;
- dm->wl_scc.null_role2 = RTW89_WIFI_ROLE_P2P_CLIENT;
- dm->wl_scc.ebt_null = 0; /* no ext-slot-control */
- _action_by_bt(rtwdev);
- return;
- case BTC_WLMROLE_STA_STA:
- dm->wl_scc.null_role1 = RTW89_WIFI_ROLE_STATION;
- dm->wl_scc.null_role2 = RTW89_WIFI_ROLE_STATION;
- dm->wl_scc.ebt_null = 0; /* no ext-slot-control */
- _action_by_bt(rtwdev);
- return;
- case BTC_WLMROLE_STA_GC_NOA:
- case BTC_WLMROLE_STA_GO:
- case BTC_WLMROLE_STA_GO_NOA:
- dm->wl_scc.null_role1 = RTW89_WIFI_ROLE_STATION;
- dm->wl_scc.null_role2 = RTW89_WIFI_ROLE_NONE;
- dur = mrole_noa_duration;
-
- if (wl->status.map._4way) {
- dm->wl_scc.ebt_null = 0;
- policy_type = BTC_CXP_OFFE_WL;
- } else if (bt->link_info.status.map.connect == 0) {
- dm->wl_scc.ebt_null = 0;
- policy_type = BTC_CXP_OFFE_2GISOB;
- } else if (bt->link_info.a2dp_desc.exist &&
- dur < btc->bt_req_len[RTW89_PHY_0]) {
- dm->wl_scc.ebt_null = 1; /* tx null at EBT */
- policy_type = BTC_CXP_OFFE_2GBWMIXB2;
- } else if (bt->link_info.a2dp_desc.exist ||
- bt->link_info.pan_desc.exist) {
- dm->wl_scc.ebt_null = 1; /* tx null at EBT */
- policy_type = BTC_CXP_OFFE_2GBWISOB;
- } else {
- dm->wl_scc.ebt_null = 0;
- policy_type = BTC_CXP_OFFE_2GBWISOB;
- }
- break;
- default:
- break;
- }
- }
-
- _set_ant(rtwdev, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
- _set_policy(rtwdev, policy_type, BTC_ACT_WL_2G_SCC);
-}
-
-static void _action_wl_2g_scc_v8(struct rtw89_dev *rtwdev)
-{
- struct rtw89_btc *btc = &rtwdev->btc;
- struct rtw89_btc_wl_info *wl = &btc->cx.wl;
- struct rtw89_btc_bt_info *bt = &btc->cx.bt0;
- struct rtw89_btc_dm *dm = &btc->dm;
- u16 policy_type = BTC_CXP_OFF_BT;
-
- if (btc->ant_type == BTC_ANT_SHARED) {
- if (wl->status.map._4way)
- policy_type = BTC_CXP_OFFE_WL;
- else if (bt->link_info.status.map.connect == 0)
- policy_type = BTC_CXP_OFFE_2GISOB;
- else
- policy_type = BTC_CXP_OFFE_2GBWISOB;
- } else {
- policy_type = BTC_CXP_OFF_EQ0;
- }
-
- dm->e2g_slot_limit = BTC_E2G_LIMIT_DEF;
+ if (!dm->tdd_bind.bt_smap.connect)
+ policy_type = BTC_CXP_OFFE_2GISOB;
+ else
+ policy_type = BTC_CXP_OFFE_2GBWISOB;
- _set_ant(rtwdev, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
+ _set_ant(rtwdev, NM_EXEC, BTC_PHY_ALL, BTC_ANT_PTA);
_set_policy(rtwdev, policy_type, BTC_ACT_WL_2G_SCC);
}
@@ -8180,14 +8109,7 @@ void _run_coex(struct rtw89_dev *rtwdev, enum btc_reason_and_action reason)
break;
case BTC_WLINK_2G_SCC:
bt->scan_rx_low_pri = true;
- if (ver->fwlrole == 0)
- _action_wl_2g_scc(rtwdev);
- else if (ver->fwlrole == 1)
- _action_wl_2g_scc_v1(rtwdev);
- else if (ver->fwlrole == 2 || ver->fwlrole == 7)
- _action_wl_2g_scc_v2(rtwdev);
- else if (ver->fwlrole == 8)
- _action_wl_2g_scc_v8(rtwdev);
+ _action_wl_2g_scc(rtwdev);
break;
case BTC_WLINK_2G_MCC:
bt->scan_rx_low_pri = true;
@@ -10115,7 +10037,8 @@ static const char *id_to_ant(u32 id)
CASE_BTC_ANTPATH_STR(W25G);
CASE_BTC_ANTPATH_STR(FREERUN);
CASE_BTC_ANTPATH_STR(WRFK);
- CASE_BTC_ANTPATH_STR(BRFK);
+ CASE_BTC_ANTPATH_STR(WRFK2);
+ CASE_BTC_ANTPATH_STR(PTA);
CASE_BTC_ANTPATH_STR(MAX);
default:
return "unknown";
diff --git a/drivers/net/wireless/realtek/rtw89/core.h b/drivers/net/wireless/realtek/rtw89/core.h
index 21bdf229723c..eb814425f536 100644
--- a/drivers/net/wireless/realtek/rtw89/core.h
+++ b/drivers/net/wireless/realtek/rtw89/core.h
@@ -1832,10 +1832,11 @@ struct rtw89_btc_wl_role_info_bpos {
u16 nan: 1;
};
-struct rtw89_btc_wl_scc_ctrl {
- u8 null_role1;
- u8 null_role2;
- u8 ebt_null; /* if tx null at EBT slot */
+struct rtw89_btc_eslot_ctrl {
+ u8 en; /* 1: toggle tx-flow-ctrl (null 0/1), tx-pause by Ext-slot */
+ u8 nulltx_role1;
+ u8 nulltx_role2;
+ u8 nulltx_pre_time; /* null-tx time prior to EBT-start (from E2G-end) */
};
union rtw89_btc_wl_role_info_map {
@@ -3275,7 +3276,7 @@ struct rtw89_btc_dm {
struct rtw89_btc_rf_trx_para_v9 rf_trx_para;
struct rtw89_btc_wl_tx_limit_para wl_tx_limit;
struct rtw89_btc_dm_step dm_step;
- struct rtw89_btc_wl_scc_ctrl wl_scc;
+ struct rtw89_btc_eslot_ctrl eslot_ctrl;
struct rtw89_btc_trx_info trx_info;
union rtw89_btc_dm_error_map error;
struct rtw89_btc_bind_info tdd_bind;
--
2.25.1
^ permalink raw reply related
* [PATCH rtw-next 6/9] wifi: rtw89: coex: Add WiFi/Bluetooth adapter binding info
From: Ping-Ke Shih @ 2026-07-03 11:43 UTC (permalink / raw)
To: linux-wireless; +Cc: ku920601
In-Reply-To: <20260703114311.2609942-1-pkshih@realtek.com>
From: Ching-Te Ku <ku920601@realtek.com>
To bind Wi-Fi/Bluetooth with which adapter, in which band.
Signed-off-by: Ching-Te Ku <ku920601@realtek.com>
Signed-off-by: Ping-Ke Shih <pkshih@realtek.com>
---
drivers/net/wireless/realtek/rtw89/coex.c | 309 ++++++++++++++++++++--
drivers/net/wireless/realtek/rtw89/core.h | 121 ++++++++-
2 files changed, 396 insertions(+), 34 deletions(-)
diff --git a/drivers/net/wireless/realtek/rtw89/coex.c b/drivers/net/wireless/realtek/rtw89/coex.c
index ff3c05101ab3..435a4a5d2c2d 100644
--- a/drivers/net/wireless/realtek/rtw89/coex.c
+++ b/drivers/net/wireless/realtek/rtw89/coex.c
@@ -3349,7 +3349,7 @@ static void _set_rf_trx_para(struct rtw89_dev *rtwdev)
/* decide trx_para_level */
if (btc->ant_type == BTC_ANT_SHARED) {
/* fix LNA2 + TIA gain not change by GNT_BT */
- if ((btc->dm.wl_btg_rx && b->profile_cnt.now != 0) ||
+ if ((btc->dm.wl_btg_rx && b->link_cnt.now != 0) ||
dm->bt_only == 1)
dm->trx_para_level = 1; /* for better BT ACI issue */
else
@@ -3357,7 +3357,7 @@ static void _set_rf_trx_para(struct rtw89_dev *rtwdev)
} else { /* non-shared antenna */
dm->trx_para_level = 5;
/* modify trx_para if WK 2.4G-STA-DL + bt link */
- if (b->profile_cnt.now != 0 &&
+ if (b->link_cnt.now != 0 &&
link_mode == BTC_WLINK_2G_STA &&
wl->status.map.traffic_dir & BIT(RTW89_TFC_UL)) { /* uplink */
if (wl->rssi_level == 4 && bt->rssi_level > 2)
@@ -3606,7 +3606,7 @@ static void _set_bt_afh_info_v0(struct rtw89_dev *rtwdev)
if (wl->afh_info.en == en &&
wl->afh_info.ch == ch &&
wl->afh_info.bw == bw &&
- b->profile_cnt.last == b->profile_cnt.now) {
+ b->link_cnt.last == b->link_cnt.now) {
rtw89_debug(rtwdev, RTW89_DBG_BTC,
"[BTC], %s(): return because no change!\n",
__func__);
@@ -3777,7 +3777,7 @@ static bool _check_freerun(struct rtw89_dev *rtwdev)
return true;
}
- if (bt_linfo->profile_cnt.now == 0) {
+ if (bt_linfo->link_cnt.now == 0) {
btc->dm.trx_para_level = 5;
return true;
}
@@ -5497,7 +5497,7 @@ static void _set_wl_preagc_ctrl(struct rtw89_dev *rtwdev)
} else if (link_mode == BTC_WLINK_5G) {
is_preagc = BTC_PREAGC_DISABLE;
} else if (link_mode == BTC_WLINK_NOLINK ||
- btc->cx.bt0.link_info.profile_cnt.now == 0) {
+ btc->cx.bt0.link_info.link_cnt.now == 0) {
is_preagc = BTC_PREAGC_DISABLE;
} else if (dm->tdma_now.type != CXTDMA_OFF &&
!bt_linfo->hfp_desc.exist &&
@@ -5683,7 +5683,7 @@ static void _set_wl_tx_limit(struct rtw89_dev *rtwdev)
else
igno_bt = btc->ctrl.ctrl.igno_bt;
- if (btc->dm.freerun || igno_bt || b->profile_cnt.now == 0 ||
+ if (btc->dm.freerun || igno_bt || b->link_cnt.now == 0 ||
mode == BTC_WLINK_5G || mode == BTC_WLINK_NOLINK) {
enable = 0;
tx_time = BTC_MAX_TX_TIME_DEF;
@@ -6003,7 +6003,7 @@ static void _action_wl_2g_mcc(struct rtw89_dev *rtwdev)
_set_ant(rtwdev, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
if (btc->ant_type == BTC_ANT_SHARED) { /* shared-antenna */
- if (btc->cx.bt0.link_info.profile_cnt.now == 0)
+ if (btc->cx.bt0.link_info.link_cnt.now == 0)
_set_policy(rtwdev, BTC_CXP_OFFE_DEF2,
BTC_ACT_WL_2G_MCC);
else
@@ -6021,7 +6021,7 @@ static void _action_wl_2g_scc(struct rtw89_dev *rtwdev)
_set_ant(rtwdev, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
if (btc->ant_type == BTC_ANT_SHARED) { /* shared-antenna */
- if (btc->cx.bt0.link_info.profile_cnt.now == 0)
+ if (btc->cx.bt0.link_info.link_cnt.now == 0)
_set_policy(rtwdev,
BTC_CXP_OFFE_DEF2, BTC_ACT_WL_2G_SCC);
else
@@ -6199,7 +6199,7 @@ static void _action_wl_2g_ap(struct rtw89_dev *rtwdev)
_set_ant(rtwdev, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
if (btc->ant_type == BTC_ANT_SHARED) {
- if (btc->cx.bt0.link_info.profile_cnt.now == 0)
+ if (btc->cx.bt0.link_info.link_cnt.now == 0)
_set_policy(rtwdev, BTC_CXP_OFFE_DEF2,
BTC_ACT_WL_2G_AP);
else
@@ -6216,7 +6216,7 @@ static void _action_wl_2g_go(struct rtw89_dev *rtwdev)
_set_ant(rtwdev, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
if (btc->ant_type == BTC_ANT_SHARED) { /* shared-antenna */
- if (btc->cx.bt0.link_info.profile_cnt.now == 0)
+ if (btc->cx.bt0.link_info.link_cnt.now == 0)
_set_policy(rtwdev,
BTC_CXP_OFFE_DEF2, BTC_ACT_WL_2G_GO);
else
@@ -6247,7 +6247,7 @@ static void _action_wl_2g_nan(struct rtw89_dev *rtwdev)
_set_ant(rtwdev, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
if (btc->ant_type == BTC_ANT_SHARED) { /* shared-antenna */
- if (btc->cx.bt0.link_info.profile_cnt.now == 0)
+ if (btc->cx.bt0.link_info.link_cnt.now == 0)
_set_policy(rtwdev,
BTC_CXP_OFFE_DEF2, BTC_ACT_WL_2G_NAN);
else
@@ -7742,6 +7742,273 @@ static bool _chk_wl_rfk_request(struct rtw89_dev *rtwdev)
return false;
}
+static void _set_bind_info(struct rtw89_btc *btc, u8 type)
+{
+ struct rtw89_btc_cx *cx = &btc->cx;
+ struct rtw89_btc_dm *dm = &btc->dm;
+ struct rtw89_btc_wl_info *wl = &cx->wl;
+ struct rtw89_btc_bt_info *bt = &cx->bt0;
+ struct rtw89_btc_bt_link_info *b;
+ struct rtw89_btc_bind_info *bd;
+ u8 path_hwb[BTC_RF_NUM] = {RTW89_PHY_0, RTW89_PHY_1};
+ u8 link_weight[BTC_ALL_BT_EZL][BTC_BT_BMAX];
+ u8 map[BTC_RF_NUM][BTC_ALL_BT_EZL];
+ u8 b2g_score = 0, b5g_score = 0;
+ u8 i, j, rf_band_map, thres;
+ u8 weight[BTC_BT_BMAX] = {};
+
+ if (type == BTC_MECH_TDD) {
+ bd = &dm->tdd_bind;
+ memcpy(map, dm->tdd_map, sizeof(map));
+ thres = 30; /* BT profile score threshold for TDMA */
+ } else {
+ bd = &dm->fdd_bind;
+ memcpy(map, dm->fdd_map, sizeof(map));
+ thres = 5;
+ }
+
+ memset(bd, 0, sizeof(*bd));
+ /* compare BT 2GHz/5GHz profile by link-weighting */
+ for (i = 0; i < BTC_BT_BMAX; i++) {
+ link_weight[BTC_BT_1ST][i] = cx->bt0.link_weight[i];
+ link_weight[BTC_BT_2ND][i] = cx->bt1.link_weight[i];
+ link_weight[BTC_BT_EXT][i] = cx->bt_ext.link_weight[i];
+ }
+
+ /*
+ * get 2GHz/5GHz link weight score by "band-overlap" map
+ * link_weight from _update_bt_link_cnt(),
+ * if link_weight >30 --> TDMA-required
+ */
+ for (j = 0; j < BTC_ALL_BT_EZL; j++) {
+ rf_band_map = map[BTC_RF_S0][j] | map[BTC_RF_S1][j];
+ if (rf_band_map & BIT(RTW89_BAND_2G))
+ b2g_score += link_weight[j][BTC_BT_B2G];
+ if (rf_band_map & BIT(RTW89_BAND_5G))
+ b5g_score += link_weight[j][BTC_BT_B5G];
+ }
+
+ /* rf-band bound by comparing link weight */
+ if (b2g_score == 0 && b5g_score == 0) /* no-rf-band overlap */
+ bd->rf_band = 0;
+ else if (b5g_score > b2g_score)
+ bd->rf_band = BIT(BTC_BT_B5G);
+ else
+ bd->rf_band = BIT(BTC_BT_B2G);
+
+ /*
+ * if MR_WTYPE_MLD2L1R_NONMLD, FW will change 2+0/0+2/1+1
+ * Therefore, BTC_MLO_RF_xxx is not real-time state.
+ * In this case, RF_S0->HWB0, RF_S1->HWB1
+ * If link-mode change by _ntfy_generic(BTC_GNTFY_MRCX_INFO)
+ * HW-Band is decided by wl->mlo_info.mrcx_act_hwb_map
+ */
+ if (wl->mlo_info.wtype == RTW89_MR_WTYPE_MLD2L1R_NONMLD) {
+ /* TODO: Should patched WiFi mode & WiFi role patch */
+ } else {
+ /*
+ * Dual-RF_band(HWB)TDMA if BT-profile is TDMA-type at both
+ * 2GHz and 5GHz.
+ * ex: 1+1: HWB0 5GHz + BT0 5GHz (BIS, HDT)
+ * && HWB1 2.4GHz + BT1 2.4GHz(PAN)
+ * for TDD: the link score must > 30 (from _bt_link_cnt)
+ * for FDD: the link score must > 5 (bt enable)
+ */
+ if ((wl->mlo_info.rf_combination == BTC_MLO_RF_1_PLUS_1 ||
+ wl->mlo_info.rf_combination == BTC_MLO_RF_2_PLUS_2) &&
+ (b2g_score >= thres && b5g_score >= thres)) {
+ bd->rf_band = BIT(BTC_BT_B2G) | BIT(BTC_BT_B5G);
+ }
+
+ if (wl->mlo_info.rf_combination == BTC_MLO_RF_2_PLUS_0)
+ path_hwb[BTC_RF_S1] = RTW89_PHY_0; /* 2+0 RF-S0/1->HWB0 */
+ else if (wl->mlo_info.rf_combination == BTC_MLO_RF_0_PLUS_2)
+ path_hwb[BTC_RF_S0] = RTW89_PHY_1; /* 2+0 RF-S0/1->HWB1 */
+ }
+
+ /* Get HWB-sel and BT-sel by rf-band-binding */
+ for (i = 0; i < BTC_RF_NUM; i++) {
+ for (j = 0; j < BTC_ALL_BT_EZL; j++) {
+ if (!(map[i][j] & bd->rf_band)) /* no-overlap */
+ continue;
+
+ bd->wl_hwb_sel |= BIT(path_hwb[i]);
+ bd->bt_sel |= BIT(j);
+ }
+ }
+
+ /* TODO: Should patched WiFi mode & WiFi role patch */
+
+ /* update Bind-BT status map for BT0/BT1 */
+ for (i = BTC_BT_1ST; i < BTC_ALL_BT_EZL; i++) {
+ if (!(bd->bt_sel & BIT(i)))
+ continue;
+
+ for (j = BTC_BT_B2G; j <= BTC_BT_B5G; j++) {
+ if (!(bd->rf_band & BIT(j)))
+ continue;
+
+ if (i == BTC_BT_EXT) {
+ bd->bt_profile |= cx->bt_ext.profile_map[j];
+ weight[j] = cx->bt_ext.link_weight[j];
+ if (weight[j] > bd->bt_link_weight) /* max */
+ bd->bt_link_weight = weight[j];
+ continue;
+ } else if (i == BTC_BT_1ST) {
+ bt = &cx->bt0;
+ } else {
+ bt = &cx->bt1;
+ }
+
+ if (j == BTC_BT_B2G)
+ b = &bt->link_info;
+ else
+ b = &bt->link_info_56g;
+
+ bd->bt_profile |= b->status.map.profile_map;
+ bd->bt_smap.a2dp_active |= b->a2dp_desc.active;
+ bd->bt_smap.a2dp_sink |= b->a2dp_desc.sink;
+ bd->bt_smap.pan_active |= b->pan_desc.active;
+ bd->bt_smap.connect |= b->status.map.connect;
+ bd->bt_smap.hid_cnt += (u8)b->hid_desc.pair_cnt;
+ bd->bt_smap.hid_type |= b->hid_desc.type;
+ bd->bt_smap.cis_cnt += (u8)b->leaudio_desc.cis_cnt;
+ bd->bt_smap.link_cnt += b->link_cnt.now;
+ bd->bt_smap.inq_page |= b->status.map.inq_pag;
+ bd->bt_smap.page |= b->pag;
+
+ if (bt->link_weight[j] > bd->bt_link_weight) /* max */
+ bd->bt_link_weight = bt->link_weight[j];
+
+ if (b->slave_role)
+ bd->bt_smap.slave_role = b->slave_role;
+
+ if (b->a2dp_desc.vendor_id != 0)
+ bd->bt_smap.a2dp_vendor_id =
+ b->a2dp_desc.vendor_id;
+ }
+ }
+
+ if (bd->bt_profile & BTC_BT_HFP)
+ bd->bt_smap.hfp_exist = 1;
+ if (bd->bt_profile & BTC_BT_HID)
+ bd->bt_smap.hid_exist = 1;
+ if (bd->bt_profile & BTC_BT_A2DP)
+ bd->bt_smap.a2dp_exist = 1;
+ if (bd->bt_profile & BTC_BT_PAN)
+ bd->bt_smap.pan_exist = 1;
+ if (bd->bt_profile & BTC_BT_BIS)
+ bd->bt_smap.bis_exist = 1;
+ if (bd->bt_profile & BTC_BT_CIS)
+ bd->bt_smap.cis_exist = 1;
+ if (bd->bt_profile & BTC_BT_THREAD)
+ bd->bt_smap.thread_exist = 1;
+ if (bd->bt_profile & BTC_BT_ULL)
+ bd->bt_smap.ull_exist = 1;
+}
+
+#define _bind_is_btonly 0x7
+static void _set_coex_binding(struct rtw89_btc *btc)
+{
+ struct rtw89_btc_cx *cx = &btc->cx;
+ struct rtw89_btc_extsoc_info *bt2 = &cx->bt_ext;
+ struct rtw89_btc_bt_info *bt0 = &cx->bt0;
+ struct rtw89_btc_bt_info *bt1 = &cx->bt1;
+ struct rtw89_btc_wl_info *wl = &cx->wl;
+ struct rtw89_btc_dm *dm = &btc->dm;
+ u8 path_hwb[BTC_RF_NUM] = {RTW89_PHY_0, RTW89_PHY_1};
+ u8 wl_rf_band[RTW89_BAND_NUM] = {};
+ u8 i, j, val = 0;
+
+ /*
+ * sit_xmap(Space-Interaction) = ant_xmap | xtk_xmap
+ * 1: WL-BT space-interference, always 1 if BTG/BTA/SPDT = 1
+ * if dedicated-ant, it may be 1 if BT-Tx is bigger than WL-Rx(xtk_xmap)
+ *
+ * ant_xmap(ANT-Division-Multiplexing)
+ * ==> dedicated-ant->0, BTG/BTA/SPDT->1
+ *
+ * xtk_xmap(Cross-talk map)-> calculate WL/BT interference by SIR
+ * ==> 1: interference, 0: no-interference
+ *
+ * fdm_map(Frequency-Division-Multiplexing): WL/BT RF_Band overlap-map
+ * 2bit-map: bit[1]:5GHz/6GHz, bit[0]:2.4GHz
+ */
+ for (i = 0; i < RTW89_PHY_NUM; i++) {
+ if (wl->rf_band_map[i] & BIT(RTW89_BAND_2G))
+ wl_rf_band[i] |= BIT(RTW89_BAND_2G);
+
+ if (wl->rf_band_map[i] & (BIT(RTW89_BAND_5G) | BIT(RTW89_BAND_6G)))
+ wl_rf_band[i] |= BIT(RTW89_BAND_5G);
+
+ dm->fit_xmap[i][BTC_BT_1ST] = wl_rf_band[i] & bt0->rf_band_map;
+ dm->fit_xmap[i][BTC_BT_2ND] = wl_rf_band[i] & bt1->rf_band_map;
+ dm->fit_xmap[i][BTC_BT_EXT] = wl_rf_band[i] & bt2->rf_band_map;
+ }
+
+ /*
+ * if MR_WTYPE_MLD2L1R_NONMLD, FW will change 2+0/0+2/1+1
+ * Therefore, BTC_MLO_RF_xxx is not real-time state.
+ * if link mode change by _ntfy_generic(BTC_GNTFY_MRCX_INFO)
+ * the HW-BAND is decided by wl->mlo_info.mrcx_act_hwb_map
+ * In this case, BTC_RF_S0->HWB0, BTC_RF_S1->HWB1
+ */
+ if (wl->mlo_info.wtype == RTW89_MR_WTYPE_MLD2L1R_NONMLD) {
+ if (wl->role_info.link_mode != BTC_WLINK_2G_MCC ||
+ wl->role_info.link_mode != BTC_WLINK_25G_MCC ||
+ wl->role_info.link_mode != BTC_WLINK_25G_DBCC) {/* mode chg */
+ if (wl->mlo_info.mrcx_act_hwb_map == BIT(RTW89_PHY_1))
+ path_hwb[BTC_RF_S0] = RTW89_PHY_1;/* S0/1->HWB1 */
+ else
+ path_hwb[BTC_RF_S1] = RTW89_PHY_0;/* S0/1->HWB0 */
+ }
+ } else {
+ if (wl->mlo_info.rf_combination == BTC_MLO_RF_2_PLUS_0)
+ path_hwb[BTC_RF_S1] = RTW89_PHY_0; /* 2+0 RF-S0/1->HWB0 */
+ else if (wl->mlo_info.rf_combination == BTC_MLO_RF_0_PLUS_2)
+ path_hwb[BTC_RF_S0] = RTW89_PHY_1; /* 2+0 RF-S0/1->HWB1 */
+ }
+
+ /*
+ * tdd_map = sit_xmap * fdm_map, 1: WL-RF-Sx vs. BTx take TDD-Action
+ * fdd_map =(!sit_xmap) * fdm_map, 1: WL-RF-Sx vs.BTx take FDD-Action
+ * co-rx map = ant_xmap * fdm_map 1:WL/BT co-rx (for halbb-btg-ctrl)
+ * sit_xmap,ant_xmap = 0 or 1, so tdd/fdd use multiplication (*)
+ */
+
+ for (i = 0; i < BTC_RF_NUM; i++)
+ for (j = 0; j < BTC_ALL_BT_EZL; j++) {
+ dm->tdd_map[i][j] = dm->sit_xmap[i][j] *
+ dm->fit_xmap[path_hwb[i]][j];
+ dm->fdd_map[i][j] = !dm->sit_xmap[i][j] *
+ dm->fit_xmap[path_hwb[i]][j];
+ dm->corx_map[i][j] = dm->ant_xmap[i][j] *
+ dm->fit_xmap[path_hwb[i]][j];
+ }
+
+ /* TDD-Binding */
+ _set_bind_info(btc, BTC_MECH_TDD);
+
+ /* FDD-Binding */
+ _set_bind_info(btc, BTC_MECH_FDD);
+
+ dm->out_of_band = !dm->tdd_bind.rf_band && !dm->fdd_bind.rf_band;
+ dm->fdd_en = !!dm->fdd_bind.rf_band;
+ dm->tdd_en = !!dm->tdd_bind.rf_band;
+
+ /* set BT on/off state for GNT_WL Combined-MUX control */
+ if (bt0->enable.now)
+ val |= BIT(0);
+
+ if (bt1->enable.now)
+ val |= BIT(1);
+
+ if (bt2->func_type)
+ val |= BIT(2);
+
+ dm->ost_info.bt_enable_state = dm->bt_only ? _bind_is_btonly : val;
+}
+
static
void _run_coex(struct rtw89_dev *rtwdev, enum btc_reason_and_action reason)
{
@@ -7842,6 +8109,8 @@ void _run_coex(struct rtw89_dev *rtwdev, enum btc_reason_and_action reason)
bt->scan_rx_low_pri = false;
igno_bt = false;
+ _set_coex_binding(btc);
+
dm->freerun_chk = _check_freerun(rtwdev); /* check if meet freerun */
if (always_freerun) {
@@ -8370,8 +8639,8 @@ static void _update_bt_info(struct rtw89_dev *rtwdev, u8 *buf, u32 len)
"[BTC], %s(): bt_info[2]=0x%02x\n",
__func__, bt->raw_info[2]);
- b->profile_cnt.last = b->profile_cnt.now;
- b->profile_cnt.now = 0;
+ b->link_cnt.last = b->link_cnt.now;
+ b->link_cnt.now = 0;
hid->type = 0;
/* parse raw info low-Byte2 */
@@ -8384,13 +8653,13 @@ static void _update_bt_info(struct rtw89_dev *rtwdev, u8 *buf, u32 len)
bt->bcnt[BTC_BCNT_INQPAG] += !!(bt->inq_pag.now && !bt->inq_pag.last);
hfp->exist = btinfo.lb2.hfp;
- b->profile_cnt.now += (u8)hfp->exist;
+ b->link_cnt.now += (u8)hfp->exist;
hid->exist = btinfo.lb2.hid;
- b->profile_cnt.now += (u8)hid->exist;
+ b->link_cnt.now += (u8)hid->exist;
a2dp->exist = btinfo.lb2.a2dp;
- b->profile_cnt.now += (u8)a2dp->exist;
+ b->link_cnt.now += (u8)a2dp->exist;
pan->exist = btinfo.lb2.pan;
- b->profile_cnt.now += (u8)pan->exist;
+ b->link_cnt.now += (u8)pan->exist;
btc->dm.trx_info.bt_profile = u32_get_bits(btinfo.val, BT_PROFILE_PROTOCOL_MASK);
/* parse raw info low-Byte3 */
@@ -9418,7 +9687,7 @@ static int _show_bt_info(struct rtw89_dev *rtwdev, char *buf, size_t bufsz)
p += scnprintf(p, end - p, " %-15s : profile:%s%s%s%s%s ",
"[profile]",
- (bt_linfo->profile_cnt.now == 0) ? "None," : "",
+ (bt_linfo->link_cnt.now == 0) ? "None," : "",
bt_linfo->hfp_desc.exist ? "HFP," : "",
bt_linfo->hid_desc.exist ? "HID," : "",
bt_linfo->a2dp_desc.exist ?
@@ -9520,7 +9789,7 @@ static int _show_bt_info(struct rtw89_dev *rtwdev, char *buf, size_t bufsz)
p += scnprintf(p, end - p, "\n");
}
- if (ver_main >= 9 && bt_linfo->profile_cnt.now)
+ if (ver_main >= 9 && bt_linfo->link_cnt.now)
rtw89_btc_fw_en_rpt(rtwdev, RPT_EN_BT_TX_PWR_LVL, true);
else
rtw89_btc_fw_en_rpt(rtwdev, RPT_EN_BT_TX_PWR_LVL, false);
@@ -9542,7 +9811,7 @@ static int _show_bt_info(struct rtw89_dev *rtwdev, char *buf, size_t bufsz)
}
p += scnprintf(p, end - p, "\n");
- if (bt_linfo->profile_cnt.now || bt_linfo->status.map.ble_connect)
+ if (bt_linfo->link_cnt.now || bt_linfo->status.map.ble_connect)
rtw89_btc_fw_en_rpt(rtwdev, RPT_EN_BT_AFH_MAP, true);
else
rtw89_btc_fw_en_rpt(rtwdev, RPT_EN_BT_AFH_MAP, false);
diff --git a/drivers/net/wireless/realtek/rtw89/core.h b/drivers/net/wireless/realtek/rtw89/core.h
index 3f77707e2733..21bdf229723c 100644
--- a/drivers/net/wireless/realtek/rtw89/core.h
+++ b/drivers/net/wireless/realtek/rtw89/core.h
@@ -1445,6 +1445,11 @@ enum rtw89_btc_bt_state_cnt {
BTC_BCNT_NUM,
};
+enum rtw89_btc_bt_mech_type {
+ BTC_MECH_TDD = 0,
+ BTC_MECH_FDD = 1,
+};
+
enum rtw89_btc_bt_rf_band {
BTC_BT_B2G = 0x0, /* 2.4GHz */
BTC_BT_B5G = 0x1, /* 5GHz or 6GHz */
@@ -1463,6 +1468,12 @@ enum rtw89_btc_bt_profile {
BTC_BT_HID = BIT(1),
BTC_BT_A2DP = BIT(2),
BTC_BT_PAN = BIT(3),
+ BTC_BT_BIS = BIT(4),
+ BTC_BT_CIS = BIT(5),
+ BTC_BT_THREAD = BIT(6),
+ BTC_BT_ULL = BIT(7),
+ BTC_BT_LEGACY = 0xf,
+ BTC_BT_FULL = 0x3f,
BTC_PROFILE_MAX = 4,
};
@@ -1688,16 +1699,16 @@ struct rtw89_btc_bt_ver_info {
};
struct rtw89_btc_bool_sta_chg {
- u32 now: 1;
- u32 last: 1;
- u32 remain: 1;
- u32 srvd: 29;
+ u8 now: 1;
+ u8 last: 1;
+ u8 remain: 1;
+ u8 srvd: 5;
};
struct rtw89_btc_u8_sta_chg {
u8 now;
u8 last;
- u8 remain;
+ u8 chg;
u8 rsvd;
};
@@ -1956,6 +1967,8 @@ struct rtw89_btc_bt_smap {
u32 sco_busy: 1;
u32 mesh_busy: 1;
u32 inq_pag: 1;
+ u32 profile_map: 8;
+ u32 rsvd: 18;
};
union rtw89_btc_bt_state_map {
@@ -1974,14 +1987,30 @@ struct rtw89_btc_bt_txpwr_desc {
u8 le_gain_index;
};
+struct rtw89_btc_bt_leaudio_desc {
+ u32 bis_exist: 1;
+ u32 bis_exist_last: 1;
+ u32 cis_exist: 1;
+ u32 cis_exist_last: 1;
+ u32 bis_cnt: 3;
+ u32 cis_cnt: 3;
+ u32 rssi: 8;
+ u32 bis_cnt_last: 3;
+ u32 cis_cnt_last: 3;
+ u32 rsvd: 8;
+
+ u16 diff_t;
+};
+
struct rtw89_btc_bt_link_info {
- struct rtw89_btc_u8_sta_chg profile_cnt;
+ struct rtw89_btc_u8_sta_chg link_cnt;
struct rtw89_btc_bool_sta_chg multi_link;
struct rtw89_btc_bool_sta_chg relink;
struct rtw89_btc_bt_hfp_desc hfp_desc;
struct rtw89_btc_bt_hid_desc hid_desc;
struct rtw89_btc_bt_a2dp_desc a2dp_desc;
struct rtw89_btc_bt_pan_desc pan_desc;
+ struct rtw89_btc_bt_leaudio_desc leaudio_desc;
union rtw89_btc_bt_state_map status;
struct rtw89_btc_bt_txpwr_desc bt_txpwr_desc;
@@ -1990,14 +2019,59 @@ struct rtw89_btc_bt_link_info {
u8 rssi_state[BTC_BT_RSSI_THMAX];
u8 afh_map[BTC_BT_AFH_GROUP];
u8 afh_map_le[BTC_BT_AFH_LE_GROUP];
+ u8 rssi;
+
+ u8 role_sw: 1;
+ u8 slave_role: 1;
+ u8 afh_update: 1;
+ u8 cqddr: 1;
+ u8 tx_3m: 1;
+ u8 inq: 1;
+ u8 pag: 1;
+ u8 igno_wl: 1;
+
+ u8 ble_scan_en: 1;
+ u8 reinit: 1;
+ u8 rsvd: 6;
+};
- u32 role_sw: 1;
- u32 slave_role: 1;
- u32 afh_update: 1;
- u32 cqddr: 1;
- u32 rssi: 8;
- u32 tx_3m: 1;
- u32 rsvd: 19;
+struct rtw89_btc_bind_bt_status {
+ u8 a2dp_active: 1;
+ u8 a2dp_sink: 1;
+ u8 pan_active: 1;
+ u8 connect: 1;
+ u8 inq_page: 1;
+ u8 multi_link: 1;
+ u8 slave_role: 1;
+ u8 page: 1;
+
+ u8 hfp_exist: 1;
+ u8 hid_exist: 1;
+ u8 a2dp_exist: 1;
+ u8 pan_exist: 1;
+ u8 bis_exist: 1;
+ u8 cis_exist: 1;
+ u8 thread_exist: 1;
+ u8 ull_exist: 1;
+
+ u8 hid_cnt;
+ u8 hid_type;
+ u8 cis_cnt;
+ u8 link_cnt;
+
+ u16 a2dp_vendor_id;
+};
+
+struct rtw89_btc_bind_info {
+ u8 wl_hwb_sel; /* map */
+ u8 wl_link_mode;
+ u8 wl_bg_mode;
+ u8 rf_band; /* map, 0: no any rf-band bind */
+ u8 bt_sel; /* map */
+ u8 bt_link_weight; /* select the highest weight between bt/rf-band */
+
+ u32 bt_profile; /* map */
+ struct rtw89_btc_bind_bt_status bt_smap;
};
struct rtw89_btc_extsoc_info {
@@ -2105,6 +2179,7 @@ struct rtw89_btc_wl_info {
u8 coex_mode;
u8 pta_req_mac;
u8 bt_polut_type[RTW89_PHY_NUM]; /* BT polluted WL-Tx type for phy0/1 */
+ u8 rf_band_map[RTW89_PHY_NUM]; /* rf_band bit-map */
bool is_5g_hi_channel;
bool go_client_exist;
@@ -2291,6 +2366,7 @@ union rtw89_btc_fbtc_btscan {
struct rtw89_btc_bt_info {
struct rtw89_btc_bt_link_info link_info;
+ struct rtw89_btc_bt_link_info link_info_56g;
struct rtw89_btc_bt_scan_info_v1 scan_info_v1[BTC_SCAN_MAX1];
struct rtw89_btc_bt_scan_info_v2 scan_info_v2[CXSCAN_MAX];
struct rtw89_btc_bt_ver_info ver_info;
@@ -2301,6 +2377,7 @@ struct rtw89_btc_bt_info {
u8 raw_info[BTC_BTINFO_MAX]; /* raw bt info from mailbox */
u8 txpwr_info[BTC_BTINFO_MAX];
+ u8 link_weight[BTC_BT_BMAX]; /* Link Weight for RF-band/HWB selection */
u8 rssi_level;
u8 rf_band_map;
u8 func_type;
@@ -3178,6 +3255,7 @@ struct rtw89_btc_fbtc_outsrc_set_info {
u8 pta_req_hw_band;
u8 rf_gbt_source;
+ u8 bt_enable_state;
} __packed;
union rtw89_btc_fbtc_slot_u {
@@ -3200,8 +3278,20 @@ struct rtw89_btc_dm {
struct rtw89_btc_wl_scc_ctrl wl_scc;
struct rtw89_btc_trx_info trx_info;
union rtw89_btc_dm_error_map error;
+ struct rtw89_btc_bind_info tdd_bind;
+ struct rtw89_btc_bind_info fdd_bind;
u32 cnt_dm[BTC_DCNT_NUM];
u32 cnt_notify[BTC_NCNT_NUM];
+ u8 ant_xmap[BTC_RF_NUM][BTC_ALL_BT_EZL]; /* WL-BT ANT interact-map */
+ u8 xtk_xmap[BTC_RF_NUM][BTC_ALL_BT_EZL]; /* 1: If RSSI<(BT-Pin -SIR) */
+ u8 sit_xmap[BTC_RF_NUM][BTC_ALL_BT_EZL]; /* WL-BT space interact-map */
+ u8 fit_xmap[RTW89_PHY_NUM][BTC_ALL_BT_EZL]; /* HWB-BT freq interact-map */
+ u8 tdd_map[BTC_RF_NUM][BTC_ALL_BT_EZL]; /* WL-BT tdd-map */
+ u8 fdd_map[BTC_RF_NUM][BTC_ALL_BT_EZL]; /* WL-BT fdd-map */
+ u8 corx_map[BTC_RF_NUM][BTC_ALL_BT_EZL]; /* WL-BT Co-Rx */
+
+ u8 sit_xmap_last[BTC_RF_NUM][BTC_ALL_BT_EZL];
+ u8 fit_xmap_last[RTW89_PHY_NUM][BTC_ALL_BT_EZL];
u32 update_slot_map;
u32 set_ant_path;
@@ -3239,9 +3329,12 @@ struct rtw89_btc_dm {
u8 freerun_chk: 1;
u8 wl_pre_agc_rb: 2;
u8 bt_select: 2; /* 0:s0, 1:s1, 2:s0 & s1, refer to enum btc_bt_index */
+
u8 slot_req_more: 1;
+ u8 out_of_band: 1;
+ u8 fdd_en: 1;
+ u8 tdd_en: 1;
u8 lps_ctrl_scbd: 1;
-
u8 lps_ctrl_scbd_last: 1;
u8 lps_ctrl_change: 1;
};
--
2.25.1
^ permalink raw reply related
* [PATCH rtw-next 5/9] wifi: rtw89: coex: Add Bluetooth binding for Bluetooth RX gain setting
From: Ping-Ke Shih @ 2026-07-03 11:43 UTC (permalink / raw)
To: linux-wireless; +Cc: ku920601
In-Reply-To: <20260703114311.2609942-1-pkshih@realtek.com>
From: Ching-Te Ku <ku920601@realtek.com>
Dual Bluetooth the each of Bluetooth may use different RX gain by their
condition.
Signed-off-by: Ching-Te Ku <ku920601@realtek.com>
Signed-off-by: Ping-Ke Shih <pkshih@realtek.com>
---
drivers/net/wireless/realtek/rtw89/coex.c | 86 ++++++++++++++++++-----
1 file changed, 68 insertions(+), 18 deletions(-)
diff --git a/drivers/net/wireless/realtek/rtw89/coex.c b/drivers/net/wireless/realtek/rtw89/coex.c
index 2080253559a7..ff3c05101ab3 100644
--- a/drivers/net/wireless/realtek/rtw89/coex.c
+++ b/drivers/net/wireless/realtek/rtw89/coex.c
@@ -730,6 +730,7 @@ enum btc_w2b_scoreboard {
BTC_WSCB_SCAN = BIT(2),
BTC_WSCB_UNDERTEST = BIT(3),
BTC_WSCB_RXGAIN = BIT(4),
+ BTC_WSCB_5GHICH = BIT(6),
BTC_WSCB_WLBUSY = BIT(7),
BTC_WSCB_EXTFEM = BIT(8),
BTC_WSCB_TDMA = BIT(9),
@@ -738,6 +739,9 @@ enum btc_w2b_scoreboard {
BTC_WSCB_RXSCAN_PRI = BIT(12),
BTC_WSCB_BT_HILNA = BIT(13),
BTC_WSCB_BTLOG = BIT(14),
+ BTC_WSCB_CTCODE = BIT(15),
+ BTC_WSCB_RXGAIN_56G = BIT(16),
+ BTC_WSCB_BT_HILNA_56G = BIT(17),
BTC_WSCB_ALL = GENMASK(23, 0),
};
@@ -3224,33 +3228,79 @@ static void _set_bt_tx_power(struct rtw89_dev *rtwdev, bool force_exec, u8 bid,
}
#define BTC_BT_RX_NORMAL_LVL 7
-
-static void _set_bt_rx_gain(struct rtw89_dev *rtwdev, u8 level)
+static void _set_bt_rx_gain(struct rtw89_dev *rtwdev, bool force_exec, u8 bid,
+ u8 rf_band, u8 level)
{
struct rtw89_btc *btc = &rtwdev->btc;
- struct rtw89_btc_bt_info *bt = &btc->cx.bt0;
+ struct rtw89_btc_cx *cx = &btc->cx;
+ struct rtw89_btc_bt_info *bt = &cx->bt0;
+ u8 h2c_func = SET_BT_LNA_CONSTRAIN;
+ u8 i, id_start, id_stop;
+ bool state = false;
+ u32 scbd_bit = 0;
+ u8 buf[2] = {};
+ u8 len = sizeof(*buf);
- if (bt->bcnt[BTC_BCNT_INFOUPDATE] == 0)
+ if (bt->bcnt[BTC_BCNT_INFOUPDATE] == 0 || !rf_band)
return;
- if ((bt->rf_para.rx_gain_freerun == level ||
- level > BTC_BT_RX_NORMAL_LVL) &&
- (!rtwdev->chip->scbd || bt->lna_constrain == level))
+ if (bt->rf_para.rx_gain_freerun == level ||
+ level > BTC_BT_RX_NORMAL_LVL || !rtwdev->chip->scbd ||
+ bid > BTC_ALL_BT)
return;
- bt->rf_para.rx_gain_freerun = level;
- btc->dm.rf_trx_para.bt_rx_gain[BTC_BT_1ST] = level;
-
- rtw89_debug(rtwdev, RTW89_DBG_BTC,
- "[BTC], %s(): level = %d\n",
- __func__, level);
+ if (bid == BTC_ALL_BT) {
+ id_start = BTC_BT_1ST;
+ id_stop = BTC_BT_2ND;
+ } else {
+ id_start = bid;
+ id_stop = bid;
+ }
- if (level == BTC_BT_RX_NORMAL_LVL)
- _write_scbd(rtwdev, BTC_WSCB_RXGAIN, false);
+ if (rf_band == RTW89_BAND_2G)
+ scbd_bit |= BTC_WSCB_RXGAIN;
else
- _write_scbd(rtwdev, BTC_WSCB_RXGAIN, true);
+ scbd_bit |= BTC_WSCB_RXGAIN_56G;
+
+ for (i = id_start; i <= id_stop; i++) {
+ if (i == BTC_BT_2ND) {
+ if (!(rtwdev->chip->para_ver & BTC_FEAT_DUAL_BT))
+ continue;
+
+ bt = &cx->bt1;
+ h2c_func |= BT_H2C_FUNC_BT2ND;
+ }
+
+ /* return if same setup */
+ if (!force_exec && !btc->cli_h2c_cmd) {
+ if (rf_band == RTW89_BAND_2G &&
+ bt->lna_constrain == level)
+ continue;
+ else if (rf_band != RTW89_BAND_2G &&
+ bt->lna_constrain_6g == level)
+ continue;
+ }
+
+ buf[0] = level;
+ buf[1] = rf_band;
+
+ if (rtwdev->chip->chip_gen == RTW89_CHIP_AX)
+ len = SET_RF_PARA_AX_LEN;
+
+ if (_send_fw_cmd(rtwdev, BTFC_SET, h2c_func, buf, len)) {
+ rtw89_debug(rtwdev, RTW89_DBG_BTC,
+ "[BTC], %s(): bt%d_rx_gain_level = %d\n",
+ __func__, i, level);
+ }
+
+ btc->dm.rf_trx_para.bt_rx_gain[i] = level;
+
+ if (buf[0] != BTC_BT_RX_NORMAL_LVL)
+ state = true;
+
+ _write_scbd(rtwdev, scbd_bit, state);
+ }
- _send_fw_cmd(rtwdev, BTFC_SET, SET_BT_LNA_CONSTRAIN, &level, sizeof(level));
}
static void _set_rf_trx_para(struct rtw89_dev *rtwdev)
@@ -3361,7 +3411,7 @@ static void _set_rf_trx_para(struct rtw89_dev *rtwdev)
_set_wl_tx_power(rtwdev, para.wl_tx_power[RTW89_PHY_0], RTW89_PHY_0);
_set_wl_rx_gain(rtwdev, para.wl_rx_gain[RTW89_PHY_0], RTW89_PHY_0);
_set_bt_tx_power(rtwdev, true, bid, rf_band, para.bt_tx_power[BTC_BT_1ST]);
- _set_bt_rx_gain(rtwdev, para.bt_rx_gain[BTC_BT_1ST]);
+ _set_bt_rx_gain(rtwdev, true, bid, rf_band, para.bt_rx_gain[BTC_BT_1ST]);
}
next:
--
2.25.1
^ permalink raw reply related
* [PATCH rtw-next 4/9] wifi: rtw89: coex: Add Bluetooth binding for Bluetooth TX power setting
From: Ping-Ke Shih @ 2026-07-03 11:43 UTC (permalink / raw)
To: linux-wireless; +Cc: ku920601
In-Reply-To: <20260703114311.2609942-1-pkshih@realtek.com>
From: Ching-Te Ku <ku920601@realtek.com>
Dual Bluetooth the each of Bluetooth may use different TX power by their
condition.
Signed-off-by: Ching-Te Ku <ku920601@realtek.com>
Signed-off-by: Ping-Ke Shih <pkshih@realtek.com>
---
drivers/net/wireless/realtek/rtw89/coex.c | 65 ++++++++++++++++++-----
drivers/net/wireless/realtek/rtw89/core.h | 15 ++++--
drivers/net/wireless/realtek/rtw89/fw.h | 3 ++
3 files changed, 67 insertions(+), 16 deletions(-)
diff --git a/drivers/net/wireless/realtek/rtw89/coex.c b/drivers/net/wireless/realtek/rtw89/coex.c
index 14cc62cf399d..2080253559a7 100644
--- a/drivers/net/wireless/realtek/rtw89/coex.c
+++ b/drivers/net/wireless/realtek/rtw89/coex.c
@@ -3078,6 +3078,7 @@ static void _set_bt_ignore_wlan_act(struct rtw89_dev *rtwdev, u8 enable)
#define WL_TX_POWER_FRA_PART GENMASK(1, 0)
#define B_BTC_WL_TX_POWER_SIGN BIT(7)
#define B_TSSI_WL_TX_POWER_SIGN BIT(8)
+#define SET_RF_PARA_AX_LEN 1
static void _set_wl_tx_power(struct rtw89_dev *rtwdev, u32 level, u8 phy_map)
{
@@ -3161,28 +3162,64 @@ static void _set_wl_rx_gain(struct rtw89_dev *rtwdev, u32 level, u8 phy_map)
chip->ops->btc_set_wl_rx_gain(rtwdev, level);
}
-static void _set_bt_tx_power(struct rtw89_dev *rtwdev, u8 level)
+static void _set_bt_tx_power(struct rtw89_dev *rtwdev, bool force_exec, u8 bid,
+ u8 rf_band, u8 level)
{
struct rtw89_btc *btc = &rtwdev->btc;
struct rtw89_btc_bt_info *bt = &btc->cx.bt0;
- int ret;
- u8 buf;
+ u8 h2c_func = SET_BT_TX_PWR;
+ u8 i, id_start, id_stop;
+ u8 buf[2] = {};
+ u8 len = sizeof(*buf);
- if (bt->bcnt[BTC_BCNT_INFOUPDATE] == 0)
+ if (bt->bcnt[BTC_BCNT_INFOUPDATE] == 0 || !rf_band)
return;
if (bt->rf_para.tx_pwr_freerun == level)
return;
- rtw89_debug(rtwdev, RTW89_DBG_BTC,
- "[BTC], %s(): level = %d\n",
- __func__, level);
+ if (bid == BTC_ALL_BT) {
+ id_start = BTC_BT_1ST;
+ id_stop = BTC_BT_2ND;
+ } else {
+ id_start = bid;
+ id_stop = bid;
+ }
- buf = (s8)(-level);
- ret = _send_fw_cmd(rtwdev, BTFC_SET, SET_BT_TX_PWR, &buf, 1);
- if (!ret) {
- bt->rf_para.tx_pwr_freerun = level;
- btc->dm.rf_trx_para.bt_tx_power[BTC_BT_1ST] = level;
+ for (i = id_start; i <= id_stop; i++) {
+ if (i == BTC_BT_2ND) {
+ if (!(rtwdev->chip->para_ver & BTC_FEAT_DUAL_BT))
+ continue;
+
+ bt = &btc->cx.bt1;
+ h2c_func |= BT_H2C_FUNC_BT2ND;
+ }
+
+ buf[0] = (s8)(-level);
+ buf[1] = rf_band; /* bit-map: bit1->5GHz/6Ghz, bit0->2.4GHz */
+
+ if (!force_exec && !btc->cli_h2c_cmd) {
+ if (rf_band == RTW89_BAND_2G &&
+ bt->tx_power_now == level)
+ continue;
+ else if (rf_band != RTW89_BAND_2G &&
+ bt->tx_power_now_6g == level)
+ continue;
+ }
+
+ if (rtwdev->chip->chip_gen == RTW89_CHIP_AX)
+ len = SET_RF_PARA_AX_LEN;
+
+ if (_send_fw_cmd(rtwdev, BTFC_SET, h2c_func, buf, len)) {
+ btc->dm.rf_trx_para.bt_tx_power[i] = level;
+ if (rf_band == RTW89_BAND_2G)
+ bt->tx_power_now = level;
+ else
+ bt->tx_power_now_6g = level;
+ rtw89_debug(rtwdev, RTW89_DBG_BTC,
+ "[BTC], %s(): bt%d_tx_power_level = %d\n",
+ __func__, i, level);
+ }
}
}
@@ -3229,6 +3266,8 @@ static void _set_rf_trx_para(struct rtw89_dev *rtwdev)
struct rtw89_btc_rf_trx_para_v9 para;
u8 lv, link_mode = 0, i, dbcc_2g_phy = 0;
u8 ul_para_num, dl_para_num;
+ u8 rf_band = RTW89_BAND_2G;
+ u8 bid = BTC_BT_1ST;
u32 wl_stb_chg = 0;
if (ver->fwlrole == 0) {
@@ -3321,7 +3360,7 @@ static void _set_rf_trx_para(struct rtw89_dev *rtwdev)
} else {
_set_wl_tx_power(rtwdev, para.wl_tx_power[RTW89_PHY_0], RTW89_PHY_0);
_set_wl_rx_gain(rtwdev, para.wl_rx_gain[RTW89_PHY_0], RTW89_PHY_0);
- _set_bt_tx_power(rtwdev, para.bt_tx_power[BTC_BT_1ST]);
+ _set_bt_tx_power(rtwdev, true, bid, rf_band, para.bt_tx_power[BTC_BT_1ST]);
_set_bt_rx_gain(rtwdev, para.bt_rx_gain[BTC_BT_1ST]);
}
diff --git a/drivers/net/wireless/realtek/rtw89/core.h b/drivers/net/wireless/realtek/rtw89/core.h
index a0f6929873ab..3f77707e2733 100644
--- a/drivers/net/wireless/realtek/rtw89/core.h
+++ b/drivers/net/wireless/realtek/rtw89/core.h
@@ -2302,7 +2302,18 @@ struct rtw89_btc_bt_info {
u8 raw_info[BTC_BTINFO_MAX]; /* raw bt info from mailbox */
u8 txpwr_info[BTC_BTINFO_MAX];
u8 rssi_level;
+ u8 rf_band_map;
u8 func_type;
+ u8 tx_power_now;
+ u8 tx_power_now_6g;
+
+ u8 fw_ver_mismatch: 1;
+ u8 band_56G_support: 1;
+ u8 hi_lna_rx: 1;
+ u8 lna_constrain: 3;
+ u8 hi_lna_rx_6g: 1;
+ u8 lna_constrain_6g: 3;
+ u8 rsvd: 6;
u32 scbd;
u32 feature;
@@ -2316,11 +2327,9 @@ struct rtw89_btc_bt_info {
u32 inq: 1;
u32 pag: 1;
u32 run_patch_code: 1;
- u32 hi_lna_rx: 1;
u32 scan_rx_low_pri: 1;
u32 scan_info_update: 1;
- u32 lna_constrain: 3;
- u32 rsvd: 17;
+ u32 rsvd1: 22;
u32 bcnt[BTC_BCNT_NUM];
};
diff --git a/drivers/net/wireless/realtek/rtw89/fw.h b/drivers/net/wireless/realtek/rtw89/fw.h
index de8b77de8705..a6f3b28b9e33 100644
--- a/drivers/net/wireless/realtek/rtw89/fw.h
+++ b/drivers/net/wireless/realtek/rtw89/fw.h
@@ -2337,6 +2337,9 @@ struct rtw89_h2c_arp_offload {
#define RTW89_H2C_ARP_OFFLOAD_W0_PKT_ID GENMASK(31, 24)
#define RTW89_H2C_ARP_OFFLOAD_W1_CONTENT GENMASK(31, 0)
+#define BT_H2C_FUNC_BT2ND 0x80
+#define BT_C2H_FUNC_BT2ND 0x80
+
enum rtw89_btc_btf_h2c_class {
BTFC_SET = 0x10,
BTFC_GET = 0x11,
--
2.25.1
^ permalink raw reply related
* [PATCH rtw-next 3/9] wifi: rtw89: coex: Update TDMA descriptor for dual MAC
From: Ping-Ke Shih @ 2026-07-03 11:43 UTC (permalink / raw)
To: linux-wireless; +Cc: ku920601
In-Reply-To: <20260703114311.2609942-1-pkshih@realtek.com>
From: Ching-Te Ku <ku920601@realtek.com>
The mechanism needs information to know which MAC is coexisting with which
Bluetooth and when to enable TDMA with which MAC. So change an variable to
describe the binding target.
Signed-off-by: Ching-Te Ku <ku920601@realtek.com>
Signed-off-by: Ping-Ke Shih <pkshih@realtek.com>
---
drivers/net/wireless/realtek/rtw89/coex.c | 15 ++++++++-------
drivers/net/wireless/realtek/rtw89/core.h | 4 ++--
2 files changed, 10 insertions(+), 9 deletions(-)
diff --git a/drivers/net/wireless/realtek/rtw89/coex.c b/drivers/net/wireless/realtek/rtw89/coex.c
index 196bec751070..14cc62cf399d 100644
--- a/drivers/net/wireless/realtek/rtw89/coex.c
+++ b/drivers/net/wireless/realtek/rtw89/coex.c
@@ -2288,9 +2288,9 @@ static void _append_tdma(struct rtw89_dev *rtwdev)
}
rtw89_debug(rtwdev, RTW89_DBG_BTC,
- "[BTC], %s(): type:%d, rxflctrl=%d, txpause=%d, wtgle_n=%d, leak_n=%d, ext_ctrl=%d\n",
+ "[BTC], %s(): type:%d, rxflctrl=%d, txflctrl=%d, bind=%d, leak_n=%d, ext_ctrl=%d\n",
__func__, dm->tdma.type, dm->tdma.rxflctrl,
- dm->tdma.txpause, dm->tdma.wtgle_n, dm->tdma.leak_n,
+ dm->tdma.txflctrl, dm->tdma.bind, dm->tdma.leak_n,
dm->tdma.ext_ctrl);
}
@@ -3733,7 +3733,8 @@ static bool _check_freerun(struct rtw89_dev *rtwdev)
#define _tdma_set_flctrl(btc, flc) ({(btc)->dm.tdma.rxflctrl = flc; })
#define _tdma_set_flctrl_role(btc, role) ({(btc)->dm.tdma.rxflctrl_role = role; })
-#define _tdma_set_tog(btc, wtg) ({(btc)->dm.tdma.wtgle_n = wtg; })
+#define _tdma_set_rxflctrl(btc, rxflc) ({(btc)->dm.tdma.rxflctrl = rxflc; })
+#define _tdma_set_txflctrl(btc, txflc) ({(btc)->dm.tdma.txflctrl = txflc; })
#define _tdma_set_lek(btc, lek) ({(btc)->dm.tdma.leak_n = lek; })
struct btc_btinfo_lb2 {
@@ -9967,13 +9968,13 @@ static int _show_fbtc_tdma(struct rtw89_dev *rtwdev, char *buf, size_t bufsz)
p += scnprintf(p, end - p,
" %-15s : ", "[tdma_policy]");
p += scnprintf(p, end - p,
- "type:%d, rx_flow_ctrl:%d, tx_pause:%d, ",
+ "type:%d, rx_flow_ctrl:%d, txflctrl:%d, ",
(u32)t->type,
- t->rxflctrl, t->txpause);
+ t->rxflctrl, t->txflctrl);
p += scnprintf(p, end - p,
- "wl_toggle_n:%d, leak_n:%d, ext_ctrl:%d, ",
- t->wtgle_n, t->leak_n, t->ext_ctrl);
+ "bind:%d, leak_n:%d, ext_ctrl:%d, ",
+ t->bind, t->leak_n, t->ext_ctrl);
p += scnprintf(p, end - p,
"policy_type:%d",
diff --git a/drivers/net/wireless/realtek/rtw89/core.h b/drivers/net/wireless/realtek/rtw89/core.h
index 1e72c9b9f3b7..a0f6929873ab 100644
--- a/drivers/net/wireless/realtek/rtw89/core.h
+++ b/drivers/net/wireless/realtek/rtw89/core.h
@@ -2354,8 +2354,8 @@ struct rtw89_btc_cx {
struct rtw89_btc_fbtc_tdma {
u8 type; /* btc_ver::fcxtdma */
u8 rxflctrl;
- u8 txpause;
- u8 wtgle_n;
+ u8 txflctrl;
+ u8 bind;
u8 leak_n;
u8 ext_ctrl;
u8 rxflctrl_role;
--
2.25.1
^ permalink raw reply related
* [PATCH rtw-next 2/9] wifi: rtw89: coex: add rtw89_btc_init() entry for initialization once
From: Ping-Ke Shih @ 2026-07-03 11:43 UTC (permalink / raw)
To: linux-wireless; +Cc: ku920601
In-Reply-To: <20260703114311.2609942-1-pkshih@realtek.com>
From: Ching-Te Ku <ku920601@realtek.com>
Separate these two type of initialize entry. Because Wi-Fi power save
leaving will also call the initializing, but don't have to reset all the
stored variables.
Signed-off-by: Ching-Te Ku <ku920601@realtek.com>
Signed-off-by: Ping-Ke Shih <pkshih@realtek.com>
---
drivers/net/wireless/realtek/rtw89/coex.c | 35 ++++++++++++++---------
drivers/net/wireless/realtek/rtw89/coex.h | 1 +
drivers/net/wireless/realtek/rtw89/core.c | 1 +
3 files changed, 24 insertions(+), 13 deletions(-)
diff --git a/drivers/net/wireless/realtek/rtw89/coex.c b/drivers/net/wireless/realtek/rtw89/coex.c
index 43de238c18f8..196bec751070 100644
--- a/drivers/net/wireless/realtek/rtw89/coex.c
+++ b/drivers/net/wireless/realtek/rtw89/coex.c
@@ -7858,6 +7858,28 @@ void _run_coex(struct rtw89_dev *rtwdev, enum btc_reason_and_action reason)
_action_common(rtwdev);
}
+void rtw89_btc_init(struct rtw89_dev *rtwdev)
+{
+ const struct rtw89_chip_info *chip = rtwdev->chip;
+ struct rtw89_btc *btc = &rtwdev->btc;
+ struct rtw89_btc_wl_info *wl = &btc->cx.wl;
+ const struct rtw89_btc_ver *ver = btc->ver;
+
+ rtw89_debug(rtwdev, RTW89_DBG_BTC,
+ "[BTC], %s(): Init %s !!\n", __func__,
+ chip_id_str(chip->chip_id));
+
+ _reset_btc_var(rtwdev, BTC_RESET_ALL);
+
+ btc->dm.run_reason = BTC_RSN_NONE;
+ btc->dm.run_action = BTC_ACT_NONE;
+ if (ver->fcxctrl >= 7)
+ btc->ctrl.ctrl_v7.igno_bt = true;
+ else
+ btc->ctrl.ctrl.igno_bt = true;
+ wl->status.map.init_ok = true;
+}
+
void rtw89_btc_ntfy_poweron(struct rtw89_dev *rtwdev)
{
struct rtw89_btc *btc = &rtwdev->btc;
@@ -7941,19 +7963,6 @@ void rtw89_btc_ntfy_init(struct rtw89_dev *rtwdev, u8 mode)
const struct rtw89_chip_info *chip = rtwdev->chip;
const struct rtw89_btc_ver *ver = btc->ver;
- rtw89_debug(rtwdev, RTW89_DBG_BTC,
- "[BTC], %s(): Init %s !!\n", __func__,
- chip_id_str(chip->chip_id));
-
- _reset_btc_var(rtwdev, BTC_RESET_ALL);
- btc->dm.run_reason = BTC_RSN_NONE;
- btc->dm.run_action = BTC_ACT_NONE;
- if (ver->fcxctrl >= 7)
- btc->ctrl.ctrl_v7.igno_bt = true;
- else
- btc->ctrl.ctrl.igno_bt = true;
- wl->status.map.init_ok = true;
-
rtw89_debug(rtwdev, RTW89_DBG_BTC,
"[BTC], %s(): mode=%d\n", __func__, mode);
diff --git a/drivers/net/wireless/realtek/rtw89/coex.h b/drivers/net/wireless/realtek/rtw89/coex.h
index 259c6e2c0e3c..fb151f68eb64 100644
--- a/drivers/net/wireless/realtek/rtw89/coex.h
+++ b/drivers/net/wireless/realtek/rtw89/coex.h
@@ -272,6 +272,7 @@ enum btc_wl_gpio_debug {
BTC_DBG_USER_DEF = 31,
};
+void rtw89_btc_init(struct rtw89_dev *rtwdev);
void rtw89_btc_ntfy_poweron(struct rtw89_dev *rtwdev);
void rtw89_btc_ntfy_poweroff(struct rtw89_dev *rtwdev);
void rtw89_btc_ntfy_init(struct rtw89_dev *rtwdev, u8 mode);
diff --git a/drivers/net/wireless/realtek/rtw89/core.c b/drivers/net/wireless/realtek/rtw89/core.c
index 26b744dfbcf8..85aeb9e90812 100644
--- a/drivers/net/wireless/realtek/rtw89/core.c
+++ b/drivers/net/wireless/realtek/rtw89/core.c
@@ -7488,6 +7488,7 @@ static int rtw89_core_register_hw(struct rtw89_dev *rtwdev)
}
rtw89_rfkill_polling_init(rtwdev);
+ rtw89_btc_init(rtwdev);
return 0;
--
2.25.1
^ permalink raw reply related
* [PATCH rtw-next 1/9] wifi: rtw89: coex: Add Init info version 10
From: Ping-Ke Shih @ 2026-07-03 11:43 UTC (permalink / raw)
To: linux-wireless; +Cc: ku920601
In-Reply-To: <20260703114311.2609942-1-pkshih@realtek.com>
From: Ching-Te Ku <ku920601@realtek.com>
The version 10 Init info add I/O offload type & variable Bluetooth
function (EX: Zigbee/Thread...etc) into the structure definition.
Firmware need to synchronize these information to do corresponding
setting.
Signed-off-by: Ching-Te Ku <ku920601@realtek.com>
Signed-off-by: Ping-Ke Shih <pkshih@realtek.com>
---
drivers/net/wireless/realtek/rtw89/coex.c | 58 +++++++++++++++++--
drivers/net/wireless/realtek/rtw89/coex.h | 6 ++
drivers/net/wireless/realtek/rtw89/core.h | 54 ++++++++++++++++-
drivers/net/wireless/realtek/rtw89/fw.c | 41 +++++++++++++
drivers/net/wireless/realtek/rtw89/fw.h | 6 ++
drivers/net/wireless/realtek/rtw89/rtw8851b.c | 2 -
drivers/net/wireless/realtek/rtw89/rtw8852a.c | 1 -
.../wireless/realtek/rtw89/rtw8852b_common.c | 1 -
drivers/net/wireless/realtek/rtw89/rtw8852c.c | 1 -
drivers/net/wireless/realtek/rtw89/rtw8922a.c | 1 -
10 files changed, 159 insertions(+), 12 deletions(-)
diff --git a/drivers/net/wireless/realtek/rtw89/coex.c b/drivers/net/wireless/realtek/rtw89/coex.c
index 1361d4d54528..43de238c18f8 100644
--- a/drivers/net/wireless/realtek/rtw89/coex.c
+++ b/drivers/net/wireless/realtek/rtw89/coex.c
@@ -2822,6 +2822,8 @@ static void _fw_set_drv_info(struct rtw89_dev *rtwdev, u8 index)
case CXDRVINFO_INIT:
if (ver->fcxinit == 7)
rtw89_fw_h2c_cxdrv_init_v7(rtwdev, index);
+ else if (ver->fcxinit == 10)
+ rtw89_fw_h2c_cxdrv_init_v10(rtwdev, index);
else
rtw89_fw_h2c_cxdrv_init(rtwdev, index);
break;
@@ -7884,15 +7886,30 @@ void rtw89_btc_ntfy_poweroff(struct rtw89_dev *rtwdev)
btc->cx.wl.status.map.rf_off_pre = btc->cx.wl.status.map.rf_off;
}
+#define BTC_PLATFORM_LITTLE_ENDIAN 0
static void _set_init_info(struct rtw89_dev *rtwdev)
{
const struct rtw89_chip_info *chip = rtwdev->chip;
struct rtw89_btc *btc = &rtwdev->btc;
const struct rtw89_btc_ver *ver = btc->ver;
struct rtw89_btc_dm *dm = &btc->dm;
+ struct rtw89_btc_cx *cx = &btc->cx;
struct rtw89_btc_wl_info *wl = &btc->cx.wl;
- if (ver->fcxinit == 7) {
+ if (ver->fcxinit == 10) {
+ dm->init_info.init_v10.init_mode = wl->coex_mode;
+ dm->init_info.init_v10.wl_init_ok = wl->status.map.init_ok;
+ dm->init_info.init_v10.endian_type = BTC_PLATFORM_LITTLE_ENDIAN;
+
+ dm->init_info.init_v10.module = btc->mdinfo.md_v10;
+
+ dm->init_info.init_v10.bt0_function = cx->bt0.func_type;
+ dm->init_info.init_v10.bt1_function = cx->bt1.func_type;
+ dm->init_info.init_v10.bt2_function = cx->bt_ext.func_type;
+
+ dm->init_info.init_v10.pta_mode = RTW89_MAC_AX_COEX_RTK_MODE;
+ dm->init_info.init_v10.pta_direction = RTW89_MAC_AX_COEX_INNER;
+ } else if (ver->fcxinit == 7) {
dm->init_info.init_v7.wl_only = (u8)dm->wl_only;
dm->init_info.init_v7.bt_only = (u8)dm->bt_only;
dm->init_info.init_v7.wl_init_ok = (u8)wl->status.map.init_ok;
@@ -7908,6 +7925,12 @@ static void _set_init_info(struct rtw89_dev *rtwdev)
dm->init_info.init.wl_guard_ch = chip->afh_guard_ch;
dm->init_info.init.module = btc->mdinfo.md;
}
+
+ _fw_set_drv_info(rtwdev, CXDRVINFO_INIT);
+ _fw_set_drv_info(rtwdev, CXDRVINFO_CTRL);
+ rtw89_btc_fw_set_slots(rtwdev);
+ btc_fw_set_monreg(rtwdev);
+ _set_wl_tx_power(rtwdev, RTW89_BTC_WL_DEF_TX_PWR, RTW89_PHY_0);
}
void rtw89_btc_ntfy_init(struct rtw89_dev *rtwdev, u8 mode)
@@ -7918,13 +7941,18 @@ void rtw89_btc_ntfy_init(struct rtw89_dev *rtwdev, u8 mode)
const struct rtw89_chip_info *chip = rtwdev->chip;
const struct rtw89_btc_ver *ver = btc->ver;
+ rtw89_debug(rtwdev, RTW89_DBG_BTC,
+ "[BTC], %s(): Init %s !!\n", __func__,
+ chip_id_str(chip->chip_id));
+
_reset_btc_var(rtwdev, BTC_RESET_ALL);
btc->dm.run_reason = BTC_RSN_NONE;
btc->dm.run_action = BTC_ACT_NONE;
- if (ver->fcxctrl == 7)
+ if (ver->fcxctrl >= 7)
btc->ctrl.ctrl_v7.igno_bt = true;
else
btc->ctrl.ctrl.igno_bt = true;
+ wl->status.map.init_ok = true;
rtw89_debug(rtwdev, RTW89_DBG_BTC,
"[BTC], %s(): mode=%d\n", __func__, mode);
@@ -7934,9 +7962,11 @@ void rtw89_btc_ntfy_init(struct rtw89_dev *rtwdev, u8 mode)
dm->wl_only = mode == BTC_MODE_WL ? 1 : 0;
dm->bt_only = mode == BTC_MODE_BT ? 1 : 0;
wl->status.map.rf_off = mode == BTC_MODE_WLOFF ? 1 : 0;
-
- chip->ops->btc_set_rfe(rtwdev);
- chip->ops->btc_init_cfg(rtwdev);
+ dm->vid = rtwdev->custid;
+ if (ver->fcxctrl >= 7)
+ btc->ctrl.ctrl_v7.always_freerun = mode == BTC_MODE_COTX;
+ else
+ btc->ctrl.ctrl.always_freerun = mode == BTC_MODE_COTX;
if (!wl->status.map.init_ok) {
rtw89_debug(rtwdev, RTW89_DBG_BTC,
@@ -7946,8 +7976,26 @@ void rtw89_btc_ntfy_init(struct rtw89_dev *rtwdev, u8 mode)
return;
}
+ if (rtwdev->chip->para_ver & BTC_FEAT_DUAL_BT) {
+ btc->cx.bt1.enable.now = 1;
+ btc->cx.bt1.run_patch_code = 1;
+ }
+
+ if (rtwdev->chip->para_ver & BTC_FEAT_H2C_MACRO) {
+ btc->cx.bt0.enable.now = 1;
+ btc->cx.bt0.run_patch_code = 1;
+ btc->io_oflld_type = BTC_IO_OFLD_BTC_H2C;
+ } else {
+ btc->io_oflld_type = BTC_IO_OFLD_NO_SUPPORT;
+ _update_bt_scbd(rtwdev, true);
+ }
+
+ chip->ops->btc_set_rfe(rtwdev);
+ chip->ops->btc_init_cfg(rtwdev);
+
_write_scbd(rtwdev,
BTC_WSCB_ACTIVE | BTC_WSCB_ON | BTC_WSCB_BTLOG, true);
+
if (rtw89_mac_get_ctrl_path(rtwdev)) {
rtw89_debug(rtwdev, RTW89_DBG_BTC,
"[BTC], %s(): PTA owner warning!!\n",
diff --git a/drivers/net/wireless/realtek/rtw89/coex.h b/drivers/net/wireless/realtek/rtw89/coex.h
index 6ac14611607c..259c6e2c0e3c 100644
--- a/drivers/net/wireless/realtek/rtw89/coex.h
+++ b/drivers/net/wireless/realtek/rtw89/coex.h
@@ -16,6 +16,8 @@ enum btc_mode {
BTC_MODE_WL,
BTC_MODE_BT,
BTC_MODE_WLOFF,
+ BTC_MODE_COTX,
+ BTC_MODE_MECHANISM_INIT,
BTC_MODE_MAX
};
@@ -212,6 +214,10 @@ enum btc_chip_feature {
BTC_FEAT_NEW_BBAPI_FLOW = BIT(3), /* new btg_ctrl/pre_agc_ctrl */
BTC_FEAT_MLO_SUPPORT = BIT(4),
BTC_FEAT_H2C_MACRO = BIT(5),
+ BTC_FEAT_DUAL_BT = BIT(6),
+ BTC_FEAT_BT_6G = BIT(7),
+ BTC_FEAT_MULTI_PTA = BIT(8),
+ BTC_FEAT_DUAL_BTGA = BIT(9) /* the future A-Die */
};
enum btc_wl_mode {
diff --git a/drivers/net/wireless/realtek/rtw89/core.h b/drivers/net/wireless/realtek/rtw89/core.h
index 5dde620b1e5e..1e72c9b9f3b7 100644
--- a/drivers/net/wireless/realtek/rtw89/core.h
+++ b/drivers/net/wireless/realtek/rtw89/core.h
@@ -1451,6 +1451,12 @@ enum rtw89_btc_bt_rf_band {
BTC_BT_BMAX = 0x2
};
+enum rtw89_btc_io_offload_type {
+ BTC_IO_OFLD_NO_SUPPORT = 0,
+ BTC_IO_OFLD_MAC_API = 1,
+ BTC_IO_OFLD_BTC_H2C = 2
+};
+
enum rtw89_btc_bt_profile {
BTC_BT_NOPROFILE = 0,
BTC_BT_HFP = BIT(0),
@@ -1483,6 +1489,19 @@ struct rtw89_btc_ant_info_v7 {
u8 rsvd;
} __packed;
+struct rtw89_btc_ant_info_v10 {
+ u8 type; /* shared, dedicated(non-shared) */
+ u8 num; /* antenna count */
+ u8 isolation; /* Ant-Iso between WL/BT */
+ u8 single_pos; /* wifi 1ss-1ant at 0:S0 or 1:S1 */
+
+ u8 stream_cnt; /* spatial_stream count: Tx[7:4], Rx[3:0] */
+ u8 btg_pos; /* BT0 btg-circuit at 0:WL-S0/1:WL-S1 */
+ u8 btg1_pos; /* BT1 btg-circuit at 0:WL-S0/1:WL-S1 */
+ u8 func[5]; /* function at 1~5 Ant refer to enum btc_bt_func_type */
+ u8 ant_xmap[2][4];
+} __packed;
+
enum rtw89_tfc_dir {
RTW89_TFC_UL,
RTW89_TFC_DL,
@@ -2129,9 +2148,24 @@ struct rtw89_btc_module_v7 {
struct rtw89_btc_ant_info_v7 ant;
} __packed;
+struct rtw89_btc_module_v10 {
+ u8 rfe_type;
+ u8 wa_type; /* Refer to enum btc_wa_type */
+ u8 kt_ver;
+ u8 kt_ver_adie;
+
+ u8 bt0_pos; /* wl-end view: get from efuse, must compare bt.btg_type*/
+ u8 bt0_sw_type; /* BT Ant-switch: None(non-share), Int(BTG), Ext(SPDT)*/
+ u8 bt1_pos; /* BTC_BT_ALONE or BTC_BT_BTG */
+ u8 bt1_sw_type;
+
+ struct rtw89_btc_ant_info_v10 ant;
+} __packed;
+
union rtw89_btc_module_info {
struct rtw89_btc_module md;
struct rtw89_btc_module_v7 md_v7;
+ struct rtw89_btc_module_v10 md_v10;
};
#define RTW89_BTC_DM_MAXSTEP 30
@@ -2170,9 +2204,24 @@ struct rtw89_btc_init_info_v7 {
struct rtw89_btc_module_v7 module;
} __packed;
+struct rtw89_btc_init_info_v10 {
+ u8 endian_type; /* 0: little-endian, 1:big-endian */
+ u8 init_mode; /* refer to enum BTC_MODE_xxx */
+ u8 wl_init_ok;
+ u8 bt0_function;
+
+ u8 bt1_function;
+ u8 bt2_function;
+ u8 pta_mode;
+ u8 pta_direction;
+
+ struct rtw89_btc_module_v10 module;
+};
+
union rtw89_btc_init_info_u {
struct rtw89_btc_init_info init;
struct rtw89_btc_init_info_v7 init_v7;
+ struct rtw89_btc_init_info_v10 init_v10;
};
struct rtw89_btc_wl_tx_limit_para {
@@ -2253,6 +2302,7 @@ struct rtw89_btc_bt_info {
u8 raw_info[BTC_BTINFO_MAX]; /* raw bt info from mailbox */
u8 txpwr_info[BTC_BTINFO_MAX];
u8 rssi_level;
+ u8 func_type;
u32 scbd;
u32 feature;
@@ -3173,6 +3223,7 @@ struct rtw89_btc_dm {
u8 run_reason;
u8 run_action;
u8 wl_tx_pwr_phy_map;
+ u8 vid;
u8 wl_pre_agc: 2;
u8 wl_lna2: 1;
@@ -3203,7 +3254,7 @@ struct rtw89_btc_ctrl_v7 {
union rtw89_btc_ctrl_list {
struct rtw89_btc_ctrl ctrl;
- struct rtw89_btc_ctrl_v7 ctrl_v7;
+ struct rtw89_btc_ctrl_v7 ctrl_v7; /* ver 8, 9 is the same */
};
struct rtw89_btc_dbg {
@@ -3425,6 +3476,7 @@ struct rtw89_btc {
u8 policy[RTW89_BTC_POLICY_MAXLEN];
u8 ant_type;
u8 btg_pos;
+ u8 io_oflld_type;
u16 policy_len;
u16 policy_type;
u32 hubmsg_cnt;
diff --git a/drivers/net/wireless/realtek/rtw89/fw.c b/drivers/net/wireless/realtek/rtw89/fw.c
index 9d98805835d6..b97c6e9c18bc 100644
--- a/drivers/net/wireless/realtek/rtw89/fw.c
+++ b/drivers/net/wireless/realtek/rtw89/fw.c
@@ -5863,6 +5863,47 @@ int rtw89_fw_h2c_cxdrv_init_v7(struct rtw89_dev *rtwdev, u8 type)
return ret;
}
+int rtw89_fw_h2c_cxdrv_init_v10(struct rtw89_dev *rtwdev, u8 type)
+{
+ struct rtw89_btc *btc = &rtwdev->btc;
+ struct rtw89_btc_dm *dm = &btc->dm;
+ struct rtw89_btc_init_info_v10 *init_info = &dm->init_info.init_v10;
+ struct rtw89_h2c_cxinit_v10 *h2c;
+ u32 len = sizeof(*h2c);
+ struct sk_buff *skb;
+ int ret;
+
+ skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, len);
+ if (!skb) {
+ rtw89_err(rtwdev, "failed to alloc skb for h2c cxdrv_init_v10\n");
+ return -ENOMEM;
+ }
+ skb_put(skb, len);
+ h2c = (struct rtw89_h2c_cxinit_v10 *)skb->data;
+
+ h2c->hdr.type = type;
+ h2c->hdr.ver = btc->ver->fcxinit;
+ h2c->hdr.len = len - H2C_LEN_CXDRVHDR_V7;
+ h2c->init = *init_info;
+
+ rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
+ H2C_CAT_OUTSRC, BTFC_SET,
+ SET_DRV_INFO, 0, 0,
+ len);
+
+ ret = rtw89_h2c_tx(rtwdev, skb, false);
+ if (ret) {
+ rtw89_err(rtwdev, "failed to send h2c\n");
+ goto fail;
+ }
+
+ return 0;
+fail:
+ dev_kfree_skb_any(skb);
+
+ return ret;
+}
+
#define PORT_DATA_OFFSET 4
#define H2C_LEN_CXDRVINFO_ROLE_DBCC_LEN 12
#define H2C_LEN_CXDRVINFO_ROLE_SIZE(max_role_num) \
diff --git a/drivers/net/wireless/realtek/rtw89/fw.h b/drivers/net/wireless/realtek/rtw89/fw.h
index 71e8554a7af7..de8b77de8705 100644
--- a/drivers/net/wireless/realtek/rtw89/fw.h
+++ b/drivers/net/wireless/realtek/rtw89/fw.h
@@ -2592,6 +2592,11 @@ struct rtw89_h2c_cxinit_v7 {
struct rtw89_btc_init_info_v7 init;
} __packed;
+struct rtw89_h2c_cxinit_v10 {
+ struct rtw89_h2c_cxhdr_v7 hdr;
+ struct rtw89_btc_init_info_v10 init;
+} __packed;
+
static inline void RTW89_SET_FWCMD_CXROLE_CONNECT_CNT(void *cmd, u8 val)
{
u8p_replace_bits((u8 *)(cmd) + 2, val, GENMASK(7, 0));
@@ -5380,6 +5385,7 @@ int rtw89_fw_h2c_tx_history(struct rtw89_dev *rtwdev, u16 mac_id);
int rtw89_fw_h2c_drv_ctrl_fw(struct rtw89_dev *rtwdev);
int rtw89_fw_h2c_cxdrv_init(struct rtw89_dev *rtwdev, u8 type);
int rtw89_fw_h2c_cxdrv_init_v7(struct rtw89_dev *rtwdev, u8 type);
+int rtw89_fw_h2c_cxdrv_init_v10(struct rtw89_dev *rtwdev, u8 type);
int rtw89_fw_h2c_cxdrv_role(struct rtw89_dev *rtwdev, u8 type);
int rtw89_fw_h2c_cxdrv_role_v1(struct rtw89_dev *rtwdev, u8 type);
int rtw89_fw_h2c_cxdrv_role_v2(struct rtw89_dev *rtwdev, u8 type);
diff --git a/drivers/net/wireless/realtek/rtw89/rtw8851b.c b/drivers/net/wireless/realtek/rtw89/rtw8851b.c
index 4caf231c6287..a1a63588cb90 100644
--- a/drivers/net/wireless/realtek/rtw89/rtw8851b.c
+++ b/drivers/net/wireless/realtek/rtw89/rtw8851b.c
@@ -2277,8 +2277,6 @@ static void rtw8851b_btc_init_cfg(struct rtw89_dev *rtwdev)
/* enable BT counter 0xda40[16,2] = 2b'11 */
rtw89_write32_set(rtwdev, R_AX_CSR_MODE, B_AX_BT_CNT_RST | B_AX_STATIS_BT_EN);
-
- btc->cx.wl.status.map.init_ok = true;
}
static
diff --git a/drivers/net/wireless/realtek/rtw89/rtw8852a.c b/drivers/net/wireless/realtek/rtw89/rtw8852a.c
index 78addc0aef69..055c67a07cea 100644
--- a/drivers/net/wireless/realtek/rtw89/rtw8852a.c
+++ b/drivers/net/wireless/realtek/rtw89/rtw8852a.c
@@ -1945,7 +1945,6 @@ static void rtw8852a_btc_init_cfg(struct rtw89_dev *rtwdev)
/* enable BT counter 0xda40[16,2] = 2b'11 */
rtw89_write32_set(rtwdev,
R_AX_CSR_MODE, B_AX_BT_CNT_RST | B_AX_STATIS_BT_EN);
- btc->cx.wl.status.map.init_ok = true;
}
static
diff --git a/drivers/net/wireless/realtek/rtw89/rtw8852b_common.c b/drivers/net/wireless/realtek/rtw89/rtw8852b_common.c
index df5fbae50ff5..7d409a64869f 100644
--- a/drivers/net/wireless/realtek/rtw89/rtw8852b_common.c
+++ b/drivers/net/wireless/realtek/rtw89/rtw8852b_common.c
@@ -1838,7 +1838,6 @@ static void __rtw8852bx_btc_init_cfg(struct rtw89_dev *rtwdev)
/* enable BT counter 0xda40[16,2] = 2b'11 */
rtw89_write32_set(rtwdev, R_AX_CSR_MODE, B_AX_BT_CNT_RST | B_AX_STATIS_BT_EN);
- btc->cx.wl.status.map.init_ok = true;
}
static
diff --git a/drivers/net/wireless/realtek/rtw89/rtw8852c.c b/drivers/net/wireless/realtek/rtw89/rtw8852c.c
index 29a3c90021f3..9e630b897986 100644
--- a/drivers/net/wireless/realtek/rtw89/rtw8852c.c
+++ b/drivers/net/wireless/realtek/rtw89/rtw8852c.c
@@ -2761,7 +2761,6 @@ static void rtw8852c_btc_init_cfg(struct rtw89_dev *rtwdev)
rtw89_write32_set(rtwdev,
R_AX_BT_CNT_CFG, B_AX_BT_CNT_EN |
B_AX_BT_CNT_RST_V1);
- btc->cx.wl.status.map.init_ok = true;
}
static
diff --git a/drivers/net/wireless/realtek/rtw89/rtw8922a.c b/drivers/net/wireless/realtek/rtw89/rtw8922a.c
index 6d4301661b04..382034eb27d0 100644
--- a/drivers/net/wireless/realtek/rtw89/rtw8922a.c
+++ b/drivers/net/wireless/realtek/rtw89/rtw8922a.c
@@ -2828,7 +2828,6 @@ static void rtw8922a_btc_init_cfg(struct rtw89_dev *rtwdev)
rtw89_write32(rtwdev, R_BTC_ZB_COEX_TBL_1, 0xda5a5a5a);
rtw89_write32(rtwdev, R_BTC_ZB_BREAK_TBL, 0xf0ffffff);
- btc->cx.wl.status.map.init_ok = true;
}
static void
--
2.25.1
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox