headers
Michal Kazior | 17 May 2013 08:26
Favicon

[PATCH] ath10k: program FW with appropriate regdomain

We already setup scan channel list upon regdomain
update but we should also setup the regpair to the
FW.

Signed-off-by: Michal Kazior <michal.kazior <at> tieto.com>
---
 drivers/net/wireless/ath/ath10k/mac.c |   13 +++++++++++++
 drivers/net/wireless/ath/ath10k/wmi.c |   18 ++++++++++--------
 drivers/net/wireless/ath/ath10k/wmi.h |    3 ++-
 3 files changed, 25 insertions(+), 9 deletions(-)

diff --git a/drivers/net/wireless/ath/ath10k/mac.c b/drivers/net/wireless/ath/ath10k/mac.c
index 974f992..49e3940 100644
--- a/drivers/net/wireless/ath/ath10k/mac.c
+++ b/drivers/net/wireless/ath/ath10k/mac.c
 <at>  <at>  -1249,6 +1249,7  <at>  <at>  static void ath10k_reg_notifier(struct wiphy *wiphy,
 				struct regulatory_request *request)
 {
 	struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
+	struct reg_dmn_pair_mapping *regpair;
 	struct ath10k *ar = hw->priv;
 	int ret;

 <at>  <at>  -1257,6 +1258,18  <at>  <at>  static void ath10k_reg_notifier(struct wiphy *wiphy,
 	ret = ath10k_update_channel_list(ar);
 	if (ret)
 		ath10k_warn("could not update channel list (%d)\n", ret);
+
+	regpair = ar->ath_common.regulatory.regpair;
+	/* Target allows setting up per-band regdomain but ath_common provides
(Continue reading)

Permalink | Reply | 0 comments |
headers
Vittorio G (VittGam | 16 May 2013 20:57

ath9k_htc max VIF limit set to 2

Hello everybody,


The ATH9K_HTC_MAX_VIF and ATH9K_HTC_MAX_BCN_VIF defines, as well as the ieee80211_iface_combination.max_interfaces and ieee80211_iface_limit.max properties are all set to 2 in the driver code.

I'd like to know if this is some hardware or firmware limit, or if this could be changed to something higher as in the regular ath9k driver, which seems to have the limit set at 2048 STAs, 8 APs and 2048 total concurrent VIFs instead.

I'm asking this before testing because I don't know if I could eventually damage the hardware if this is a hardware limitation (I don't think that it would be possible to damage the hardware by doing this, but who knows...)


Thanks,
Vittorio G
_______________________________________________
ath9k-devel mailing list
ath9k-devel <at> lists.ath9k.org
https://lists.ath9k.org/mailman/listinfo/ath9k-devel
Permalink | Reply | 1 comment |
headers
Michal Kazior | 16 May 2013 15:01
Favicon

[PATCH] ath10k: remove unnecessary include

We already do forward declaration of ath10k and
ath10k_vif in wmi.h.

Signed-off-by: Michal Kazior <michal.kazior <at> tieto.com>
---
 drivers/net/wireless/ath/ath10k/wmi.h |    2 --
 1 file changed, 2 deletions(-)

diff --git a/drivers/net/wireless/ath/ath10k/wmi.h b/drivers/net/wireless/ath/ath10k/wmi.h
index ccab87e..c6e6343 100644
--- a/drivers/net/wireless/ath/ath10k/wmi.h
+++ b/drivers/net/wireless/ath/ath10k/wmi.h
 <at>  <at>  -21,8 +21,6  <at>  <at> 
 #include <linux/types.h>
 #include <net/mac80211.h>

-#include "core.h"
-
 /*
  * This file specifies the WMI interface for the Unified Software
  * Architecture.
--

-- 
1.7.9.5
Permalink | Reply | 0 comments |
headers
Michal Kazior | 16 May 2013 11:09
Favicon

[PATCH 0/7] ath10k: tx flow control fixes

This addresses some `tx failed` issues and minor
issues I've found along.

This is a resend as a PATCH rather than an RFC.

Updates include:
 * added `ath10k: detect htt pending tx limit at runtime`
 * dropped htc tx polling with a timer patch
 * dropped explicit htt tx polling from
   `ath10k: introduce proper htt tx flow control`
   (this was deadlocking, and is no longer necessary anyway)

Michal Kazior (7):
  ath10k: change errno if we run out of msdu_ids
  ath10k: ath10k_htc_prepare_tx_skb() never fails
  ath10k: add lockdep asserts to htc skb dequeuing
  ath10k: simplify htc flow control
  ath10k: remove unused queue limit
  ath10k: introduce proper htt tx flow control
  ath10k: detect htt pending tx limit at runtime

 drivers/net/wireless/ath/ath10k/htc.c    |  106 +++++++-----------------------
 drivers/net/wireless/ath/ath10k/htc.h    |    4 --
 drivers/net/wireless/ath/ath10k/htt.c    |   25 ++-----
 drivers/net/wireless/ath/ath10k/htt.h    |   26 ++------
 drivers/net/wireless/ath/ath10k/htt_tx.c |   83 +++++++++++++++++++++--
 drivers/net/wireless/ath/ath10k/mac.c    |    2 +-
 drivers/net/wireless/ath/ath10k/txrx.c   |    5 +-
 7 files changed, 116 insertions(+), 135 deletions(-)

--

-- 
1.7.9.5
Permalink | Reply | 7 comments |
headers
Michal Kazior | 16 May 2013 10:52
Favicon

[PATCH] ath10k: remove static mac address mask

FW can dynamically adjust to multiple mac
addresses. It reports it's preferred base mac
address, but we can freely create derivative
addresses for vdevs.

Signed-off-by: Michal Kazior <michal.kazior <at> tieto.com>
---
 drivers/net/wireless/ath/ath10k/wmi.c |    8 --------
 1 file changed, 8 deletions(-)

diff --git a/drivers/net/wireless/ath/ath10k/wmi.c b/drivers/net/wireless/ath/ath10k/wmi.c
index 0d5070d..895567b 100644
--- a/drivers/net/wireless/ath/ath10k/wmi.c
+++ b/drivers/net/wireless/ath/ath10k/wmi.c
 <at>  <at>  -907,14 +907,6  <at>  <at>  static int ath10k_wmi_ready_event_rx(struct ath10k *ar, struct sk_buff *skb)

 	memcpy(ar->mac_addr, ev->mac_addr.addr, ETH_ALEN);

-	/* FIXME: FW should report possible addresses we can use. This is a
-	 *        development workaround. wpa_supplicant generates addresses
-	 *        that do not work with the FW without this. Once this is
-	 *        submitted upstream we should either get rid of this either by
-	 *        reducing functionality or forcing FW team to take action. */
-	memcpy(ar->hw->wiphy->perm_addr, ev->mac_addr.addr, ETH_ALEN);
-	memcpy(ar->hw->wiphy->addr_mask, "\x00\x00\x00\xFF\xFF\xFF", ETH_ALEN);
-
 	ath10k_dbg(ATH10K_DBG_WMI,
 		   "wmi event ready sw_version %u abi_version %u mac_addr %pM status %d\n",
 		   __le32_to_cpu(ev->sw_version),
--

-- 
1.7.9.5
Permalink | Reply | 0 comments |
headers
Michal Kazior | 16 May 2013 10:27
Favicon

[PATCH] ath10k: remove CTRY_DEFAULT assignment

The country is be overwritten by the eeprom
regdomain that we read from WMI event anyway.

Signed-off-by: Michal Kazior <michal.kazior <at> tieto.com>
---
 drivers/net/wireless/ath/ath10k/mac.c |    1 -
 1 file changed, 1 deletion(-)

diff --git a/drivers/net/wireless/ath/ath10k/mac.c b/drivers/net/wireless/ath/ath10k/mac.c
index 974f992..9454ff3 100644
--- a/drivers/net/wireless/ath/ath10k/mac.c
+++ b/drivers/net/wireless/ath/ath10k/mac.c
 <at>  <at>  -2941,7 +2941,6  <at>  <at>  int ath10k_mac_register(struct ath10k *ar)
 	ar->hw->wiphy->iface_combinations = &ath10k_if_comb;
 	ar->hw->wiphy->n_iface_combinations = 1;

-	ar->ath_common.regulatory.country_code = CTRY_DEFAULT;
 	ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
 			    ath10k_reg_notifier);
 	if (ret) {
--

-- 
1.7.9.5
Permalink | Reply | 0 comments |
headers
Joe Perches | 16 May 2013 09:05

[PATCH 2/2] ath10k: Neaten ath10k_<level> uses

Standardize the logging messages a bit.

A couple of typos were fixed.
Standardize the use of "VDEV:%d" instead of mixing in some "VDEV: %d".

Signed-off-by: Joe Perches <joe <at> perches.com>
---

Resending to ath9k per Kalle

 drivers/net/wireless/ath/ath10k/ce.c     |   6 +-
 drivers/net/wireless/ath/ath10k/core.c   |   2 +-
 drivers/net/wireless/ath/ath10k/htc.c    |  24 +++----
 drivers/net/wireless/ath/ath10k/htt_rx.c |   2 +-
 drivers/net/wireless/ath/ath10k/htt_tx.c |   2 +-
 drivers/net/wireless/ath/ath10k/mac.c    | 119 ++++++++++++++++---------------
 drivers/net/wireless/ath/ath10k/pci.c    |  44 ++++++------
 drivers/net/wireless/ath/ath10k/wmi.c    |   4 +-
 8 files changed, 102 insertions(+), 101 deletions(-)

diff --git a/drivers/net/wireless/ath/ath10k/ce.c b/drivers/net/wireless/ath/ath10k/ce.c
index 61a8ac7..36aa524 100644
--- a/drivers/net/wireless/ath/ath10k/ce.c
+++ b/drivers/net/wireless/ath/ath10k/ce.c
 <at>  <at>  -1126,13 +1126,13  <at>  <at>  struct ce_state *ath10k_ce_init(struct ath10k *ar,

 	ce_state = ath10k_ce_init_state(ar, ce_id, attr);
 	if (!ce_state) {
-		ath10k_err("Failed to initialize CE state for ID: %d\n", ce_id);
+		ath10k_err("failed to initialize CE state for ID: %d\n", ce_id);
 		return NULL;
 	}

 	if (attr->src_nentries) {
 		if (ath10k_ce_init_src_ring(ar, ce_id, ce_state, attr)) {
-			ath10k_err("Failed to initialize CE src ring for ID: %d\n",
+			ath10k_err("failed to initialize CE src ring for ID: %d\n",
 				   ce_id);
 			ath10k_ce_deinit(ce_state);
 			return NULL;
 <at>  <at>  -1141,7 +1141,7  <at>  <at>  struct ce_state *ath10k_ce_init(struct ath10k *ar,

 	if (attr->dest_nentries) {
 		if (ath10k_ce_init_dest_ring(ar, ce_id, ce_state, attr)) {
-			ath10k_err("Failed to initialize CE dest ring for ID: %d\n",
+			ath10k_err("failed to initialize CE dest ring for ID: %d\n",
 				   ce_id);
 			ath10k_ce_deinit(ce_state);
 			return NULL;
diff --git a/drivers/net/wireless/ath/ath10k/core.c b/drivers/net/wireless/ath/ath10k/core.c
index b258042..c13de8b 100644
--- a/drivers/net/wireless/ath/ath10k/core.c
+++ b/drivers/net/wireless/ath/ath10k/core.c
 <at>  <at>  -84,7 +84,7  <at>  <at>  static int ath10k_check_fw_version(struct ath10k *ar)
 		 SUPPORTED_FW_MAJOR, SUPPORTED_FW_MINOR,
 		 SUPPORTED_FW_RELEASE, SUPPORTED_FW_BUILD);

-	ath10k_warn("WARNING: Firmware version %s is not officially supported.\n",
+	ath10k_warn("WARNING: Firmware version %s is not officially supported\n",
 		    ar->hw->wiphy->fw_version);
 	ath10k_warn("Please upgrade to version %s (or newer)\n", version);

diff --git a/drivers/net/wireless/ath/ath10k/htc.c b/drivers/net/wireless/ath/ath10k/htc.c
index 9b6c681..1e1251a 100644
--- a/drivers/net/wireless/ath/ath10k/htc.c
+++ b/drivers/net/wireless/ath/ath10k/htc.c
 <at>  <at>  -88,7 +88,7  <at>  <at>  static struct sk_buff *ath10k_htc_build_tx_ctrl_skb(void *ar)

 	skb = dev_alloc_skb(ATH10K_HTC_CONTROL_BUFFER_SIZE);
 	if (!skb) {
-		ath10k_warn("Unable to allocate ctrl skb\n");
+		ath10k_warn("unable to allocate ctrl skb\n");
 		return NULL;
 	}

 <at>  <at>  -304,7 +304,7  <at>  <at>  int ath10k_htc_send(struct ath10k_htc *htc,
 	struct ath10k_htc_ep *ep = &htc->endpoint[eid];

 	if (eid >= ATH10K_HTC_EP_COUNT) {
-		ath10k_warn("Invalid endpoint id: %d\n", eid);
+		ath10k_warn("invalid endpoint id: %d\n", eid);
 		return -ENOENT;
 	}

 <at>  <at>  -382,7 +382,7  <at>  <at>  ath10k_htc_process_credit_report(struct ath10k_htc *htc,
 	int i, n_reports;

 	if (len % sizeof(*report))
-		ath10k_warn("Uneven credit report len %d", len);
+		ath10k_warn("uneven credit report len %d", len);

 	n_reports = len / sizeof(*report);

 <at>  <at>  -427,7 +427,7  <at>  <at>  static int ath10k_htc_process_trailer(struct ath10k_htc *htc,

 		if (record->hdr.len > length) {
 			/* no room left in buffer for record */
-			ath10k_warn("Invalid record length: %d\n",
+			ath10k_warn("invalid record length: %d\n",
 				    record->hdr.len);
 			status = -EINVAL;
 			break;
 <at>  <at>  -437,7 +437,7  <at>  <at>  static int ath10k_htc_process_trailer(struct ath10k_htc *htc,
 		case ATH10K_HTC_RECORD_CREDITS:
 			len = sizeof(struct ath10k_htc_credit_report);
 			if (record->hdr.len < len) {
-				ath10k_warn("Credit report too long\n");
+				ath10k_warn("credit report too long\n");
 				status = -EINVAL;
 				break;
 			}
 <at>  <at>  -535,7 +535,7  <at>  <at>  static int ath10k_htc_rx_completion_handler(struct ath10k *ar,

 		if ((trailer_len < min_len) ||
 		    (trailer_len > payload_len)) {
-			ath10k_warn("Invalid trailer length: %d\n",
+			ath10k_warn("invalid trailer length: %d\n",
 				    trailer_len);
 			status = -EPROTO;
 			goto out;
 <at>  <at>  -722,7 +722,7  <at>  <at>  int ath10k_htc_wait_target(struct ath10k_htc *htc)
 	}

 	if (htc->control_resp_len < sizeof(msg->hdr) + sizeof(msg->ready)) {
-		ath10k_err("Invalid HTC ready msg len:%d\n",
+		ath10k_err("invalid HTC ready msg len:%d\n",
 			   htc->control_resp_len);

 		status = -ECOMM;
 <at>  <at>  -735,7 +735,7  <at>  <at>  int ath10k_htc_wait_target(struct ath10k_htc *htc)
 	credit_size  = __le16_to_cpu(msg->ready.credit_size);

 	if (message_id != ATH10K_HTC_MSG_READY_ID) {
-		ath10k_err("Invalid HTC ready msg: 0x%x\n", message_id);
+		ath10k_err("invalid HTC ready msg: 0x%x\n", message_id);
 		status = -ECOMM;
 		goto err_target;
 	}
 <at>  <at>  -750,7 +750,7  <at>  <at>  int ath10k_htc_wait_target(struct ath10k_htc *htc)
 	if ((htc->total_transmit_credits == 0) ||
 	    (htc->target_credit_size == 0)) {
 		status = -ECOMM;
-		ath10k_err("Invalid credit size received\n");
+		ath10k_err("invalid credit size received\n");
 		goto err_target;
 	}

 <at>  <at>  -812,7 +812,7  <at>  <at>  int ath10k_htc_connect_service(struct ath10k_htc *htc,

 	skb = ath10k_htc_build_tx_ctrl_skb(htc->ar);
 	if (!skb) {
-		ath10k_err("Failed to allocate HTC packet\n");
+		ath10k_err("failed to allocate HTC packet\n");
 		return -ENOMEM;
 	}

 <at>  <at>  -850,7 +850,7  <at>  <at>  int ath10k_htc_connect_service(struct ath10k_htc *htc,
 	if (status <= 0) {
 		if (status == 0)
 			status = -ETIMEDOUT;
-		ath10k_err("Service connect timeout: %d\n", status);
+		ath10k_err("service connect timeout: %d\n", status);
 		return status;
 	}

 <at>  <at>  -863,7 +863,7  <at>  <at>  int ath10k_htc_connect_service(struct ath10k_htc *htc,
 	if ((message_id != ATH10K_HTC_MSG_CONNECT_SERVICE_RESP_ID) ||
 	    (htc->control_resp_len < sizeof(msg->hdr) +
 	     sizeof(msg->connect_service_response))) {
-		ath10k_err("Invalid resp message ID 0x%x", message_id);
+		ath10k_err("invalid resp message ID 0x%x", message_id);
 		return -EPROTO;
 	}

diff --git a/drivers/net/wireless/ath/ath10k/htt_rx.c b/drivers/net/wireless/ath/ath10k/htt_rx.c
index 21385b3..cccf4b8 100644
--- a/drivers/net/wireless/ath/ath10k/htt_rx.c
+++ b/drivers/net/wireless/ath/ath10k/htt_rx.c
 <at>  <at>  -285,7 +285,7  <at>  <at>  static int ath10k_htt_rx_amsdu_pop(struct ath10k_htt *htt,
 		ath10k_warn("htt rx ring is empty!\n");

 	if (htt->rx_confused) {
-		ath10k_warn("htt is confused. refusing rx\n");
+		ath10k_warn("htt is confused - refusing rx\n");
 		return 0;
 	}

diff --git a/drivers/net/wireless/ath/ath10k/htt_tx.c b/drivers/net/wireless/ath/ath10k/htt_tx.c
index 4df9494..3e4a5c3 100644
--- a/drivers/net/wireless/ath/ath10k/htt_tx.c
+++ b/drivers/net/wireless/ath/ath10k/htt_tx.c
 <at>  <at>  -334,7 +334,7  <at>  <at>  int ath10k_htt_tx(struct ath10k_htt *htt, struct sk_buff *msdu)
 	}

 	if (!IS_ALIGNED((unsigned long)txdesc->data, 4)) {
-		ath10k_warn("htt alignment check failed. dropping packet.\n");
+		ath10k_warn("htt alignment check failed - dropping packet\n");
 		res = -EIO;
 		goto err;
 	}
diff --git a/drivers/net/wireless/ath/ath10k/mac.c b/drivers/net/wireless/ath/ath10k/mac.c
index f3daa51..5637341 100644
--- a/drivers/net/wireless/ath/ath10k/mac.c
+++ b/drivers/net/wireless/ath/ath10k/mac.c
 <at>  <at>  -428,7 +428,7  <at>  <at>  static int ath10k_vdev_start(struct ath10k_vif *arvif)

 	ret = ath10k_wmi_vdev_start(ar, &arg);
 	if (ret) {
-		ath10k_warn("WMI vdev start failed: ret %d\n", ret);
+		ath10k_warn("WMI vdev start failed: %d\n", ret);
 		return ret;
 	}

 <at>  <at>  -452,7 +452,7  <at>  <at>  static int ath10k_vdev_stop(struct ath10k_vif *arvif)

 	ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id);
 	if (ret) {
-		ath10k_warn("WMI vdev stop failed: ret %d\n", ret);
+		ath10k_warn("WMI vdev stop failed: %d\n", ret);
 		return ret;
 	}

 <at>  <at>  -491,13 +491,13  <at>  <at>  static int ath10k_monitor_start(struct ath10k *ar, int vdev_id)

 	ret = ath10k_wmi_vdev_start(ar, &arg);
 	if (ret) {
-		ath10k_warn("Monitor vdev start failed: ret %d\n", ret);
+		ath10k_warn("Monitor vdev start failed: %d\n", ret);
 		return ret;
 	}

 	ret = ath10k_vdev_setup_sync(ar);
 	if (ret) {
-		ath10k_warn("Monitor vdev setup failed %d\n", ret);
+		ath10k_warn("Monitor vdev setup failed: %d\n", ret);
 		return ret;
 	}

 <at>  <at>  -558,7 +558,7  <at>  <at>  static int ath10k_monitor_create(struct ath10k *ar)

 	bit = ffs(ar->free_vdev_map);
 	if (bit == 0) {
-		ath10k_warn("No free VDEV slots\n");
+		ath10k_warn("no free VDEV slots\n");
 		return -ENOMEM;
 	}

 <at>  <at>  -569,7 +569,8  <at>  <at>  static int ath10k_monitor_create(struct ath10k *ar)
 				     WMI_VDEV_TYPE_MONITOR,
 				     0, ar->mac_addr);
 	if (ret) {
-		ath10k_warn("WMI vdev monitor create failed: ret %d\n", ret);
+		ath10k_warn("WMI vdev monitor create failed: %d\n",
+			    ret);
 		goto vdev_fail;
 	}

 <at>  <at>  -628,11 +629,11  <at>  <at>  static void ath10k_control_beaconing(struct ath10k_vif *arvif,

 	ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, 0, info->bssid);
 	if (ret) {
-		ath10k_warn("Failed to bring up VDEV: %d\n",
+		ath10k_warn("failed to bring up VDEV:%d\n",
 			    arvif->vdev_id);
 		return;
 	}
-	ath10k_dbg(MAC, "VDEV: %d up\n", arvif->vdev_id);
+	ath10k_dbg(MAC, "VDEV:%d up\n", arvif->vdev_id);
 }

 static void ath10k_control_ibss(struct ath10k_vif *arvif,
 <at>  <at>  -644,7 +645,7  <at>  <at>  static void ath10k_control_ibss(struct ath10k_vif *arvif,
 	if (!info->ibss_joined) {
 		ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, self_peer);
 		if (ret)
-			ath10k_warn("Failed to delete IBSS self peer:%pM for VDEV:%d ret:%d\n",
+			ath10k_warn("failed to delete IBSS self peer:%pM for VDEV:%d - %d\n",
 				    self_peer, arvif->vdev_id, ret);

 		if (is_zero_ether_addr(arvif->u.ibss.bssid))
 <at>  <at>  -653,7 +654,7  <at>  <at>  static void ath10k_control_ibss(struct ath10k_vif *arvif,
 		ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id,
 					 arvif->u.ibss.bssid);
 		if (ret) {
-			ath10k_warn("Failed to delete IBSS BSSID peer:%pM for VDEV:%d ret:%d\n",
+			ath10k_warn("failed to delete IBSS BSSID peer:%pM for VDEV:%d - %d\n",
 				    arvif->u.ibss.bssid, arvif->vdev_id, ret);
 			return;
 		}
 <at>  <at>  -665,7 +666,7  <at>  <at>  static void ath10k_control_ibss(struct ath10k_vif *arvif,

 	ret = ath10k_peer_create(arvif->ar, arvif->vdev_id, self_peer);
 	if (ret) {
-		ath10k_warn("Failed to create IBSS self peer:%pM for VDEV:%d ret:%d\n",
+		ath10k_warn("failed to create IBSS self peer:%pM for VDEV:%d - %d\n",
 			    self_peer, arvif->vdev_id, ret);
 		return;
 	}
 <at>  <at>  -674,7 +675,7  <at>  <at>  static void ath10k_control_ibss(struct ath10k_vif *arvif,
 					WMI_VDEV_PARAM_ATIM_WINDOW,
 					ATH10K_DEFAULT_ATIM);
 	if (ret)
-		ath10k_warn("Failed to set IBSS ATIM for VDEV:%d ret:%d\n",
+		ath10k_warn("failed to set IBSS ATIM for VDEV:%d - %d\n",
 			    arvif->vdev_id, ret);
 }

 <at>  <at>  -702,7 +703,7  <at>  <at>  static void ath10k_ps_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
 						  param,
 						  conf->dynamic_ps_timeout);
 		if (ret) {
-			ath10k_warn("Failed to set inactivity time for VDEV: %d\n",
+			ath10k_warn("failed to set inactivity time for VDEV:%d\n",
 				    arvif->vdev_id);
 			return;
 		}
 <at>  <at>  -715,10 +716,10  <at>  <at>  static void ath10k_ps_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
 	ar_iter->ret = ath10k_wmi_set_psmode(ar_iter->ar, arvif->vdev_id,
 					     psmode);
 	if (ar_iter->ret)
-		ath10k_warn("Failed to set PS Mode: %d for VDEV: %d\n",
+		ath10k_warn("failed to set PS Mode: %d for VDEV:%d\n",
 			    psmode, arvif->vdev_id);
 	else
-		ath10k_dbg(MAC, "Set PS Mode: %d for VDEV: %d\n",
+		ath10k_dbg(MAC, "Set PS Mode: %d for VDEV:%d\n",
 			   psmode, arvif->vdev_id);
 }

 <at>  <at>  -1062,7 +1063,7  <at>  <at>  static void ath10k_bss_assoc(struct ieee80211_hw *hw,

 	ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
 	if (!ap_sta) {
-		ath10k_warn("Failed to find station entry for %pM\n",
+		ath10k_warn("failed to find station entry for %pM\n",
 			    bss_conf->bssid);
 		rcu_read_unlock();
 		return;
 <at>  <at>  -1070,7 +1071,7  <at>  <at>  static void ath10k_bss_assoc(struct ieee80211_hw *hw,

 	ret = ath10k_peer_assoc(ar, arvif, ap_sta, bss_conf);
 	if (ret) {
-		ath10k_warn("Peer assoc failed for %pM\n", bss_conf->bssid);
+		ath10k_warn("peer assoc failed for %pM\n", bss_conf->bssid);
 		rcu_read_unlock();
 		return;
 	}
 <at>  <at>  -1080,10 +1081,10  <at>  <at>  static void ath10k_bss_assoc(struct ieee80211_hw *hw,
 	ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, bss_conf->aid,
 				 bss_conf->bssid);
 	if (ret)
-		ath10k_warn("VDEV: %d up failed: ret %d\n",
+		ath10k_warn("VDEV:%d up failed: ret %d\n",
 			    arvif->vdev_id, ret);
 	else
-		ath10k_dbg(MAC, "VDEV: %d associated, BSSID: %pM, AID: %d\n",
+		ath10k_dbg(MAC, "VDEV:%d associated, BSSID: %pM, AID: %d\n",
 			   arvif->vdev_id, bss_conf->bssid, bss_conf->aid);
 }

 <at>  <at>  -1105,7 +1106,7  <at>  <at>  static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
 	 */
 	ret = ath10k_vdev_stop(arvif);
 	if (!ret)
-		ath10k_dbg(MAC, "VDEV: %d stopped\n", arvif->vdev_id);
+		ath10k_dbg(MAC, "VDEV:%d stopped\n", arvif->vdev_id);

 	/*
 	 * If we don't call VDEV-DOWN after VDEV-STOP FW will remain active and
 <at>  <at>  -1116,7 +1117,7  <at>  <at>  static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
 	 */
 	ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
 	if (ret)
-		ath10k_dbg(MAC, "VDEV: %d ath10k_wmi_vdev_down failed (%d)\n",
+		ath10k_dbg(MAC, "VDEV:%d ath10k_wmi_vdev_down failed (%d)\n",
 			   arvif->vdev_id, ret);

 	ath10k_wmi_flush_tx(ar);
 <at>  <at>  -1362,7 +1363,7  <at>  <at>  static void ath10k_tx_htt(struct ath10k *ar, struct sk_buff *skb)
 		ret = ath10k_htt_tx(ar->htt, skb);

 	if (ret) {
-		ath10k_warn("tx failed (%d). dropping packet.\n", ret);
+		ath10k_warn("tx failed (%d) - dropping packet\n", ret);
 		ieee80211_free_txskb(ar->hw, skb);
 	}
 }
 <at>  <at>  -1707,7 +1708,7  <at>  <at>  static int ath10k_add_interface(struct ieee80211_hw *hw,
 	arvif->vif = vif;

 	if ((vif->type == NL80211_IFTYPE_MONITOR) && ar->monitor_present) {
-		ath10k_warn("Only one monitor interface allowed\n");
+		ath10k_warn("only one monitor interface allowed\n");
 		ret = -EBUSY;
 		goto exit;
 	}
 <at>  <at>  -1762,18 +1763,18  <at>  <at>  static int ath10k_add_interface(struct ieee80211_hw *hw,
 	ret = ath10k_wmi_vdev_set_param(ar, 0, WMI_VDEV_PARAM_DEF_KEYID,
 					arvif->def_wep_key_index);
 	if (ret)
-		ath10k_warn("Failed to set default keyid: %d\n", ret);
+		ath10k_warn("failed to set default keyid: %d\n", ret);

 	ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
 					WMI_VDEV_PARAM_TX_ENCAP_TYPE,
 					ATH10K_HW_TXRX_NATIVE_WIFI);
 	if (ret)
-		ath10k_warn("Failed to set TX encap: %d\n", ret);
+		ath10k_warn("failed to set TX encap: %d\n", ret);

 	if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
 		ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr);
 		if (ret) {
-			ath10k_warn("Failed to create peer for AP: %d\n", ret);
+			ath10k_warn("failed to create peer for AP: %d\n", ret);
 			goto exit;
 		}
 	}
 <at>  <at>  -1784,21 +1785,21  <at>  <at>  static int ath10k_add_interface(struct ieee80211_hw *hw,
 		ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
 						  param, value);
 		if (ret)
-			ath10k_warn("Failed to set RX wake policy: %d\n", ret);
+			ath10k_warn("failed to set RX wake policy: %d\n", ret);

 		param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
 		value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
 		ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
 						  param, value);
 		if (ret)
-			ath10k_warn("Failed to set TX wake thresh: %d\n", ret);
+			ath10k_warn("failed to set TX wake thresh: %d\n", ret);

 		param = WMI_STA_PS_PARAM_PSPOLL_COUNT;
 		value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
 		ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
 						  param, value);
 		if (ret)
-			ath10k_warn("Failed to set PSPOLL count: %d\n", ret);
+			ath10k_warn("failed to set PSPOLL count: %d\n", ret);
 	}

 	if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
 <at>  <at>  -1825,7 +1826,7  <at>  <at>  static void ath10k_remove_interface(struct ieee80211_hw *hw,
 	if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
 		ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, vif->addr);
 		if (ret)
-			ath10k_warn("Failed to remove peer for AP: %d\n", ret);
+			ath10k_warn("failed to remove peer for AP: %d\n", ret);

 		kfree(arvif->u.ap.noa_data);
 	}
 <at>  <at>  -1873,14 +1874,14  <at>  <at>  static void ath10k_configure_filter(struct ieee80211_hw *hw,
 	    !ar->monitor_enabled) {
 		ret = ath10k_monitor_start(ar, ar->monitor_vdev_id);
 		if (ret)
-			ath10k_warn("Unable to start monitor mode\n");
+			ath10k_warn("unable to start monitor mode\n");
 		else
 			ath10k_dbg(MAC, "Monitor mode started\n");
 	} else if (!(ar->filter_flags & FIF_PROMISC_IN_BSS) &&
 		   ar->monitor_enabled) {
 		ret = ath10k_monitor_stop(ar);
 		if (ret)
-			ath10k_warn("Unable to stop monitor mode\n");
+			ath10k_warn("unable to stop monitor mode\n");
 		else
 			ath10k_dbg(MAC, "Monitor mode stopped\n");
 	}
 <at>  <at>  -1908,10 +1909,10  <at>  <at>  static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
 						WMI_VDEV_PARAM_BEACON_INTERVAL,
 						arvif->beacon_interval);
 		if (ret)
-			ath10k_warn("Failed to set beacon interval for VDEV: %d\n",
+			ath10k_warn("failed to set beacon interval for VDEV:%d\n",
 				    arvif->vdev_id);
 		else
-			ath10k_dbg(MAC, "Beacon interval: %d set for VDEV: %d\n",
+			ath10k_dbg(MAC, "Beacon interval: %d set for VDEV:%d\n",
 				   arvif->beacon_interval, arvif->vdev_id);
 	}

 <at>  <at>  -1920,11 +1921,11  <at>  <at>  static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
 						WMI_PDEV_PARAM_BEACON_TX_MODE,
 						WMI_BEACON_STAGGERED_MODE);
 		if (ret)
-			ath10k_warn("Failed to set beacon mode for VDEV: %d\n",
+			ath10k_warn("failed to set beacon mode for VDEV:%d\n",
 				    arvif->vdev_id);
 		else
 			ath10k_dbg(MAC,
-				   "Set staggered beacon mode for VDEV: %d\n",
+				   "Set staggered beacon mode for VDEV:%d\n",
 				   arvif->vdev_id);
 	}

 <at>  <at>  -1935,10 +1936,10  <at>  <at>  static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
 						WMI_VDEV_PARAM_DTIM_PERIOD,
 						arvif->dtim_period);
 		if (ret)
-			ath10k_warn("Failed to set dtim period for VDEV: %d\n",
+			ath10k_warn("failed to set dtim period for VDEV:%d\n",
 				    arvif->vdev_id);
 		else
-			ath10k_dbg(MAC, "Set dtim period: %d for VDEV: %d\n",
+			ath10k_dbg(MAC, "Set dtim period: %d for VDEV:%d\n",
 				   arvif->dtim_period, arvif->vdev_id);
 	}

 <at>  <at>  -1955,10 +1956,10  <at>  <at>  static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
 			ret = ath10k_peer_create(ar, arvif->vdev_id,
 						 info->bssid);
 			if (ret)
-				ath10k_warn("Failed to add peer: %pM for VDEV: %d\n",
+				ath10k_warn("failed to add peer: %pM for VDEV:%d\n",
 					    info->bssid, arvif->vdev_id);
 			else
-				ath10k_dbg(MAC, "Added peer: %pM for VDEV: %d\n",
+				ath10k_dbg(MAC, "Added peer: %pM for VDEV:%d\n",
 					   info->bssid, arvif->vdev_id);

 <at>  <at>  -1973,7 +1974,7  <at>  <at>  static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
 				ret = ath10k_vdev_start(arvif);
 				if (!ret)
 					ath10k_dbg(MAC,
-						   "VDEV: %d started with BSSID: %pM\n",
+						   "VDEV:%d started with BSSID: %pM\n",
 						   arvif->vdev_id, info->bssid);
 			}

 <at>  <at>  -2002,10 +2003,10  <at>  <at>  static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
 						WMI_VDEV_PARAM_ENABLE_RTSCTS,
 						cts_prot);
 		if (ret)
-			ath10k_warn("Failed to set CTS prot for VDEV: %d\n",
+			ath10k_warn("failed to set CTS prot for VDEV:%d\n",
 				    arvif->vdev_id);
 		else
-			ath10k_dbg(MAC, "Set CTS prot: %d for VDEV: %d\n",
+			ath10k_dbg(MAC, "Set CTS prot: %d for VDEV:%d\n",
 				   cts_prot, arvif->vdev_id);
 	}

 <at>  <at>  -2021,10 +2022,10  <at>  <at>  static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
 						WMI_VDEV_PARAM_SLOT_TIME,
 						slottime);
 		if (ret)
-			ath10k_warn("Failed to set erp slot for VDEV: %d\n",
+			ath10k_warn("failed to set erp slot for VDEV:%d\n",
 				    arvif->vdev_id);
 		else
-			ath10k_dbg(MAC, "Set slottime: %d for VDEV: %d\n",
+			ath10k_dbg(MAC, "Set slottime: %d for VDEV:%d\n",
 				   slottime, arvif->vdev_id);
 	}

 <at>  <at>  -2039,10 +2040,10  <at>  <at>  static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
 						WMI_VDEV_PARAM_PREAMBLE,
 						preamble);
 		if (ret)
-			ath10k_warn("Failed to set preamble for VDEV: %d\n",
+			ath10k_warn("failed to set preamble for VDEV:%d\n",
 				    arvif->vdev_id);
 		else
-			ath10k_dbg(MAC, "Set preamble: %d for VDEV: %d\n",
+			ath10k_dbg(MAC, "Set preamble: %d for VDEV:%d\n",
 				   preamble, arvif->vdev_id);
 	}

 <at>  <at>  -2228,10 +2229,10  <at>  <at>  static int ath10k_sta_state(struct ieee80211_hw *hw,
 		 */
 		ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr);
 		if (ret)
-			ath10k_warn("Failed to add peer: %pM for VDEV: %d\n",
+			ath10k_warn("failed to add peer: %pM for VDEV:%d\n",
 				    sta->addr, arvif->vdev_id);
 		else
-			ath10k_dbg(MAC, "Added peer: %pM for VDEV: %d\n",
+			ath10k_dbg(MAC, "Added peer: %pM for VDEV:%d\n",
 				   sta->addr, arvif->vdev_id);
 	} else if ((old_state == IEEE80211_STA_NONE &&
 		    new_state == IEEE80211_STA_NOTEXIST)) {
 <at>  <at>  -2240,10 +2241,10  <at>  <at>  static int ath10k_sta_state(struct ieee80211_hw *hw,
 		 */
 		ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
 		if (ret)
-			ath10k_warn("Failed to delete peer: %pM for VDEV: %d\n",
+			ath10k_warn("failed to delete peer: %pM for VDEV:%d\n",
 				    sta->addr, arvif->vdev_id);
 		else
-			ath10k_dbg(MAC, "Removed peer: %pM for VDEV: %d\n",
+			ath10k_dbg(MAC, "Removed peer: %pM for VDEV:%d\n",
 				   sta->addr, arvif->vdev_id);

 		if (vif->type == NL80211_IFTYPE_STATION)
 <at>  <at>  -2257,7 +2258,7  <at>  <at>  static int ath10k_sta_state(struct ieee80211_hw *hw,
 		 */
 		ret = ath10k_station_assoc(ar, arvif, sta);
 		if (ret)
-			ath10k_warn("Failed to associate station: %pM\n",
+			ath10k_warn("failed to associate station: %pM\n",
 				    sta->addr);
 		else
 			ath10k_dbg(MAC, "Station %pM moved to assoc state\n",
 <at>  <at>  -2271,7 +2272,7  <at>  <at>  static int ath10k_sta_state(struct ieee80211_hw *hw,
 		 */
 		ret = ath10k_station_disassoc(ar, arvif, sta);
 		if (ret)
-			ath10k_warn("Failed to disassociate station: %pM\n",
+			ath10k_warn("failed to disassociate station: %pM\n",
 				    sta->addr);
 		else
 			ath10k_dbg(MAC,
 <at>  <at>  -2491,10 +2492,10  <at>  <at>  static void ath10k_set_rts_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
 						 WMI_VDEV_PARAM_RTS_THRESHOLD,
 						 rts);
 	if (ar_iter->ret)
-		ath10k_warn("Failed to set RTS threshold for VDEV: %d\n",
+		ath10k_warn("failed to set RTS threshold for VDEV:%d\n",
 			    arvif->vdev_id);
 	else
-		ath10k_dbg(MAC, "Set RTS threshold: %d for VDEV: %d\n",
+		ath10k_dbg(MAC, "Set RTS threshold: %d for VDEV:%d\n",
 			   rts, arvif->vdev_id);
 }

 <at>  <at>  -2531,10 +2532,10  <at>  <at>  static void ath10k_set_frag_iter(void *data, u8 *mac, struct ieee80211_vif *vif)

 	ar_iter->ret = ret;
 	if (ar_iter->ret)
-		ath10k_warn("Failed to set frag threshold for VDEV: %d\n",
+		ath10k_warn("failed to set frag threshold for VDEV:%d\n",
 			    arvif->vdev_id);
 	else
-		ath10k_dbg(MAC, "Set frag threshold: %d for VDEV: %d\n",
+		ath10k_dbg(MAC, "Set frag threshold: %d for VDEV:%d\n",
 			   frag, arvif->vdev_id);
 }

 <at>  <at>  -2823,7 +2824,7  <at>  <at>  struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
 						   ath10k_get_arvif_iter,
 						   &arvif_iter);
 	if (!arvif_iter.arvif) {
-		ath10k_warn("No VIF found for VDEV: %d\n", vdev_id);
+		ath10k_warn("No VIF found for VDEV:%d\n", vdev_id);
 		return NULL;
 	}

 <at>  <at>  -2931,7 +2932,7  <at>  <at>  int ath10k_mac_register(struct ath10k *ar)
 	ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
 			    ath10k_reg_notifier);
 	if (ret) {
-		ath10k_err("Regulatory initialization failed\n");
+		ath10k_err("regulatory initialization failed\n");
 		return ret;
 	}

diff --git a/drivers/net/wireless/ath/ath10k/pci.c b/drivers/net/wireless/ath/ath10k/pci.c
index 9f650b7..912e073 100644
--- a/drivers/net/wireless/ath/ath10k/pci.c
+++ b/drivers/net/wireless/ath/ath10k/pci.c
 <at>  <at>  -428,7 +428,7  <at>  <at>  static void ath10k_pci_wait(struct ath10k *ar)
 		msleep(10);

 	if (n < 0)
-		ath10k_warn("Unable to wakeup target\n");
+		ath10k_warn("unable to wakeup target\n");
 }

 void ath10k_do_pci_wake(struct ath10k *ar)
 <at>  <at>  -646,7 +646,7  <at>  <at>  static int ath10k_pci_hif_send_head(struct ath10k *ar, u8 pipe_id,
 	/* Make sure we have resources to handle this request */
 	spin_lock_bh(&pipe_info->pipe_lock);
 	if (!pipe_info->num_sends_allowed) {
-		ath10k_warn("Pipe: %d is full\n", pipe_id);
+		ath10k_warn("pipe: %d is full\n", pipe_id);
 		spin_unlock_bh(&pipe_info->pipe_lock);
 		return -ENOSR;
 	}
 <at>  <at>  -911,7 +911,7  <at>  <at>  static void ath10k_pci_process_ce(struct ath10k *ar)
 		} else {
 			ret = ath10k_pci_post_rx_pipe(compl->pipe_info, 1);
 			if (ret) {
-				ath10k_warn("Unable to post recv buffer for pipe: %d\n",
+				ath10k_warn("unable to post recv buffer for pipe: %d\n",
 					    compl->pipe_info->pipe_num);
 				break;
 			}
 <at>  <at>  -1102,7 +1102,7  <at>  <at>  static int ath10k_pci_post_rx(struct ath10k *ar)
 		ret = ath10k_pci_post_rx_pipe(pipe_info,
 					      attr->dest_nentries - 1);
 		if (ret) {
-			ath10k_warn("Unable to replenish recv buffers for pipe: %d\n",
+			ath10k_warn("unable to replenish recv buffers for pipe: %d\n",
 				    pipe_num);

 			for (; pipe_num >= 0; pipe_num--) {
 <at>  <at>  -1494,7 +1494,7  <at>  <at>  static int ath10k_pci_wake_target_cpu(struct ath10k *ar)
 					      CORE_CTRL_ADDRESS,
 					  &core_ctrl);
 	if (ret) {
-		ath10k_warn("Unable to read core ctrl\n");
+		ath10k_warn("unable to read core ctrl\n");
 		return ret;
 	}

 <at>  <at>  -1505,7 +1505,7  <at>  <at>  static int ath10k_pci_wake_target_cpu(struct ath10k *ar)
 					       CORE_CTRL_ADDRESS,
 					   core_ctrl);
 	if (ret)
-		ath10k_warn("Unable to set interrupt mask\n");
+		ath10k_warn("unable to set interrupt mask\n");

 	return ret;
 }
 <at>  <at>  -1531,13 +1531,13  <at>  <at>  static int ath10k_pci_init_config(struct ath10k *ar)
 	ret = ath10k_pci_diag_read_access(ar, interconnect_targ_addr,
 					  &pcie_state_targ_addr);
 	if (ret != 0) {
-		ath10k_err("Failed to get pcie state addr: %d\n", ret);
+		ath10k_err("failed to get pcie state addr: %d\n", ret);
 		return ret;
 	}

 	if (pcie_state_targ_addr == 0) {
 		ret = -EIO;
-		ath10k_err("Invalid pcie state addr\n");
+		ath10k_err("invalid pcie state addr\n");
 		return ret;
 	}

 <at>  <at>  -1546,13 +1546,13  <at>  <at>  static int ath10k_pci_init_config(struct ath10k *ar)
 						   pipe_cfg_addr),
 					  &pipe_cfg_targ_addr);
 	if (ret != 0) {
-		ath10k_err("Failed to get pipe cfg addr: %d\n", ret);
+		ath10k_err("failed to get pipe cfg addr: %d\n", ret);
 		return ret;
 	}

 	if (pipe_cfg_targ_addr == 0) {
 		ret = -EIO;
-		ath10k_err("Invalid pipe cfg addr\n");
+		ath10k_err("invalid pipe cfg addr\n");
 		return ret;
 	}

 <at>  <at>  -1561,7 +1561,7  <at>  <at>  static int ath10k_pci_init_config(struct ath10k *ar)
 				 sizeof(target_ce_config_wlan));

 	if (ret != 0) {
-		ath10k_err("Failed to write pipe cfg: %d\n", ret);
+		ath10k_err("failed to write pipe cfg: %d\n", ret);
 		return ret;
 	}

 <at>  <at>  -1570,13 +1570,13  <at>  <at>  static int ath10k_pci_init_config(struct ath10k *ar)
 						   svc_to_pipe_map),
 					  &svc_to_pipe_map);
 	if (ret != 0) {
-		ath10k_err("Failed to get svc/pipe map: %d\n", ret);
+		ath10k_err("failed to get svc/pipe map: %d\n", ret);
 		return ret;
 	}

 	if (svc_to_pipe_map == 0) {
 		ret = -EIO;
-		ath10k_err("Invalid svc_to_pipe map\n");
+		ath10k_err("invalid svc_to_pipe map\n");
 		return ret;
 	}

 <at>  <at>  -1584,7 +1584,7  <at>  <at>  static int ath10k_pci_init_config(struct ath10k *ar)
 				 target_service_to_ce_map_wlan,
 				 sizeof(target_service_to_ce_map_wlan));
 	if (ret != 0) {
-		ath10k_err("Failed to write svc/pipe map: %d\n", ret);
+		ath10k_err("failed to write svc/pipe map: %d\n", ret);
 		return ret;
 	}

 <at>  <at>  -1593,7 +1593,7  <at>  <at>  static int ath10k_pci_init_config(struct ath10k *ar)
 						   config_flags),
 					  &pcie_config_flags);
 	if (ret != 0) {
-		ath10k_err("Failed to get pcie config_flags: %d\n", ret);
+		ath10k_err("failed to get pcie config_flags: %d\n", ret);
 		return ret;
 	}

 <at>  <at>  -1604,7 +1604,7  <at>  <at>  static int ath10k_pci_init_config(struct ath10k *ar)
 				 &pcie_config_flags,
 				 sizeof(pcie_config_flags));
 	if (ret != 0) {
-		ath10k_err("Failed to write pcie config_flags: %d\n", ret);
+		ath10k_err("failed to write pcie config_flags: %d\n", ret);
 		return ret;
 	}

 <at>  <at>  -1613,7 +1613,7  <at>  <at>  static int ath10k_pci_init_config(struct ath10k *ar)

 	ret = ath10k_pci_diag_read_access(ar, ealloc_targ_addr, &ealloc_value);
 	if (ret != 0) {
-		ath10k_err("Faile to get early alloc val: %d\n", ret);
+		ath10k_err("failed to get early alloc val: %d\n", ret);
 		return ret;
 	}

 <at>  <at>  -1625,7 +1625,7  <at>  <at>  static int ath10k_pci_init_config(struct ath10k *ar)

 	ret = ath10k_pci_diag_write_access(ar, ealloc_targ_addr, ealloc_value);
 	if (ret != 0) {
-		ath10k_err("Failed to set early alloc val: %d\n", ret);
+		ath10k_err("failed to set early alloc val: %d\n", ret);
 		return ret;
 	}

 <at>  <at>  -1634,7 +1634,7  <at>  <at>  static int ath10k_pci_init_config(struct ath10k *ar)

 	ret = ath10k_pci_diag_read_access(ar, flag2_targ_addr, &flag2_value);
 	if (ret != 0) {
-		ath10k_err("Failed to get option val: %d\n", ret);
+		ath10k_err("failed to get option val: %d\n", ret);
 		return ret;
 	}

 <at>  <at>  -1642,7 +1642,7  <at>  <at>  static int ath10k_pci_init_config(struct ath10k *ar)

 	ret = ath10k_pci_diag_write_access(ar, flag2_targ_addr, flag2_value);
 	if (ret != 0) {
-		ath10k_err("Failed to set option val: %d\n", ret);
+		ath10k_err("failed to set option val: %d\n", ret);
 		return ret;
 	}

 <at>  <at>  -1666,7 +1666,7  <at>  <at>  static int ath10k_pci_ce_init(struct ath10k *ar)

 		pipe_info->ce_hdl = ath10k_ce_init(ar, pipe_num, attr);
 		if (pipe_info->ce_hdl == NULL) {
-			ath10k_err("Unable to initialize CE for pipe: %d\n",
+			ath10k_err("unable to initialize CE for pipe: %d\n",
 				   pipe_num);

 			/* It is safe to call it here. It checks if ce_hdl is
 <at>  <at>  -2148,7 +2148,7  <at>  <at>  static int ath10k_pci_probe(struct pci_dev *pdev,
 		break;
 	default:
 		ret = -ENODEV;
-		ath10k_err("Unkown device ID: %d\n", pci_dev->device);
+		ath10k_err("Unknown device ID: %d\n", pci_dev->device);
 		goto err_ar_pci;
 	}

diff --git a/drivers/net/wireless/ath/ath10k/wmi.c b/drivers/net/wireless/ath/ath10k/wmi.c
index 1f530ee..3db07e72 100644
--- a/drivers/net/wireless/ath/ath10k/wmi.c
+++ b/drivers/net/wireless/ath/ath10k/wmi.c
 <at>  <at>  -841,7 +841,7  <at>  <at>  static void ath10k_wmi_service_ready_event_rx(struct ath10k *ar,
 	struct wmi_service_ready_event *ev = (void *)skb->data;

 	if (skb->len < sizeof(*ev)) {
-		ath10k_warn("Service ready event was %d B but expected %zu B. Wrong firmware version?\n",
+		ath10k_warn("service ready event was %d B but expected %zu B. Wrong firmware version?\n",
 			    skb->len, sizeof(*ev));
 		return;
 	}
 <at>  <at>  -1035,7 +1035,7  <at>  <at>  static void ath10k_wmi_event_process(struct ath10k *ar, struct sk_buff *skb)
 		ath10k_wmi_ready_event_rx(ar, skb);
 		break;
 	default:
-		ath10k_warn("Unknown eventid: %d\n", id);
+		ath10k_warn("unknown eventid: %d\n", id);
 		break;
 	}

--

-- 
1.8.1.2.459.gbcd45b4.dirty
Permalink | Reply | 0 comments |
headers
Joe Perches | 16 May 2013 09:03

[PATCH 1/2] ath10k: Convert ath10k_dbg uses

Neaten and shorten the uses of ath10k_dbg and ath10k_dbg_dump.

Add macros to hold the "ATH10K_DBG_" mask portion of the functions.
Add if (0) to non-debug uses of macros.
Coalesce formats, align arguments.
Standardize __func__ uses to "%s: ".
Add a couple missing newlines to formats.

Signed-off-by: Joe Perches <joe <at> perches.com>
---

Resending to ath9k-devel per Kalle

 drivers/net/wireless/ath/ath10k/bmi.c    |  13 +--
 drivers/net/wireless/ath/ath10k/core.c   |  11 +--
 drivers/net/wireless/ath/ath10k/debug.c  |  10 +-
 drivers/net/wireless/ath/ath10k/debug.h  |  33 +++++--
 drivers/net/wireless/ath/ath10k/htc.c    |  51 +++++-----
 drivers/net/wireless/ath/ath10k/htt.c    |  11 +--
 drivers/net/wireless/ath/ath10k/htt_rx.c |  42 ++++----
 drivers/net/wireless/ath/ath10k/htt_tx.c |  17 ++--
 drivers/net/wireless/ath/ath10k/mac.c    |  86 +++++++---------
 drivers/net/wireless/ath/ath10k/pci.c    |  39 ++++----
 drivers/net/wireless/ath/ath10k/txrx.c   |  10 +-
 drivers/net/wireless/ath/ath10k/wmi.c    | 163 ++++++++++++++-----------------
 12 files changed, 226 insertions(+), 260 deletions(-)

diff --git a/drivers/net/wireless/ath/ath10k/bmi.c b/drivers/net/wireless/ath/ath10k/bmi.c
index 1a2ef51..29f2254 100644
--- a/drivers/net/wireless/ath/ath10k/bmi.c
+++ b/drivers/net/wireless/ath/ath10k/bmi.c
 <at>  <at>  -27,7 +27,7  <at>  <at>  int ath10k_bmi_done(struct ath10k *ar)
 	int ret;
 
 	if (ar->bmi.done_sent) {
-		ath10k_dbg(ATH10K_DBG_CORE, "%s skipped\n", __func__);
+		ath10k_dbg(CORE, "%s: skipped\n", __func__);
 		return 0;
 	}
 
 <at>  <at>  -40,7 +40,7  <at>  <at>  int ath10k_bmi_done(struct ath10k *ar)
 		return ret;
 	}
 
-	ath10k_dbg(ATH10K_DBG_CORE, "BMI done\n");
+	ath10k_dbg(CORE, "BMI done\n");
 	return 0;
 }
 
 <at>  <at>  -91,8 +91,7  <at>  <at>  int ath10k_bmi_read_memory(struct ath10k *ar,
 		return -EBUSY;
 	}
 
-	ath10k_dbg(ATH10K_DBG_CORE,
-		   "%s: (device: 0x%p, address: 0x%x, length: %d)\n",
+	ath10k_dbg(CORE, "%s: (device: 0x%p, address: 0x%x, length: %d)\n",
 		   __func__, ar, address, length);
 
 	while (length) {
 <at>  <at>  -131,8 +130,7  <at>  <at>  int ath10k_bmi_write_memory(struct ath10k *ar,
 		return -EBUSY;
 	}
 
-	ath10k_dbg(ATH10K_DBG_CORE,
-		   "%s: (device: 0x%p, address: 0x%x, length: %d)\n",
+	ath10k_dbg(CORE, "%s: (device: 0x%p, address: 0x%x, length: %d)\n",
 		   __func__, ar, address, length);
 
 	while (length) {
 <at>  <at>  -177,8 +175,7  <at>  <at>  int ath10k_bmi_execute(struct ath10k *ar, u32 address, u32 *param)
 		return -EBUSY;
 	}
 
-	ath10k_dbg(ATH10K_DBG_CORE,
-		   "%s: (device: 0x%p, address: 0x%x, param: %d)\n",
+	ath10k_dbg(CORE, "%s: (device: 0x%p, address: 0x%x, param: %d)\n",
 		   __func__, ar, address, *param);
 
 	cmd.id            = __cpu_to_le32(BMI_EXECUTE);
diff --git a/drivers/net/wireless/ath/ath10k/core.c b/drivers/net/wireless/ath/ath10k/core.c
index 2b3426b..b258042 100644
--- a/drivers/net/wireless/ath/ath10k/core.c
+++ b/drivers/net/wireless/ath/ath10k/core.c
 <at>  <at>  -64,7 +64,7  <at>  <at>  static const struct ath10k_hw_params ath10k_hw_params_list[] = {
 
 static void ath10k_send_suspend_complete(struct ath10k *ar)
 {
-	ath10k_dbg(ATH10K_DBG_CORE, "%s\n", __func__);
+	ath10k_dbg(CORE, "%s: called\n", __func__);
 
 	ar->is_target_paused = true;
 	wake_up(&ar->event_queue);
 <at>  <at>  -112,7 +112,7  <at>  <at>  static int ath10k_init_connect_htc(struct ath10k *ar)
 		goto timeout;
 	}
 
-	ath10k_dbg(ATH10K_DBG_CORE, "core wmi ready\n");
+	ath10k_dbg(CORE, "core wmi ready\n");
 	return 0;
 
 timeout:
 <at>  <at>  -214,8 +214,7  <at>  <at>  static int ath10k_push_board_ext_data(struct ath10k *ar,
 		return ret;
 	}
 
-	ath10k_dbg(ATH10K_DBG_CORE,
-		   "ath10k: Board extended Data download addr: 0x%x\n",
+	ath10k_dbg(CORE, "Board extended Data download addr: 0x%x\n",
 		   board_ext_data_addr);
 
 	if (board_ext_data_addr == 0)
 <at>  <at>  -636,7 +635,7  <at>  <at>  int ath10k_core_target_suspend(struct ath10k *ar)
 {
 	int ret;
 
-	ath10k_dbg(ATH10K_DBG_CORE, "%s: called", __func__);
+	ath10k_dbg(CORE, "%s: called\n", __func__);
 
 	ret = ath10k_wmi_pdev_suspend_target(ar);
 	if (ret)
 <at>  <at>  -650,7 +649,7  <at>  <at>  int ath10k_core_target_resume(struct ath10k *ar)
 {
 	int ret;
 
-	ath10k_dbg(ATH10K_DBG_CORE, "%s: called", __func__);
+	ath10k_dbg(CORE, "%s: called\n", __func__);
 
 	ret = ath10k_wmi_pdev_resume_target(ar);
 	if (ret)
diff --git a/drivers/net/wireless/ath/ath10k/debug.c b/drivers/net/wireless/ath/ath10k/debug.c
index 499034b..4d6c467 100644
--- a/drivers/net/wireless/ath/ath10k/debug.c
+++ b/drivers/net/wireless/ath/ath10k/debug.c
 <at>  <at>  -464,7 +464,7  <at>  <at>  int ath10k_debug_create(struct ath10k *ar)
 #endif /* CONFIG_ATH10K_DEBUGFS */
 
 #ifdef CONFIG_ATH10K_DEBUG
-void ath10k_dbg(enum ath10k_debug_mask mask, const char *fmt, ...)
+void _ath10k_dbg(enum ath10k_debug_mask mask, const char *fmt, ...)
 {
 	struct va_format vaf;
 	va_list args;
 <at>  <at>  -481,15 +481,15  <at>  <at>  void ath10k_dbg(enum ath10k_debug_mask mask, const char *fmt, ...)
 
 	va_end(args);
 }
-EXPORT_SYMBOL(ath10k_dbg);
+EXPORT_SYMBOL(_ath10k_dbg);
 
-void ath10k_dbg_dump(enum ath10k_debug_mask mask,
+void _ath10k_dbg_dump(enum ath10k_debug_mask mask,
 		     const char *msg, const char *prefix,
 		     const void *buf, size_t len)
 {
 	if (ath10k_debug_mask & mask) {
 		if (msg)
-			ath10k_dbg(mask, "%s\n", msg);
+			_ath10k_dbg(mask, "%s\n", msg);
 
 		print_hex_dump_bytes(prefix, DUMP_PREFIX_OFFSET, buf, len);
 	}
 <at>  <at>  -498,6 +498,6  <at>  <at>  void ath10k_dbg_dump(enum ath10k_debug_mask mask,
 	trace_ath10k_log_dbg_dump(msg ? msg : "", prefix ? prefix : "",
 				  buf, len);
 }
-EXPORT_SYMBOL(ath10k_dbg_dump);
+EXPORT_SYMBOL(_ath10k_dbg_dump);
 
 #endif /* CONFIG_ATH10K_DEBUG */
diff --git a/drivers/net/wireless/ath/ath10k/debug.h b/drivers/net/wireless/ath/ath10k/debug.h
index e7fb640..4996a0a 100644
--- a/drivers/net/wireless/ath/ath10k/debug.h
+++ b/drivers/net/wireless/ath/ath10k/debug.h
 <at>  <at>  -67,11 +67,16  <at>  <at>  static inline void ath10k_debug_read_target_stats(struct ath10k *ar,
 #endif /* CONFIG_ATH10K_DEBUGFS */
 
 #ifdef CONFIG_ATH10K_DEBUG
-extern __printf(2, 3) void ath10k_dbg(enum ath10k_debug_mask mask,
-				      const char *fmt, ...);
-void ath10k_dbg_dump(enum ath10k_debug_mask mask,
-		     const char *msg, const char *prefix,
-		     const void *buf, size_t len);
+extern __printf(2, 3) void _ath10k_dbg(enum ath10k_debug_mask mask,
+				       const char *fmt, ...);
+#define ath10k_dbg(mask, fmt, ...)					\
+	_ath10k_dbg(ATH10K_DBG_##mask, fmt, ##__VA_ARGS__)
+void _ath10k_dbg_dump(enum ath10k_debug_mask mask,
+		      const char *msg, const char *prefix,
+		      const void *buf, size_t len);
+#define ath10k_dbg_dump(mask, msg, prefix, buf, len)			\
+	_ath10k_dbg_dump(ATH10K_DBG_##mask, msg, prefix, buf, len)
+
 #else /* CONFIG_ATH10K_DEBUG */
 
 static inline int ath10k_dbg(enum ath10k_debug_mask dbg_mask,
 <at>  <at>  -79,11 +84,23  <at>  <at>  static inline int ath10k_dbg(enum ath10k_debug_mask dbg_mask,
 {
 	return 0;
 }
+#define ath10k_dbg(mask, fmt, ...)					\
+do {									\
+	if (0)								\
+		_ath10k_dbg(ATH10K_DBG_##mask, fmt, ##__VA_ARGS__);	\
+} while (0)
 
-static inline void ath10k_dbg_dump(enum ath10k_debug_mask mask,
-				   const char *msg, const char *prefix,
-				   const void *buf, size_t len)
+static inline void _ath10k_dbg_dump(enum ath10k_debug_mask mask,
+				    const char *msg, const char *prefix,
+				    const void *buf, size_t len)
 {
 }
+
+#define ath10k_dbg_dump(mask, msg, prefix, buf, len)			\
+do {									\
+	if (0)								\
+		_ath10k_dbg_dump(ATH10K_DBG_##mask, msg, prefix, buf, len); \
+} while (0)
+
 #endif /* CONFIG_ATH10K_DEBUG */
 #endif /* _DEBUG_H_ */
diff --git a/drivers/net/wireless/ath/ath10k/htc.c b/drivers/net/wireless/ath/ath10k/htc.c
index af95e87..9b6c681 100644
--- a/drivers/net/wireless/ath/ath10k/htc.c
+++ b/drivers/net/wireless/ath/ath10k/htc.c
 <at>  <at>  -31,7 +31,7  <at>  <at>  static inline void ath10k_htc_stop_queue(struct ath10k_htc_ep *ep)
 	if (ep->ep_ops.stop_queue)
 		ep->ep_ops.stop_queue(ep->htc->ar);
 
-	ath10k_dbg(ATH10K_DBG_HTC, "ep %d stop\n", ep->eid);
+	ath10k_dbg(HTC, "ep %d stop\n", ep->eid);
 	ep->tx_queue_stopped = true;
 }
 
 <at>  <at>  -43,13 +43,13  <at>  <at>  static inline void ath10k_htc_wake_queue(struct ath10k_htc_ep *ep)
 	if (ep->ep_ops.wake_queue)
 		ep->ep_ops.wake_queue(ep->htc->ar);
 
-	ath10k_dbg(ATH10K_DBG_HTC, "ep %d wake\n", ep->eid);
+	ath10k_dbg(HTC, "ep %d wake\n", ep->eid);
 	ep->tx_queue_stopped = false;
 }
 
 static inline void ath10k_htc_recalc_queue(struct ath10k_htc_ep *ep, int delta)
 {
-	ath10k_dbg(ATH10K_DBG_HTC, "ep %d queue len %d +%d max %d\n",
+	ath10k_dbg(HTC, "ep %d queue len %d +%d max %d\n",
 		   ep->eid, ep->tx_queue_len, delta, ep->max_tx_queue_depth);
 
 	if (ep->max_tx_queue_depth == 0)
 <at>  <at>  -98,7 +98,7  <at>  <at>  static struct sk_buff *ath10k_htc_build_tx_ctrl_skb(void *ar)
 	skb_cb = ATH10K_SKB_CB(skb);
 	memset(skb_cb, 0, sizeof(*skb_cb));
 
-	ath10k_dbg(ATH10K_DBG_HTC, "%s: skb %p\n", __func__, skb);
+	ath10k_dbg(HTC, "%s: skb %p\n", __func__, skb);
 	return skb;
 }
 
 <at>  <at>  -112,8 +112,7  <at>  <at>  static inline void ath10k_htc_restore_tx_skb(struct ath10k_htc *htc,
 static void ath10k_htc_notify_tx_completion(struct ath10k_htc_ep *ep,
 					    struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_HTC, "%s: ep %d skb %p\n", __func__,
-		   ep->eid, skb);
+	ath10k_dbg(HTC, "%s: ep %d skb %p\n", __func__, ep->eid, skb);
 
 	ath10k_htc_restore_tx_skb(ep->htc, skb);
 
 <at>  <at>  -134,8 +133,7  <at>  <at>  static bool ath10k_htc_ep_need_credit_update(struct ath10k_htc_ep *ep)
 	if (ep->tx_credits >= ep->tx_credits_per_max_message)
 		return false;
 
-	ath10k_dbg(ATH10K_DBG_HTC, "HTC: endpoint %d needs credit update\n",
-		   ep->eid);
+	ath10k_dbg(HTC, "HTC: endpoint %d needs credit update\n", ep->eid);
 	return true;
 }
 
 <at>  <at>  -169,8 +167,7  <at>  <at>  static int ath10k_htc_issue_skb(struct ath10k_htc *htc,
 	struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(skb);
 	int ret;
 
-	ath10k_dbg(ATH10K_DBG_HTC, "%s: ep %d skb %p\n", __func__,
-		   ep->eid, skb);
+	ath10k_dbg(HTC, "%s: ep %d skb %p\n", __func__, ep->eid, skb);
 
 	ret = ath10k_htc_prepare_tx_skb(ep, skb);
 	if (ret)
 <at>  <at>  -231,7 +228,7  <at>  <at>  static struct sk_buff *ath10k_htc_get_skb_credit_based(struct ath10k_htc *htc,
 			credits_required++;
 	}
 
-	ath10k_dbg(ATH10K_DBG_HTC, "Credits required %d got %d\n",
+	ath10k_dbg(HTC, "Credits required %d got %d\n",
 		   credits_required, ep->tx_credits);
 
 	if (ep->tx_credits < credits_required) {
 <at>  <at>  -394,7 +391,7  <at>  <at>  ath10k_htc_process_credit_report(struct ath10k_htc *htc,
 		if (report->eid >= ATH10K_HTC_EP_COUNT)
 			break;
 
-		ath10k_dbg(ATH10K_DBG_HTC, "ep %d got %d credits\n",
+		ath10k_dbg(HTC, "ep %d got %d credits\n",
 			   report->eid, report->credits);
 
 		ep = &htc->endpoint[report->eid];
 <at>  <at>  -464,7 +461,7  <at>  <at>  static int ath10k_htc_process_trailer(struct ath10k_htc *htc,
 	}
 
 	if (status)
-		ath10k_dbg_dump(ATH10K_DBG_HTC, "htc rx bad trailer", "",
+		ath10k_dbg_dump(HTC, "htc rx bad trailer", "",
 				orig_buffer, orig_length);
 
 	return status;
 <at>  <at>  -491,8 +488,7  <at>  <at>  static int ath10k_htc_rx_completion_handler(struct ath10k *ar,
 
 	if (eid >= ATH10K_HTC_EP_COUNT) {
 		ath10k_warn("HTC Rx: invalid eid %d\n", eid);
-		ath10k_dbg_dump(ATH10K_DBG_HTC, "htc bad header", "",
-				hdr, sizeof(*hdr));
+		ath10k_dbg_dump(HTC, "htc bad header", "", hdr, sizeof(*hdr));
 		status = -EINVAL;
 		goto out;
 	}
 <at>  <at>  -513,18 +509,18  <at>  <at>  static int ath10k_htc_rx_completion_handler(struct ath10k *ar,
 	if (payload_len + sizeof(*hdr) > ATH10K_HTC_MAX_LEN) {
 		ath10k_warn("HTC rx frame too long, len: %zu\n",
 			    payload_len + sizeof(*hdr));
-		ath10k_dbg_dump(ATH10K_DBG_HTC, "htc bad rx pkt len", "",
+		ath10k_dbg_dump(HTC, "htc bad rx pkt len", "",
 				hdr, sizeof(*hdr));
 		status = -EINVAL;
 		goto out;
 	}
 
 	if (skb->len < payload_len) {
-		ath10k_dbg(ATH10K_DBG_HTC,
+		ath10k_dbg(HTC,
 			   "HTC Rx: insufficient length, got %d, expected %d\n",
 			   skb->len, payload_len);
-		ath10k_dbg_dump(ATH10K_DBG_HTC, "htc bad rx pkt len",
-				"", hdr, sizeof(*hdr));
+		ath10k_dbg_dump(HTC, "htc bad rx pkt len", "",
+				hdr, sizeof(*hdr));
 		status = -EINVAL;
 		goto out;
 	}
 <at>  <at>  -593,8 +589,7  <at>  <at>  static int ath10k_htc_rx_completion_handler(struct ath10k *ar,
 		goto out;
 	}
 
-	ath10k_dbg(ATH10K_DBG_HTC, "htc rx completion ep %d skb %p\n",
-		   eid, skb);
+	ath10k_dbg(HTC, "htc rx completion ep %d skb %p\n", eid, skb);
 	ep->ep_ops.ep_rx_complete(ar, skb);
 
 	/* skb is now owned by the rx completion handler */
 <at>  <at>  -748,8 +743,7  <at>  <at>  int ath10k_htc_wait_target(struct ath10k_htc *htc)
 	htc->total_transmit_credits = credit_count;
 	htc->target_credit_size = credit_size;
 
-	ath10k_dbg(ATH10K_DBG_HTC,
-		   "Target ready! transmit resources: %d size:%d\n",
+	ath10k_dbg(HTC, "Target ready! transmit resources: %d size:%d\n",
 		   htc->total_transmit_credits,
 		   htc->target_credit_size);
 
 <at>  <at>  -873,7 +867,7  <at>  <at>  int ath10k_htc_connect_service(struct ath10k_htc *htc,
 		return -EPROTO;
 	}
 
-	ath10k_dbg(ATH10K_DBG_HTC,
+	ath10k_dbg(HTC,
 		   "HTC Service %s connect response: status: 0x%x, assigned ep: 0x%x\n",
 		   htc_service_name(service_id),
 		   resp_msg->status, resp_msg->eid);
 <at>  <at>  -933,18 +927,17  <at>  <at>  setup:
 	if (status)
 		return status;
 
-	ath10k_dbg(ATH10K_DBG_HTC,
+	ath10k_dbg(HTC,
 		   "HTC service: %s UL pipe: %d DL pipe: %d eid: %d ready\n",
 		   htc_service_name(ep->service_id), ep->ul_pipe_id,
 		   ep->dl_pipe_id, ep->eid);
 
-	ath10k_dbg(ATH10K_DBG_HTC,
-		   "EP %d UL polled: %d, DL polled: %d\n",
+	ath10k_dbg(HTC, "EP %d UL polled: %d, DL polled: %d\n",
 		   ep->eid, ep->ul_is_polled, ep->dl_is_polled);
 
 	if (disable_credit_flow_ctrl && ep->tx_credit_flow_enabled) {
 		ep->tx_credit_flow_enabled = false;
-		ath10k_dbg(ATH10K_DBG_HTC,
+		ath10k_dbg(HTC,
 			   "HTC service: %s eid: %d TX flow control disabled\n",
 			   htc_service_name(ep->service_id), assigned_eid);
 	}
 <at>  <at>  -988,7 +981,7  <at>  <at>  int ath10k_htc_start(struct ath10k_htc *htc)
 	msg->hdr.message_id =
 		__cpu_to_le16(ATH10K_HTC_MSG_SETUP_COMPLETE_EX_ID);
 
-	ath10k_dbg(ATH10K_DBG_HTC, "HTC is using TX credit flow control\n");
+	ath10k_dbg(HTC, "HTC is using TX credit flow control\n");
 
 	status = ath10k_htc_send(htc, ATH10K_HTC_EP_0, skb);
 	if (status) {
diff --git a/drivers/net/wireless/ath/ath10k/htt.c b/drivers/net/wireless/ath/ath10k/htt.c
index 4131cc6..6406bc5 100644
--- a/drivers/net/wireless/ath/ath10k/htt.c
+++ b/drivers/net/wireless/ath/ath10k/htt.c
 <at>  <at>  -115,12 +115,11  <at>  <at>  err_htc_attach:
 
 static int ath10k_htt_verify_version(struct ath10k_htt *htt)
 {
-	ath10k_dbg(ATH10K_DBG_HTT,
-		   "htt target version %d.%d; host version %d.%d\n",
-		    htt->target_version_major,
-		    htt->target_version_minor,
-		    HTT_CURRENT_VERSION_MAJOR,
-		    HTT_CURRENT_VERSION_MINOR);
+	ath10k_dbg(HTT, "htt target version %d.%d; host version %d.%d\n",
+		   htt->target_version_major,
+		   htt->target_version_minor,
+		   HTT_CURRENT_VERSION_MAJOR,
+		   HTT_CURRENT_VERSION_MINOR);
 
 	if (htt->target_version_major != HTT_CURRENT_VERSION_MAJOR) {
 		ath10k_err("htt major versions are incompatible!\n");
diff --git a/drivers/net/wireless/ath/ath10k/htt_rx.c b/drivers/net/wireless/ath/ath10k/htt_rx.c
index de058d7..21385b3 100644
--- a/drivers/net/wireless/ath/ath10k/htt_rx.c
+++ b/drivers/net/wireless/ath/ath10k/htt_rx.c
 <at>  <at>  -298,7 +298,7  <at>  <at>  static int ath10k_htt_rx_amsdu_pop(struct ath10k_htt *htt,
 				 msdu->len + skb_tailroom(msdu),
 				 DMA_FROM_DEVICE);
 
-		ath10k_dbg_dump(ATH10K_DBG_HTT_DUMP, NULL, "htt rx: ",
+		ath10k_dbg_dump(HTT_DUMP, NULL, "htt rx: ",
 				msdu->data, msdu->len + skb_tailroom(msdu));
 
 		rx_desc = (struct htt_rx_desc *)msdu->data;
 <at>  <at>  -391,7 +391,7  <at>  <at>  static int ath10k_htt_rx_amsdu_pop(struct ath10k_htt *htt,
 					 next->len + skb_tailroom(next),
 					 DMA_FROM_DEVICE);
 
-			ath10k_dbg_dump(ATH10K_DBG_HTT_DUMP, NULL, "htt rx: ",
+			ath10k_dbg_dump(HTT_DUMP, NULL, "htt rx: ",
 					next->data,
 					next->len + skb_tailroom(next));
 
 <at>  <at>  -500,7 +500,7  <at>  <at>  int ath10k_htt_rx_attach(struct ath10k_htt *htt)
 	if (__ath10k_htt_rx_ring_fill_n(htt, htt->rx_ring.fill_level))
 		goto err_fill_ring;
 
-	ath10k_dbg(ATH10K_DBG_HTT, "HTT RX ring size: %d, fill_level: %d\n",
+	ath10k_dbg(HTT, "HTT RX ring size: %d, fill_level: %d\n",
 		   htt->rx_ring.size, htt->rx_ring.fill_level);
 	return 0;
 
 <at>  <at>  -824,7 +824,7  <at>  <at>  static void ath10k_htt_rx_handler(struct ath10k_htt *htt,
 			     HTT_RX_INDICATION_INFO1_NUM_MPDU_RANGES);
 	mpdu_ranges = htt_rx_ind_get_mpdu_ranges(rx);
 
-	ath10k_dbg_dump(ATH10K_DBG_HTT_DUMP, NULL, "htt rx ind: ",
+	ath10k_dbg_dump(HTT_DUMP, NULL, "htt rx ind: ",
 			rx, sizeof(*rx) +
 			(sizeof(struct htt_rx_indication_mpdu_range) *
 				num_mpdu_ranges));
 <at>  <at>  -851,7 +851,7  <at>  <at>  static void ath10k_htt_rx_handler(struct ath10k_htt *htt,
 			}
 
 			if (msdu_head->len == 0) {
-				ath10k_dbg(ATH10K_DBG_HTT,
+				ath10k_dbg(HTT,
 					   "htt rx dropping due to zero-len\n");
 				ath10k_htt_rx_free_msdu_chain(msdu_head);
 				continue;
 <at>  <at>  -873,7 +873,7  <at>  <at>  static void ath10k_htt_rx_handler(struct ath10k_htt *htt,
 			if (status != HTT_RX_IND_MPDU_STATUS_OK &&
 			    status != HTT_RX_IND_MPDU_STATUS_TKIP_MIC_ERR &&
 			    !htt->ar->monitor_enabled) {
-				ath10k_dbg(ATH10K_DBG_HTT,
+				ath10k_dbg(HTT,
 					   "htt rx ignoring frame w/ status %d\n",
 					   status);
 				ath10k_htt_rx_free_msdu_chain(msdu_head);
 <at>  <at>  -911,9 +911,9  <at>  <at>  static void ath10k_htt_rx_handler(struct ath10k_htt *htt,
 			}
 
 			if (ath10k_htt_rx_hdr_is_amsdu((void *)info.skb->data))
-				ath10k_dbg(ATH10K_DBG_HTT, "htt mpdu is amsdu\n");
+				ath10k_dbg(HTT, "htt mpdu is amsdu\n");
 
-			ath10k_dbg_dump(ATH10K_DBG_HTT_DUMP, NULL, "htt mpdu: ",
+			ath10k_dbg_dump(HTT_DUMP, NULL, "htt mpdu: ",
 					info.skb->data, info.skb->len);
 			ath10k_process_rx(htt->ar, &info);
 		}
 <at>  <at>  -945,7 +945,7  <at>  <at>  static void ath10k_htt_rx_frag_handler(struct ath10k_htt *htt,
 	msdu_chaining = ath10k_htt_rx_amsdu_pop(htt, &fw_desc, &fw_desc_len,
 						&msdu_head, &msdu_tail);
 
-	ath10k_dbg(ATH10K_DBG_HTT_DUMP, "htt rx frag ahead\n");
+	ath10k_dbg(HTT_DUMP, "htt rx frag ahead\n");
 
 	if (!msdu_head) {
 		ath10k_warn("htt rx frag no data\n");
 <at>  <at>  -1022,13 +1022,13  <at>  <at>  static void ath10k_htt_rx_frag_handler(struct ath10k_htt *htt,
 
 	skb_trim(info.skb, info.skb->len - trim);
 
-	ath10k_dbg_dump(ATH10K_DBG_HTT_DUMP, NULL, "htt frag mpdu: ",
+	ath10k_dbg_dump(HTT_DUMP, NULL, "htt frag mpdu: ",
 			info.skb->data, info.skb->len);
 	ath10k_process_rx(htt->ar, &info);
 
 end:
 	if (fw_desc_len > 0) {
-		ath10k_dbg(ATH10K_DBG_HTT,
+		ath10k_dbg(HTT,
 			   "expecting more fragmented rx in one indication %d\n",
 			   fw_desc_len);
 	}
 <at>  <at>  -1043,8 +1043,7  <at>  <at>  void ath10k_htt_t2h_msg_handler(struct ath10k *ar, struct sk_buff *skb)
 	if (!IS_ALIGNED((unsigned long)skb->data, 4))
 		ath10k_warn("unaligned htt message, expect trouble\n");
 
-	ath10k_dbg(ATH10K_DBG_HTT, "HTT RX, msg_type: 0x%0X\n",
-		   resp->hdr.msg_type);
+	ath10k_dbg(HTT, "HTT RX, msg_type: 0x%0X\n", resp->hdr.msg_type);
 	switch (resp->hdr.msg_type) {
 	case HTT_T2H_MSG_TYPE_VERSION_CONF: {
 		htt->target_version_major = resp->ver_resp.major;
 <at>  <at>  -1118,7 +1117,7  <at>  <at>  void ath10k_htt_t2h_msg_handler(struct ath10k *ar, struct sk_buff *skb)
 			break;
 		}
 
-		ath10k_dbg(ATH10K_DBG_HTT, "htt tx completion num_msdus %d\n",
+		ath10k_dbg(HTT, "htt tx completion num_msdus %d\n",
 			   resp->data_tx_completion.num_msdus);
 
 		for (i = 0; i < resp->data_tx_completion.num_msdus; i++) {
 <at>  <at>  -1132,16 +1131,15  <at>  <at>  void ath10k_htt_t2h_msg_handler(struct ath10k *ar, struct sk_buff *skb)
 		struct ath10k *ar = htt->ar;
 		struct htt_security_indication *ev = &resp->security_indication;
 
-		ath10k_dbg(ATH10K_DBG_HTT,
-			   "sec ind peer_id %d unicast %d type %d\n",
-			  __le16_to_cpu(ev->peer_id),
-			  !!(ev->flags & HTT_SECURITY_IS_UNICAST),
-			  MS(ev->flags, HTT_SECURITY_TYPE));
+		ath10k_dbg(HTT, "sec ind peer_id %d unicast %d type %d\n",
+			   __le16_to_cpu(ev->peer_id),
+			   !!(ev->flags & HTT_SECURITY_IS_UNICAST),
+			   MS(ev->flags, HTT_SECURITY_TYPE));
 		complete(&ar->install_key_done);
 		break;
 	}
 	case HTT_T2H_MSG_TYPE_RX_FRAG_IND: {
-		ath10k_dbg_dump(ATH10K_DBG_HTT_DUMP, NULL, "htt event: ",
+		ath10k_dbg_dump(HTT_DUMP, NULL, "htt event: ",
 				skb->data, skb->len);
 		ath10k_htt_rx_frag_handler(htt, &resp->rx_frag_ind);
 		break;
 <at>  <at>  -1155,9 +1153,9  <at>  <at>  void ath10k_htt_t2h_msg_handler(struct ath10k *ar, struct sk_buff *skb)
 	case HTT_T2H_MSG_TYPE_RX_DELBA:
 	case HTT_T2H_MSG_TYPE_RX_FLUSH:
 	default:
-		ath10k_dbg(ATH10K_DBG_HTT, "htt event (%d) not handled\n",
+		ath10k_dbg(HTT, "htt event (%d) not handled\n",
 			   resp->hdr.msg_type);
-		ath10k_dbg_dump(ATH10K_DBG_HTT_DUMP, NULL, "htt event: ",
+		ath10k_dbg_dump(HTT_DUMP, NULL, "htt event: ",
 				skb->data, skb->len);
 		break;
 	};
diff --git a/drivers/net/wireless/ath/ath10k/htt_tx.c b/drivers/net/wireless/ath/ath10k/htt_tx.c
index cde50a3..4df9494 100644
--- a/drivers/net/wireless/ath/ath10k/htt_tx.c
+++ b/drivers/net/wireless/ath/ath10k/htt_tx.c
 <at>  <at>  -32,7 +32,7  <at>  <at>  int ath10k_htt_tx_alloc_msdu_id(struct ath10k_htt *htt)
 	if (msdu_id == HTT_MAX_NUM_PENDING_TX)
 		return -ENOMEM;
 
-	ath10k_dbg(ATH10K_DBG_HTT, "htt tx alloc msdu_id %d\n", msdu_id);
+	ath10k_dbg(HTT, "htt tx alloc msdu_id %d\n", msdu_id);
 	__set_bit(msdu_id, htt->used_msdu_ids);
 	return msdu_id;
 }
 <at>  <at>  -44,7 +44,7  <at>  <at>  void ath10k_htt_tx_free_msdu_id(struct ath10k_htt *htt, u16 msdu_id)
 	if (!test_bit(msdu_id, htt->used_msdu_ids))
 		ath10k_warn("trying to free unallocated msdu_id %d\n", msdu_id);
 
-	ath10k_dbg(ATH10K_DBG_HTT, "htt tx free msdu_id %hu\n", msdu_id);
+	ath10k_dbg(HTT, "htt tx free msdu_id %hu\n", msdu_id);
 	__clear_bit(msdu_id, htt->used_msdu_ids);
 }
 
 <at>  <at>  -70,8 +70,7  <at>  <at>  static void ath10k_htt_tx_cleanup_pending(struct ath10k_htt *htt)
 		if (!txdesc)
 			continue;
 
-		ath10k_dbg(ATH10K_DBG_HTT, "force cleanup msdu_id %hu\n",
-			   msdu_id);
+		ath10k_dbg(HTT, "force cleanup msdu_id %hu\n", msdu_id);
 
 		if (ATH10K_SKB_CB(txdesc)->htt.refcount > 0)
 			ATH10K_SKB_CB(txdesc)->htt.refcount = 1;
 <at>  <at>  -366,13 +365,11  <at>  <at>  int ath10k_htt_tx(struct ath10k_htt *htt, struct sk_buff *msdu)
 	if (res)
 		goto err;
 
-	ath10k_dbg(ATH10K_DBG_HTT, "txfrag 0x%llx msdu 0x%llx\n",
+	ath10k_dbg(HTT, "txfrag 0x%llx msdu 0x%llx\n",
 		   (unsigned long long) ATH10K_SKB_CB(txfrag)->paddr,
 		   (unsigned long long) ATH10K_SKB_CB(msdu)->paddr);
-	ath10k_dbg_dump(ATH10K_DBG_HTT_DUMP, NULL, "txfrag: ",
-			txfrag->data, frag_len);
-	ath10k_dbg_dump(ATH10K_DBG_HTT_DUMP, NULL, "msdu: ",
-			msdu->data, msdu->len);
+	ath10k_dbg_dump(HTT_DUMP, NULL, "txfrag: ", txfrag->data, frag_len);
+	ath10k_dbg_dump(HTT_DUMP, NULL, "msdu: ", msdu->data, msdu->len);
 
 	skb_put(txdesc, desc_len);
 	cmd = (struct htt_cmd *)txdesc->data;
 <at>  <at>  -380,7 +377,7  <at>  <at>  int ath10k_htt_tx(struct ath10k_htt *htt, struct sk_buff *msdu)
 
 	tid = ATH10K_SKB_CB(msdu)->htt.tid;
 
-	ath10k_dbg(ATH10K_DBG_HTT, "htt data tx using tid %hhu\n", tid);
+	ath10k_dbg(HTT, "htt data tx using tid %hhu\n", tid);
 
 	flags0  = 0;
 	if (!ieee80211_has_protected(hdr->frame_control))
diff --git a/drivers/net/wireless/ath/ath10k/mac.c b/drivers/net/wireless/ath/ath10k/mac.c
index 974f992..f3daa51 100644
--- a/drivers/net/wireless/ath/ath10k/mac.c
+++ b/drivers/net/wireless/ath/ath10k/mac.c
 <at>  <at>  -573,7 +573,7  <at>  <at>  static int ath10k_monitor_create(struct ath10k *ar)
 		goto vdev_fail;
 	}
 
-	ath10k_dbg(ATH10K_DBG_MAC, "Monitor interface created, vdev id: %d\n",
+	ath10k_dbg(MAC, "Monitor interface created, vdev id: %d\n",
 		   ar->monitor_vdev_id);
 
 	ar->monitor_present = true;
 <at>  <at>  -605,7 +605,7  <at>  <at>  static int ath10k_monitor_destroy(struct ath10k *ar)
 	ar->free_vdev_map |= 1 << (ar->monitor_vdev_id);
 	ar->monitor_present = false;
 
-	ath10k_dbg(ATH10K_DBG_MAC, "Monitor interface destroyed, vdev id: %d\n",
+	ath10k_dbg(MAC, "Monitor interface destroyed, vdev id: %d\n",
 		   ar->monitor_vdev_id);
 	return ret;
 }
 <at>  <at>  -632,7 +632,7  <at>  <at>  static void ath10k_control_beaconing(struct ath10k_vif *arvif,
 			    arvif->vdev_id);
 		return;
 	}
-	ath10k_dbg(ATH10K_DBG_MAC, "VDEV: %d up\n", arvif->vdev_id);
+	ath10k_dbg(MAC, "VDEV: %d up\n", arvif->vdev_id);
 }
 
 static void ath10k_control_ibss(struct ath10k_vif *arvif,
 <at>  <at>  -718,7 +718,7  <at>  <at>  static void ath10k_ps_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
 		ath10k_warn("Failed to set PS Mode: %d for VDEV: %d\n",
 			    psmode, arvif->vdev_id);
 	else
-		ath10k_dbg(ATH10K_DBG_MAC, "Set PS Mode: %d for VDEV: %d\n",
+		ath10k_dbg(MAC, "Set PS Mode: %d for VDEV: %d\n",
 			   psmode, arvif->vdev_id);
 }
 
 <at>  <at>  -794,12 +794,12  <at>  <at>  static void ath10k_peer_assoc_h_crypto(struct ath10k *ar,
 
 	/* FIXME: base on RSN IE/WPA IE is a correct idea? */
 	if (rsnie || wpaie) {
-		ath10k_dbg(ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__);
+		ath10k_dbg(WMI, "%s: rsn ie found\n", __func__);
 		arg->peer_flags |= WMI_PEER_NEED_PTK_4_WAY;
 	}
 
 	if (wpaie) {
-		ath10k_dbg(ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__);
+		ath10k_dbg(WMI, "%s: wpa ie found\n", __func__);
 		arg->peer_flags |= WMI_PEER_NEED_GTK_2_WAY;
 	}
 }
 <at>  <at>  -901,7 +901,7  <at>  <at>  static void ath10k_peer_assoc_h_ht(struct ath10k *ar,
 	arg->peer_ht_rates.num_rates = n;
 	arg->peer_num_spatial_streams = max((n+7) / 8, 1);
 
-	ath10k_dbg(ATH10K_DBG_MAC, "mcs cnt %d nss %d\n",
+	ath10k_dbg(MAC, "mcs cnt %d nss %d\n",
 		   arg->peer_ht_rates.num_rates,
 		   arg->peer_num_spatial_streams);
 }
 <at>  <at>  -919,7 +919,7  <at>  <at>  static void ath10k_peer_assoc_h_qos_ap(struct ath10k *ar,
 		arg->peer_flags |= WMI_PEER_QOS;
 
 	if (sta->wme && sta->uapsd_queues) {
-		ath10k_dbg(ATH10K_DBG_MAC, "uapsd_queues: 0x%X, max_sp: %d\n",
+		ath10k_dbg(MAC, "uapsd_queues: 0x%X, max_sp: %d\n",
 			   sta->uapsd_queues, sta->max_sp);
 
 		arg->peer_flags |= WMI_PEER_APSD;
 <at>  <at>  -1083,8 +1083,7  <at>  <at>  static void ath10k_bss_assoc(struct ieee80211_hw *hw,
 		ath10k_warn("VDEV: %d up failed: ret %d\n",
 			    arvif->vdev_id, ret);
 	else
-		ath10k_dbg(ATH10K_DBG_MAC,
-			   "VDEV: %d associated, BSSID: %pM, AID: %d\n",
+		ath10k_dbg(MAC, "VDEV: %d associated, BSSID: %pM, AID: %d\n",
 			   arvif->vdev_id, bss_conf->bssid, bss_conf->aid);
 }
 
 <at>  <at>  -1106,8 +1105,7  <at>  <at>  static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
 	 */
 	ret = ath10k_vdev_stop(arvif);
 	if (!ret)
-		ath10k_dbg(ATH10K_DBG_MAC, "VDEV: %d stopped\n",
-			   arvif->vdev_id);
+		ath10k_dbg(MAC, "VDEV: %d stopped\n", arvif->vdev_id);
 
 	/*
 	 * If we don't call VDEV-DOWN after VDEV-STOP FW will remain active and
 <at>  <at>  -1118,7 +1116,7  <at>  <at>  static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
 	 */
 	ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
 	if (ret)
-		ath10k_dbg(ATH10K_DBG_MAC, "VDEV: %d ath10k_wmi_vdev_down failed (%d)\n",
+		ath10k_dbg(MAC, "VDEV: %d ath10k_wmi_vdev_down failed (%d)\n",
 			   arvif->vdev_id, ret);
 
 	ath10k_wmi_flush_tx(ar);
 <at>  <at>  -1229,7 +1227,7  <at>  <at>  static int ath10k_update_channel_list(struct ath10k *ar)
 			if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN))
 				continue;
 
-			ath10k_dbg(ATH10K_DBG_WMI,
+			ath10k_dbg(WMI,
 				   "%s: [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
 				   __func__, ch - arg.channels, arg.n_channels,
 				   ch->freq, ch->max_power, ch->max_reg_power,
 <at>  <at>  -1310,7 +1308,7  <at>  <at>  static void ath10k_tx_h_update_wep_key(struct sk_buff *skb)
 	if (key->keyidx == arvif->def_wep_key_index)
 		return;
 
-	ath10k_dbg(ATH10K_DBG_MAC, "new wep keyidx will be %d\n", key->keyidx);
+	ath10k_dbg(MAC, "new wep keyidx will be %d\n", key->keyidx);
 
 	ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
 					WMI_VDEV_PARAM_DEF_KEYID,
 <at>  <at>  -1406,8 +1404,7  <at>  <at>  void ath10k_offchan_tx_work(struct work_struct *work)
 
 		mutex_lock(&ar->conf_mutex);
 
-		ath10k_dbg(ATH10K_DBG_MAC, "processing offchannel skb %p\n",
-			   skb);
+		ath10k_dbg(MAC, "processing offchannel skb %p\n", skb);
 
 		hdr = (struct ieee80211_hdr *)skb->data;
 		peer_addr = ieee80211_get_DA(hdr);
 <at>  <at>  -1418,7 +1415,7  <at>  <at>  void ath10k_offchan_tx_work(struct work_struct *work)
 		spin_unlock_bh(&ar->data_lock);
 
 		if (peer)
-			ath10k_dbg(ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n",
+			ath10k_dbg(MAC, "peer %pM on vdev %d already present\n",
 				   peer_addr, vdev_id);
 
 		if (!peer) {
 <at>  <at>  -1579,7 +1576,7  <at>  <at>  static void ath10k_tx(struct ieee80211_hw *hw,
 
 	/* We should disable CCK RATE due to P2P */
 	if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
-		ath10k_dbg(ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
+		ath10k_dbg(MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
 
 	/* we must calculate tid before we apply qos workaround
 	 * as we'd lose the qos control field */
 <at>  <at>  -1605,7 +1602,7  <at>  <at>  static void ath10k_tx(struct ieee80211_hw *hw,
 		ATH10K_SKB_CB(skb)->htt.vdev_id = ar->scan.vdev_id;
 		spin_unlock_bh(&ar->data_lock);
 
-		ath10k_dbg(ATH10K_DBG_MAC, "queued offchannel skb %p\n", skb);
+		ath10k_dbg(MAC, "queued offchannel skb %p\n", skb);
 
 		skb_queue_tail(&ar->offchan_tx_queue, skb);
 		ieee80211_queue_work(hw, &ar->offchan_tx_work);
 <at>  <at>  -1656,7 +1653,7  <at>  <at>  static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
 	mutex_lock(&ar->conf_mutex);
 
 	if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
-		ath10k_dbg(ATH10K_DBG_MAC, "Config channel %d mhz\n",
+		ath10k_dbg(MAC, "Config channel %d mhz\n",
 			   conf->chandef.chan->center_freq);
 		spin_lock_bh(&ar->data_lock);
 		ar->rx_channel = conf->chandef.chan;
 <at>  <at>  -1752,7 +1749,7  <at>  <at>  static int ath10k_add_interface(struct ieee80211_hw *hw,
 		break;
 	}
 
-	ath10k_dbg(ATH10K_DBG_MAC, "Add interface: id %d type %d subtype %d\n",
+	ath10k_dbg(MAC, "Add interface: id %d type %d subtype %d\n",
 		   arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype);
 
 	ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
 <at>  <at>  -1821,7 +1818,7  <at>  <at>  static void ath10k_remove_interface(struct ieee80211_hw *hw,
 
 	mutex_lock(&ar->conf_mutex);
 
-	ath10k_dbg(ATH10K_DBG_MAC, "Remove interface: id %d\n", arvif->vdev_id);
+	ath10k_dbg(MAC, "Remove interface: id %d\n", arvif->vdev_id);
 
 	ar->free_vdev_map |= 1 << (arvif->vdev_id);
 
 <at>  <at>  -1878,14 +1875,14  <at>  <at>  static void ath10k_configure_filter(struct ieee80211_hw *hw,
 		if (ret)
 			ath10k_warn("Unable to start monitor mode\n");
 		else
-			ath10k_dbg(ATH10K_DBG_MAC, "Monitor mode started\n");
+			ath10k_dbg(MAC, "Monitor mode started\n");
 	} else if (!(ar->filter_flags & FIF_PROMISC_IN_BSS) &&
 		   ar->monitor_enabled) {
 		ret = ath10k_monitor_stop(ar);
 		if (ret)
 			ath10k_warn("Unable to stop monitor mode\n");
 		else
-			ath10k_dbg(ATH10K_DBG_MAC, "Monitor mode stopped\n");
+			ath10k_dbg(MAC, "Monitor mode stopped\n");
 	}
 
 	mutex_unlock(&ar->conf_mutex);
 <at>  <at>  -1914,8 +1911,7  <at>  <at>  static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
 			ath10k_warn("Failed to set beacon interval for VDEV: %d\n",
 				    arvif->vdev_id);
 		else
-			ath10k_dbg(ATH10K_DBG_MAC,
-				   "Beacon interval: %d set for VDEV: %d\n",
+			ath10k_dbg(MAC, "Beacon interval: %d set for VDEV: %d\n",
 				   arvif->beacon_interval, arvif->vdev_id);
 	}
 
 <at>  <at>  -1927,7 +1923,7  <at>  <at>  static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
 			ath10k_warn("Failed to set beacon mode for VDEV: %d\n",
 				    arvif->vdev_id);
 		else
-			ath10k_dbg(ATH10K_DBG_MAC,
+			ath10k_dbg(MAC,
 				   "Set staggered beacon mode for VDEV: %d\n",
 				   arvif->vdev_id);
 	}
 <at>  <at>  -1942,8 +1938,7  <at>  <at>  static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
 			ath10k_warn("Failed to set dtim period for VDEV: %d\n",
 				    arvif->vdev_id);
 		else
-			ath10k_dbg(ATH10K_DBG_MAC,
-				   "Set dtim period: %d for VDEV: %d\n",
+			ath10k_dbg(MAC, "Set dtim period: %d for VDEV: %d\n",
 				   arvif->dtim_period, arvif->vdev_id);
 	}
 
 <at>  <at>  -1963,8 +1958,7  <at>  <at>  static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
 				ath10k_warn("Failed to add peer: %pM for VDEV: %d\n",
 					    info->bssid, arvif->vdev_id);
 			else
-				ath10k_dbg(ATH10K_DBG_MAC,
-					   "Added peer: %pM for VDEV: %d\n",
+				ath10k_dbg(MAC, "Added peer: %pM for VDEV: %d\n",
 					   info->bssid, arvif->vdev_id);
 

 <at>  <at>  -1978,7 +1972,7  <at>  <at>  static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
 
 				ret = ath10k_vdev_start(arvif);
 				if (!ret)
-					ath10k_dbg(ATH10K_DBG_MAC,
+					ath10k_dbg(MAC,
 						   "VDEV: %d started with BSSID: %pM\n",
 						   arvif->vdev_id, info->bssid);
 			}
 <at>  <at>  -2011,8 +2005,7  <at>  <at>  static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
 			ath10k_warn("Failed to set CTS prot for VDEV: %d\n",
 				    arvif->vdev_id);
 		else
-			ath10k_dbg(ATH10K_DBG_MAC,
-				   "Set CTS prot: %d for VDEV: %d\n",
+			ath10k_dbg(MAC, "Set CTS prot: %d for VDEV: %d\n",
 				   cts_prot, arvif->vdev_id);
 	}
 
 <at>  <at>  -2031,8 +2024,7  <at>  <at>  static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
 			ath10k_warn("Failed to set erp slot for VDEV: %d\n",
 				    arvif->vdev_id);
 		else
-			ath10k_dbg(ATH10K_DBG_MAC,
-				   "Set slottime: %d for VDEV: %d\n",
+			ath10k_dbg(MAC, "Set slottime: %d for VDEV: %d\n",
 				   slottime, arvif->vdev_id);
 	}
 
 <at>  <at>  -2050,8 +2042,7  <at>  <at>  static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
 			ath10k_warn("Failed to set preamble for VDEV: %d\n",
 				    arvif->vdev_id);
 		else
-			ath10k_dbg(ATH10K_DBG_MAC,
-				   "Set preamble: %d for VDEV: %d\n",
+			ath10k_dbg(MAC, "Set preamble: %d for VDEV: %d\n",
 				   preamble, arvif->vdev_id);
 	}
 
 <at>  <at>  -2240,8 +2231,7  <at>  <at>  static int ath10k_sta_state(struct ieee80211_hw *hw,
 			ath10k_warn("Failed to add peer: %pM for VDEV: %d\n",
 				    sta->addr, arvif->vdev_id);
 		else
-			ath10k_dbg(ATH10K_DBG_MAC,
-				   "Added peer: %pM for VDEV: %d\n",
+			ath10k_dbg(MAC, "Added peer: %pM for VDEV: %d\n",
 				   sta->addr, arvif->vdev_id);
 	} else if ((old_state == IEEE80211_STA_NONE &&
 		    new_state == IEEE80211_STA_NOTEXIST)) {
 <at>  <at>  -2253,8 +2243,7  <at>  <at>  static int ath10k_sta_state(struct ieee80211_hw *hw,
 			ath10k_warn("Failed to delete peer: %pM for VDEV: %d\n",
 				    sta->addr, arvif->vdev_id);
 		else
-			ath10k_dbg(ATH10K_DBG_MAC,
-				   "Removed peer: %pM for VDEV: %d\n",
+			ath10k_dbg(MAC, "Removed peer: %pM for VDEV: %d\n",
 				   sta->addr, arvif->vdev_id);
 
 		if (vif->type == NL80211_IFTYPE_STATION)
 <at>  <at>  -2271,8 +2260,7  <at>  <at>  static int ath10k_sta_state(struct ieee80211_hw *hw,
 			ath10k_warn("Failed to associate station: %pM\n",
 				    sta->addr);
 		else
-			ath10k_dbg(ATH10K_DBG_MAC,
-				   "Station %pM moved to assoc state\n",
+			ath10k_dbg(MAC, "Station %pM moved to assoc state\n",
 				   sta->addr);
 	} else if (old_state == IEEE80211_STA_ASSOC &&
 		   new_state == IEEE80211_STA_AUTH &&
 <at>  <at>  -2286,7 +2274,7  <at>  <at>  static int ath10k_sta_state(struct ieee80211_hw *hw,
 			ath10k_warn("Failed to disassociate station: %pM\n",
 				    sta->addr);
 		else
-			ath10k_dbg(ATH10K_DBG_MAC,
+			ath10k_dbg(MAC,
 				   "Station %pM moved to disassociated state\n",
 				   sta->addr);
 	}
 <at>  <at>  -2506,8 +2494,7  <at>  <at>  static void ath10k_set_rts_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
 		ath10k_warn("Failed to set RTS threshold for VDEV: %d\n",
 			    arvif->vdev_id);
 	else
-		ath10k_dbg(ATH10K_DBG_MAC,
-			   "Set RTS threshold: %d for VDEV: %d\n",
+		ath10k_dbg(MAC, "Set RTS threshold: %d for VDEV: %d\n",
 			   rts, arvif->vdev_id);
 }
 
 <at>  <at>  -2547,8 +2534,7  <at>  <at>  static void ath10k_set_frag_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
 		ath10k_warn("Failed to set frag threshold for VDEV: %d\n",
 			    arvif->vdev_id);
 	else
-		ath10k_dbg(ATH10K_DBG_MAC,
-			   "Set frag threshold: %d for VDEV: %d\n",
+		ath10k_dbg(MAC, "Set frag threshold: %d for VDEV: %d\n",
 			   frag, arvif->vdev_id);
 }
 
diff --git a/drivers/net/wireless/ath/ath10k/pci.c b/drivers/net/wireless/ath/ath10k/pci.c
index 8e4e832..9f650b7 100644
--- a/drivers/net/wireless/ath/ath10k/pci.c
+++ b/drivers/net/wireless/ath/ath10k/pci.c
 <at>  <at>  -241,8 +241,7  <at>  <at>  done:
 				__le32_to_cpu(((__le32 *)data_buf)[i]);
 		}
 	} else
-		ath10k_dbg(ATH10K_DBG_PCI, "%s failure (0x%x)\n",
-			   __func__, address);
+		ath10k_dbg(PCI, "%s: failure (0x%x)\n", __func__, address);
 
 	if (data_buf)
 		pci_free_consistent(ar_pci->pdev, orig_nbytes,
 <at>  <at>  -392,8 +391,7  <at>  <at>  done:
 	}
 
 	if (ret != 0)
-		ath10k_dbg(ATH10K_DBG_PCI, "%s failure (0x%x)\n", __func__,
-			   address);
+		ath10k_dbg(PCI, "%s: failure (0x%x)\n", __func__, address);
 
 	return ret;
 }
 <at>  <at>  -636,12 +634,11  <at>  <at>  static int ath10k_pci_hif_send_head(struct ath10k *ar, u8 pipe_id,
 	if (len & 3)
 		ath10k_warn("skb not aligned to 4-byte boundary (%d)\n", len);
 
-	ath10k_dbg(ATH10K_DBG_PCI,
+	ath10k_dbg(PCI,
 		   "pci send data vaddr %p paddr 0x%llx len %d as %d bytes\n",
 		   nbuf->data, (unsigned long long) skb_cb->paddr,
 		   nbuf->len, len);
-	ath10k_dbg_dump(ATH10K_DBG_PCI_DUMP, NULL,
-			"ath10k tx: data: ",
+	ath10k_dbg_dump(PCI_DUMP, NULL, "ath10k tx: data: ",
 			nbuf->data, nbuf->len);
 
 	ath10k_ce_sendlist_buf_add(&sendlist, skb_cb->paddr, len, flags);
 <at>  <at>  -749,7 +746,7  <at>  <at>  static void ath10k_pci_hif_post_init(struct ath10k *ar,
 {
 	struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
 
-	ath10k_dbg(ATH10K_DBG_PCI, "%s\n", __func__);
+	ath10k_dbg(PCI, "%s: called\n", __func__);
 
 	memcpy(&ar_pci->msg_callbacks_current, callbacks,
 	       sizeof(ar_pci->msg_callbacks_current));
 <at>  <at>  -922,11 +919,11  <at>  <at>  static void ath10k_pci_process_ce(struct ath10k *ar)
 			skb = (struct sk_buff *)compl->transfer_context;
 			nbytes = compl->nbytes;
 
-			ath10k_dbg(ATH10K_DBG_PCI,
-				   "ath10k_pci_ce_recv_data netbuf=%p  nbytes=%d\n",
+			ath10k_dbg(PCI,
+				   "ath10k_pci_ce_recv_data netbuf=%p nbytes=%d\n",
 				   skb, nbytes);
-			ath10k_dbg_dump(ATH10K_DBG_PCI_DUMP, NULL,
-					"ath10k rx: ", skb->data, nbytes);
+			ath10k_dbg_dump(PCI_DUMP, NULL, "ath10k rx: ",
+					skb->data, nbytes);
 
 			if (skb->len + skb_tailroom(skb) >= nbytes) {
 				skb_trim(skb, 0);
 <at>  <at>  -1252,7 +1249,7  <at>  <at>  static void ath10k_pci_ce_deinit(struct ath10k *ar)
 
 static void ath10k_pci_hif_stop(struct ath10k *ar)
 {
-	ath10k_dbg(ATH10K_DBG_PCI, "%s\n", __func__);
+	ath10k_dbg(PCI, "%s: called\n", __func__);
 
 	ath10k_pci_stop_ce(ar);
 
 <at>  <at>  -2115,10 +2112,10  <at>  <at>  static void ath10k_pci_dump_features(struct ath10k_pci *ar_pci)
 
 		switch (i) {
 		case ATH10K_PCI_FEATURE_MSI_X:
-			ath10k_dbg(ATH10K_DBG_PCI, "device supports MSI-X\n");
+			ath10k_dbg(PCI, "device supports MSI-X\n");
 			break;
 		case ATH10K_PCI_FEATURE_HW_1_0_WARKAROUND:
-			ath10k_dbg(ATH10K_DBG_PCI, "QCA988X_1.0 workaround enabled\n");
+			ath10k_dbg(PCI, "QCA988X_1.0 workaround enabled\n");
 			break;
 		}
 	}
 <at>  <at>  -2133,7 +2130,7  <at>  <at>  static int ath10k_pci_probe(struct pci_dev *pdev,
 	struct ath10k_pci *ar_pci;
 	u32 lcr_val;
 
-	ath10k_dbg(ATH10K_DBG_PCI, "%s\n", __func__);
+	ath10k_dbg(PCI, "%s: called\n", __func__);
 
 	ar_pci = kzalloc(sizeof(*ar_pci), GFP_KERNEL);
 	if (ar_pci == NULL)
 <at>  <at>  -2263,10 +2260,10  <at>  <at>  static int ath10k_pci_probe(struct pci_dev *pdev,
 		goto err_intr;
 
 	if (ath10k_target_ps) {
-		ath10k_dbg(ATH10K_DBG_PCI, "on-chip power save enabled\n");
+		ath10k_dbg(PCI, "on-chip power save enabled\n");
 	} else {
 		/* Force AWAKE forever */
-		ath10k_dbg(ATH10K_DBG_PCI, "on-chip power save disabled\n");
+		ath10k_dbg(PCI, "on-chip power save disabled\n");
 		ath10k_do_pci_wake(ar);
 	}
 
 <at>  <at>  -2319,7 +2316,7  <at>  <at>  static void ath10k_pci_remove(struct pci_dev *pdev)
 	struct ath10k *ar = pci_get_drvdata(pdev);
 	struct ath10k_pci *ar_pci;
 
-	ath10k_dbg(ATH10K_DBG_PCI, "%s\n", __func__);
+	ath10k_dbg(PCI, "%s: called\n", __func__);
 
 	if (!ar)
 		return;
 <at>  <at>  -2356,7 +2353,7  <at>  <at>  static int ath10k_pci_suspend(struct device *device)
 	u32 val;
 	int ret, retval;
 
-	ath10k_dbg(ATH10K_DBG_PCI, "%s\n", __func__);
+	ath10k_dbg(PCI, "%s: called\n", __func__);
 
 	if (!ar)
 		return -ENODEV;
 <at>  <at>  -2415,7 +2412,7  <at>  <at>  static int ath10k_pci_resume(struct device *device)
 	int ret;
 	u32 val;
 
-	ath10k_dbg(ATH10K_DBG_PCI, "%s\n", __func__);
+	ath10k_dbg(PCI, "%s: called\n", __func__);
 
 	if (!ar)
 		return -ENODEV;
diff --git a/drivers/net/wireless/ath/ath10k/txrx.c b/drivers/net/wireless/ath/ath10k/txrx.c
index a32448c..68e1cf0 100644
--- a/drivers/net/wireless/ath/ath10k/txrx.c
+++ b/drivers/net/wireless/ath/ath10k/txrx.c
 <at>  <at>  -39,7 +39,7  <at>  <at>  static void ath10k_report_offchan_tx(struct ath10k *ar, struct sk_buff *skb)
 	complete(&ar->offchan_tx_completed);
 	ar->offchan_tx_skb = NULL; /* just for sanity */
 
-	ath10k_dbg(ATH10K_DBG_HTT, "completed offchannel skb %p\n", skb);
+	ath10k_dbg(HTT, "completed offchannel skb %p\n", skb);
 out:
 	spin_unlock_bh(&ar->data_lock);
 }
 <at>  <at>  -107,7 +107,7  <at>  <at>  void ath10k_txrx_tx_completed(struct ath10k_htt *htt,
 {
 	struct sk_buff *txdesc;
 
-	ath10k_dbg(ATH10K_DBG_HTT, "htt tx completion msdu_id %u discard %d no_ack %d\n",
+	ath10k_dbg(HTT, "htt tx completion msdu_id %u discard %d no_ack %d\n",
 		   tx_done->msdu_id, !!tx_done->discard, !!tx_done->no_ack);
 
 	if (tx_done->msdu_id >= ARRAY_SIZE(htt->pending_tx)) {
 <at>  <at>  -277,7 +277,7  <at>  <at>  void ath10k_process_rx(struct ath10k *ar, struct htt_rx_info *info)
 	status->band = ch->band;
 	status->freq = ch->center_freq;
 
-	ath10k_dbg(ATH10K_DBG_HTT,
+	ath10k_dbg(HTT,
 		   "rx skb %p len %u %s%s%s%s%s %srate_idx %u vht_nss %u freq %u band %u\n",
 		   info->skb,
 		   info->skb->len,
 <at>  <at>  -378,7 +378,7  <at>  <at>  void ath10k_peer_map_event(struct ath10k_htt *htt,
 		wake_up(&ar->peer_mapping_wq);
 	}
 
-	ath10k_dbg(ATH10K_DBG_HTT, "htt peer map vdev %d peer %pM id %d\n",
+	ath10k_dbg(HTT, "htt peer map vdev %d peer %pM id %d\n",
 		   ev->vdev_id, ev->addr, ev->peer_id);
 
 	set_bit(ev->peer_id, peer->peer_ids);
 <at>  <at>  -399,7 +399,7  <at>  <at>  void ath10k_peer_unmap_event(struct ath10k_htt *htt,
 		goto exit;
 	}
 
-	ath10k_dbg(ATH10K_DBG_HTT, "htt peer unmap vdev %d peer %pM id %d\n",
+	ath10k_dbg(HTT, "htt peer unmap vdev %d peer %pM id %d\n",
 		   peer->vdev_id, peer->addr, ev->peer_id);
 
 	clear_bit(ev->peer_id, peer->peer_ids);
diff --git a/drivers/net/wireless/ath/ath10k/wmi.c b/drivers/net/wireless/ath/ath10k/wmi.c
index 0d5070d..1f530ee 100644
--- a/drivers/net/wireless/ath/ath10k/wmi.c
+++ b/drivers/net/wireless/ath/ath10k/wmi.c
 <at>  <at>  -138,36 +138,35  <at>  <at>  static int ath10k_wmi_event_scan(struct ath10k *ar, struct sk_buff *skb)
 	scan_id    = __le32_to_cpu(event->scan_id);
 	vdev_id    = __le32_to_cpu(event->vdev_id);
 
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_SCAN_EVENTID\n");
-	ath10k_dbg(ATH10K_DBG_WMI,
-		   "scan event type %d reason %d freq %d req_id %d "
-		   "scan_id %d vdev_id %d\n",
+	ath10k_dbg(WMI, "WMI_SCAN_EVENTID\n");
+	ath10k_dbg(WMI,
+		   "scan event type %d reason %d freq %d req_id %d scan_id %d vdev_id %d\n",
 		   event_type, reason, freq, req_id, scan_id, vdev_id);
 
 	spin_lock_bh(&ar->data_lock);
 
 	switch (event_type) {
 	case WMI_SCAN_EVENT_STARTED:
-		ath10k_dbg(ATH10K_DBG_WMI, "SCAN_EVENT_STARTED\n");
+		ath10k_dbg(WMI, "SCAN_EVENT_STARTED\n");
 		if (ar->scan.in_progress && ar->scan.is_roc)
 			ieee80211_ready_on_channel(ar->hw);
 
 		complete(&ar->scan.started);
 		break;
 	case WMI_SCAN_EVENT_COMPLETED:
-		ath10k_dbg(ATH10K_DBG_WMI, "SCAN_EVENT_COMPLETED\n");
+		ath10k_dbg(WMI, "SCAN_EVENT_COMPLETED\n");
 		switch (reason) {
 		case WMI_SCAN_REASON_COMPLETED:
-			ath10k_dbg(ATH10K_DBG_WMI, "SCAN_REASON_COMPLETED\n");
+			ath10k_dbg(WMI, "SCAN_REASON_COMPLETED\n");
 			break;
 		case WMI_SCAN_REASON_CANCELLED:
-			ath10k_dbg(ATH10K_DBG_WMI, "SCAN_REASON_CANCELED\n");
+			ath10k_dbg(WMI, "SCAN_REASON_CANCELED\n");
 			break;
 		case WMI_SCAN_REASON_PREEMPTED:
-			ath10k_dbg(ATH10K_DBG_WMI, "SCAN_REASON_PREEMPTED\n");
+			ath10k_dbg(WMI, "SCAN_REASON_PREEMPTED\n");
 			break;
 		case WMI_SCAN_REASON_TIMEDOUT:
-			ath10k_dbg(ATH10K_DBG_WMI, "SCAN_REASON_TIMEDOUT\n");
+			ath10k_dbg(WMI, "SCAN_REASON_TIMEDOUT\n");
 			break;
 		default:
 			break;
 <at>  <at>  -193,11 +192,11  <at>  <at>  static int ath10k_wmi_event_scan(struct ath10k *ar, struct sk_buff *skb)
 		ar->scan.in_progress = false;
 		break;
 	case WMI_SCAN_EVENT_BSS_CHANNEL:
-		ath10k_dbg(ATH10K_DBG_WMI, "SCAN_EVENT_BSS_CHANNEL\n");
+		ath10k_dbg(WMI, "SCAN_EVENT_BSS_CHANNEL\n");
 		ar->scan_channel = NULL;
 		break;
 	case WMI_SCAN_EVENT_FOREIGN_CHANNEL:
-		ath10k_dbg(ATH10K_DBG_WMI, "SCAN_EVENT_FOREIGN_CHANNEL\n");
+		ath10k_dbg(WMI, "SCAN_EVENT_FOREIGN_CHANNEL\n");
 		ar->scan_channel = ieee80211_get_channel(ar->hw->wiphy, freq);
 		if (ar->scan.in_progress && ar->scan.is_roc &&
 		    ar->scan.roc_freq == freq) {
 <at>  <at>  -205,13 +204,13  <at>  <at>  static int ath10k_wmi_event_scan(struct ath10k *ar, struct sk_buff *skb)
 		}
 		break;
 	case WMI_SCAN_EVENT_DEQUEUED:
-		ath10k_dbg(ATH10K_DBG_WMI, "SCAN_EVENT_DEQUEUED\n");
+		ath10k_dbg(WMI, "SCAN_EVENT_DEQUEUED\n");
 		break;
 	case WMI_SCAN_EVENT_PREEMPTED:
-		ath10k_dbg(ATH10K_DBG_WMI, "WMI_SCAN_EVENT_PREEMPTED\n");
+		ath10k_dbg(WMI, "WMI_SCAN_EVENT_PREEMPTED\n");
 		break;
 	case WMI_SCAN_EVENT_START_FAILED:
-		ath10k_dbg(ATH10K_DBG_WMI, "WMI_SCAN_EVENT_START_FAILED\n");
+		ath10k_dbg(WMI, "WMI_SCAN_EVENT_START_FAILED\n");
 		break;
 	default:
 		break;
 <at>  <at>  -328,7 +327,7  <at>  <at>  static int ath10k_wmi_event_mgmt_rx(struct ath10k *ar, struct sk_buff *skb)
 
 	memset(status, 0, sizeof(*status));
 
-	ath10k_dbg(ATH10K_DBG_WMI, "event mgmt rx status %08x\n", rx_status);
+	ath10k_dbg(WMI, "event mgmt rx status %08x\n", rx_status);
 
 	if (rx_status & WMI_RX_STATUS_ERR_DECRYPT) {
 		dev_kfree_skb(skb);
 <at>  <at>  -362,13 +361,11  <at>  <at>  static int ath10k_wmi_event_mgmt_rx(struct ath10k *ar, struct sk_buff *skb)
 					~IEEE80211_FCTL_PROTECTED);
 	}
 
-	ath10k_dbg(ATH10K_DBG_WMI,
-		   "event mgmt rx skb %p len %d ftype %02x stype %02x\n",
+	ath10k_dbg(WMI, "event mgmt rx skb %p len %d ftype %02x stype %02x\n",
 		   skb, skb->len,
 		   fc & IEEE80211_FCTL_FTYPE, fc & IEEE80211_FCTL_STYPE);
 
-	ath10k_dbg(ATH10K_DBG_WMI,
-		   "event mgmt rx freq %d band %d snr %d, rate_idx %d\n",
+	ath10k_dbg(WMI, "event mgmt rx freq %d band %d snr %d, rate_idx %d\n",
 		   status->freq, status->band, status->signal,
 		   status->rate_idx);
 
 <at>  <at>  -384,17 +381,17  <at>  <at>  static int ath10k_wmi_event_mgmt_rx(struct ath10k *ar, struct sk_buff *skb)
 
 static void ath10k_wmi_event_chan_info(struct ath10k *ar, struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_CHAN_INFO_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_CHAN_INFO_EVENTID\n");
 }
 
 static void ath10k_wmi_event_echo(struct ath10k *ar, struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_ECHO_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_ECHO_EVENTID\n");
 }
 
 static void ath10k_wmi_event_debug_mesg(struct ath10k *ar, struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_DEBUG_MESG_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_DEBUG_MESG_EVENTID\n");
 }
 
 static void ath10k_wmi_event_update_stats(struct ath10k *ar,
 <at>  <at>  -402,7 +399,7  <at>  <at>  static void ath10k_wmi_event_update_stats(struct ath10k *ar,
 {
 	struct wmi_stats_event *ev = (struct wmi_stats_event *)skb->data;
 
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_UPDATE_STATS_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_UPDATE_STATS_EVENTID\n");
 
 	ath10k_debug_read_target_stats(ar, ev);
 }
 <at>  <at>  -412,7 +409,7  <at>  <at>  static void ath10k_wmi_event_vdev_start_resp(struct ath10k *ar,
 {
 	struct wmi_vdev_start_response_event *ev;
 
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_VDEV_START_RESP_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_VDEV_START_RESP_EVENTID\n");
 
 	ev = (struct wmi_vdev_start_response_event *)skb->data;
 
 <at>  <at>  -425,14 +422,14  <at>  <at>  static void ath10k_wmi_event_vdev_start_resp(struct ath10k *ar,
 static void ath10k_wmi_event_vdev_stopped(struct ath10k *ar,
 					  struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_VDEV_STOPPED_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_VDEV_STOPPED_EVENTID\n");
 	complete(&ar->vdev_setup_done);
 }
 
 static void ath10k_wmi_event_peer_sta_kickout(struct ath10k *ar,
 					      struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_PEER_STA_KICKOUT_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_PEER_STA_KICKOUT_EVENTID\n");
 }
 
 /*
 <at>  <at>  -533,7 +530,7  <at>  <at>  static void ath10k_wmi_update_tim(struct ath10k *ar,
 	tim->bitmap_ctrl = !!__le32_to_cpu(bcn_info->tim_info.tim_mcast);
 	memcpy(tim->virtual_map, arvif->u.ap.tim_bitmap, pvm_len);
 
-	ath10k_dbg(ATH10K_DBG_BEACON, "dtim %d/%d mcast %d pvmlen %d\n",
+	ath10k_dbg(BEACON, "dtim %d/%d mcast %d pvmlen %d\n",
 		   tim->dtim_count, tim->dtim_period,
 		   tim->bitmap_ctrl, pvm_len);
 }
 <at>  <at>  -611,7 +608,7  <at>  <at>  static void ath10k_wmi_update_noa(struct ath10k *ar, struct ath10k_vif *arvif,
 	if (arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
 		return;
 
-	ath10k_dbg(ATH10K_DBG_BEACON, "noa changed: %d\n", noa->changed);
+	ath10k_dbg(BEACON, "noa changed: %d\n", noa->changed);
 	if (noa->changed & WMI_P2P_NOA_CHANGED_BIT) {
 		new_len = ath10k_p2p_calc_noa_ie_len(noa);
 		if (!new_len)
 <at>  <at>  -658,12 +655,12  <at>  <at>  static void ath10k_wmi_event_host_swba(struct ath10k *ar, struct sk_buff *skb)
 	int vdev_id = 0;
 	int ret;
 
-	ath10k_dbg(ATH10K_DBG_BEACON, "WMI_HOST_SWBA_EVENTID\n");
+	ath10k_dbg(BEACON, "WMI_HOST_SWBA_EVENTID\n");
 
 	ev = (struct wmi_host_swba_event *)skb->data;
 	map = __le32_to_cpu(ev->vdev_map);
 
-	ath10k_dbg(ATH10K_DBG_BEACON, "host swba:\n"
+	ath10k_dbg(BEACON, "host swba:\n"
 		   "-vdev map 0x%x\n",
 		   ev->vdev_map);
 
 <at>  <at>  -680,7 +677,7  <at>  <at>  static void ath10k_wmi_event_host_swba(struct ath10k *ar, struct sk_buff *skb)
 
 		bcn_info = &ev->bcn_info[i];
 
-		ath10k_dbg(ATH10K_DBG_BEACON,
+		ath10k_dbg(BEACON,
 			   "-bcn_info[%d]:\n"
 			   "--tim_len %d\n"
 			   "--tim_mcast %d\n"
 <at>  <at>  -730,112 +727,112  <at>  <at>  static void ath10k_wmi_event_host_swba(struct ath10k *ar, struct sk_buff *skb)
 static void ath10k_wmi_event_tbttoffset_update(struct ath10k *ar,
 					       struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_TBTTOFFSET_UPDATE_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_TBTTOFFSET_UPDATE_EVENTID\n");
 }
 
 static void ath10k_wmi_event_phyerr(struct ath10k *ar, struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_PHYERR_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_PHYERR_EVENTID\n");
 }
 
 static void ath10k_wmi_event_roam(struct ath10k *ar, struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_ROAM_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_ROAM_EVENTID\n");
 }
 
 static void ath10k_wmi_event_profile_match(struct ath10k *ar,
 				    struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_PROFILE_MATCH\n");
+	ath10k_dbg(WMI, "WMI_PROFILE_MATCH\n");
 }
 
 static void ath10k_wmi_event_debug_print(struct ath10k *ar,
 				  struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_DEBUG_PRINT_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_DEBUG_PRINT_EVENTID\n");
 }
 
 static void ath10k_wmi_event_pdev_qvit(struct ath10k *ar, struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_PDEV_QVIT_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_PDEV_QVIT_EVENTID\n");
 }
 
 static void ath10k_wmi_event_wlan_profile_data(struct ath10k *ar,
 					       struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_WLAN_PROFILE_DATA_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_WLAN_PROFILE_DATA_EVENTID\n");
 }
 
 static void ath10k_wmi_event_rtt_measurement_report(struct ath10k *ar,
 					     struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_RTT_MEASUREMENT_REPORT_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_RTT_MEASUREMENT_REPORT_EVENTID\n");
 }
 
 static void ath10k_wmi_event_tsf_measurement_report(struct ath10k *ar,
 					     struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_TSF_MEASUREMENT_REPORT_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_TSF_MEASUREMENT_REPORT_EVENTID\n");
 }
 
 static void ath10k_wmi_event_rtt_error_report(struct ath10k *ar,
 					      struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_RTT_ERROR_REPORT_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_RTT_ERROR_REPORT_EVENTID\n");
 }
 
 static void ath10k_wmi_event_wow_wakeup_host(struct ath10k *ar,
 					     struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_WOW_WAKEUP_HOST_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_WOW_WAKEUP_HOST_EVENTID\n");
 }
 
 static void ath10k_wmi_event_dcs_interference(struct ath10k *ar,
 					      struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_DCS_INTERFERENCE_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_DCS_INTERFERENCE_EVENTID\n");
 }
 
 static void ath10k_wmi_event_pdev_tpc_config(struct ath10k *ar,
 					     struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_PDEV_TPC_CONFIG_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_PDEV_TPC_CONFIG_EVENTID\n");
 }
 
 static void ath10k_wmi_event_pdev_ftm_intg(struct ath10k *ar,
 					   struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_PDEV_FTM_INTG_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_PDEV_FTM_INTG_EVENTID\n");
 }
 
 static void ath10k_wmi_event_gtk_offload_status(struct ath10k *ar,
 					 struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_GTK_OFFLOAD_STATUS_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_GTK_OFFLOAD_STATUS_EVENTID\n");
 }
 
 static void ath10k_wmi_event_gtk_rekey_fail(struct ath10k *ar,
 					    struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_GTK_REKEY_FAIL_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_GTK_REKEY_FAIL_EVENTID\n");
 }
 
 static void ath10k_wmi_event_delba_complete(struct ath10k *ar,
 					    struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_TX_DELBA_COMPLETE_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_TX_DELBA_COMPLETE_EVENTID\n");
 }
 
 static void ath10k_wmi_event_addba_complete(struct ath10k *ar,
 					    struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_TX_ADDBA_COMPLETE_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_TX_ADDBA_COMPLETE_EVENTID\n");
 }
 
 static void ath10k_wmi_event_vdev_install_key_complete(struct ath10k *ar,
 						struct sk_buff *skb)
 {
-	ath10k_dbg(ATH10K_DBG_WMI, "WMI_VDEV_INSTALL_KEY_COMPLETE_EVENTID\n");
+	ath10k_dbg(WMI, "WMI_VDEV_INSTALL_KEY_COMPLETE_EVENTID\n");
 }
 
 static void ath10k_wmi_service_ready_event_rx(struct ath10k *ar,
 <at>  <at>  -883,7 +880,7  <at>  <at>  static void ath10k_wmi_service_ready_event_rx(struct ath10k *ar,
 			    __le32_to_cpu(ev->num_mem_reqs));
 	}
 
-	ath10k_dbg(ATH10K_DBG_WMI,
+	ath10k_dbg(WMI,
 		   "wmi event service ready sw_ver 0x%08x sw_ver1 0x%08x abi_ver %u phy_cap 0x%08x ht_cap 0x%08x vht_cap 0x%08x vht_supp_msc 0x%08x sys_cap_info 0x%08x mem_reqs %u\n",
 		   __le32_to_cpu(ev->sw_version),
 		   __le32_to_cpu(ev->sw_version_1),
 <at>  <at>  -915,7 +912,7  <at>  <at>  static int ath10k_wmi_ready_event_rx(struct ath10k *ar, struct sk_buff *skb)
 	memcpy(ar->hw->wiphy->perm_addr, ev->mac_addr.addr, ETH_ALEN);
 	memcpy(ar->hw->wiphy->addr_mask, "\x00\x00\x00\xFF\xFF\xFF", ETH_ALEN);
 
-	ath10k_dbg(ATH10K_DBG_WMI,
+	ath10k_dbg(WMI,
 		   "wmi event ready sw_version %u abi_version %u mac_addr %pM status %d\n",
 		   __le32_to_cpu(ev->sw_version),
 		   __le32_to_cpu(ev->abi_version),
 <at>  <at>  -1177,8 +1174,7  <at>  <at>  int ath10k_wmi_pdev_set_channel(struct ath10k *ar,
 	cmd->chan.reg_classid       = arg->reg_class_id;
 	cmd->chan.antenna_max       = arg->max_antenna_gain;
 
-	ath10k_dbg(ATH10K_DBG_WMI,
-		   "wmi set channel mode %d freq %d\n",
+	ath10k_dbg(WMI, "wmi set channel mode %d freq %d\n",
 		   arg->mode, arg->freq);
 
 	return ath10k_wmi_cmd_send(ar, skb, WMI_PDEV_SET_CHANNEL_CMDID);
 <at>  <at>  -1224,8 +1220,7  <at>  <at>  int ath10k_wmi_pdev_set_param(struct ath10k *ar, enum wmi_pdev_param id,
 	cmd->param_id    = __cpu_to_le32(id);
 	cmd->param_value = __cpu_to_le32(value);
 
-	ath10k_dbg(ATH10K_DBG_WMI, "wmi pdev set param %d value %d\n",
-		   id, value);
+	ath10k_dbg(WMI, "wmi pdev set param %d value %d\n", id, value);
 	return ath10k_wmi_cmd_send(ar, skb, WMI_PDEV_SET_PARAM_CMDID);
 }
 
 <at>  <at>  -1295,7 +1290,7  <at>  <at>  int ath10k_wmi_cmd_init(struct ath10k *ar)
 	cmd->num_host_mem_chunks = 0;
 	memcpy(&cmd->resource_config, &config, sizeof(config));
 
-	ath10k_dbg(ATH10K_DBG_WMI, "wmi init\n");
+	ath10k_dbg(WMI, "wmi init\n");
 	return ath10k_wmi_cmd_send(ar, buf, WMI_INIT_CMDID);
 }
 
 <at>  <at>  -1456,7 +1451,7  <at>  <at>  int ath10k_wmi_start_scan(struct ath10k *ar,
 		return -EINVAL;
 	}
 
-	ath10k_dbg(ATH10K_DBG_WMI, "wmi start scan\n");
+	ath10k_dbg(WMI, "wmi start scan\n");
 	return ath10k_wmi_cmd_send(ar, skb, WMI_START_SCAN_CMDID);
 }
 
 <at>  <at>  -1514,8 +1509,7  <at>  <at>  int ath10k_wmi_stop_scan(struct ath10k *ar, const struct wmi_stop_scan_arg *arg)
 	cmd->scan_id     = __cpu_to_le32(scan_id);
 	cmd->scan_req_id = __cpu_to_le32(req_id);
 
-	ath10k_dbg(ATH10K_DBG_WMI,
-		   "wmi stop scan reqid %d req_type %d vdev/scan_id %d\n",
+	ath10k_dbg(WMI, "wmi stop scan reqid %d req_type %d vdev/scan_id %d\n",
 		   arg->req_id, arg->req_type, arg->u.scan_id);
 	return ath10k_wmi_cmd_send(ar, skb, WMI_STOP_SCAN_CMDID);
 }
 <at>  <at>  -1538,7 +1532,7  <at>  <at>  int ath10k_wmi_vdev_create(struct ath10k *ar, u32 vdev_id,
 	cmd->vdev_subtype = __cpu_to_le32(subtype);
 	memcpy(cmd->vdev_macaddr.addr, macaddr, ETH_ALEN);
 
-	ath10k_dbg(ATH10K_DBG_WMI,
+	ath10k_dbg(WMI,
 		   "WMI vdev create: id %d type %d subtype %d macaddr %pM\n",
 		   vdev_id, type, subtype, macaddr);
 
 <at>  <at>  -1557,8 +1551,7  <at>  <at>  int ath10k_wmi_vdev_delete(struct ath10k *ar, u32 vdev_id)
 	cmd = (struct wmi_vdev_delete_cmd *)skb->data;
 	cmd->vdev_id = __cpu_to_le32(vdev_id);
 
-	ath10k_dbg(ATH10K_DBG_WMI,
-		   "WMI vdev delete id %d\n", vdev_id);
+	ath10k_dbg(WMI, "WMI vdev delete id %d\n", vdev_id);
 
 	return ath10k_wmi_cmd_send(ar, skb, WMI_VDEV_DELETE_CMDID);
 }
 <at>  <at>  -1624,9 +1617,9  <at>  <at>  static int ath10k_wmi_vdev_start_restart(struct ath10k *ar,
 	cmd->chan.reg_classid = arg->channel.reg_class_id;
 	cmd->chan.antenna_max = arg->channel.max_antenna_gain;
 
-	ath10k_dbg(ATH10K_DBG_WMI,
-		   "wmi vdev %s id 0x%x freq %d, mode %d, ch_flags: 0x%0X,"
-		   "max_power: %d\n", cmdname, arg->vdev_id, arg->channel.freq,
+	ath10k_dbg(WMI,
+		   "wmi vdev %s id 0x%x freq %d, mode %d, ch_flags: 0x%0X, max_power: %d\n",
+		   cmdname, arg->vdev_id, arg->channel.freq,
 		   arg->channel.mode, flags, arg->channel.max_power);
 
 	return ath10k_wmi_cmd_send(ar, skb, cmd_id);
 <at>  <at>  -1658,7 +1651,7  <at>  <at>  int ath10k_wmi_vdev_stop(struct ath10k *ar, u32 vdev_id)
 	cmd = (struct wmi_vdev_stop_cmd *)skb->data;
 	cmd->vdev_id = __cpu_to_le32(vdev_id);
 
-	ath10k_dbg(ATH10K_DBG_WMI, "wmi vdev stop id 0x%x\n", vdev_id);
+	ath10k_dbg(WMI, "wmi vdev stop id 0x%x\n", vdev_id);
 
 	return ath10k_wmi_cmd_send(ar, skb, WMI_VDEV_STOP_CMDID);
 }
 <at>  <at>  -1677,8 +1670,7  <at>  <at>  int ath10k_wmi_vdev_up(struct ath10k *ar, u32 vdev_id, u32 aid, const u8 *bssid)
 	cmd->vdev_assoc_id = __cpu_to_le32(aid);
 	memcpy(&cmd->vdev_bssid.addr, bssid, 6);
 
-	ath10k_dbg(ATH10K_DBG_WMI,
-		   "wmi mgmt vdev up id 0x%x assoc id %d bssid %pM\n",
+	ath10k_dbg(WMI, "wmi mgmt vdev up id 0x%x assoc id %d bssid %pM\n",
 		   vdev_id, aid, bssid);
 
 	return ath10k_wmi_cmd_send(ar, skb, WMI_VDEV_UP_CMDID);
 <at>  <at>  -1696,8 +1688,7  <at>  <at>  int ath10k_wmi_vdev_down(struct ath10k *ar, u32 vdev_id)
 	cmd = (struct wmi_vdev_down_cmd *)skb->data;
 	cmd->vdev_id = __cpu_to_le32(vdev_id);
 
-	ath10k_dbg(ATH10K_DBG_WMI,
-		   "wmi mgmt vdev down id 0x%x\n", vdev_id);
+	ath10k_dbg(WMI, "wmi mgmt vdev down id 0x%x\n", vdev_id);
 
 	return ath10k_wmi_cmd_send(ar, skb, WMI_VDEV_DOWN_CMDID);
 }
 <at>  <at>  -1717,8 +1708,7  <at>  <at>  int ath10k_wmi_vdev_set_param(struct ath10k *ar, u32 vdev_id,
 	cmd->param_id    = __cpu_to_le32(param_id);
 	cmd->param_value = __cpu_to_le32(param_value);
 
-	ath10k_dbg(ATH10K_DBG_WMI,
-		   "wmi vdev id 0x%x set param %d value %d\n",
+	ath10k_dbg(WMI, "wmi vdev id 0x%x set param %d value %d\n",
 		   vdev_id, param_id, param_value);
 
 	return ath10k_wmi_cmd_send(ar, skb, WMI_VDEV_SET_PARAM_CMDID);
 <at>  <at>  -1770,8 +1760,7  <at>  <at>  int ath10k_wmi_peer_create(struct ath10k *ar, u32 vdev_id,
 	cmd->vdev_id = __cpu_to_le32(vdev_id);
 	memcpy(cmd->peer_macaddr.addr, peer_addr, ETH_ALEN);
 
-	ath10k_dbg(ATH10K_DBG_WMI,
-		   "wmi peer create vdev_id %d peer_addr %pM\n",
+	ath10k_dbg(WMI, "wmi peer create vdev_id %d peer_addr %pM\n",
 		   vdev_id, peer_addr);
 	return ath10k_wmi_cmd_send(ar, skb, WMI_PEER_CREATE_CMDID);
 }
 <at>  <at>  -1790,8 +1779,7  <at>  <at>  int ath10k_wmi_peer_delete(struct ath10k *ar, u32 vdev_id,
 	cmd->vdev_id = __cpu_to_le32(vdev_id);
 	memcpy(cmd->peer_macaddr.addr, peer_addr, ETH_ALEN);
 
-	ath10k_dbg(ATH10K_DBG_WMI,
-		   "wmi peer delete vdev_id %d peer_addr %pM\n",
+	ath10k_dbg(WMI, "wmi peer delete vdev_id %d peer_addr %pM\n",
 		   vdev_id, peer_addr);
 	return ath10k_wmi_cmd_send(ar, skb, WMI_PEER_DELETE_CMDID);
 }
 <at>  <at>  -1811,8 +1799,7  <at>  <at>  int ath10k_wmi_peer_flush(struct ath10k *ar, u32 vdev_id,
 	cmd->peer_tid_bitmap = __cpu_to_le32(tid_bitmap);
 	memcpy(cmd->peer_macaddr.addr, peer_addr, ETH_ALEN);
 
-	ath10k_dbg(ATH10K_DBG_WMI,
-		   "wmi peer flush vdev_id %d peer_addr %pM tids %08x\n",
+	ath10k_dbg(WMI, "wmi peer flush vdev_id %d peer_addr %pM tids %08x\n",
 		   vdev_id, peer_addr, tid_bitmap);
 	return ath10k_wmi_cmd_send(ar, skb, WMI_PEER_FLUSH_TIDS_CMDID);
 }
 <at>  <at>  -1834,8 +1821,7  <at>  <at>  int ath10k_wmi_peer_set_param(struct ath10k *ar, u32 vdev_id,
 	cmd->param_value = __cpu_to_le32(param_value);
 	memcpy(&cmd->peer_macaddr.addr, peer_addr, 6);
 
-	ath10k_dbg(ATH10K_DBG_WMI,
-		   "wmi vdev %d peer 0x%pM set param %d value %d\n",
+	ath10k_dbg(WMI, "wmi vdev %d peer 0x%pM set param %d value %d\n",
 		   vdev_id, peer_addr, param_id, param_value);
 
 	return ath10k_wmi_cmd_send(ar, skb, WMI_PEER_SET_PARAM_CMDID);
 <at>  <at>  -1855,9 +1841,7  <at>  <at>  int ath10k_wmi_set_psmode(struct ath10k *ar, u32 vdev_id,
 	cmd->vdev_id     = __cpu_to_le32(vdev_id);
 	cmd->sta_ps_mode = __cpu_to_le32(psmode);
 
-	ath10k_dbg(ATH10K_DBG_WMI,
-		   "wmi set powersave id 0x%x mode %d\n",
-		   vdev_id, psmode);
+	ath10k_dbg(WMI, "wmi set powersave id 0x%x mode %d\n", vdev_id, psmode);
 
 	return ath10k_wmi_cmd_send(ar, skb, WMI_STA_POWERSAVE_MODE_CMDID);
 }
 <at>  <at>  -1878,8 +1862,7  <at>  <at>  int ath10k_wmi_set_sta_ps_param(struct ath10k *ar, u32 vdev_id,
 	cmd->param_id    = __cpu_to_le32(param_id);
 	cmd->param_value = __cpu_to_le32(value);
 
-	ath10k_dbg(ATH10K_DBG_WMI,
-		   "wmi sta ps param vdev_id 0x%x param %d value %d\n",
+	ath10k_dbg(WMI, "wmi sta ps param vdev_id 0x%x param %d value %d\n",
 		   vdev_id, param_id, value);
 	return ath10k_wmi_cmd_send(ar, skb, WMI_STA_POWERSAVE_PARAM_CMDID);
 }
 <at>  <at>  -1903,7 +1886,7  <at>  <at>  int ath10k_wmi_set_ap_ps_param(struct ath10k *ar, u32 vdev_id, const u8 *mac,
 	cmd->param_value = __cpu_to_le32(value);
 	memcpy(&cmd->peer_macaddr, mac, ETH_ALEN);
 
-	ath10k_dbg(ATH10K_DBG_WMI,
+	ath10k_dbg(WMI,
 		   "wmi ap ps param vdev_id 0x%X param %d value %d mac_addr %pM\n",
 		   vdev_id, param_id, value, mac);
 
 <at>  <at>  -2054,7 +2037,7  <at>  <at>  int ath10k_wmi_pdev_set_wmm_params(struct ath10k *ar,
 	ath10k_wmi_pdev_set_wmm_param(&cmd->ac_vi, &arg->ac_vi);
 	ath10k_wmi_pdev_set_wmm_param(&cmd->ac_vo, &arg->ac_vo);
 
-	ath10k_dbg(ATH10K_DBG_WMI, "wmi pdev set wmm params\n");
+	ath10k_dbg(WMI, "wmi pdev set wmm params\n");
 	return ath10k_wmi_cmd_send(ar, skb, WMI_PDEV_SET_WMM_PARAMS_CMDID);
 }
 
 <at>  <at>  -2070,6 +2053,6  <at>  <at>  int ath10k_wmi_request_stats(struct ath10k *ar, enum wmi_stats_id stats_id)
 	cmd = (struct wmi_request_stats_cmd *)skb->data;
 	cmd->stats_id = __cpu_to_le32(stats_id);
 
-	ath10k_dbg(ATH10K_DBG_WMI, "wmi request stats %d\n", (int)stats_id);
+	ath10k_dbg(WMI, "wmi request stats %d\n", (int)stats_id);
 	return ath10k_wmi_cmd_send(ar, skb, WMI_REQUEST_STATS_CMDID);
 }
--

-- 
1.8.1.2.459.gbcd45b4.dirty
Permalink | Reply | 1 comment |
headers
Theij | 14 May 2013 14:03

DNXA-H1 WiFi mini PCIe module (AR9390) Linux driver

Hello,

I’m working on a Wi-Fi AP device using the DNXA-H1 WiFi mini PCIe module (having the AR9390) and need the Atheros Linux SDK / Driver for the same. Please let me know as to where I could download the driver / mail it to me if possible.

 

Regards,

Theij

 

_______________________________________________
ath9k-devel mailing list
ath9k-devel <at> lists.ath9k.org
https://lists.ath9k.org/mailman/listinfo/ath9k-devel
Permalink | Reply | 0 comments |
headers
Michal Kazior | 13 May 2013 14:38
Favicon

[PATCH] ath10k: kill ath_common() wrapper function

No need for this silly abstraction. Also rename
the structure member so it makes more sense when
used.

Signed-off-by: Michal Kazior <michal.kazior <at> tieto.com>
---
 drivers/net/wireless/ath/ath10k/core.c |    6 ++----
 drivers/net/wireless/ath/ath10k/core.h |    7 +------
 drivers/net/wireless/ath/ath10k/mac.c  |   11 +++++------
 drivers/net/wireless/ath/ath10k/wmi.c  |    3 +--
 4 files changed, 9 insertions(+), 18 deletions(-)

diff --git a/drivers/net/wireless/ath/ath10k/core.c b/drivers/net/wireless/ath/ath10k/core.c
index 564a39f..2b3426b 100644
--- a/drivers/net/wireless/ath/ath10k/core.c
+++ b/drivers/net/wireless/ath/ath10k/core.c
 <at>  <at>  -445,15 +445,13  <at>  <at>  struct ath10k *ath10k_core_create(void *hif_priv, struct device *dev,
 				  const struct ath10k_hif_ops *hif_ops)
 {
 	struct ath10k *ar;
-	struct ath_common *common;

 	ar = ath10k_mac_create();
 	if (!ar)
 		return NULL;

-	common = ath10k_common(ar);
-	common->priv = ar;
-	common->hw = ar->hw;
+	ar->ath_common.priv = ar;
+	ar->ath_common.hw = ar->hw;

 	ar->p2p = !!ath10k_p2p;
 	ar->dev = dev;
diff --git a/drivers/net/wireless/ath/ath10k/core.h b/drivers/net/wireless/ath/ath10k/core.h
index 6c681cf..39cee58 100644
--- a/drivers/net/wireless/ath/ath10k/core.h
+++ b/drivers/net/wireless/ath/ath10k/core.h
 <at>  <at>  -250,7 +250,7  <at>  <at>  struct ath10k_debug {
 };

 struct ath10k {
-	struct ath_common common;
+	struct ath_common ath_common;
 	struct ieee80211_hw *hw;
 	struct device *dev;
 	u8 mac_addr[ETH_ALEN];
 <at>  <at>  -354,11 +354,6  <at>  <at>  struct ath10k {
 #endif
 };

-static inline struct ath_common *ath10k_common(struct ath10k *ar)
-{
-	return &ar->common;
-}
-
 struct ath10k *ath10k_core_create(void *hif_priv, struct device *dev,
 				  enum ath10k_bus bus,
 				  const struct ath10k_hif_ops *hif_ops);
diff --git a/drivers/net/wireless/ath/ath10k/mac.c b/drivers/net/wireless/ath/ath10k/mac.c
index bf7954b..14e7ada 100644
--- a/drivers/net/wireless/ath/ath10k/mac.c
+++ b/drivers/net/wireless/ath/ath10k/mac.c
 <at>  <at>  -1185,7 +1185,7  <at>  <at>  static void ath10k_reg_notifier(struct wiphy *wiphy,
 	struct ath10k *ar = hw->priv;
 	int ret;

-	ath_reg_notifier_apply(wiphy, request, &ath10k_common(ar)->regulatory);
+	ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);

 	ret = ath10k_update_channel_list(ar);
 	if (ret)
 <at>  <at>  -2741,7 +2741,6  <at>  <at>  struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)

 int ath10k_mac_register(struct ath10k *ar)
 {
-	struct ath_common *common = ath10k_common(ar);
 	struct ieee80211_supported_band *band;
 	struct ieee80211_sta_ht_cap ht_cap;
 	void *channels;
 <at>  <at>  -2835,8 +2834,8  <at>  <at>  int ath10k_mac_register(struct ath10k *ar)
 	ar->hw->wiphy->iface_combinations = &ath10k_if_comb;
 	ar->hw->wiphy->n_iface_combinations = 1;

-	common->regulatory.country_code = CTRY_DEFAULT;
-	ret = ath_regd_init(&common->regulatory, ar->hw->wiphy,
+	ar->ath_common.regulatory.country_code = CTRY_DEFAULT;
+	ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
 			    ath10k_reg_notifier);
 	if (ret) {
 		ath10k_err("Regulatory initialization failed\n");
 <at>  <at>  -2849,9 +2848,9  <at>  <at>  int ath10k_mac_register(struct ath10k *ar)
 		return ret;
 	}

-	if (!ath_is_world_regd(&common->regulatory)) {
+	if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
 		ret = regulatory_hint(ar->hw->wiphy,
-				      common->regulatory.alpha2);
+				      ar->ath_common.regulatory.alpha2);
 		if (ret)
 			goto exit;
 	}
diff --git a/drivers/net/wireless/ath/ath10k/wmi.c b/drivers/net/wireless/ath/ath10k/wmi.c
index d2d712d..e2f8ff9 100644
--- a/drivers/net/wireless/ath/ath10k/wmi.c
+++ b/drivers/net/wireless/ath/ath10k/wmi.c
 <at>  <at>  -853,7 +853,6  <at>  <at>  static void ath10k_wmi_event_vdev_install_key_complete(struct ath10k *ar,
 static void ath10k_wmi_service_ready_event_rx(struct ath10k *ar,
 					      struct sk_buff *skb)
 {
-	struct ath_common *common = ath10k_common(ar);
 	struct wmi_service_ready_event *ev = (void *)skb->data;

 	if (skb->len < sizeof(*ev)) {
 <at>  <at>  -874,7 +873,7  <at>  <at>  static void ath10k_wmi_service_ready_event_rx(struct ath10k *ar,
 	ar->fw_version_build = (__le32_to_cpu(ev->sw_version_1) & 0x0000ffff);
 	ar->phy_capability = __le32_to_cpu(ev->phy_capability);

-	common->regulatory.current_rd =
+	ar->ath_common.regulatory.current_rd =
 		__le32_to_cpu(ev->hal_reg_capabilities.eeprom_rd);

 	ath10k_debug_read_service_map(ar, ev->wmi_service_bitmap,
--

-- 
1.7.9.5
Permalink | Reply | 1 comment |
headers
Jose Antonio Delgado Alfonso | 10 May 2013 16:05
Picon

Virtual interfaces and time-division multiplexing for different uses

Hi all,

First, apologize for the massive email.

I'm trying to use the ACS in a virtual interface at the same time that I'm using hostapd with another virtual interface. The result is the clients connected to the hosapd get disconnect when the ACS is running.

In my understanding, correct me if I'm wrong, the driver can not multiplex these both tasks at the same time. Could it be possible to implement that stuff in the driver or is it already implemented but I'm making some mistake?

Thanks in advance,
Regards.

Jose A. Delgado
_______________________________________________
ath9k-devel mailing list
ath9k-devel <at> lists.ath9k.org
https://lists.ath9k.org/mailman/listinfo/ath9k-devel
Permalink | Reply | 1 comment |

Gmane