2024-05-28 06:36:27

by Harshitha Prem

Subject: [PATCH v7 0/8] wifi: ath12k: Introduce device group abstraction

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.

v7:
- Added linux-wireless mailer to cc.
- Removed Acked-by tag from "[PATCH v6 8/8]" as it has minor change.

v6:
- Addressed smatch error seen on "[PATCH v5 8/8] wifi: ath12k: move
ath12k_hw from per soc to group"
- Rebased to ToT
v5:
- on "[PATCH 8/8] wifi: ath12k: move ath12k_hw from per soc to
group", refactor the ath12k_mac_hw_allocate() api based on ag rather
than ab and update hardware abstraction array size in ath12k_hw_group
as ATH12K_GROUP_MAX_RADIO.
- Rebased to ToT
v4:
- Modified the cover letter
v3:
- Removed depends-on tag of "wifi: ath12k: Refactor the hardware recovery
procedures" as it is merged to ToT
- Addressed the deadlock warning seen during rmmod.

v2:
- Rebased to ToT

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 device to group

drivers/net/wireless/ath/ath12k/core.c | 431 +++++++++++++++++++++----
drivers/net/wireless/ath/ath12k/core.h | 87 ++++-
drivers/net/wireless/ath/ath12k/dp.c | 19 +-
drivers/net/wireless/ath/ath12k/dp.h | 2 +-
drivers/net/wireless/ath/ath12k/mac.c | 117 ++++---
drivers/net/wireless/ath/ath12k/mac.h | 9 +-
drivers/net/wireless/ath/ath12k/pci.c | 2 +
drivers/net/wireless/ath/ath12k/qmi.c | 10 +-
8 files changed, 544 insertions(+), 133 deletions(-)


base-commit: f8320064a28242448eeb9fece08abd865ea8a226
--
2.34.1

2024-05-28 06:36:27

by Harshitha Prem

Subject: [PATCH v7 3/8] wifi: ath12k: Add ath12k_get_num_hw api

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]>
Acked-by: Jeff Johnson <[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 3925bb70d479..7ad65ace7123 100644
--- a/drivers/net/wireless/ath/ath12k/core.c
+++ b/drivers/net/wireless/ath/ath12k/core.c
@@ -946,7 +946,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;
@@ -998,7 +998,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;
@@ -1037,7 +1037,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 3f5c9fa9d04c..a22f3561deb0 100644
--- a/drivers/net/wireless/ath/ath12k/core.h
+++ b/drivers/net/wireless/ath/ath12k/core.h
@@ -1062,4 +1062,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 f8e8320b8598..66587c5ea8fd 100644
--- a/drivers/net/wireless/ath/ath12k/mac.c
+++ b/drivers/net/wireless/ath/ath12k/mac.c
@@ -9157,7 +9157,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);
@@ -9184,7 +9184,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;
@@ -9254,7 +9254,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;
@@ -9277,7 +9277,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

2024-05-28 06:36:43

by Harshitha Prem

Subject: [PATCH v7 7/8] wifi: ath12k: refactor core start based on hardware group

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]>
Acked-by: Jeff Johnson <[email protected]>
---
drivers/net/wireless/ath/ath12k/core.c | 214 +++++++++++++++++++------
drivers/net/wireless/ath/ath12k/core.h | 32 ++++
2 files changed, 195 insertions(+), 51 deletions(-)

diff --git a/drivers/net/wireless/ath/ath12k/core.c b/drivers/net/wireless/ath/ath12k/core.c
index ebe31cbb6435..4edc71ccf312 100644
--- a/drivers/net/wireless/ath/ath12k/core.c
+++ b/drivers/net/wireless/ath/ath12k/core.c
@@ -563,6 +563,9 @@ 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);
+
if (!test_bit(ATH12K_FLAG_CRASH_FLUSH, &ab->dev_flags))
ath12k_qmi_firmware_stop(ab);

@@ -689,11 +692,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);
}

@@ -702,6 +709,8 @@ static int ath12k_core_start(struct ath12k_base *ab,
{
int ret;

+ lockdep_assert_held(&ab->core_lock);
+
ret = ath12k_wmi_attach(ab);
if (ret) {
ath12k_err(ab, "failed to attach wmi: %d\n", ret);
@@ -795,6 +804,11 @@ static int ath12k_core_start(struct ath12k_base *ab,
/* ACPI is optional so continue in case of an error */
ath12k_dbg(ab, ATH12K_DBG_BOOT, "acpi failed: %d\n", ret);

+ /* 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:
@@ -806,6 +820,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)
{
@@ -823,9 +940,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 = ath12k_ab_to_ag(ab);
+ int ret, i;

ret = ath12k_core_start_firmware(ab, ATH12K_FIRMWARE_MODE_NORMAL);
if (ret) {
@@ -845,59 +971,48 @@ int ath12k_core_qmi_firmware_ready(struct ath12k_base *ab)
goto err_firmware_stop;
}

+ 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;
}

@@ -1149,6 +1264,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);
@@ -1258,7 +1377,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;

@@ -1292,19 +1411,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;
@@ -1332,14 +1438,20 @@ static void ath12k_core_hw_group_cleanup(struct ath12k_hw_group *ag)
return;

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);
}
+
mutex_unlock(&ag->mutex_lock);
}

diff --git a/drivers/net/wireless/ath/ath12k/core.h b/drivers/net/wireless/ath/ath12k/core.h
index a6b8c100ebc8..d955deb08fd4 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,
};

struct ath12k_tx_conf {
@@ -736,6 +743,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;
@@ -1087,4 +1096,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

2024-05-28 06:36:51

by Harshitha Prem

Subject: [PATCH v7 8/8] wifi: ath12k: move ath12k_hw from per device to group

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/dp.c | 19 ++----
drivers/net/wireless/ath/ath12k/dp.h | 2 +-
drivers/net/wireless/ath/ath12k/mac.c | 90 ++++++++++++++++++--------
drivers/net/wireless/ath/ath12k/mac.h | 9 +--
6 files changed, 110 insertions(+), 87 deletions(-)

diff --git a/drivers/net/wireless/ath/ath12k/core.c b/drivers/net/wireless/ath/ath12k/core.c
index 4edc71ccf312..e59251fb3736 100644
--- a/drivers/net/wireless/ath/ath12k/core.c
+++ b/drivers/net/wireless/ath/ath12k/core.c
@@ -830,11 +830,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);
}

@@ -851,6 +846,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)
@@ -861,6 +858,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)
@@ -868,31 +882,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);
@@ -919,7 +908,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 d955deb08fd4..fcdd945ba7ea 100644
--- a/drivers/net/wireless/ath/ath12k/core.h
+++ b/drivers/net/wireless/ath/ath12k/core.h
@@ -60,6 +60,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

@@ -748,6 +749,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[ATH12K_GROUP_MAX_RADIO];
+ u8 num_hw;
};

/**
@@ -819,15 +829,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;
@@ -1083,18 +1084,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/dp.c b/drivers/net/wireless/ath/ath12k/dp.c
index 61aa78d8bd8c..5cc5eac26751 100644
--- a/drivers/net/wireless/ath/ath12k/dp.c
+++ b/drivers/net/wireless/ath/ath12k/dp.c
@@ -980,21 +980,14 @@ void ath12k_dp_pdev_free(struct ath12k_base *ab)
ath12k_dp_rx_pdev_free(ab, i);
}

-void ath12k_dp_pdev_pre_alloc(struct ath12k_base *ab)
+void ath12k_dp_pdev_pre_alloc(struct ath12k *ar)
{
- struct ath12k *ar;
- struct ath12k_pdev_dp *dp;
- int i;
+ struct ath12k_pdev_dp *dp = &ar->dp;

- for (i = 0; i < ab->num_radios; i++) {
- ar = ab->pdevs[i].ar;
- dp = &ar->dp;
- dp->mac_id = i;
- atomic_set(&dp->num_tx_pending, 0);
- init_waitqueue_head(&dp->tx_empty_waitq);
-
- /* TODO: Add any RXDMA setup required per pdev */
- }
+ dp->mac_id = ar->pdev_idx;
+ atomic_set(&dp->num_tx_pending, 0);
+ init_waitqueue_head(&dp->tx_empty_waitq);
+ /* TODO: Add any RXDMA setup required per pdev */
}

bool ath12k_dp_wmask_compaction_rx_tlv_supported(struct ath12k_base *ab)
diff --git a/drivers/net/wireless/ath/ath12k/dp.h b/drivers/net/wireless/ath/ath12k/dp.h
index 742094545089..00c0a76841df 100644
--- a/drivers/net/wireless/ath/ath12k/dp.h
+++ b/drivers/net/wireless/ath/ath12k/dp.h
@@ -1815,7 +1815,7 @@ void ath12k_dp_free(struct ath12k_base *ab);
int ath12k_dp_alloc(struct ath12k_base *ab);
void ath12k_dp_cc_config(struct ath12k_base *ab);
int ath12k_dp_pdev_alloc(struct ath12k_base *ab);
-void ath12k_dp_pdev_pre_alloc(struct ath12k_base *ab);
+void ath12k_dp_pdev_pre_alloc(struct ath12k *ar);
void ath12k_dp_pdev_free(struct ath12k_base *ab);
int ath12k_dp_tx_htt_srng_setup(struct ath12k_base *ab, u32 ring_id,
int mac_id, enum hal_ring_type ring_type);
diff --git a/drivers/net/wireless/ath/ath12k/mac.c b/drivers/net/wireless/ath/ath12k/mac.c
index 4ab9846f154c..870e7351ed08 100644
--- a/drivers/net/wireless/ath/ath12k/mac.c
+++ b/drivers/net/wireless/ath/ath12k/mac.c
@@ -9144,19 +9144,13 @@ static void ath12k_mac_setup(struct ath12k *ar)
skb_queue_head_init(&ar->wmi_mgmt_tx_queue);
}

-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);

@@ -9180,8 +9174,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;

@@ -9200,12 +9195,13 @@ static void ath12k_mac_hw_destroy(struct ath12k_hw *ah)
ieee80211_free_hw(ah->hw);
}

-static struct ath12k_hw *ath12k_mac_hw_allocate(struct ath12k_base *ab,
+static struct ath12k_hw *ath12k_mac_hw_allocate(struct ath12k_hw_group *ag,
struct ath12k_pdev_map *pdev_map,
u8 num_pdev_map)
{
struct ieee80211_hw *hw;
struct ath12k *ar;
+ struct ath12k_base *ab;
struct ath12k_pdev *pdev;
struct ath12k_hw *ah;
int i;
@@ -9218,7 +9214,7 @@ static struct ath12k_hw *ath12k_mac_hw_allocate(struct ath12k_base *ab,

ah = ath12k_hw_to_ah(hw);
ah->hw = hw;
- ah->ab = ab;
+ ah->ab = pdev_map[0].ab;
ah->num_radio = num_pdev_map;

mutex_init(&ah->hw_mutex);
@@ -9237,23 +9233,30 @@ static struct ath12k_hw *ath12k_mac_hw_allocate(struct ath12k_base *ab,
pdev->ar = ar;

ath12k_mac_setup(ar);
+ ath12k_dp_pdev_pre_alloc(ar);
}

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++) {
@@ -9266,26 +9269,60 @@ void ath12k_mac_destroy(struct ath12k_base *ab)
}
}

-int ath12k_mac_allocate(struct ath12k_base *ab)
+static void ath12k_mac_set_device_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;

- for (i = 0; i < ath12k_get_num_hw(ab); i++) {
+ 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++) {
for (j = 0; j < radio_per_hw; j++) {
+ ab = ag->ab[device_id];
pdev_map[j].ab = ab;
- pdev_map[j].pdev_idx = (i * radio_per_hw) + j;
+ pdev_map[j].pdev_idx = mac_id;
+ mac_id++;
+
+ /* If mac_id falls beyond the current device MACs then
+ * move to next device
+ */
+ if (mac_id >= ab->num_radios) {
+ mac_id = 0;
+ device_id++;
+ ath12k_mac_set_device_defaults(ab);
+ }
}

- ah = ath12k_mac_hw_allocate(ab, pdev_map, radio_per_hw);
+ ah = ath12k_mac_hw_allocate(ag, pdev_map, radio_per_hw);
if (!ah) {
ath12k_warn(ab, "failed to allocate mac80211 hw device for hw_idx %d\n",
i);
@@ -9293,11 +9330,10 @@ int ath12k_mac_allocate(struct ath12k_base *ab)
goto err;
}

- ath12k_ab_set_ah(ab, i, ah);
+ 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 69fd282b9dd3..f0ea0b5f50e4 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

2024-05-28 06:37:35

by Harshitha Prem

Subject: [PATCH v7 6/8] wifi: ath12k: Introduce device group abstraction

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]>
Acked-by: Jeff Johnson <[email protected]>
---
drivers/net/wireless/ath/ath12k/core.c | 218 ++++++++++++++++++++++++-
drivers/net/wireless/ath/ath12k/core.h | 19 +++
drivers/net/wireless/ath/ath12k/pci.c | 1 +
3 files changed, 229 insertions(+), 9 deletions(-)

diff --git a/drivers/net/wireless/ath/ath12k/core.c b/drivers/net/wireless/ath/ath12k/core.c
index 7ad65ace7123..ebe31cbb6435 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;
@@ -1185,20 +1188,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);

@@ -1209,8 +1303,114 @@ 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;

- ath12k_core_soc_destroy(ab);
+ if (WARN_ON(!ag))
+ return;
+
+ for (i = 0; i < ag->num_devices; i++) {
+ ab = ag->ab[i];
+ if (!ab)
+ continue;
+
+ if (test_and_clear_bit(ATH12K_FLAG_HW_GROUP_ATTACHED, &ab->dev_flags))
+ ath12k_core_soc_destroy(ab);
+ }
+}
+
+static void ath12k_core_hw_group_cleanup(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);
+ }
+ mutex_unlock(&ag->mutex_lock);
+}
+
+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_cleanup(ab->ag);
+ 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 bc2a9e1b1885..a6b8c100ebc8 100644
--- a/drivers/net/wireless/ath/ath12k/core.h
+++ b/drivers/net/wireless/ath/ath12k/core.h
@@ -59,6 +59,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,
};

struct ath12k_tx_conf {
@@ -725,6 +730,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
*
@@ -925,6 +941,8 @@ struct ath12k_base {

#endif /* CONFIG_ACPI */

+ struct ath12k_hw_group *ag;
+
/* must be last */
u8 drv_priv[] __aligned(sizeof(void *));
};
@@ -955,6 +973,7 @@ int ath12k_core_resume_early(struct ath12k_base *ab);
int ath12k_core_resume(struct ath12k_base *ab);
int ath12k_core_suspend(struct ath12k_base *ab);
int ath12k_core_suspend_late(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 8f37f6efb8a2..82d6aedb0963 100644
--- a/drivers/net/wireless/ath/ath12k/pci.c
+++ b/drivers/net/wireless/ath/ath12k/pci.c
@@ -1522,6 +1522,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, false);
ath12k_qmi_deinit_service(ab);
+ ath12k_core_unassign_hw_group(ab);
goto qmi_fail;
}

--
2.34.1

2024-05-28 06:37:43

by Harshitha Prem

Subject: [PATCH v7 5/8] wifi: ath12k: move ATH12K_FLAG_REGISTERED flag set to mac_register api

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]>
Acked-by: Jeff Johnson <[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 66587c5ea8fd..4ab9846f154c 100644
--- a/drivers/net/wireless/ath/ath12k/mac.c
+++ b/drivers/net/wireless/ath/ath12k/mac.c
@@ -9165,6 +9165,7 @@ int ath12k_mac_register(struct ath12k_base *ab)
goto err;
}

+ set_bit(ATH12K_FLAG_REGISTERED, &ab->dev_flags);
return 0;

err:
@@ -9184,6 +9185,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 4bec52afa507..cbe77507c9ec 100644
--- a/drivers/net/wireless/ath/ath12k/qmi.c
+++ b/drivers/net/wireless/ath/ath12k/qmi.c
@@ -3333,11 +3333,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

2024-05-28 22:04:46

by Jeff Johnson

Subject: Re: [PATCH v7 0/8] wifi: ath12k: Introduce device group abstraction

On 5/27/2024 11:35 PM, Harshitha Prem wrote:
> 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.
>
> v7:
> - Added linux-wireless mailer to cc.
> - Removed Acked-by tag from "[PATCH v6 8/8]" as it has minor change.
>
> v6:
> - Addressed smatch error seen on "[PATCH v5 8/8] wifi: ath12k: move
> ath12k_hw from per soc to group"
> - Rebased to ToT
> v5:
> - on "[PATCH 8/8] wifi: ath12k: move ath12k_hw from per soc to
> group", refactor the ath12k_mac_hw_allocate() api based on ag rather
> than ab and update hardware abstraction array size in ath12k_hw_group
> as ATH12K_GROUP_MAX_RADIO.
> - Rebased to ToT
> v4:
> - Modified the cover letter
> v3:
> - Removed depends-on tag of "wifi: ath12k: Refactor the hardware recovery
> procedures" as it is merged to ToT
> - Addressed the deadlock warning seen during rmmod.
>
> v2:
> - Rebased to ToT
>
> 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 device to group
>
> drivers/net/wireless/ath/ath12k/core.c | 431 +++++++++++++++++++++----
> drivers/net/wireless/ath/ath12k/core.h | 87 ++++-
> drivers/net/wireless/ath/ath12k/dp.c | 19 +-
> drivers/net/wireless/ath/ath12k/dp.h | 2 +-
> drivers/net/wireless/ath/ath12k/mac.c | 117 ++++---
> drivers/net/wireless/ath/ath12k/mac.h | 9 +-
> drivers/net/wireless/ath/ath12k/pci.c | 2 +
> drivers/net/wireless/ath/ath12k/qmi.c | 10 +-
> 8 files changed, 544 insertions(+), 133 deletions(-)
>
>
> base-commit: f8320064a28242448eeb9fece08abd865ea8a226

With this series I'm seeing a firmware crash upon resume from hibernation, but
I'm not sure if it is the same intermittent crash I reported in another thread
where firmware is not correctly handling a low physical memory address.

Baochen & Kalle, since this issue may be specific to my laptop, can you
validate hibernation on your setups?

2024-05-29 03:15:15

by Baochen Qiang

Subject: Re: [PATCH v7 0/8] wifi: ath12k: Introduce device group abstraction

On 5/29/2024 6:04 AM, Jeff Johnson wrote:
> On 5/27/2024 11:35 PM, Harshitha Prem wrote:
>> 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.
>>
>> v7:
>> - Added linux-wireless mailer to cc.
>> - Removed Acked-by tag from "[PATCH v6 8/8]" as it has minor change.
>>
>> v6:
>> - Addressed smatch error seen on "[PATCH v5 8/8] wifi: ath12k: move
>> ath12k_hw from per soc to group"
>> - Rebased to ToT
>> v5:
>> - on "[PATCH 8/8] wifi: ath12k: move ath12k_hw from per soc to
>> group", refactor the ath12k_mac_hw_allocate() api based on ag rather
>> than ab and update hardware abstraction array size in ath12k_hw_group
>> as ATH12K_GROUP_MAX_RADIO.
>> - Rebased to ToT
>> v4:
>> - Modified the cover letter
>> v3:
>> - Removed depends-on tag of "wifi: ath12k: Refactor the hardware recovery
>> procedures" as it is merged to ToT
>> - Addressed the deadlock warning seen during rmmod.
>>
>> v2:
>> - Rebased to ToT
>>
>> 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 device to group
>>
>> drivers/net/wireless/ath/ath12k/core.c | 431 +++++++++++++++++++++----
>> drivers/net/wireless/ath/ath12k/core.h | 87 ++++-
>> drivers/net/wireless/ath/ath12k/dp.c | 19 +-
>> drivers/net/wireless/ath/ath12k/dp.h | 2 +-
>> drivers/net/wireless/ath/ath12k/mac.c | 117 ++++---
>> drivers/net/wireless/ath/ath12k/mac.h | 9 +-
>> drivers/net/wireless/ath/ath12k/pci.c | 2 +
>> drivers/net/wireless/ath/ath12k/qmi.c | 10 +-
>> 8 files changed, 544 insertions(+), 133 deletions(-)
>>
>>
>> base-commit: f8320064a28242448eeb9fece08abd865ea8a226
>
> With this series I'm seeing a firmware crash upon resume from hibernation, but
> I'm not sure if it is the same intermittent crash I reported in another thread
> where firmware is not correctly handling a low physical memory address.
>
> Baochen & Kalle, since this issue may be specific to my laptop, can you
> validate hibernation on your setups?
I can also see a firmware crash upon resume. I am using ath-202405281746 as code base.
>

2024-05-29 07:59:20

by Kalle Valo

Subject: Re: [PATCH v7 0/8] wifi: ath12k: Introduce device group abstraction

Baochen Qiang <[email protected]> writes:

> On 5/29/2024 6:04 AM, Jeff Johnson wrote:
>> On 5/27/2024 11:35 PM, Harshitha Prem wrote:
>>> 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.
>>>
>>> v7:
>>> - Added linux-wireless mailer to cc.
>>> - Removed Acked-by tag from "[PATCH v6 8/8]" as it has minor change.
>>>
>>> v6:
>>> - Addressed smatch error seen on "[PATCH v5 8/8] wifi: ath12k: move
>>> ath12k_hw from per soc to group"
>>> - Rebased to ToT
>>> v5:
>>> - on "[PATCH 8/8] wifi: ath12k: move ath12k_hw from per soc to
>>> group", refactor the ath12k_mac_hw_allocate() api based on ag rather
>>> than ab and update hardware abstraction array size in ath12k_hw_group
>>> as ATH12K_GROUP_MAX_RADIO.
>>> - Rebased to ToT
>>> v4:
>>> - Modified the cover letter
>>> v3:
>>> - Removed depends-on tag of "wifi: ath12k: Refactor the hardware recovery
>>> procedures" as it is merged to ToT
>>> - Addressed the deadlock warning seen during rmmod.
>>>
>>> v2:
>>> - Rebased to ToT
>>>
>>> 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 device to group
>>>
>>> drivers/net/wireless/ath/ath12k/core.c | 431 +++++++++++++++++++++----
>>> drivers/net/wireless/ath/ath12k/core.h | 87 ++++-
>>> drivers/net/wireless/ath/ath12k/dp.c | 19 +-
>>> drivers/net/wireless/ath/ath12k/dp.h | 2 +-
>>> drivers/net/wireless/ath/ath12k/mac.c | 117 ++++---
>>> drivers/net/wireless/ath/ath12k/mac.h | 9 +-
>>> drivers/net/wireless/ath/ath12k/pci.c | 2 +
>>> drivers/net/wireless/ath/ath12k/qmi.c | 10 +-
>>> 8 files changed, 544 insertions(+), 133 deletions(-)
>>>
>>>
>>> base-commit: f8320064a28242448eeb9fece08abd865ea8a226
>>
>> With this series I'm seeing a firmware crash upon resume from hibernation, but
>> I'm not sure if it is the same intermittent crash I reported in another thread
>> where firmware is not correctly handling a low physical memory address.
>>
>> Baochen & Kalle, since this issue may be specific to my laptop, can you
>> validate hibernation on your setups?
>
> I can also see a firmware crash upon resume. I am using
> ath-202405281746 as code base.

I also noticed that my WCN7850 resume tests were failing with an older
version of this patch. But I cannot provide more information as I'm
bisecting the v6.10-rc1 regression right now.

--
https://patchwork.kernel.org/project/linux-wireless/list/

https://wireless.wiki.kernel.org/en/developers/documentation/submittingpatches

2024-05-29 22:28:18

by Jeff Johnson

Subject: Re: [PATCH v7 0/8] wifi: ath12k: Introduce device group abstraction

On 5/28/2024 8:13 PM, Baochen Qiang wrote:
>
>
> On 5/29/2024 6:04 AM, Jeff Johnson wrote:
>> On 5/27/2024 11:35 PM, Harshitha Prem wrote:
>>> 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.
>>>
>>> v7:
>>> - Added linux-wireless mailer to cc.
>>> - Removed Acked-by tag from "[PATCH v6 8/8]" as it has minor change.
>>>
>>> v6:
>>> - Addressed smatch error seen on "[PATCH v5 8/8] wifi: ath12k: move
>>> ath12k_hw from per soc to group"
>>> - Rebased to ToT
>>> v5:
>>> - on "[PATCH 8/8] wifi: ath12k: move ath12k_hw from per soc to
>>> group", refactor the ath12k_mac_hw_allocate() api based on ag rather
>>> than ab and update hardware abstraction array size in ath12k_hw_group
>>> as ATH12K_GROUP_MAX_RADIO.
>>> - Rebased to ToT
>>> v4:
>>> - Modified the cover letter
>>> v3:
>>> - Removed depends-on tag of "wifi: ath12k: Refactor the hardware recovery
>>> procedures" as it is merged to ToT
>>> - Addressed the deadlock warning seen during rmmod.
>>>
>>> v2:
>>> - Rebased to ToT
>>>
>>> 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 device to group
>>>
>>> drivers/net/wireless/ath/ath12k/core.c | 431 +++++++++++++++++++++----
>>> drivers/net/wireless/ath/ath12k/core.h | 87 ++++-
>>> drivers/net/wireless/ath/ath12k/dp.c | 19 +-
>>> drivers/net/wireless/ath/ath12k/dp.h | 2 +-
>>> drivers/net/wireless/ath/ath12k/mac.c | 117 ++++---
>>> drivers/net/wireless/ath/ath12k/mac.h | 9 +-
>>> drivers/net/wireless/ath/ath12k/pci.c | 2 +
>>> drivers/net/wireless/ath/ath12k/qmi.c | 10 +-
>>> 8 files changed, 544 insertions(+), 133 deletions(-)
>>>
>>>
>>> base-commit: f8320064a28242448eeb9fece08abd865ea8a226
>>
>> With this series I'm seeing a firmware crash upon resume from hibernation, but
>> I'm not sure if it is the same intermittent crash I reported in another thread
>> where firmware is not correctly handling a low physical memory address.
>>
>> Baochen & Kalle, since this issue may be specific to my laptop, can you
>> validate hibernation on your setups?
> I can also see a firmware crash upon resume. I am using ath-202405281746 as code base.

I bisected to:
[PATCH v7 7/8] wifi: ath12k: refactor core start based on hardware group

2024-05-31 10:05:42

by Harshitha Prem

Subject: Re: [PATCH v7 0/8] wifi: ath12k: Introduce device group abstraction

On 5/30/2024 3:58 AM, Jeff Johnson wrote:
> On 5/28/2024 8:13 PM, Baochen Qiang wrote:
>>
>>
>> On 5/29/2024 6:04 AM, Jeff Johnson wrote:
>>> On 5/27/2024 11:35 PM, Harshitha Prem wrote:
>>>> 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.
>>>>
>>>> v7:
>>>> - Added linux-wireless mailer to cc.
>>>> - Removed Acked-by tag from "[PATCH v6 8/8]" as it has minor change.
>>>>
>>>> v6:
>>>> - Addressed smatch error seen on "[PATCH v5 8/8] wifi: ath12k: move
>>>> ath12k_hw from per soc to group"
>>>> - Rebased to ToT
>>>> v5:
>>>> - on "[PATCH 8/8] wifi: ath12k: move ath12k_hw from per soc to
>>>> group", refactor the ath12k_mac_hw_allocate() api based on ag rather
>>>> than ab and update hardware abstraction array size in ath12k_hw_group
>>>> as ATH12K_GROUP_MAX_RADIO.
>>>> - Rebased to ToT
>>>> v4:
>>>> - Modified the cover letter
>>>> v3:
>>>> - Removed depends-on tag of "wifi: ath12k: Refactor the hardware recovery
>>>> procedures" as it is merged to ToT
>>>> - Addressed the deadlock warning seen during rmmod.
>>>>
>>>> v2:
>>>> - Rebased to ToT
>>>>
>>>> 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 device to group
>>>>
>>>> drivers/net/wireless/ath/ath12k/core.c | 431 +++++++++++++++++++++----
>>>> drivers/net/wireless/ath/ath12k/core.h | 87 ++++-
>>>> drivers/net/wireless/ath/ath12k/dp.c | 19 +-
>>>> drivers/net/wireless/ath/ath12k/dp.h | 2 +-
>>>> drivers/net/wireless/ath/ath12k/mac.c | 117 ++++---
>>>> drivers/net/wireless/ath/ath12k/mac.h | 9 +-
>>>> drivers/net/wireless/ath/ath12k/pci.c | 2 +
>>>> drivers/net/wireless/ath/ath12k/qmi.c | 10 +-
>>>> 8 files changed, 544 insertions(+), 133 deletions(-)
>>>>
>>>>
>>>> base-commit: f8320064a28242448eeb9fece08abd865ea8a226
>>>
>>> With this series I'm seeing a firmware crash upon resume from hibernation, but
>>> I'm not sure if it is the same intermittent crash I reported in another thread
>>> where firmware is not correctly handling a low physical memory address.
>>>
>>> Baochen & Kalle, since this issue may be specific to my laptop, can you
>>> validate hibernation on your setups?
>> I can also see a firmware crash upon resume. I am using ath-202405281746 as code base.
>
> I bisected to:
> [PATCH v7 7/8] wifi: ath12k: refactor core start based on hardware group
>
>
Thank you so much, Jeff. Identified the possible reason that is causing
the firmware assert with hibernation scenario and will address it in
next version.

2024-05-31 13:34:30

by [email protected]

Subject: Re: [PATCH v7 0/8] wifi: ath12k: Introduce device group abstraction

Is there a limit to the number of hardware abstraction layers? My current platform has 3 physical WiFi 7 modules in one machine - one for each frequency 2.4 GHz, 5 GHz, and 6GHz. Is this currently not supported? 
What if I want to connect more than 3 modules including identical modules of the same frequency? My setup will not be utilizing combined frequency modules.
FYI, in my platform, each module is connected to its own PCIe slot, and has its own antennas so I assume it would be recognized as its own wireless device by the OS (i.e wlan0, wlan1, wlan2, etc.).

I ask this question because my WiFi7 module manufacturer (Compex) informed me that multiple modules (either different frequencies or same frequencies) in the same machine is not supported by ath12k at this time.
Sorry for the intrusion.

Prashant Gupta


On Fri, 31 May 2024 15:35:24 +0530, Harshitha Prem <[email protected]> wrote:

>> On 5/30/2024 3:58 AM, Jeff Johnson wrote:
>> > On 5/28/2024 8:13 PM, Baochen Qiang wrote:
>> >>
>> >>
>> >> On 5/29/2024 6:04 AM, Jeff Johnson wrote:
>> >>> On 5/27/2024 11:35 PM, Harshitha Prem wrote:
>> >>>> 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.
>> >>>>
>> >>>> v7:
>> >>>> - Added linux-wireless mailer to cc.
>> >>>> - Removed Acked-by tag from "[PATCH v6 8/8]" as it has minor change.
>> >>>>
>> >>>> v6:
>> >>>> - Addressed smatch error seen on "[PATCH v5 8/8] wifi: ath12k: move
>> >>>> ath12k_hw from per soc to group"
>> >>>> - Rebased to ToT
>> >>>> v5:
>> >>>> - on "[PATCH 8/8] wifi: ath12k: move ath12k_hw from per soc to
>> >>>> group", refactor the ath12k_mac_hw_allocate() api based on ag rather
>> >>>> than ab and update hardware abstraction array size in ath12k_hw_group
>> >>>> as ATH12K_GROUP_MAX_RADIO.
>> >>>> - Rebased to ToT
>> >>>> v4:
>> >>>> - Modified the cover letter
>> >>>> v3:
>> >>>> - Removed depends-on tag of "wifi: ath12k: Refactor the hardware recovery
>> >>>> procedures" as it is merged to ToT
>> >>>> - Addressed the deadlock warning seen during rmmod.
>> >>>>
>> >>>> v2:
>> >>>> - Rebased to ToT
>> >>>>
>> >>>> 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 device to group
>> >>>>
>> >>>> drivers/net/wireless/ath/ath12k/core.c | 431 +++++++++++++++++++++----
>> >>>> drivers/net/wireless/ath/ath12k/core.h | 87 ++++-
>> >>>> drivers/net/wireless/ath/ath12k/dp.c | 19 +-
>> >>>> drivers/net/wireless/ath/ath12k/dp.h | 2 +-
>> >>>> drivers/net/wireless/ath/ath12k/mac.c | 117 ++++---
>> >>>> drivers/net/wireless/ath/ath12k/mac.h | 9 +-
>> >>>> drivers/net/wireless/ath/ath12k/pci.c | 2 +
>> >>>> drivers/net/wireless/ath/ath12k/qmi.c | 10 +-
>> >>>> 8 files changed, 544 insertions(+), 133 deletions(-)
>> >>>>
>> >>>>
>> >>>> base-commit: f8320064a28242448eeb9fece08abd865ea8a226
>> >>>
>> >>> With this series I'm seeing a firmware crash upon resume from hibernation, but
>> >>> I'm not sure if it is the same intermittent crash I reported in another thread
>> >>> where firmware is not correctly handling a low physical memory address.
>> >>>
>> >>> Baochen & Kalle, since this issue may be specific to my laptop, can you
>> >>> validate hibernation on your setups?
>> >> I can also see a firmware crash upon resume. I am using ath-202405281746 as code base.
>> >
>> > I bisected to:
>> > [PATCH v7 7/8] wifi: ath12k: refactor core start based on hardware group
>> >
>> >
>> Thank you so much, Jeff. Identified the possible reason that is causing
>> the firmware assert with hibernation scenario and will address it in
>> next version.

2024-06-03 05:03:36

by Vasanthakumar Thiagarajan

Subject: Re: [PATCH v7 0/8] wifi: ath12k: Introduce device group abstraction

On 5/31/2024 6:49 PM, [email protected] wrote:
> Is there a limit to the number of hardware abstraction layers?

Please note that grouping multiple hardware under one wiphy is still not supported in
ath12k. This patch series is a strep towards such architecture. When the full hardware
grouping support is added, there will not be any restrictions in the number of hardware
which can be be grouped under only wiphy.

My current platform has 3 physical WiFi 7 modules in one machine - one for each
frequency 2.4 GHz, 5 GHz, and 6GHz. Is this currently not supported?

This should work with ath12k as all three will be registered as three different wiphys.

> What if I want to connect more than 3 modules including identical modules of the same frequency? My setup will not be utilizing combined frequency modules.

Grouping hardware having same frequency capability will make things very complex, I dont
think it is worthy of the effort especially there is no obvious real use case to combine
such radios under one wiphy.

> FYI, in my platform, each module is connected to its own PCIe slot, and has its own antennas so I assume it would be recognized as its own wireless device by the OS (i.e wlan0, wlan1, wlan2, etc.).
>

Yes, each hardware will be registered as separate phy and wlan
interfaces with respective capability can be created on top of
them.

Vasanth


>
> On Fri, 31 May 2024 15:35:24 +0530, Harshitha Prem <[email protected]> wrote:
>
>>> On 5/30/2024 3:58 AM, Jeff Johnson wrote:
>>>> On 5/28/2024 8:13 PM, Baochen Qiang wrote:
>>>>>
>>>>>
>>>>> On 5/29/2024 6:04 AM, Jeff Johnson wrote:
>>>>>> On 5/27/2024 11:35 PM, Harshitha Prem wrote:
>>>>>>> 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.
>>>>>>>
>>>>>>> v7:
>>>>>>> - Added linux-wireless mailer to cc.
>>>>>>> - Removed Acked-by tag from "[PATCH v6 8/8]" as it has minor change.
>>>>>>>
>>>>>>> v6:
>>>>>>> - Addressed smatch error seen on "[PATCH v5 8/8] wifi: ath12k: move
>>>>>>> ath12k_hw from per soc to group"
>>>>>>> - Rebased to ToT
>>>>>>> v5:
>>>>>>> - on "[PATCH 8/8] wifi: ath12k: move ath12k_hw from per soc to
>>>>>>> group", refactor the ath12k_mac_hw_allocate() api based on ag rather
>>>>>>> than ab and update hardware abstraction array size in ath12k_hw_group
>>>>>>> as ATH12K_GROUP_MAX_RADIO.
>>>>>>> - Rebased to ToT
>>>>>>> v4:
>>>>>>> - Modified the cover letter
>>>>>>> v3:
>>>>>>> - Removed depends-on tag of "wifi: ath12k: Refactor the hardware recovery
>>>>>>> procedures" as it is merged to ToT
>>>>>>> - Addressed the deadlock warning seen during rmmod.
>>>>>>>
>>>>>>> v2:
>>>>>>> - Rebased to ToT
>>>>>>>
>>>>>>> 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 device to group
>>>>>>>
>>>>>>> drivers/net/wireless/ath/ath12k/core.c | 431 +++++++++++++++++++++----
>>>>>>> drivers/net/wireless/ath/ath12k/core.h | 87 ++++-
>>>>>>> drivers/net/wireless/ath/ath12k/dp.c | 19 +-
>>>>>>> drivers/net/wireless/ath/ath12k/dp.h | 2 +-
>>>>>>> drivers/net/wireless/ath/ath12k/mac.c | 117 ++++---
>>>>>>> drivers/net/wireless/ath/ath12k/mac.h | 9 +-
>>>>>>> drivers/net/wireless/ath/ath12k/pci.c | 2 +
>>>>>>> drivers/net/wireless/ath/ath12k/qmi.c | 10 +-
>>>>>>> 8 files changed, 544 insertions(+), 133 deletions(-)
>>>>>>>
>>>>>>>
>>>>>>> base-commit: f8320064a28242448eeb9fece08abd865ea8a226
>>>>>>
>>>>>> With this series I'm seeing a firmware crash upon resume from hibernation, but
>>>>>> I'm not sure if it is the same intermittent crash I reported in another thread
>>>>>> where firmware is not correctly handling a low physical memory address.
>>>>>>
>>>>>> Baochen & Kalle, since this issue may be specific to my laptop, can you
>>>>>> validate hibernation on your setups?
>>>>> I can also see a firmware crash upon resume. I am using ath-202405281746 as code base.
>>>>
>>>> I bisected to:
>>>> [PATCH v7 7/8] wifi: ath12k: refactor core start based on hardware group
>>>>
>>>>
>>> Thank you so much, Jeff. Identified the possible reason that is causing
>>> the firmware assert with hibernation scenario and will address it in
>>> next version.
>

2024-06-03 14:32:19

by [email protected]

Subject: Re: [PATCH v7 0/8] wifi: ath12k: Introduce device group abstraction

Thank you for your reply. I have passed this information along to my board manufacturer (Compex) and we are currently working on a solution for the ath12k failing to recognize my module in the board-2.bin


Prashant

On Mon, 3 Jun 2024 10:33:09 +0530, Vasanthakumar Thiagarajan <[email protected]> wrote:

>> On 5/31/2024 6:49 PM, [email protected] wrote:
>> > Is there a limit to the number of hardware abstraction layers?
>>
>> Please note that grouping multiple hardware under one wiphy is still not supported in
>> ath12k. This patch series is a strep towards such architecture. When the full hardware
>> grouping support is added, there will not be any restrictions in the number of hardware
>> which can be be grouped under only wiphy.
>>
>> My current platform has 3 physical WiFi 7 modules in one machine - one for each
>> frequency 2.4 GHz, 5 GHz, and 6GHz. Is this currently not supported?
>>
>> This should work with ath12k as all three will be registered as three different wiphys.
>>
>> > What if I want to connect more than 3 modules including identical modules of the same frequency? My setup will not be utilizing combined frequency modules.
>>
>> Grouping hardware having same frequency capability will make things very complex, I dont
>> think it is worthy of the effort especially there is no obvious real use case to combine
>> such radios under one wiphy.
>>
>> > FYI, in my platform, each module is connected to its own PCIe slot, and has its own antennas so I assume it would be recognized as its own wireless device by the OS (i.e wlan0, wlan1, wlan2, etc.).
>> >
>>
>> Yes, each hardware will be registered as separate phy and wlan
>> interfaces with respective capability can be created on top of
>> them.
>>
>> Vasanth
>>
>>
>> >
>> > On Fri, 31 May 2024 15:35:24 +0530, Harshitha Prem wrote:
>> >
>> >>> On 5/30/2024 3:58 AM, Jeff Johnson wrote:
>> >>>> On 5/28/2024 8:13 PM, Baochen Qiang wrote:
>> >>>>>
>> >>>>>
>> >>>>> On 5/29/2024 6:04 AM, Jeff Johnson wrote:
>> >>>>>> On 5/27/2024 11:35 PM, Harshitha Prem wrote:
>> >>>>>>> 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.
>> >>>>>>>
>> >>>>>>> v7:
>> >>>>>>> - Added linux-wireless mailer to cc.
>> >>>>>>> - Removed Acked-by tag from "[PATCH v6 8/8]" as it has minor change.
>> >>>>>>>
>> >>>>>>> v6:
>> >>>>>>> - Addressed smatch error seen on "[PATCH v5 8/8] wifi: ath12k: move
>> >>>>>>> ath12k_hw from per soc to group"
>> >>>>>>> - Rebased to ToT
>> >>>>>>> v5:
>> >>>>>>> - on "[PATCH 8/8] wifi: ath12k: move ath12k_hw from per soc to
>> >>>>>>> group", refactor the ath12k_mac_hw_allocate() api based on ag rather
>> >>>>>>> than ab and update hardware abstraction array size in ath12k_hw_group
>> >>>>>>> as ATH12K_GROUP_MAX_RADIO.
>> >>>>>>> - Rebased to ToT
>> >>>>>>> v4:
>> >>>>>>> - Modified the cover letter
>> >>>>>>> v3:
>> >>>>>>> - Removed depends-on tag of "wifi: ath12k: Refactor the hardware recovery
>> >>>>>>> procedures" as it is merged to ToT
>> >>>>>>> - Addressed the deadlock warning seen during rmmod.
>> >>>>>>>
>> >>>>>>> v2:
>> >>>>>>> - Rebased to ToT
>> >>>>>>>
>> >>>>>>> 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 device to group
>> >>>>>>>
>> >>>>>>> drivers/net/wireless/ath/ath12k/core.c | 431 +++++++++++++++++++++----
>> >>>>>>> drivers/net/wireless/ath/ath12k/core.h | 87 ++++-
>> >>>>>>> drivers/net/wireless/ath/ath12k/dp.c | 19 +-
>> >>>>>>> drivers/net/wireless/ath/ath12k/dp.h | 2 +-
>> >>>>>>> drivers/net/wireless/ath/ath12k/mac.c | 117 ++++---
>> >>>>>>> drivers/net/wireless/ath/ath12k/mac.h | 9 +-
>> >>>>>>> drivers/net/wireless/ath/ath12k/pci.c | 2 +
>> >>>>>>> drivers/net/wireless/ath/ath12k/qmi.c | 10 +-
>> >>>>>>> 8 files changed, 544 insertions(+), 133 deletions(-)
>> >>>>>>>
>> >>>>>>>
>> >>>>>>> base-commit: f8320064a28242448eeb9fece08abd865ea8a226
>> >>>>>>
>> >>>>>> With this series I'm seeing a firmware crash upon resume from hibernation, but
>> >>>>>> I'm not sure if it is the same intermittent crash I reported in another thread
>> >>>>>> where firmware is not correctly handling a low physical memory address.
>> >>>>>>
>> >>>>>> Baochen & Kalle, since this issue may be specific to my laptop, can you
>> >>>>>> validate hibernation on your setups?
>> >>>>> I can also see a firmware crash upon resume. I am using ath-202405281746 as code base.
>> >>>>
>> >>>> I bisected to:
>> >>>> [PATCH v7 7/8] wifi: ath12k: refactor core start based on hardware group
>> >>>>
>> >>>>
>> >>> Thank you so much, Jeff. Identified the possible reason that is causing
>> >>> the firmware assert with hibernation scenario and will address it in
>> >>> next version.
>> >