To support multi-link operation, multiple devices with different bands say
2 GHz or 5 GHz or 6 GHz can be combined together as a group and provide
an abstraction to mac80211.
Device group abstraction - when there are multiple devices that are
connected by any means of communication interface between them, then these
devices can be combined together as a single group using a group id to form
a group abstraction. In ath12k driver, this abstraction would be named as
ath12k_hw_group (ag).
Please find below illustration of device group abstraction with two
devices.
Grouping of multiple devices (in future)
+------------------------------------------------------------------------+
| +-------------------------------------+ +-------------------+ |
| | +-----------+ | | +-----------+ | | +-----------+ | |
| | | ar (2GHz) | | | | ar (5GHz) | | | | ar (6GHz) | | |
| | +-----------+ | | +-----------+ | | +-----------+ | |
| | ath12k_base (ab) | | ath12k_base (ab) | |
| | (Dual band device) | | | |
| +-------------------------------------+ +-------------------+ |
| ath12k_hw_group (ag) based on group id |
+------------------------------------------------------------------------+
Say for example, device 1 has two radios (2 GHz and 5 GHz band) and
device 2 has one radio (6 GHz).
In existing code -
device 1 will have two hardware abstractions hw1 (2 GHz) and hw2
(5 GHz) will be registered separately to mac80211 as phy0 and phy1
respectively. Similarly, device 2 will register its hw (6GHz) as
phy2 to mac80211.
In future, with multi-link abstraction
combination 1 - Different group id for device1 and device 2
Device 1 will create a single hardware abstraction hw1
(2 GHz and 5 GHz) and will be registered to mac80211 as
phy0. similarly, device 2 will register its hardware
(6 GHz) to mac80211 as phy1.
combination 2 - Same group id for device1 and device 2
Both device details are combined together as a group, say
group1, with single hardware abstraction of radios 2 GHz,
5 GHz and 6 GHz band details and will be registered to
mac80211 as phy0.
Add base infrastructure changes to add device grouping abstraction with
a single device.
This patch series brings the base code changes with following order:
1. Refactor existing code which would facilitate in introducing
device group abstraction.
2. Create a device group abstraction during device probe.
3. Start the device group only after QMI firmware ready event is
received for all the devices that are combined in the group.
4. Move the hardware abstractions (ath12k_hw - ah) from device
(ath12k_base - ab) to device group abstraction (ag) as it would
ease in having different combinations of group abstraction that
can be registered to mac80211.
Depends-on:
[PATCH 0/3] wifi: ath12k: Refactor the hardware recovery
procedures
Karthikeyan Periyasamy (8):
wifi: ath12k: Refactor core start api
wifi: ath12k: Add helpers to get or set ath12k_hw
wifi: ath12k: Add ath12k_get_num_hw api
wifi: ath12k: Introduce QMI firmware ready flag
wifi: ath12k: move ATH12K_FLAG_REGISTERED flag set to mac_register api
wifi: ath12k: Introduce device group abstraction
wifi: ath12k: refactor core start based on hardware group
wifi: ath12k: move ath12k_hw from per soc to group
drivers/net/wireless/ath/ath12k/core.c | 428 +++++++++++++++++++++----
drivers/net/wireless/ath/ath12k/core.h | 88 ++++-
drivers/net/wireless/ath/ath12k/mac.c | 111 +++++--
drivers/net/wireless/ath/ath12k/mac.h | 9 +-
drivers/net/wireless/ath/ath12k/pci.c | 1 +
drivers/net/wireless/ath/ath12k/qmi.c | 11 +-
6 files changed, 530 insertions(+), 118 deletions(-)
base-commit: c416602943dd36fbd13af7496430723935c867a3
prerequisite-patch-id: a4d62344b11368fb7e549c03b6a31f7ba4c9e2bb
prerequisite-patch-id: b4a1e18a85d8c1e337fa133c2bd2956c33b11046
prerequisite-patch-id: b16edd310baa35e2500267e338f60c9a2e6594e1
--
2.34.1
From: Karthikeyan Periyasamy <[email protected]>
Hardware device group abstraction would be introduced, in future,
where radios across different devices can be grouped together to
support multi-link operation and register as a device group to mac80211.
Currently, ath12k_mac_allocate() and ath12k_mac_register() APIs are part
of ath12k_core_start() and ath12k_core_pdev_create() respectively and are
based on per device (ath12k_base). These APIs can be decoupled and moved
out to ath12k_core_qmi_firmware_ready() itself.
This refactor would be helpful for device group abstraction when mac80211
allocate and register will be changed from per device (ath12k_base) to
per device group (ath12k_hw_group).
Add changes to move allocate and register APIs from existing one and modify
corresponding deinit sequence.
Tested-on: QCN9274 hw2.0 PCI WLAN.WBE.1.0.1-00029-QCAHKSWPL_SILICONZ-1
Signed-off-by: Karthikeyan Periyasamy <[email protected]>
Signed-off-by: Harshitha Prem <[email protected]>
---
drivers/net/wireless/ath/ath12k/core.c | 64 +++++++++++++-------------
1 file changed, 31 insertions(+), 33 deletions(-)
diff --git a/drivers/net/wireless/ath/ath12k/core.c b/drivers/net/wireless/ath/ath12k/core.c
index 6a1be790128b..994411405b55 100644
--- a/drivers/net/wireless/ath/ath12k/core.c
+++ b/drivers/net/wireless/ath/ath12k/core.c
@@ -540,12 +540,13 @@ u32 ath12k_core_get_max_num_tids(struct ath12k_base *ab)
static void ath12k_core_stop(struct ath12k_base *ab)
{
- if (!test_bit(ATH12K_FLAG_CRASH_FLUSH, &ab->dev_flags))
- ath12k_qmi_firmware_stop(ab);
-
+ ath12k_dp_rx_pdev_reo_cleanup(ab);
ath12k_hif_stop(ab);
ath12k_wmi_detach(ab);
- ath12k_dp_rx_pdev_reo_cleanup(ab);
+ ath12k_dp_free(ab);
+
+ if (!test_bit(ATH12K_FLAG_CRASH_FLUSH, &ab->dev_flags))
+ ath12k_qmi_firmware_stop(ab);
/* De-Init of components as needed */
}
@@ -647,7 +648,7 @@ static int ath12k_core_soc_create(struct ath12k_base *ab)
static void ath12k_core_soc_destroy(struct ath12k_base *ab)
{
- ath12k_dp_free(ab);
+ ath12k_hif_power_down(ab);
ath12k_reg_free(ab);
ath12k_debugfs_soc_destroy(ab);
ath12k_qmi_deinit_service(ab);
@@ -657,30 +658,17 @@ static int ath12k_core_pdev_create(struct ath12k_base *ab)
{
int ret;
- ret = ath12k_mac_register(ab);
- if (ret) {
- ath12k_err(ab, "failed register the radio with mac80211: %d\n", ret);
- return ret;
- }
-
ret = ath12k_dp_pdev_alloc(ab);
if (ret) {
ath12k_err(ab, "failed to attach DP pdev: %d\n", ret);
- goto err_mac_unregister;
+ return ret;
}
return 0;
-
-err_mac_unregister:
- ath12k_mac_unregister(ab);
-
- return ret;
}
static void ath12k_core_pdev_destroy(struct ath12k_base *ab)
{
- ath12k_mac_unregister(ab);
- ath12k_hif_irq_disable(ab);
ath12k_dp_pdev_free(ab);
}
@@ -738,19 +726,12 @@ static int ath12k_core_start(struct ath12k_base *ab,
goto err_hif_stop;
}
- ret = ath12k_mac_allocate(ab);
- if (ret) {
- ath12k_err(ab, "failed to create new hw device with mac80211 :%d\n",
- ret);
- goto err_hif_stop;
- }
-
ath12k_dp_cc_config(ab);
ret = ath12k_dp_rx_pdev_reo_setup(ab);
if (ret) {
ath12k_err(ab, "failed to initialize reo destination rings: %d\n", ret);
- goto err_mac_destroy;
+ goto err_hif_stop;
}
ath12k_dp_hal_rx_desc_init(ab);
@@ -788,8 +769,6 @@ static int ath12k_core_start(struct ath12k_base *ab,
err_reo_cleanup:
ath12k_dp_rx_pdev_reo_cleanup(ab);
-err_mac_destroy:
- ath12k_mac_destroy(ab);
err_hif_stop:
ath12k_hif_stop(ab);
err_wmi_detach:
@@ -843,11 +822,25 @@ int ath12k_core_qmi_firmware_ready(struct ath12k_base *ab)
goto err_dp_free;
}
+ ret = ath12k_mac_allocate(ab);
+ if (ret) {
+ ath12k_err(ab, "failed to create new hw device with mac80211 :%d\n",
+ ret);
+ goto err_core_stop;
+ }
+
+ ret = ath12k_mac_register(ab);
+ if (ret) {
+ ath12k_err(ab, "failed register the radio with mac80211: %d\n", ret);
+ goto err_mac_destroy;
+ }
+
ret = ath12k_core_pdev_create(ab);
if (ret) {
ath12k_err(ab, "failed to create pdev core: %d\n", ret);
- goto err_core_stop;
+ goto err_mac_unregister;
}
+
ath12k_hif_irq_enable(ab);
ret = ath12k_core_rfkill_config(ab);
@@ -861,10 +854,14 @@ int ath12k_core_qmi_firmware_ready(struct ath12k_base *ab)
return 0;
err_core_pdev_destroy:
+ ath12k_hif_irq_disable(ab);
ath12k_core_pdev_destroy(ab);
+err_mac_unregister:
+ ath12k_mac_unregister(ab);
+err_mac_destroy:
+ ath12k_mac_destroy(ab);
err_core_stop:
ath12k_core_stop(ab);
- ath12k_mac_destroy(ab);
err_dp_free:
ath12k_dp_free(ab);
mutex_unlock(&ab->core_lock);
@@ -1181,13 +1178,14 @@ void ath12k_core_deinit(struct ath12k_base *ab)
{
mutex_lock(&ab->core_lock);
+ ath12k_hif_irq_disable(ab);
ath12k_core_pdev_destroy(ab);
+ ath12k_mac_unregister(ab);
+ ath12k_mac_destroy(ab);
ath12k_core_stop(ab);
mutex_unlock(&ab->core_lock);
- ath12k_hif_power_down(ab);
- ath12k_mac_destroy(ab);
ath12k_core_soc_destroy(ab);
ath12k_fw_unmap(ab);
}
--
2.34.1
From: Karthikeyan Periyasamy <[email protected]>
Currently, one or more ath12k_hw is part of a device (ath12k_base) but
in future, it would be part of device group abstraction (ath12k_hw_group),
i.e., when multiple radios (ar) across different devices can be combined
together in a device group (ath12k_hw_group).
In order to facilitate the above transition, introduce helpers such as
ath12k_ab_to_ah() and ath12k_ab_set_ah() to get and set values of ath12k_hw
respectively.
Tested-on: QCN9274 hw2.0 PCI WLAN.WBE.1.0.1-00029-QCAHKSWPL_SILICONZ-1
Signed-off-by: Karthikeyan Periyasamy <[email protected]>
Signed-off-by: Harshitha Prem <[email protected]>
---
drivers/net/wireless/ath/ath12k/core.c | 6 +++---
drivers/net/wireless/ath/ath12k/core.h | 11 +++++++++++
drivers/net/wireless/ath/ath12k/mac.c | 23 +++++++++++++----------
3 files changed, 27 insertions(+), 13 deletions(-)
diff --git a/drivers/net/wireless/ath/ath12k/core.c b/drivers/net/wireless/ath/ath12k/core.c
index 994411405b55..07b795784cbd 100644
--- a/drivers/net/wireless/ath/ath12k/core.c
+++ b/drivers/net/wireless/ath/ath12k/core.c
@@ -921,7 +921,7 @@ static void ath12k_rfkill_work(struct work_struct *work)
spin_unlock_bh(&ab->base_lock);
for (i = 0; i < ab->num_hw; i++) {
- ah = ab->ah[i];
+ ah = ath12k_ab_to_ah(ab, i);
if (!ah)
continue;
@@ -973,7 +973,7 @@ static void ath12k_core_pre_reconfigure_recovery(struct ath12k_base *ab)
set_bit(ATH12K_FLAG_CRASH_FLUSH, &ab->dev_flags);
for (i = 0; i < ab->num_hw; i++) {
- ah = ab->ah[i];
+ ah = ath12k_ab_to_ah(ab, i);
if (!ah || ah->state == ATH12K_HW_STATE_OFF)
continue;
@@ -1012,7 +1012,7 @@ static void ath12k_core_post_reconfigure_recovery(struct ath12k_base *ab)
int i, j;
for (i = 0; i < ab->num_hw; i++) {
- ah = ab->ah[i];
+ ah = ath12k_ab_to_ah(ab, i);
if (!ah || ah->state == ATH12K_HW_STATE_OFF)
continue;
diff --git a/drivers/net/wireless/ath/ath12k/core.h b/drivers/net/wireless/ath/ath12k/core.h
index e07885843084..9ce8e01af133 100644
--- a/drivers/net/wireless/ath/ath12k/core.h
+++ b/drivers/net/wireless/ath/ath12k/core.h
@@ -1027,4 +1027,15 @@ static inline struct ieee80211_hw *ath12k_ar_to_hw(struct ath12k *ar)
#define for_each_ar(ah, ar, index) \
for ((index) = 0; ((index) < (ah)->num_radio && \
((ar) = &(ah)->radio[(index)])); (index)++)
+
+static inline struct ath12k_hw *ath12k_ab_to_ah(struct ath12k_base *ab, int idx)
+{
+ return ab->ah[idx];
+}
+
+static inline void ath12k_ab_set_ah(struct ath12k_base *ab, int idx,
+ struct ath12k_hw *ah)
+{
+ ab->ah[idx] = ah;
+}
#endif /* _CORE_H_ */
diff --git a/drivers/net/wireless/ath/ath12k/mac.c b/drivers/net/wireless/ath/ath12k/mac.c
index efbb925b257c..af820df77866 100644
--- a/drivers/net/wireless/ath/ath12k/mac.c
+++ b/drivers/net/wireless/ath/ath12k/mac.c
@@ -8787,7 +8787,7 @@ int ath12k_mac_register(struct ath12k_base *ab)
ab->free_vdev_map = (1LL << (ab->num_radios * TARGET_NUM_VDEVS)) - 1;
for (i = 0; i < ab->num_hw; i++) {
- ah = ab->ah[i];
+ ah = ath12k_ab_to_ah(ab, i);
ret = ath12k_mac_hw_register(ah);
if (ret)
@@ -8798,7 +8798,7 @@ int ath12k_mac_register(struct ath12k_base *ab)
err:
for (i = i - 1; i >= 0; i--) {
- ah = ab->ah[i];
+ ah = ath12k_ab_to_ah(ab, i);
if (!ah)
continue;
@@ -8814,7 +8814,7 @@ void ath12k_mac_unregister(struct ath12k_base *ab)
int i;
for (i = ab->num_hw - 1; i >= 0; i--) {
- ah = ab->ah[i];
+ ah = ath12k_ab_to_ah(ab, i);
if (!ah)
continue;
@@ -8872,6 +8872,7 @@ static struct ath12k_hw *ath12k_mac_hw_allocate(struct ath12k_base *ab,
void ath12k_mac_destroy(struct ath12k_base *ab)
{
struct ath12k_pdev *pdev;
+ struct ath12k_hw *ah;
int i;
for (i = 0; i < ab->num_radios; i++) {
@@ -8883,11 +8884,12 @@ void ath12k_mac_destroy(struct ath12k_base *ab)
}
for (i = 0; i < ab->num_hw; i++) {
- if (!ab->ah[i])
+ ah = ath12k_ab_to_ah(ab, i);
+ if (!ah)
continue;
- ath12k_mac_hw_destroy(ab->ah[i]);
- ab->ah[i] = NULL;
+ ath12k_mac_hw_destroy(ah);
+ ath12k_ab_set_ah(ab, i, NULL);
}
}
@@ -8918,7 +8920,7 @@ int ath12k_mac_allocate(struct ath12k_base *ab)
goto err;
}
- ab->ah[i] = ah;
+ ath12k_ab_set_ah(ab, i, ah);
}
ath12k_dp_pdev_pre_alloc(ab);
@@ -8927,11 +8929,12 @@ int ath12k_mac_allocate(struct ath12k_base *ab)
err:
for (i = i - 1; i >= 0; i--) {
- if (!ab->ah[i])
+ ah = ath12k_ab_to_ah(ab, i);
+ if (!ah)
continue;
- ath12k_mac_hw_destroy(ab->ah[i]);
- ab->ah[i] = NULL;
+ ath12k_mac_hw_destroy(ah);
+ ath12k_ab_set_ah(ab, i, NULL);
}
return ret;
--
2.34.1
From: Karthikeyan Periyasamy <[email protected]>
Currently, one or more ath12k_hw is part of device (ath12k_base) but
in future, ath12k_hw would be part of device group (ath12k_hw_group).
Hence, num_hw under device would be moved to device group.
To facilitate above transition, add helper ath12k_get_num_hw() api to
get the number of radios per device. In future, this helper would be
able to get the number of radios in a device group.
Tested-on: QCN9274 hw2.0 PCI WLAN.WBE.1.0.1-00029-QCAHKSWPL_SILICONZ-1
Signed-off-by: Karthikeyan Periyasamy <[email protected]>
Signed-off-by: Harshitha Prem <[email protected]>
---
drivers/net/wireless/ath/ath12k/core.c | 6 +++---
drivers/net/wireless/ath/ath12k/core.h | 5 +++++
drivers/net/wireless/ath/ath12k/mac.c | 8 ++++----
3 files changed, 12 insertions(+), 7 deletions(-)
diff --git a/drivers/net/wireless/ath/ath12k/core.c b/drivers/net/wireless/ath/ath12k/core.c
index 07b795784cbd..0d03648f4e10 100644
--- a/drivers/net/wireless/ath/ath12k/core.c
+++ b/drivers/net/wireless/ath/ath12k/core.c
@@ -920,7 +920,7 @@ static void ath12k_rfkill_work(struct work_struct *work)
rfkill_radio_on = ab->rfkill_radio_on;
spin_unlock_bh(&ab->base_lock);
- for (i = 0; i < ab->num_hw; i++) {
+ for (i = 0; i < ath12k_get_num_hw(ab); i++) {
ah = ath12k_ab_to_ah(ab, i);
if (!ah)
continue;
@@ -972,7 +972,7 @@ static void ath12k_core_pre_reconfigure_recovery(struct ath12k_base *ab)
if (ab->is_reset)
set_bit(ATH12K_FLAG_CRASH_FLUSH, &ab->dev_flags);
- for (i = 0; i < ab->num_hw; i++) {
+ for (i = 0; i < ath12k_get_num_hw(ab); i++) {
ah = ath12k_ab_to_ah(ab, i);
if (!ah || ah->state == ATH12K_HW_STATE_OFF)
continue;
@@ -1011,7 +1011,7 @@ static void ath12k_core_post_reconfigure_recovery(struct ath12k_base *ab)
struct ath12k *ar;
int i, j;
- for (i = 0; i < ab->num_hw; i++) {
+ for (i = 0; i < ath12k_get_num_hw(ab); i++) {
ah = ath12k_ab_to_ah(ab, i);
if (!ah || ah->state == ATH12K_HW_STATE_OFF)
continue;
diff --git a/drivers/net/wireless/ath/ath12k/core.h b/drivers/net/wireless/ath/ath12k/core.h
index 9ce8e01af133..c06bbb083ab3 100644
--- a/drivers/net/wireless/ath/ath12k/core.h
+++ b/drivers/net/wireless/ath/ath12k/core.h
@@ -1038,4 +1038,9 @@ static inline void ath12k_ab_set_ah(struct ath12k_base *ab, int idx,
{
ab->ah[idx] = ah;
}
+
+static inline int ath12k_get_num_hw(struct ath12k_base *ab)
+{
+ return ab->num_hw;
+}
#endif /* _CORE_H_ */
diff --git a/drivers/net/wireless/ath/ath12k/mac.c b/drivers/net/wireless/ath/ath12k/mac.c
index af820df77866..8516a0168f7b 100644
--- a/drivers/net/wireless/ath/ath12k/mac.c
+++ b/drivers/net/wireless/ath/ath12k/mac.c
@@ -8786,7 +8786,7 @@ int ath12k_mac_register(struct ath12k_base *ab)
ab->cc_freq_hz = 320000;
ab->free_vdev_map = (1LL << (ab->num_radios * TARGET_NUM_VDEVS)) - 1;
- for (i = 0; i < ab->num_hw; i++) {
+ for (i = 0; i < ath12k_get_num_hw(ab); i++) {
ah = ath12k_ab_to_ah(ab, i);
ret = ath12k_mac_hw_register(ah);
@@ -8813,7 +8813,7 @@ void ath12k_mac_unregister(struct ath12k_base *ab)
struct ath12k_hw *ah;
int i;
- for (i = ab->num_hw - 1; i >= 0; i--) {
+ for (i = ath12k_get_num_hw(ab) - 1; i >= 0; i--) {
ah = ath12k_ab_to_ah(ab, i);
if (!ah)
continue;
@@ -8883,7 +8883,7 @@ void ath12k_mac_destroy(struct ath12k_base *ab)
pdev->ar = NULL;
}
- for (i = 0; i < ab->num_hw; i++) {
+ for (i = 0; i < ath12k_get_num_hw(ab); i++) {
ah = ath12k_ab_to_ah(ab, i);
if (!ah)
continue;
@@ -8906,7 +8906,7 @@ int ath12k_mac_allocate(struct ath12k_base *ab)
ab->num_hw = ab->num_radios;
radio_per_hw = 1;
- for (i = 0; i < ab->num_hw; i++) {
+ for (i = 0; i < ath12k_get_num_hw(ab); i++) {
for (j = 0; j < radio_per_hw; j++) {
pdev_map[j].ab = ab;
pdev_map[j].pdev_idx = (i * radio_per_hw) + j;
--
2.34.1
From: Karthikeyan Periyasamy <[email protected]>
Currently, single device is probed and once firmware is ready, the device
is registered to mac80211. For multi-link operation, different bands of
different devices or same device would be part of a single wiphy and for
this, hardware device group abstraction would be helpful.
Hardware device group abstraction - when there are multiple devices (with
single radio or dual radio) that are connected by any means of interface
for communicating between them, then these devices can be combined
together as a single group using a group id to form a group abstraction
and register to mac80211.
The grouping information of multiple devices would be based on device tree
during device probe. If no such information is available then a single
device will be part of group abstraction and registered to mac80211 else
multiple devices advertised in device tree are combined and then registered
to mac80211.
For device group abstraction, a base structure named ath12k_hw_group (ag)
and the following helpers are introduced:
ath12k_core_hw_group_alloc() : allocate ath12k_hw_group (ag)
based on group id and number
of devices that are going to
be part of this group.
ath12k_core_hw_group_free() : free ag during deinit.
ath12k_core_assign_hw_group() : assign/map the details of group
to ath12k_base (ab).
ath12k_core_unassign_hw_group() : unassign/unmap the details of ag
in ath12k_base (ab).
ath12k_core_hw_group_create() : create the devices which are part
of group (ag).
ath12k_core_hw_group_destroy() : cleanup the devices in ag
These helpers are used during device probe and mapping the group to the
devices involved.
Please find the illustration of how multiple devices might be combined
together in future based on group id.
Grouping of multiple devices (in future)
+------------------------------------------------------------------------+
| +-------------------------------------+ +-------------------+ |
| | +-----------+ | | +-----------+ | | +-----------+ | |
| | | ar (2GHz) | | | | ar (5GHz) | | | | ar (6GHz) | | |
| | +-----------+ | | +-----------+ | | +-----------+ | |
| | ath12k_base (ab) | | ath12k_base (ab) | |
| | (Dual band device) | | | |
| +-------------------------------------+ +-------------------+ |
| ath12k_hw_group (ag) based on group id |
+------------------------------------------------------------------------+
In the above representation, two devices are combined into single group
based on group id.
Add base code changes where single device would be part of a group with an
invalid group id forming an group abstraction. Multi device grouping will
be introduced in future.
Tested-on: QCN9274 hw2.0 PCI WLAN.WBE.1.0.1-00029-QCAHKSWPL_SILICONZ-1
Signed-off-by: Karthikeyan Periyasamy <[email protected]>
Co-developed-by: Harshitha Prem <[email protected]>
Signed-off-by: Harshitha Prem <[email protected]>
---
drivers/net/wireless/ath/ath12k/core.c | 209 +++++++++++++++++++++++--
drivers/net/wireless/ath/ath12k/core.h | 20 +++
drivers/net/wireless/ath/ath12k/pci.c | 1 +
3 files changed, 220 insertions(+), 10 deletions(-)
diff --git a/drivers/net/wireless/ath/ath12k/core.c b/drivers/net/wireless/ath/ath12k/core.c
index 0d03648f4e10..0ad3c4cf48e1 100644
--- a/drivers/net/wireless/ath/ath12k/core.c
+++ b/drivers/net/wireless/ath/ath12k/core.c
@@ -21,6 +21,9 @@ unsigned int ath12k_debug_mask;
module_param_named(debug_mask, ath12k_debug_mask, uint, 0644);
MODULE_PARM_DESC(debug_mask, "Debugging mask");
+static DEFINE_MUTEX(ath12k_hw_lock);
+static struct list_head ath12k_hw_groups = LIST_HEAD_INIT(ath12k_hw_groups);
+
static int ath12k_core_rfkill_config(struct ath12k_base *ab)
{
struct ath12k *ar;
@@ -1161,20 +1164,111 @@ int ath12k_core_pre_init(struct ath12k_base *ab)
return 0;
}
-int ath12k_core_init(struct ath12k_base *ab)
+static inline
+bool ath12k_core_hw_group_create_ready(struct ath12k_hw_group *ag)
{
- int ret;
+ lockdep_assert_held(&ag->mutex_lock);
- ret = ath12k_core_soc_create(ab);
- if (ret) {
- ath12k_err(ab, "failed to create soc core: %d\n", ret);
- return ret;
+ return (ag->num_probed == ag->num_devices);
+}
+
+static struct ath12k_hw_group *
+ath12k_core_hw_group_alloc(u8 id, u8 max_devices)
+{
+ struct ath12k_hw_group *ag;
+
+ lockdep_assert_held(&ath12k_hw_lock);
+
+ ag = kzalloc(sizeof(*ag), GFP_KERNEL);
+ if (!ag)
+ return NULL;
+
+ ag->id = id;
+ ag->num_devices = max_devices;
+ list_add(&ag->list, &ath12k_hw_groups);
+ mutex_init(&ag->mutex_lock);
+
+ return ag;
+}
+
+static void ath12k_core_hw_group_free(struct ath12k_hw_group *ag)
+{
+ mutex_lock(&ath12k_hw_lock);
+
+ list_del(&ag->list);
+ kfree(ag);
+
+ mutex_unlock(&ath12k_hw_lock);
+}
+
+static struct ath12k_hw_group *ath12k_core_assign_hw_group(struct ath12k_base *ab)
+{
+ struct ath12k_hw_group *ag;
+ u32 group_id = ATH12K_INVALID_GROUP_ID;
+
+ lockdep_assert_held(&ath12k_hw_lock);
+
+ /* The grouping of multiple devices will be done based on device tree file.
+ * TODO: device tree file parsing to know about the devices involved in group.
+ *
+ * The platforms that do not have any valid group information would have each
+ * device to be part of its own invalid group.
+ *
+ * Currently, we are not parsing any device tree information and hence, grouping
+ * of multiple devices is not involved. Thus, single device is added to device
+ * group.
+ */
+ ag = ath12k_core_hw_group_alloc(group_id, 1);
+ if (!ag) {
+ ath12k_warn(ab, "unable to create new hw group\n");
+ return NULL;
}
+ ath12k_dbg(ab, ATH12K_DBG_BOOT, "Single device is added to hardware group\n");
- return 0;
+ ab->device_id = ag->num_probed++;
+ ag->ab[ab->device_id] = ab;
+ ab->ag = ag;
+
+ return ag;
}
-void ath12k_core_deinit(struct ath12k_base *ab)
+void ath12k_core_unassign_hw_group(struct ath12k_base *ab)
+{
+ struct ath12k_hw_group *ag = ab->ag;
+ u8 device_id = ab->device_id;
+ int num_probed;
+
+ if (!ag)
+ return;
+
+ mutex_lock(&ag->mutex_lock);
+
+ if (WARN_ON(device_id >= ag->num_devices)) {
+ mutex_unlock(&ag->mutex_lock);
+ return;
+ }
+
+ if (WARN_ON(ag->ab[device_id] != ab)) {
+ mutex_unlock(&ag->mutex_lock);
+ return;
+ }
+
+ ag->ab[device_id] = NULL;
+ ab->ag = NULL;
+ ab->device_id = ATH12K_INVALID_DEVICE_ID;
+
+ if (ag->num_probed)
+ ag->num_probed--;
+
+ num_probed = ag->num_probed;
+
+ mutex_unlock(&ag->mutex_lock);
+
+ if (!num_probed)
+ ath12k_core_hw_group_free(ag);
+}
+
+static void ath12k_core_device_cleanup(struct ath12k_base *ab)
{
mutex_lock(&ab->core_lock);
@@ -1185,9 +1279,104 @@ void ath12k_core_deinit(struct ath12k_base *ab)
ath12k_core_stop(ab);
mutex_unlock(&ab->core_lock);
+}
+
+static void ath12k_core_hw_group_destroy(struct ath12k_hw_group *ag)
+{
+ struct ath12k_base *ab;
+ int i;
+
+ if (!ag)
+ return;
+
+ mutex_lock(&ag->mutex_lock);
+
+ for (i = 0; i < ag->num_devices; i++) {
+ ab = ag->ab[i];
+ if (!ab)
+ continue;
+
+ if (test_bit(ATH12K_FLAG_QMI_FW_READY_COMPLETE, &ab->dev_flags))
+ ath12k_core_device_cleanup(ab);
+
+ if (test_and_clear_bit(ATH12K_FLAG_HW_GROUP_ATTACHED, &ab->dev_flags))
+ ath12k_core_soc_destroy(ab);
+
+ ath12k_fw_unmap(ab);
+ }
+
+ mutex_unlock(&ag->mutex_lock);
+}
- ath12k_core_soc_destroy(ab);
- ath12k_fw_unmap(ab);
+static int ath12k_core_hw_group_create(struct ath12k_hw_group *ag)
+{
+ int i, ret;
+ struct ath12k_base *ab;
+
+ lockdep_assert_held(&ag->mutex_lock);
+
+ for (i = 0; i < ag->num_devices; i++) {
+ ab = ag->ab[i];
+ if (!ab)
+ continue;
+
+ mutex_lock(&ab->core_lock);
+ ret = ath12k_core_soc_create(ab);
+ if (ret) {
+ mutex_unlock(&ab->core_lock);
+ ath12k_err(ab, "failed to create soc core: %d\n", ret);
+ return ret;
+ }
+ set_bit(ATH12K_FLAG_HW_GROUP_ATTACHED, &ab->dev_flags);
+ mutex_unlock(&ab->core_lock);
+ }
+
+ return 0;
+}
+
+int ath12k_core_init(struct ath12k_base *ab)
+{
+ struct ath12k_hw_group *ag;
+ int ret;
+
+ mutex_lock(&ath12k_hw_lock);
+ ag = ath12k_core_assign_hw_group(ab);
+ if (!ag) {
+ mutex_unlock(&ath12k_hw_lock);
+ ath12k_warn(ab, "unable to get hw group\n");
+ return -ENODEV;
+ }
+ mutex_unlock(&ath12k_hw_lock);
+
+ mutex_lock(&ag->mutex_lock);
+
+ ath12k_dbg(ab, ATH12K_DBG_BOOT, "num devices in group %d, num probed %d\n",
+ ag->num_devices, ag->num_probed);
+
+ if (ath12k_core_hw_group_create_ready(ag)) {
+ ret = ath12k_core_hw_group_create(ag);
+ if (ret) {
+ mutex_unlock(&ag->mutex_lock);
+ ath12k_warn(ab, "unable to create hw group\n");
+ goto err_hw_group;
+ }
+ }
+
+ mutex_unlock(&ag->mutex_lock);
+
+ return 0;
+
+err_hw_group:
+ ath12k_core_hw_group_destroy(ab->ag);
+ ath12k_core_unassign_hw_group(ab);
+
+ return ret;
+}
+
+void ath12k_core_deinit(struct ath12k_base *ab)
+{
+ ath12k_core_hw_group_destroy(ab->ag);
+ ath12k_core_unassign_hw_group(ab);
}
void ath12k_core_free(struct ath12k_base *ab)
diff --git a/drivers/net/wireless/ath/ath12k/core.h b/drivers/net/wireless/ath/ath12k/core.h
index 3961a45a3458..fd3e4e66d27c 100644
--- a/drivers/net/wireless/ath/ath12k/core.h
+++ b/drivers/net/wireless/ath/ath12k/core.h
@@ -57,6 +57,10 @@
#define ATH12K_RECONFIGURE_TIMEOUT_HZ (10 * HZ)
#define ATH12K_RECOVER_START_TIMEOUT_HZ (20 * HZ)
+#define ATH12K_MAX_SOCS 3
+#define ATH12K_INVALID_GROUP_ID 0xFF
+#define ATH12K_INVALID_DEVICE_ID 0xFF
+
enum ath12k_bdf_search {
ATH12K_BDF_SEARCH_DEFAULT,
ATH12K_BDF_SEARCH_BUS_AND_BOARD,
@@ -209,6 +213,7 @@ enum ath12k_dev_flags {
ATH12K_FLAG_CE_IRQ_ENABLED,
ATH12K_FLAG_EXT_IRQ_ENABLED,
ATH12K_FLAG_QMI_FW_READY_COMPLETE,
+ ATH12K_FLAG_HW_GROUP_ATTACHED,
};
enum ath12k_monitor_flags {
@@ -723,6 +728,17 @@ struct ath12k_soc_dp_stats {
struct ath12k_soc_dp_tx_err_stats tx_err;
};
+/* Holds info on the group of devices that are registered as a single wiphy */
+struct ath12k_hw_group {
+ struct list_head list;
+ u8 id;
+ u8 num_devices;
+ u8 num_probed;
+ struct ath12k_base *ab[ATH12K_MAX_SOCS];
+ /* To synchronize group create, assign, start, stop */
+ struct mutex mutex_lock;
+};
+
/**
* enum ath12k_link_capable_flags - link capable flags
*
@@ -903,6 +919,9 @@ struct ath12k_base {
*/
u8 mlo_capable_flags;
+ struct ath12k_hw_group *ag;
+ u8 device_id;
+
/* must be last */
u8 drv_priv[] __aligned(sizeof(void *));
};
@@ -931,6 +950,7 @@ int ath12k_core_check_smbios(struct ath12k_base *ab);
void ath12k_core_halt(struct ath12k *ar);
int ath12k_core_resume(struct ath12k_base *ab);
int ath12k_core_suspend(struct ath12k_base *ab);
+void ath12k_core_unassign_hw_group(struct ath12k_base *ab);
const struct firmware *ath12k_core_firmware_request(struct ath12k_base *ab,
const char *filename);
diff --git a/drivers/net/wireless/ath/ath12k/pci.c b/drivers/net/wireless/ath/ath12k/pci.c
index 5fa7a3d770ee..0febff3bdf56 100644
--- a/drivers/net/wireless/ath/ath12k/pci.c
+++ b/drivers/net/wireless/ath/ath12k/pci.c
@@ -1505,6 +1505,7 @@ static void ath12k_pci_remove(struct pci_dev *pdev)
if (test_bit(ATH12K_FLAG_QMI_FAIL, &ab->dev_flags)) {
ath12k_pci_power_down(ab);
ath12k_qmi_deinit_service(ab);
+ ath12k_core_unassign_hw_group(ab);
goto qmi_fail;
}
--
2.34.1
From: Karthikeyan Periyasamy <[email protected]>
Currently, mac allocate/register and core_pdev_create are initiated
immediately when QMI firmware ready event is received for a particular
device.
With hardware device group abstraction, QMI firmware ready event can be
received simultaneously for different devices in the group and so, it
should not be registered immediately rather it has to be deferred until
all devices in the group has received QMI firmware ready.
To handle this, refactor the code of core start to move the following
apis inside a wrapper ath12k_core_hw_group_start()
* ath12k_mac_allocate()
* ath12k_core_pdev_create()
* ath12k_core_rfkill_config()
* ath12k_mac_register()
* ath12k_hif_irq_enable()
similarly, move the corresponding destroy/unregister/disable apis
inside wrapper ath12k_core_hw_group_stop()
Add the device flags to indicate pdev created and IRQ enabled which would
be helpful for device clean up during failure cases.
Tested-on: QCN9274 hw2.0 PCI WLAN.WBE.1.0.1-00029-QCAHKSWPL_SILICONZ-1
Signed-off-by: Karthikeyan Periyasamy <[email protected]>
Co-developed-by: Harshitha Prem <[email protected]>
Signed-off-by: Harshitha Prem <[email protected]>
---
drivers/net/wireless/ath/ath12k/core.c | 215 +++++++++++++++++++------
drivers/net/wireless/ath/ath12k/core.h | 32 ++++
2 files changed, 196 insertions(+), 51 deletions(-)
diff --git a/drivers/net/wireless/ath/ath12k/core.c b/drivers/net/wireless/ath/ath12k/core.c
index 0ad3c4cf48e1..72cef537da8f 100644
--- a/drivers/net/wireless/ath/ath12k/core.c
+++ b/drivers/net/wireless/ath/ath12k/core.c
@@ -543,6 +543,8 @@ u32 ath12k_core_get_max_num_tids(struct ath12k_base *ab)
static void ath12k_core_stop(struct ath12k_base *ab)
{
+ clear_bit(ATH12K_FLAG_CORE_STARTED, &ab->dev_flags);
+ ath12k_dec_num_core_started(ab);
ath12k_dp_rx_pdev_reo_cleanup(ab);
ath12k_hif_stop(ab);
ath12k_wmi_detach(ab);
@@ -667,11 +669,15 @@ static int ath12k_core_pdev_create(struct ath12k_base *ab)
return ret;
}
+ set_bit(ATH12K_FLAG_PDEV_CREATED, &ab->dev_flags);
+
return 0;
}
static void ath12k_core_pdev_destroy(struct ath12k_base *ab)
{
+ clear_bit(ATH12K_FLAG_PDEV_CREATED, &ab->dev_flags);
+
ath12k_dp_pdev_free(ab);
}
@@ -679,6 +685,7 @@ static int ath12k_core_start(struct ath12k_base *ab,
enum ath12k_firmware_mode mode)
{
int ret;
+ lockdep_assert_held(&ab->core_lock);
ret = ath12k_wmi_attach(ab);
if (ret) {
@@ -768,6 +775,11 @@ static int ath12k_core_start(struct ath12k_base *ab,
goto err_reo_cleanup;
}
+ /* Indicate the core start in the appropriate group */
+ ath12k_inc_num_core_started(ab);
+
+ set_bit(ATH12K_FLAG_CORE_STARTED, &ab->dev_flags);
+
return 0;
err_reo_cleanup:
@@ -779,6 +791,109 @@ static int ath12k_core_start(struct ath12k_base *ab,
return ret;
}
+static void ath12k_core_device_cleanup(struct ath12k_base *ab)
+{
+ mutex_lock(&ab->core_lock);
+
+ if (test_and_clear_bit(ATH12K_FLAG_CORE_HIF_IRQ_ENABLED, &ab->dev_flags))
+ ath12k_hif_irq_disable(ab);
+
+ if (test_bit(ATH12K_FLAG_PDEV_CREATED, &ab->dev_flags))
+ ath12k_core_pdev_destroy(ab);
+
+ if (test_bit(ATH12K_FLAG_REGISTERED, &ab->dev_flags)) {
+ ath12k_mac_unregister(ab);
+ ath12k_mac_destroy(ab);
+ }
+
+ mutex_unlock(&ab->core_lock);
+}
+
+static void ath12k_core_hw_group_stop(struct ath12k_hw_group *ag)
+{
+ struct ath12k_base *ab;
+ int i;
+
+ lockdep_assert_held(&ag->mutex_lock);
+
+ for (i = ag->num_devices - 1; i >= 0; i--) {
+ ab = ag->ab[i];
+ if (!ab)
+ continue;
+ ath12k_core_device_cleanup(ab);
+ }
+}
+
+static int ath12k_core_hw_group_start(struct ath12k_hw_group *ag)
+{
+ struct ath12k_base *ab;
+ int ret, i;
+ bool is_registered;
+
+ lockdep_assert_held(&ag->mutex_lock);
+
+ for (i = 0; i < ag->num_devices; i++) {
+ ab = ag->ab[i];
+ if (!ab)
+ continue;
+
+ mutex_lock(&ab->core_lock);
+
+ /* Check if already registered or not, since same flow
+ * execute for HW restart case.
+ */
+ is_registered = test_bit(ATH12K_FLAG_REGISTERED, &ab->dev_flags);
+
+ if (is_registered)
+ goto core_pdev_create;
+
+ ret = ath12k_mac_allocate(ab);
+ if (ret) {
+ ath12k_err(ab, "failed to create new hw device with mac80211 :%d\n",
+ ret);
+ mutex_unlock(&ab->core_lock);
+ return ret;
+ }
+
+ ret = ath12k_mac_register(ab);
+ if (ret) {
+ ath12k_err(ab, "failed to register radio with mac80211: %d\n",
+ ret);
+ mutex_unlock(&ab->core_lock);
+ goto err;
+ }
+
+core_pdev_create:
+ ret = ath12k_core_pdev_create(ab);
+ if (ret) {
+ ath12k_err(ab, "failed to create pdev core %d\n", ret);
+ mutex_unlock(&ab->core_lock);
+ goto err;
+ }
+
+ ret = ath12k_core_rfkill_config(ab);
+ if (ret && ret != -EOPNOTSUPP) {
+ mutex_unlock(&ab->core_lock);
+ goto err;
+ }
+
+ ath12k_hif_irq_enable(ab);
+
+ set_bit(ATH12K_FLAG_CORE_HIF_IRQ_ENABLED, &ab->dev_flags);
+
+ mutex_unlock(&ab->core_lock);
+ }
+
+ set_bit(ATH12K_GROUP_FLAG_REGISTERED, &ag->flags);
+
+ return 0;
+
+err:
+ ath12k_core_hw_group_stop(ag);
+
+ return ret;
+}
+
static int ath12k_core_start_firmware(struct ath12k_base *ab,
enum ath12k_firmware_mode mode)
{
@@ -796,9 +911,18 @@ static int ath12k_core_start_firmware(struct ath12k_base *ab,
return ret;
}
+static inline
+bool ath12k_core_hw_group_start_ready(struct ath12k_hw_group *ag)
+{
+ lockdep_assert_held(&ag->mutex_lock);
+
+ return (ag->num_started == ag->num_devices);
+}
+
int ath12k_core_qmi_firmware_ready(struct ath12k_base *ab)
{
- int ret;
+ struct ath12k_hw_group *ag;
+ int ret, i;
ret = ath12k_core_start_firmware(ab, ATH12K_FIRMWARE_MODE_NORMAL);
if (ret) {
@@ -818,59 +942,50 @@ int ath12k_core_qmi_firmware_ready(struct ath12k_base *ab)
goto err_firmware_stop;
}
+ ag = ath12k_ab_to_ag(ab);
+
+ mutex_lock(&ag->mutex_lock);
mutex_lock(&ab->core_lock);
ret = ath12k_core_start(ab, ATH12K_FIRMWARE_MODE_NORMAL);
if (ret) {
ath12k_err(ab, "failed to start core: %d\n", ret);
goto err_dp_free;
}
+ mutex_unlock(&ab->core_lock);
- ret = ath12k_mac_allocate(ab);
- if (ret) {
- ath12k_err(ab, "failed to create new hw device with mac80211 :%d\n",
- ret);
- goto err_core_stop;
- }
-
- ret = ath12k_mac_register(ab);
- if (ret) {
- ath12k_err(ab, "failed register the radio with mac80211: %d\n", ret);
- goto err_mac_destroy;
+ if (ath12k_core_hw_group_start_ready(ag)) {
+ ret = ath12k_core_hw_group_start(ag);
+ if (ret) {
+ ath12k_warn(ab, "unable to start hw group\n");
+ goto err_core_stop;
+ }
+ ath12k_dbg(ab, ATH12K_DBG_BOOT, "group %d started\n", ag->id);
}
+ mutex_unlock(&ag->mutex_lock);
- ret = ath12k_core_pdev_create(ab);
- if (ret) {
- ath12k_err(ab, "failed to create pdev core: %d\n", ret);
- goto err_mac_unregister;
- }
+ return 0;
- ath12k_hif_irq_enable(ab);
+err_core_stop:
+ for (i = ag->num_devices - 1; i >= 0; i--) {
+ ab = ag->ab[i];
+ if (!ab)
+ continue;
- ret = ath12k_core_rfkill_config(ab);
- if (ret && ret != -EOPNOTSUPP) {
- ath12k_err(ab, "failed to config rfkill: %d\n", ret);
- goto err_core_pdev_destroy;
+ mutex_lock(&ab->core_lock);
+ if (test_bit(ATH12K_FLAG_CORE_STARTED, &ab->dev_flags))
+ ath12k_core_stop(ab);
+ mutex_unlock(&ab->core_lock);
}
+ goto exit;
- mutex_unlock(&ab->core_lock);
-
- return 0;
-
-err_core_pdev_destroy:
- ath12k_hif_irq_disable(ab);
- ath12k_core_pdev_destroy(ab);
-err_mac_unregister:
- ath12k_mac_unregister(ab);
-err_mac_destroy:
- ath12k_mac_destroy(ab);
-err_core_stop:
- ath12k_core_stop(ab);
err_dp_free:
ath12k_dp_free(ab);
mutex_unlock(&ab->core_lock);
err_firmware_stop:
ath12k_qmi_firmware_stop(ab);
+exit:
+ mutex_unlock(&ag->mutex_lock);
return ret;
}
@@ -1127,6 +1242,10 @@ static void ath12k_core_reset(struct work_struct *work)
ath12k_dbg(ab, ATH12K_DBG_BOOT, "reset starting\n");
+ mutex_lock(&ab->ag->mutex_lock);
+ ath12k_dec_num_core_started(ab);
+ mutex_unlock(&ab->ag->mutex_lock);
+
ab->is_reset = true;
atomic_set(&ab->recovery_start_count, 0);
reinit_completion(&ab->recovery_start);
@@ -1234,7 +1353,7 @@ static struct ath12k_hw_group *ath12k_core_assign_hw_group(struct ath12k_base *a
void ath12k_core_unassign_hw_group(struct ath12k_base *ab)
{
- struct ath12k_hw_group *ag = ab->ag;
+ struct ath12k_hw_group *ag = ath12k_ab_to_ag(ab);
u8 device_id = ab->device_id;
int num_probed;
@@ -1268,19 +1387,6 @@ void ath12k_core_unassign_hw_group(struct ath12k_base *ab)
ath12k_core_hw_group_free(ag);
}
-static void ath12k_core_device_cleanup(struct ath12k_base *ab)
-{
- mutex_lock(&ab->core_lock);
-
- ath12k_hif_irq_disable(ab);
- ath12k_core_pdev_destroy(ab);
- ath12k_mac_unregister(ab);
- ath12k_mac_destroy(ab);
- ath12k_core_stop(ab);
-
- mutex_unlock(&ab->core_lock);
-}
-
static void ath12k_core_hw_group_destroy(struct ath12k_hw_group *ag)
{
struct ath12k_base *ab;
@@ -1291,13 +1397,20 @@ static void ath12k_core_hw_group_destroy(struct ath12k_hw_group *ag)
mutex_lock(&ag->mutex_lock);
+ if (test_and_clear_bit(ATH12K_GROUP_FLAG_REGISTERED, &ag->flags))
+ ath12k_core_hw_group_stop(ag);
+
for (i = 0; i < ag->num_devices; i++) {
ab = ag->ab[i];
if (!ab)
continue;
- if (test_bit(ATH12K_FLAG_QMI_FW_READY_COMPLETE, &ab->dev_flags))
- ath12k_core_device_cleanup(ab);
+ mutex_lock(&ab->core_lock);
+
+ if (test_bit(ATH12K_FLAG_CORE_STARTED, &ab->dev_flags))
+ ath12k_core_stop(ab);
+
+ mutex_unlock(&ab->core_lock);
if (test_and_clear_bit(ATH12K_FLAG_HW_GROUP_ATTACHED, &ab->dev_flags))
ath12k_core_soc_destroy(ab);
diff --git a/drivers/net/wireless/ath/ath12k/core.h b/drivers/net/wireless/ath/ath12k/core.h
index fd3e4e66d27c..10a09ddb7bc5 100644
--- a/drivers/net/wireless/ath/ath12k/core.h
+++ b/drivers/net/wireless/ath/ath12k/core.h
@@ -200,6 +200,10 @@ enum ath12k_scan_state {
ATH12K_SCAN_ABORTING,
};
+enum ath12k_hw_group_flags {
+ ATH12K_GROUP_FLAG_REGISTERED,
+};
+
enum ath12k_dev_flags {
ATH12K_CAC_RUNNING,
ATH12K_FLAG_CRASH_FLUSH,
@@ -214,6 +218,9 @@ enum ath12k_dev_flags {
ATH12K_FLAG_EXT_IRQ_ENABLED,
ATH12K_FLAG_QMI_FW_READY_COMPLETE,
ATH12K_FLAG_HW_GROUP_ATTACHED,
+ ATH12K_FLAG_PDEV_CREATED,
+ ATH12K_FLAG_CORE_STARTED,
+ ATH12K_FLAG_CORE_HIF_IRQ_ENABLED,
};
enum ath12k_monitor_flags {
@@ -734,6 +741,8 @@ struct ath12k_hw_group {
u8 id;
u8 num_devices;
u8 num_probed;
+ u8 num_started;
+ unsigned long flags;
struct ath12k_base *ab[ATH12K_MAX_SOCS];
/* To synchronize group create, assign, start, stop */
struct mutex mutex_lock;
@@ -1064,4 +1073,27 @@ static inline int ath12k_get_num_hw(struct ath12k_base *ab)
{
return ab->num_hw;
}
+
+static inline
+struct ath12k_hw_group *ath12k_ab_to_ag(struct ath12k_base *ab)
+{
+ return ab->ag;
+}
+
+static inline
+void ath12k_inc_num_core_started(struct ath12k_base *ab)
+{
+ lockdep_assert_held(&ab->ag->mutex_lock);
+
+ ab->ag->num_started++;
+}
+
+static inline
+void ath12k_dec_num_core_started(struct ath12k_base *ab)
+{
+ lockdep_assert_held(&ab->ag->mutex_lock);
+
+ ab->ag->num_started--;
+}
+
#endif /* _CORE_H_ */
--
2.34.1
From: Karthikeyan Periyasamy <[email protected]>
Currently, hardware abstractions (ah) of different radio bands
are tightly coupled to a single device (ab). But, with hardware
device group abstraction (ag), multiple radios across different
devices in a group can possibly form different combinations of
hardware abstractions (ah) within the group. Hence, the mapping
between ah to ab can be removed and instead it can be mapped with ag.
Please find below illustration of how mapping between ath12k_hw (ah),
ath12k_base (ab) and ath12k_hw_group (ag) is changed.
current mapping of hardware abstraction (ah) with device (ab)
+------------------------------------------------+
| +-------------------------------------+ |
| | +---------------+ +---------------+ | |
| | |ath12k_hw (ah) | |ath12k_hw (ah) | | |
| | +---------------+ +---------------+ | |
| | | |
| | +-----------+ | +-----------+ | |
| | | ar (2GHz) | | | ar (5GHz) | | |
| | +-----------+ | +-----------+ | |
| | Dual band device-1 (ab) | |
| +-------------------------------------+ |
| ath12k_hw_group (ag) based on group id |
+------------------------------------------------+
After, with hardware device group abstraction
(moving ah array out of ab to ag)
+----------------------------------------------+
| +---------------+ +---------------+ |
| |ath12k_hw (ah) | |ath12k_hw (ah) | |
| +---------------+ +---------------+ |
| +-------------------------------------+ |
| | +-----------+ +-----------+ | |
| | | ar (2GHz) | | ar (5GHz) | | |
| | +-----------+ +-----------+ | |
| | Dual band device-1 (ab) | |
| +-------------------------------------+ |
| ath12k_hw_group (ag) based on group id |
+----------------------------------------------+
This decoupling of ath12k_hw (ah) from ath12k_base (ab) and mapping it
to ath12k_hw_group (ag) will help in forming different combinations of
multi-link devices.
Say for example, device 1 has two radios (2 GHz and 5 GHz band) and
device 2 has one radio (6 GHz).
In existing code -
device 1 will have two hardware abstractions hw1 (2 GHz) and
hw2 (5 GHz) will be registered separately to mac80211 as phy0
and phy1 respectively. Similarly, device 2 will register its
hw (6 GHz) as phy2 to mac80211.
In future, with multi-link abstraction
combination 1 - Different group id for device1 and device 2
Device 1 will create a single hardware abstraction hw1
(2 GHz and 5 GHz) and will be registered to mac80211 as
phy0. similarly, device 2 will register its hardware
(6 GHz) to mac80211 as phy1.
combination 2 - Same group id for device1 and device 2
Both device details are combined together as a group, say
group1, with single hardware abstraction of radios 2 GHz,
5 GHz and 6 GHz band details and will be registered to
mac80211 as phy0.
Hence, Add changes to decouple ath12k_hw (ah) from ath12k_base (ab) and
map it to ath12k_hw_group (ag).
Refactor the following APIs to help simplify the registration based on
ath12k_hw_group (ag) rather than ath12k_base (ab)
* ath12k_mac_allocate()
* ath12k_mac_destroy()
* ath12k_mac_register()
* ath12k_mac_unregister()
Tested-on: QCN9274 hw2.0 PCI WLAN.WBE.1.0.1-00029-QCAHKSWPL_SILICONZ-1
Signed-off-by: Karthikeyan Periyasamy <[email protected]>
Signed-off-by: Harshitha Prem <[email protected]>
---
drivers/net/wireless/ath/ath12k/core.c | 52 +++++++---------
drivers/net/wireless/ath/ath12k/core.h | 25 ++++----
drivers/net/wireless/ath/ath12k/mac.c | 84 +++++++++++++++++++-------
drivers/net/wireless/ath/ath12k/mac.h | 9 +--
4 files changed, 101 insertions(+), 69 deletions(-)
diff --git a/drivers/net/wireless/ath/ath12k/core.c b/drivers/net/wireless/ath/ath12k/core.c
index 72cef537da8f..a901f008f69b 100644
--- a/drivers/net/wireless/ath/ath12k/core.c
+++ b/drivers/net/wireless/ath/ath12k/core.c
@@ -801,11 +801,6 @@ static void ath12k_core_device_cleanup(struct ath12k_base *ab)
if (test_bit(ATH12K_FLAG_PDEV_CREATED, &ab->dev_flags))
ath12k_core_pdev_destroy(ab);
- if (test_bit(ATH12K_FLAG_REGISTERED, &ab->dev_flags)) {
- ath12k_mac_unregister(ab);
- ath12k_mac_destroy(ab);
- }
-
mutex_unlock(&ab->core_lock);
}
@@ -822,6 +817,8 @@ static void ath12k_core_hw_group_stop(struct ath12k_hw_group *ag)
continue;
ath12k_core_device_cleanup(ab);
}
+ ath12k_mac_unregister(ag);
+ ath12k_mac_destroy(ag);
}
static int ath12k_core_hw_group_start(struct ath12k_hw_group *ag)
@@ -832,6 +829,23 @@ static int ath12k_core_hw_group_start(struct ath12k_hw_group *ag)
lockdep_assert_held(&ag->mutex_lock);
+ /* Check if already registered or not, since same flow
+ * execute for HW restart case.
+ */
+ is_registered = test_bit(ATH12K_GROUP_FLAG_REGISTERED, &ag->flags);
+
+ if (is_registered)
+ goto core_pdev_create;
+
+ ret = ath12k_mac_allocate(ag);
+ if (WARN_ON(ret))
+ return ret;
+
+ ret = ath12k_mac_register(ag);
+ if (WARN_ON(ret))
+ goto err_mac_alloc;
+
+core_pdev_create:
for (i = 0; i < ag->num_devices; i++) {
ab = ag->ab[i];
if (!ab)
@@ -839,31 +853,6 @@ static int ath12k_core_hw_group_start(struct ath12k_hw_group *ag)
mutex_lock(&ab->core_lock);
- /* Check if already registered or not, since same flow
- * execute for HW restart case.
- */
- is_registered = test_bit(ATH12K_FLAG_REGISTERED, &ab->dev_flags);
-
- if (is_registered)
- goto core_pdev_create;
-
- ret = ath12k_mac_allocate(ab);
- if (ret) {
- ath12k_err(ab, "failed to create new hw device with mac80211 :%d\n",
- ret);
- mutex_unlock(&ab->core_lock);
- return ret;
- }
-
- ret = ath12k_mac_register(ab);
- if (ret) {
- ath12k_err(ab, "failed to register radio with mac80211: %d\n",
- ret);
- mutex_unlock(&ab->core_lock);
- goto err;
- }
-
-core_pdev_create:
ret = ath12k_core_pdev_create(ab);
if (ret) {
ath12k_err(ab, "failed to create pdev core %d\n", ret);
@@ -890,7 +879,10 @@ static int ath12k_core_hw_group_start(struct ath12k_hw_group *ag)
err:
ath12k_core_hw_group_stop(ag);
+ return ret;
+err_mac_alloc:
+ ath12k_mac_destroy(ag);
return ret;
}
diff --git a/drivers/net/wireless/ath/ath12k/core.h b/drivers/net/wireless/ath/ath12k/core.h
index 10a09ddb7bc5..6bd7f1cc1109 100644
--- a/drivers/net/wireless/ath/ath12k/core.h
+++ b/drivers/net/wireless/ath/ath12k/core.h
@@ -58,6 +58,7 @@
#define ATH12K_RECOVER_START_TIMEOUT_HZ (20 * HZ)
#define ATH12K_MAX_SOCS 3
+#define ATH12K_GROUP_MAX_RADIO (ATH12K_MAX_SOCS * MAX_RADIOS)
#define ATH12K_INVALID_GROUP_ID 0xFF
#define ATH12K_INVALID_DEVICE_ID 0xFF
@@ -746,6 +747,15 @@ struct ath12k_hw_group {
struct ath12k_base *ab[ATH12K_MAX_SOCS];
/* To synchronize group create, assign, start, stop */
struct mutex mutex_lock;
+
+ /* Holds information of wiphy (hw) registration.
+ *
+ * In Multi/Single Link Operation case, all pdevs are registered as
+ * a single wiphy. In other (legacy/Non-MLO) cases, each pdev is
+ * registered as separate wiphys.
+ */
+ struct ath12k_hw *ah[MAX_RADIOS];
+ u8 num_hw;
};
/**
@@ -816,15 +826,6 @@ struct ath12k_base {
struct ath12k_pdev __rcu *pdevs_active[MAX_RADIOS];
- /* Holds information of wiphy (hw) registration.
- *
- * In Multi/Single Link Operation case, all pdevs are registered as
- * a single wiphy. In other (legacy/Non-MLO) cases, each pdev is
- * registered as separate wiphys.
- */
- struct ath12k_hw *ah[MAX_RADIOS];
- u8 num_hw;
-
struct ath12k_wmi_hal_reg_capabilities_ext_arg hal_reg_cap[MAX_RADIOS];
unsigned long long free_vdev_map;
unsigned long long free_vdev_stats_id_map;
@@ -1060,18 +1061,18 @@ static inline struct ieee80211_hw *ath12k_ar_to_hw(struct ath12k *ar)
static inline struct ath12k_hw *ath12k_ab_to_ah(struct ath12k_base *ab, int idx)
{
- return ab->ah[idx];
+ return ab->ag->ah[idx];
}
static inline void ath12k_ab_set_ah(struct ath12k_base *ab, int idx,
struct ath12k_hw *ah)
{
- ab->ah[idx] = ah;
+ ab->ag->ah[idx] = ah;
}
static inline int ath12k_get_num_hw(struct ath12k_base *ab)
{
- return ab->num_hw;
+ return ab->ag->num_hw;
}
static inline
diff --git a/drivers/net/wireless/ath/ath12k/mac.c b/drivers/net/wireless/ath/ath12k/mac.c
index ebfd9c828dfc..1933a8bd6ce0 100644
--- a/drivers/net/wireless/ath/ath12k/mac.c
+++ b/drivers/net/wireless/ath/ath12k/mac.c
@@ -8773,19 +8773,13 @@ static void ath12k_mac_setup(struct ath12k *ar)
clear_bit(ATH12K_FLAG_MONITOR_ENABLED, &ar->monitor_flags);
}
-int ath12k_mac_register(struct ath12k_base *ab)
+int ath12k_mac_register(struct ath12k_hw_group *ag)
{
+ struct ath12k_base *ab = ag->ab[0];
struct ath12k_hw *ah;
int i;
int ret;
- if (test_bit(ATH12K_FLAG_REGISTERED, &ab->dev_flags))
- return 0;
-
- /* Initialize channel counters frequency value in hertz */
- ab->cc_freq_hz = 320000;
- ab->free_vdev_map = (1LL << (ab->num_radios * TARGET_NUM_VDEVS)) - 1;
-
for (i = 0; i < ath12k_get_num_hw(ab); i++) {
ah = ath12k_ab_to_ah(ab, i);
@@ -8809,8 +8803,9 @@ int ath12k_mac_register(struct ath12k_base *ab)
return ret;
}
-void ath12k_mac_unregister(struct ath12k_base *ab)
+void ath12k_mac_unregister(struct ath12k_hw_group *ag)
{
+ struct ath12k_base *ab = ag->ab[0];
struct ath12k_hw *ah;
int i;
@@ -8871,18 +8866,24 @@ static struct ath12k_hw *ath12k_mac_hw_allocate(struct ath12k_base *ab,
return ah;
}
-void ath12k_mac_destroy(struct ath12k_base *ab)
+void ath12k_mac_destroy(struct ath12k_hw_group *ag)
{
struct ath12k_pdev *pdev;
- struct ath12k_hw *ah;
+ struct ath12k_base *ab = ag->ab[0];
int i;
+ struct ath12k_hw *ah;
- for (i = 0; i < ab->num_radios; i++) {
- pdev = &ab->pdevs[i];
- if (!pdev->ar)
+ for (i = 0; i < ag->num_devices; i++) {
+ ab = ag->ab[i];
+ if (!ab)
continue;
- pdev->ar = NULL;
+ for (i = 0; i < ab->num_radios; i++) {
+ pdev = &ab->pdevs[i];
+ if (!pdev->ar)
+ continue;
+ pdev->ar = NULL;
+ }
}
for (i = 0; i < ath12k_get_num_hw(ab); i++) {
@@ -8895,20 +8896,45 @@ void ath12k_mac_destroy(struct ath12k_base *ab)
}
}
-int ath12k_mac_allocate(struct ath12k_base *ab)
+static inline void ath12k_set_core_defaults(struct ath12k_base *ab)
+{
+ /* Initialize channel counters frequency value in hertz */
+ ab->cc_freq_hz = 320000;
+ ab->free_vdev_map = (1LL << (ab->num_radios * TARGET_NUM_VDEVS)) - 1;
+}
+
+int ath12k_mac_allocate(struct ath12k_hw_group *ag)
{
struct ath12k_hw *ah;
+ struct ath12k_base *ab;
struct ath12k_pdev_map pdev_map[MAX_RADIOS];
int ret, i, j;
u8 radio_per_hw;
+ int mac_id, device_id;
+ int total_radio, num_hw;
- if (test_bit(ATH12K_FLAG_REGISTERED, &ab->dev_flags))
- return 0;
+ total_radio = 0;
+ for (i = 0; i < ag->num_devices; i++)
+ total_radio += ag->ab[i]->num_radios;
- ab->num_hw = ab->num_radios;
+ /* All pdev get combined and register as single wiphy based on
+ * hardware group which participate in multi-link operation else
+ * each pdev get register separately.
+ *
+ * Currently, registering as single pdevs.
+ */
radio_per_hw = 1;
+ num_hw = total_radio / radio_per_hw;
+
+ if (WARN_ON(num_hw >= ATH12K_GROUP_MAX_RADIO))
+ return -ENOSPC;
+
+ ag->num_hw = 0;
+ device_id = 0;
+ mac_id = 0;
+ for (i = 0; i < num_hw; i++) {
+ ab = ag->ab[device_id];
- for (i = 0; i < ath12k_get_num_hw(ab); i++) {
for (j = 0; j < radio_per_hw; j++) {
pdev_map[j].ab = ab;
pdev_map[j].pdev_idx = (i * radio_per_hw) + j;
@@ -8922,11 +8948,23 @@ int ath12k_mac_allocate(struct ath12k_base *ab)
goto err;
}
- ath12k_ab_set_ah(ab, i, ah);
+ mac_id++;
+ /* If mac_id falls beyond the current device MACs then
+ * move to next device
+ */
+ if (mac_id >= ab->num_radios) {
+ device_id++;
+ mac_id = 0;
+
+ /* Initialize channel counters frequency value in hertz */
+ ab->cc_freq_hz = 320000;
+ ab->free_vdev_map = (1LL << (ab->num_radios * TARGET_NUM_VDEVS)) - 1;
+ ath12k_dp_pdev_pre_alloc(ab);
+ }
+ ag->ah[i] = ah;
+ ag->num_hw++;
}
- ath12k_dp_pdev_pre_alloc(ab);
-
return 0;
err:
diff --git a/drivers/net/wireless/ath/ath12k/mac.h b/drivers/net/wireless/ath/ath12k/mac.h
index 3f5e1be0dff9..0489f5cd1378 100644
--- a/drivers/net/wireless/ath/ath12k/mac.h
+++ b/drivers/net/wireless/ath/ath12k/mac.h
@@ -13,6 +13,7 @@
struct ath12k;
struct ath12k_base;
struct ath12k_hw;
+struct ath12k_hw_group;
struct ath12k_pdev_map;
struct ath12k_generic_iter {
@@ -50,10 +51,10 @@ enum ath12k_supported_bw {
extern const struct htt_rx_ring_tlv_filter ath12k_mac_mon_status_filter_default;
-void ath12k_mac_destroy(struct ath12k_base *ab);
-void ath12k_mac_unregister(struct ath12k_base *ab);
-int ath12k_mac_register(struct ath12k_base *ab);
-int ath12k_mac_allocate(struct ath12k_base *ab);
+void ath12k_mac_destroy(struct ath12k_hw_group *ag);
+void ath12k_mac_unregister(struct ath12k_hw_group *ag);
+int ath12k_mac_register(struct ath12k_hw_group *ag);
+int ath12k_mac_allocate(struct ath12k_hw_group *ag);
int ath12k_mac_hw_ratecode_to_legacy_rate(u8 hw_rc, u8 preamble, u8 *rateidx,
u16 *rate);
u8 ath12k_mac_bitrate_to_idx(const struct ieee80211_supported_band *sband,
--
2.34.1
From: Karthikeyan Periyasamy <[email protected]>
When hardware device group abstraction is introduced, QMI firmware
ready event of different devices in a group can be received simultaneously.
To indicate firmware ready event is completed for a particular device in a
group set a flag (ATH12K_FLAG_QMI_FW_READY_COMPLETE). This would be
helpful when hardware recovery is introduced for hardware device group
abstraction.
Add changes to set/unset ATH12K_FLAG_QMI_FW_READY_COMPLETE flag for a
device.
Tested-on: QCN9274 hw2.0 PCI WLAN.WBE.1.0.1-00029-QCAHKSWPL_SILICONZ-1
Signed-off-by: Karthikeyan Periyasamy <[email protected]>
Signed-off-by: Harshitha Prem <[email protected]>
---
drivers/net/wireless/ath/ath12k/core.h | 1 +
drivers/net/wireless/ath/ath12k/qmi.c | 13 ++++++++++---
2 files changed, 11 insertions(+), 3 deletions(-)
diff --git a/drivers/net/wireless/ath/ath12k/core.h b/drivers/net/wireless/ath/ath12k/core.h
index c06bbb083ab3..3961a45a3458 100644
--- a/drivers/net/wireless/ath/ath12k/core.h
+++ b/drivers/net/wireless/ath/ath12k/core.h
@@ -208,6 +208,7 @@ enum ath12k_dev_flags {
ATH12K_FLAG_HTC_SUSPEND_COMPLETE,
ATH12K_FLAG_CE_IRQ_ENABLED,
ATH12K_FLAG_EXT_IRQ_ENABLED,
+ ATH12K_FLAG_QMI_FW_READY_COMPLETE,
};
enum ath12k_monitor_flags {
diff --git a/drivers/net/wireless/ath/ath12k/qmi.c b/drivers/net/wireless/ath/ath12k/qmi.c
index db8ba5fec2ae..0e34dfadf1b9 100644
--- a/drivers/net/wireless/ath/ath12k/qmi.c
+++ b/drivers/net/wireless/ath/ath12k/qmi.c
@@ -2968,6 +2968,8 @@ void ath12k_qmi_firmware_stop(struct ath12k_base *ab)
{
int ret;
+ clear_bit(ATH12K_FLAG_QMI_FW_READY_COMPLETE, &ab->dev_flags);
+
ret = ath12k_qmi_wlanfw_mode_send(ab, ATH12K_FIRMWARE_MODE_OFF);
if (ret < 0) {
ath12k_warn(ab, "qmi failed to send wlan mode off\n");
@@ -3262,7 +3264,8 @@ static void ath12k_qmi_driver_event_work(struct work_struct *work)
break;
case ATH12K_QMI_EVENT_FW_READY:
clear_bit(ATH12K_FLAG_QMI_FAIL, &ab->dev_flags);
- if (test_bit(ATH12K_FLAG_REGISTERED, &ab->dev_flags)) {
+ if (test_bit(ATH12K_FLAG_QMI_FW_READY_COMPLETE,
+ &ab->dev_flags)) {
ath12k_hal_dump_srng_stats(ab);
queue_work(ab->workqueue, &ab->restart_work);
break;
@@ -3271,8 +3274,12 @@ static void ath12k_qmi_driver_event_work(struct work_struct *work)
clear_bit(ATH12K_FLAG_CRASH_FLUSH,
&ab->dev_flags);
clear_bit(ATH12K_FLAG_RECOVERY, &ab->dev_flags);
- ath12k_core_qmi_firmware_ready(ab);
- set_bit(ATH12K_FLAG_REGISTERED, &ab->dev_flags);
+ ret = ath12k_core_qmi_firmware_ready(ab);
+ if (!ret) {
+ set_bit(ATH12K_FLAG_QMI_FW_READY_COMPLETE,
+ &ab->dev_flags);
+ set_bit(ATH12K_FLAG_REGISTERED, &ab->dev_flags);
+ }
break;
default:
--
2.34.1
From: Karthikeyan Periyasamy <[email protected]>
When hardware device group abstraction is introduced, in future, a group
abstraction is registered to mac80211 rather than a particular device.
Hence, setting ATH12K_FLAG_REGISTERED in QMI firmware ready event might not
be ideal.
Add changes to move set/unset of ATH12K_FLAG_REGISTERED flag inside
ath12k_mac_register() and ath12k_mac_unregister() respectively.
Tested-on: QCN9274 hw2.0 PCI WLAN.WBE.1.0.1-00029-QCAHKSWPL_SILICONZ-1
Signed-off-by: Karthikeyan Periyasamy <[email protected]>
Signed-off-by: Harshitha Prem <[email protected]>
---
drivers/net/wireless/ath/ath12k/mac.c | 2 ++
drivers/net/wireless/ath/ath12k/qmi.c | 4 +---
2 files changed, 3 insertions(+), 3 deletions(-)
diff --git a/drivers/net/wireless/ath/ath12k/mac.c b/drivers/net/wireless/ath/ath12k/mac.c
index 8516a0168f7b..ebfd9c828dfc 100644
--- a/drivers/net/wireless/ath/ath12k/mac.c
+++ b/drivers/net/wireless/ath/ath12k/mac.c
@@ -8794,6 +8794,7 @@ int ath12k_mac_register(struct ath12k_base *ab)
goto err;
}
+ set_bit(ATH12K_FLAG_REGISTERED, &ab->dev_flags);
return 0;
err:
@@ -8813,6 +8814,7 @@ void ath12k_mac_unregister(struct ath12k_base *ab)
struct ath12k_hw *ah;
int i;
+ clear_bit(ATH12K_FLAG_REGISTERED, &ab->dev_flags);
for (i = ath12k_get_num_hw(ab) - 1; i >= 0; i--) {
ah = ath12k_ab_to_ah(ab, i);
if (!ah)
diff --git a/drivers/net/wireless/ath/ath12k/qmi.c b/drivers/net/wireless/ath/ath12k/qmi.c
index 0e34dfadf1b9..b7cfb6971fae 100644
--- a/drivers/net/wireless/ath/ath12k/qmi.c
+++ b/drivers/net/wireless/ath/ath12k/qmi.c
@@ -3275,11 +3275,9 @@ static void ath12k_qmi_driver_event_work(struct work_struct *work)
&ab->dev_flags);
clear_bit(ATH12K_FLAG_RECOVERY, &ab->dev_flags);
ret = ath12k_core_qmi_firmware_ready(ab);
- if (!ret) {
+ if (!ret)
set_bit(ATH12K_FLAG_QMI_FW_READY_COMPLETE,
&ab->dev_flags);
- set_bit(ATH12K_FLAG_REGISTERED, &ab->dev_flags);
- }
break;
default:
--
2.34.1
Harshitha Prem <[email protected]> writes:
> To support multi-link operation, multiple devices with different bands say
> 2 GHz or 5 GHz or 6 GHz can be combined together as a group and provide
> an abstraction to mac80211.
>
> Device group abstraction - when there are multiple devices that are
> connected by any means of communication interface between them, then these
> devices can be combined together as a single group using a group id to form
> a group abstraction. In ath12k driver, this abstraction would be named as
> ath12k_hw_group (ag).
>
> Please find below illustration of device group abstraction with two
> devices.
>
> Grouping of multiple devices (in future)
> +------------------------------------------------------------------------+
> | +-------------------------------------+ +-------------------+ |
> | | +-----------+ | | +-----------+ | | +-----------+ | |
> | | | ar (2GHz) | | | | ar (5GHz) | | | | ar (6GHz) | | |
> | | +-----------+ | | +-----------+ | | +-----------+ | |
> | | ath12k_base (ab) | | ath12k_base (ab) | |
> | | (Dual band device) | | | |
> | +-------------------------------------+ +-------------------+ |
> | ath12k_hw_group (ag) based on group id |
> +------------------------------------------------------------------------+
>
> Say for example, device 1 has two radios (2 GHz and 5 GHz band) and
> device 2 has one radio (6 GHz).
>
> In existing code -
> device 1 will have two hardware abstractions hw1 (2 GHz) and hw2
> (5 GHz) will be registered separately to mac80211 as phy0 and phy1
> respectively. Similarly, device 2 will register its hw (6GHz) as
> phy2 to mac80211.
>
> In future, with multi-link abstraction
>
> combination 1 - Different group id for device1 and device 2
> Device 1 will create a single hardware abstraction hw1
> (2 GHz and 5 GHz) and will be registered to mac80211 as
> phy0. similarly, device 2 will register its hardware
> (6 GHz) to mac80211 as phy1.
>
> combination 2 - Same group id for device1 and device 2
> Both device details are combined together as a group, say
> group1, with single hardware abstraction of radios 2 GHz,
> 5 GHz and 6 GHz band details and will be registered to
> mac80211 as phy0.
>
> Add base infrastructure changes to add device grouping abstraction with
> a single device.
>
> This patch series brings the base code changes with following order:
> 1. Refactor existing code which would facilitate in introducing
> device group abstraction.
> 2. Create a device group abstraction during device probe.
> 3. Start the device group only after QMI firmware ready event is
> received for all the devices that are combined in the group.
> 4. Move the hardware abstractions (ath12k_hw - ah) from device
> (ath12k_base - ab) to device group abstraction (ag) as it would
> ease in having different combinations of group abstraction that
> can be registered to mac80211.
>
>
> Depends-on:
> [PATCH 0/3] wifi: ath12k: Refactor the hardware recovery
> procedures
Are you referring to this patchset:
https://patchwork.kernel.org/project/linux-wireless/list/?series=821155&state=*&order=date
That was sent three months ago and at least I couldn't find a newer
version. So I'll just drop this patchset for now without even looking at
it.
--
https://patchwork.kernel.org/project/linux-wireless/list/
https://wireless.wiki.kernel.org/en/developers/documentation/submittingpatches
On 4/23/2024 2:39 AM, Kalle Valo wrote:
> Harshitha Prem <[email protected]> writes:
>
>> To support multi-link operation, multiple devices with different bands say
>> 2 GHz or 5 GHz or 6 GHz can be combined together as a group and provide
>> an abstraction to mac80211.
>>
>> Device group abstraction - when there are multiple devices that are
>> connected by any means of communication interface between them, then these
>> devices can be combined together as a single group using a group id to form
>> a group abstraction. In ath12k driver, this abstraction would be named as
>> ath12k_hw_group (ag).
>>
>> Please find below illustration of device group abstraction with two
>> devices.
>>
>> Grouping of multiple devices (in future)
>> +------------------------------------------------------------------------+
>> | +-------------------------------------+ +-------------------+ |
>> | | +-----------+ | | +-----------+ | | +-----------+ | |
>> | | | ar (2GHz) | | | | ar (5GHz) | | | | ar (6GHz) | | |
>> | | +-----------+ | | +-----------+ | | +-----------+ | |
>> | | ath12k_base (ab) | | ath12k_base (ab) | |
>> | | (Dual band device) | | | |
>> | +-------------------------------------+ +-------------------+ |
>> | ath12k_hw_group (ag) based on group id |
>> +------------------------------------------------------------------------+
>>
>> Say for example, device 1 has two radios (2 GHz and 5 GHz band) and
>> device 2 has one radio (6 GHz).
>>
>> In existing code -
>> device 1 will have two hardware abstractions hw1 (2 GHz) and hw2
>> (5 GHz) will be registered separately to mac80211 as phy0 and phy1
>> respectively. Similarly, device 2 will register its hw (6GHz) as
>> phy2 to mac80211.
>>
>> In future, with multi-link abstraction
>>
>> combination 1 - Different group id for device1 and device 2
>> Device 1 will create a single hardware abstraction hw1
>> (2 GHz and 5 GHz) and will be registered to mac80211 as
>> phy0. similarly, device 2 will register its hardware
>> (6 GHz) to mac80211 as phy1.
>>
>> combination 2 - Same group id for device1 and device 2
>> Both device details are combined together as a group, say
>> group1, with single hardware abstraction of radios 2 GHz,
>> 5 GHz and 6 GHz band details and will be registered to
>> mac80211 as phy0.
>>
>> Add base infrastructure changes to add device grouping abstraction with
>> a single device.
>>
>> This patch series brings the base code changes with following order:
>> 1. Refactor existing code which would facilitate in introducing
>> device group abstraction.
>> 2. Create a device group abstraction during device probe.
>> 3. Start the device group only after QMI firmware ready event is
>> received for all the devices that are combined in the group.
>> 4. Move the hardware abstractions (ath12k_hw - ah) from device
>> (ath12k_base - ab) to device group abstraction (ag) as it would
>> ease in having different combinations of group abstraction that
>> can be registered to mac80211.
>>
>>
>> Depends-on:
>> [PATCH 0/3] wifi: ath12k: Refactor the hardware recovery
>> procedures
>
> Are you referring to this patchset:
>
> https://patchwork.kernel.org/project/linux-wireless/list/?series=821155&state=*&order=date
>
> That was sent three months ago and at least I couldn't find a newer
> version. So I'll just drop this patchset for now without even looking at
> it.
>
Yes, I'm stumped as well. the patch specifies:
>base-commit: c416602943dd36fbd13af7496430723935c867a3
>prerequisite-patch-id: a4d62344b11368fb7e549c03b6a31f7ba4c9e2bb
>prerequisite-patch-id: b4a1e18a85d8c1e337fa133c2bd2956c33b11046
>prerequisite-patch-id: b16edd310baa35e2500267e338f60c9a2e6594e1
but lore is unable to find those prerequisite patch-ids, which leads me to
believe that they were rebased internally but never posted.
I tried to apply the January series on top of the base-commit:
c416602943dd36fbd13af7496430723935c867a3 but it doesn't apply cleanly.
So I think we need to have a rebased and updated "Refactor the hardware
recovery procedures" first.
/jeff
Jeff Johnson <[email protected]> writes:
>>> Depends-on:
>>> [PATCH 0/3] wifi: ath12k: Refactor the hardware recovery
>>> procedures
>>
>> Are you referring to this patchset:
>>
>> https://patchwork.kernel.org/project/linux-wireless/list/?series=821155&state=*&order=date
>>
>> That was sent three months ago and at least I couldn't find a newer
>> version. So I'll just drop this patchset for now without even looking at
>> it.
>>
>
> Yes, I'm stumped as well. the patch specifies:
>>base-commit: c416602943dd36fbd13af7496430723935c867a3
>>prerequisite-patch-id: a4d62344b11368fb7e549c03b6a31f7ba4c9e2bb
>>prerequisite-patch-id: b4a1e18a85d8c1e337fa133c2bd2956c33b11046
>>prerequisite-patch-id: b16edd310baa35e2500267e338f60c9a2e6594e1
>
> but lore is unable to find those prerequisite patch-ids, which leads me to
> believe that they were rebased internally but never posted.
>
> I tried to apply the January series on top of the base-commit:
> c416602943dd36fbd13af7496430723935c867a3 but it doesn't apply cleanly.
>
> So I think we need to have a rebased and updated "Refactor the hardware
> recovery procedures" first.
Yeah, it's waste of everyone's time to submit patches like this which
don't even apply at all due to missing dependencies. Please don't do
that.
--
https://patchwork.kernel.org/project/linux-wireless/list/
https://wireless.wiki.kernel.org/en/developers/documentation/submittingpatches
On 4/24/2024 10:09 AM, Kalle Valo wrote:
> Jeff Johnson <[email protected]> writes:
>
>>>> Depends-on:
>>>> [PATCH 0/3] wifi: ath12k: Refactor the hardware recovery
>>>> procedures
>>>
>>> Are you referring to this patchset:
>>>
>>> https://patchwork.kernel.org/project/linux-wireless/list/?series=821155&state=*&order=date
>>>
>>> That was sent three months ago and at least I couldn't find a newer
>>> version. So I'll just drop this patchset for now without even looking at
>>> it.
>>>
>>
>> Yes, I'm stumped as well. the patch specifies:
>>> base-commit: c416602943dd36fbd13af7496430723935c867a3
>>> prerequisite-patch-id: a4d62344b11368fb7e549c03b6a31f7ba4c9e2bb
>>> prerequisite-patch-id: b4a1e18a85d8c1e337fa133c2bd2956c33b11046
>>> prerequisite-patch-id: b16edd310baa35e2500267e338f60c9a2e6594e1
>>
>> but lore is unable to find those prerequisite patch-ids, which leads me to
>> believe that they were rebased internally but never posted.
>>
>> I tried to apply the January series on top of the base-commit:
>> c416602943dd36fbd13af7496430723935c867a3 but it doesn't apply cleanly.
>>
>> So I think we need to have a rebased and updated "Refactor the hardware
>> recovery procedures" first.
>
> Yeah, it's waste of everyone's time to submit patches like this which
> don't even apply at all due to missing dependencies. Please don't do
> that.
>
Sure. Sorry Jeff and Kalle, My bad!. yes,the dependent patch should be
rebased. Will respawn this series after the dependencies are at the latest.
Thanks,
Harshitha