Commit 4a3c212e authored by Baochen Qiang's avatar Baochen Qiang Committed by Kalle Valo
Browse files

wifi: ath12k: add basic WoW functionalities 



Implement basic WoW functionalities such as magic-packet, disconnect
and pattern. The logic is very similar to ath11k.

When WoW is configured, ath12k_core_suspend and ath12k_core_resume
are skipped (by checking ar->state) as we are not allowed to power
cycle firmware.

Tested-on: WCN7850 hw2.0 PCI WLAN.HMT.1.0-03427-QCAHMTSWPL_V1.0_V2.0_SILICONZ-1.15378.4

Signed-off-by: default avatarBaochen Qiang <quic_bqiang@quicinc.com>
Acked-by: default avatarJeff Johnson <quic_jjohnson@quicinc.com>
Signed-off-by: default avatarKalle Valo <quic_kvalo@quicinc.com>
Link: https://patch.msgid.link/20240604055407.12506-4-quic_bqiang@quicinc.com
parent 59317417

drivers/net/wireless/ath/ath12k/core.c

+38 −8
Original line number Diff line number Diff line
@@ -43,14 +43,38 @@ static int ath12k_core_rfkill_config(struct ath12k_base *ab) 
	return ret;

}



int ath12k_core_suspend(struct ath12k_base *ab)

/* Check if we need to continue with suspend/resume operation.

 * Return:

 *	a negative value: error happens and don't continue.

 *	0:  no error but don't continue.

 *	positive value: no error and do continue.

 */

static int ath12k_core_continue_suspend_resume(struct ath12k_base *ab)

{

	struct ath12k *ar;

	int ret, i;



	if (!ab->hw_params->supports_suspend)

		return -EOPNOTSUPP;



	/* so far single_pdev_only chips have supports_suspend as true

	 * so pass 0 as a dummy pdev_id here.

	 */

	ar = ab->pdevs[0].ar;

	if (!ar || !ar->ah || ar->ah->state != ATH12K_HW_STATE_OFF)

		return 0;



	return 1;

}



int ath12k_core_suspend(struct ath12k_base *ab)

{

	struct ath12k *ar;

	int ret, i;



	ret = ath12k_core_continue_suspend_resume(ab);

	if (ret <= 0)

		return ret;



	for (i = 0; i < ab->num_radios; i++) {

		ar = ab->pdevs[i].ar;

		if (!ar)
@@ -81,8 +105,11 @@ EXPORT_SYMBOL(ath12k_core_suspend); 


int ath12k_core_suspend_late(struct ath12k_base *ab)

{

	if (!ab->hw_params->supports_suspend)

		return -EOPNOTSUPP;

	int ret;



	ret = ath12k_core_continue_suspend_resume(ab);

	if (ret <= 0)

		return ret;



	ath12k_acpi_stop(ab);
@@ -99,8 +126,9 @@ int ath12k_core_resume_early(struct ath12k_base *ab) 
{

	int ret;



	if (!ab->hw_params->supports_suspend)

		return -EOPNOTSUPP;

	ret = ath12k_core_continue_suspend_resume(ab);

	if (ret <= 0)

		return ret;



	reinit_completion(&ab->restart_completed);

	ret = ath12k_hif_power_up(ab);
@@ -114,9 +142,11 @@ EXPORT_SYMBOL(ath12k_core_resume_early); 
int ath12k_core_resume(struct ath12k_base *ab)

{

	long time_left;

	int ret;



	if (!ab->hw_params->supports_suspend)

		return -EOPNOTSUPP;

	ret = ath12k_core_continue_suspend_resume(ab);

	if (ret <= 0)

		return ret;



	time_left = wait_for_completion_timeout(&ab->restart_completed,

						ATH12K_RESET_TIMEOUT_HZ);

drivers/net/wireless/ath/ath12k/core.h

+5 −0
Original line number Diff line number Diff line
@@ -28,6 +28,7 @@ 
#include "dbring.h"

#include "fw.h"

#include "acpi.h"

#include "wow.h"



#define SM(_v, _f) (((_v) << _f##_LSB) & _f##_MASK)
@@ -607,6 +608,9 @@ struct ath12k { 
	struct work_struct wmi_mgmt_tx_work;

	struct sk_buff_head wmi_mgmt_tx_queue;



	struct ath12k_wow wow;

	struct completion target_suspend;

	bool target_suspend_ack;

	struct ath12k_per_peer_tx_stats peer_tx_stats;

	struct list_head ppdu_stats_info;

	u32 ppdu_stat_list_depth;
@@ -767,6 +771,7 @@ struct ath12k_base { 


	struct {

		struct completion wakeup_completed;

		u32 wmi_conf_rx_decap_mode;

	} wow;



	struct ath12k_ce ce;

drivers/net/wireless/ath/ath12k/htc.c

+6 −0
Original line number Diff line number Diff line
@@ -244,6 +244,11 @@ static void ath12k_htc_suspend_complete(struct ath12k_base *ab, bool ack) 
	complete(&ab->htc_suspend);

}



static void ath12k_htc_wakeup_from_suspend(struct ath12k_base *ab)

{

	ath12k_dbg(ab, ATH12K_DBG_BOOT, "boot wakeup from suspend is received\n");

}



void ath12k_htc_rx_completion_handler(struct ath12k_base *ab,

				      struct sk_buff *skb)

{
@@ -349,6 +354,7 @@ void ath12k_htc_rx_completion_handler(struct ath12k_base *ab, 
			ath12k_htc_suspend_complete(ab, false);

			break;

		case ATH12K_HTC_MSG_WAKEUP_FROM_SUSPEND_ID:

			ath12k_htc_wakeup_from_suspend(ab);

			break;

		default:

			ath12k_warn(ab, "ignoring unsolicited htc ep0 event %u\n",

drivers/net/wireless/ath/ath12k/mac.c

+14 −0
Original line number Diff line number Diff line
@@ -15,6 +15,8 @@ 
#include "dp_rx.h"

#include "peer.h"

#include "debugfs.h"

#include "hif.h"

#include "wow.h"



#define CHAN2G(_channel, _freq, _flags) { \

	.band                   = NL80211_BAND_2GHZ, \
@@ -8578,6 +8580,12 @@ static const struct ieee80211_ops ath12k_ops = { 
	.sta_statistics			= ath12k_mac_op_sta_statistics,

	.remain_on_channel              = ath12k_mac_op_remain_on_channel,

	.cancel_remain_on_channel       = ath12k_mac_op_cancel_remain_on_channel,



#ifdef CONFIG_PM

	.suspend			= ath12k_wow_op_suspend,

	.resume				= ath12k_wow_op_resume,

	.set_wakeup			= ath12k_wow_op_set_wakeup,

#endif

};



static void ath12k_mac_update_ch_list(struct ath12k *ar,
@@ -9100,6 +9108,12 @@ static int ath12k_mac_hw_register(struct ath12k_hw *ah) 
		ieee80211_hw_set(hw, SUPPORT_FAST_XMIT);

	}



	ret = ath12k_wow_init(ar);

	if (ret) {

		ath12k_warn(ar->ab, "failed to init wow: %d\n", ret);

		goto err_free_if_combs;

	}



	ret = ieee80211_register_hw(hw);

	if (ret) {

		ath12k_err(ab, "ieee80211 registration failed: %d\n", ret);

drivers/net/wireless/ath/ath12k/wmi.c

+143 −0
Original line number Diff line number Diff line
@@ -3717,6 +3717,7 @@ int ath12k_wmi_cmd_init(struct ath12k_base *ab) 
		arg.res_cfg.is_reg_cc_ext_event_supported = true;



	ab->hw_params->wmi_init(ab, &arg.res_cfg);

	ab->wow.wmi_conf_rx_decap_mode = arg.res_cfg.rx_decap_mode;



	arg.num_mem_chunks = wmi_ab->num_mem_chunks;

	arg.hw_mode_id = wmi_ab->preferred_hw_mode;
@@ -7464,3 +7465,145 @@ int ath12k_wmi_wow_enable(struct ath12k *ar) 


	return ath12k_wmi_cmd_send(ar->wmi, skb, WMI_WOW_ENABLE_CMDID);

}



int ath12k_wmi_wow_add_wakeup_event(struct ath12k *ar, u32 vdev_id,

				    enum wmi_wow_wakeup_event event,

				    u32 enable)

{

	struct wmi_wow_add_del_event_cmd *cmd;

	struct sk_buff *skb;

	size_t len;



	len = sizeof(*cmd);

	skb = ath12k_wmi_alloc_skb(ar->wmi->wmi_ab, len);

	if (!skb)

		return -ENOMEM;



	cmd = (struct wmi_wow_add_del_event_cmd *)skb->data;

	cmd->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_WOW_ADD_DEL_EVT_CMD,

						 sizeof(*cmd));

	cmd->vdev_id = cpu_to_le32(vdev_id);

	cmd->is_add = cpu_to_le32(enable);

	cmd->event_bitmap = cpu_to_le32((1 << event));



	ath12k_dbg(ar->ab, ATH12K_DBG_WMI, "wmi tlv wow add wakeup event %s enable %d vdev_id %d\n",

		   wow_wakeup_event(event), enable, vdev_id);



	return ath12k_wmi_cmd_send(ar->wmi, skb, WMI_WOW_ENABLE_DISABLE_WAKE_EVENT_CMDID);

}



int ath12k_wmi_wow_add_pattern(struct ath12k *ar, u32 vdev_id, u32 pattern_id,

			       const u8 *pattern, const u8 *mask,

			       int pattern_len, int pattern_offset)

{

	struct wmi_wow_add_pattern_cmd *cmd;

	struct wmi_wow_bitmap_pattern_params *bitmap;

	struct wmi_tlv *tlv;

	struct sk_buff *skb;

	void *ptr;

	size_t len;



	len = sizeof(*cmd) +

	      sizeof(*tlv) +			/* array struct */

	      sizeof(*bitmap) +			/* bitmap */

	      sizeof(*tlv) +			/* empty ipv4 sync */

	      sizeof(*tlv) +			/* empty ipv6 sync */

	      sizeof(*tlv) +			/* empty magic */

	      sizeof(*tlv) +			/* empty info timeout */

	      sizeof(*tlv) + sizeof(u32);	/* ratelimit interval */



	skb = ath12k_wmi_alloc_skb(ar->wmi->wmi_ab, len);

	if (!skb)

		return -ENOMEM;



	/* cmd */

	ptr = skb->data;

	cmd = ptr;

	cmd->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_WOW_ADD_PATTERN_CMD,

						 sizeof(*cmd));

	cmd->vdev_id = cpu_to_le32(vdev_id);

	cmd->pattern_id = cpu_to_le32(pattern_id);

	cmd->pattern_type = cpu_to_le32(WOW_BITMAP_PATTERN);



	ptr += sizeof(*cmd);



	/* bitmap */

	tlv = ptr;

	tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_STRUCT, sizeof(*bitmap));



	ptr += sizeof(*tlv);



	bitmap = ptr;

	bitmap->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_WOW_BITMAP_PATTERN_T,

						    sizeof(*bitmap));

	memcpy(bitmap->patternbuf, pattern, pattern_len);

	memcpy(bitmap->bitmaskbuf, mask, pattern_len);

	bitmap->pattern_offset = cpu_to_le32(pattern_offset);

	bitmap->pattern_len = cpu_to_le32(pattern_len);

	bitmap->bitmask_len = cpu_to_le32(pattern_len);

	bitmap->pattern_id = cpu_to_le32(pattern_id);



	ptr += sizeof(*bitmap);



	/* ipv4 sync */

	tlv = ptr;

	tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_STRUCT, 0);



	ptr += sizeof(*tlv);



	/* ipv6 sync */

	tlv = ptr;

	tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_STRUCT, 0);



	ptr += sizeof(*tlv);



	/* magic */

	tlv = ptr;

	tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_STRUCT, 0);



	ptr += sizeof(*tlv);



	/* pattern info timeout */

	tlv = ptr;

	tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_UINT32, 0);



	ptr += sizeof(*tlv);



	/* ratelimit interval */

	tlv = ptr;

	tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_UINT32, sizeof(u32));



	ath12k_dbg(ar->ab, ATH12K_DBG_WMI, "wmi tlv wow add pattern vdev_id %d pattern_id %d pattern_offset %d pattern_len %d\n",

		   vdev_id, pattern_id, pattern_offset, pattern_len);



	ath12k_dbg_dump(ar->ab, ATH12K_DBG_WMI, NULL, "wow pattern: ",

			bitmap->patternbuf, pattern_len);

	ath12k_dbg_dump(ar->ab, ATH12K_DBG_WMI, NULL, "wow bitmask: ",

			bitmap->bitmaskbuf, pattern_len);



	return ath12k_wmi_cmd_send(ar->wmi, skb, WMI_WOW_ADD_WAKE_PATTERN_CMDID);

}



int ath12k_wmi_wow_del_pattern(struct ath12k *ar, u32 vdev_id, u32 pattern_id)

{

	struct wmi_wow_del_pattern_cmd *cmd;

	struct sk_buff *skb;

	size_t len;



	len = sizeof(*cmd);

	skb = ath12k_wmi_alloc_skb(ar->wmi->wmi_ab, len);

	if (!skb)

		return -ENOMEM;



	cmd = (struct wmi_wow_del_pattern_cmd *)skb->data;

	cmd->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_WOW_DEL_PATTERN_CMD,

						 sizeof(*cmd));

	cmd->vdev_id = cpu_to_le32(vdev_id);

	cmd->pattern_id = cpu_to_le32(pattern_id);

	cmd->pattern_type = cpu_to_le32(WOW_BITMAP_PATTERN);



	ath12k_dbg(ar->ab, ATH12K_DBG_WMI, "wmi tlv wow del pattern vdev_id %d pattern_id %d\n",

		   vdev_id, pattern_id);



	return ath12k_wmi_cmd_send(ar->wmi, skb, WMI_WOW_DEL_WAKE_PATTERN_CMDID);

}