10 files changed, 120 insertions, 39 deletions

diff --git a/drivers/net/wireless/ath/wil6210/cfg80211.c b/drivers/net/wireless/ath/wil6210/cfg80211.c
index 0fc0b9f8e605..38332a6dfb3a 100644
--- a/drivers/net/wireless/ath/wil6210/cfg80211.c
+++ b/drivers/net/wireless/ath/wil6210/cfg80211.c
@@ -798,7 +798,7 @@ static int wil_cfg80211_del_station(struct wiphy *wiphy,
         struct wil6210_priv *wil = wiphy_to_wil(wiphy);
 
         mutex_lock(&wil->mutex);
-        wil6210_disconnect(wil, params->mac, false);
+        wil6210_disconnect(wil, params->mac, params->reason_code, false);
         mutex_unlock(&wil->mutex);
 
         return 0;
diff --git a/drivers/net/wireless/ath/wil6210/debug.c b/drivers/net/wireless/ath/wil6210/debug.c
index 8d99021d27a8..3249562d93b4 100644
--- a/drivers/net/wireless/ath/wil6210/debug.c
+++ b/drivers/net/wireless/ath/wil6210/debug.c
@@ -32,6 +32,23 @@ void wil_err(struct wil6210_priv *wil, const char *fmt, ...)
         va_end(args);
 }
 
+void wil_err_ratelimited(struct wil6210_priv *wil, const char *fmt, ...)
+{
+        if (net_ratelimit()) {
+                struct net_device *ndev = wil_to_ndev(wil);
+                struct va_format vaf = {
+                        .fmt = fmt,
+                };
+                va_list args;
+
+                va_start(args, fmt);
+                vaf.va = &args;
+                netdev_err(ndev, "%pV", &vaf);
+                trace_wil6210_log_err(&vaf);
+                va_end(args);
+        }
+}
+
 void wil_info(struct wil6210_priv *wil, const char *fmt, ...)
 {
         struct net_device *ndev = wil_to_ndev(wil);
diff --git a/drivers/net/wireless/ath/wil6210/debugfs.c b/drivers/net/wireless/ath/wil6210/debugfs.c
index 54a6ddc6301b..4e6e14501c2f 100644
--- a/drivers/net/wireless/ath/wil6210/debugfs.c
+++ b/drivers/net/wireless/ath/wil6210/debugfs.c
@@ -573,8 +573,10 @@ static ssize_t wil_write_file_txmgmt(struct file *file, const char __user *buf,
         if (!frame)
                 return -ENOMEM;
 
-        if (copy_from_user(frame, buf, len))
+        if (copy_from_user(frame, buf, len)) {
+                kfree(frame);
                 return -EIO;
+        }
 
         params.buf = frame;
         params.len = len;
@@ -614,8 +616,10 @@ static ssize_t wil_write_file_wmi(struct file *file, const char __user *buf,
                 return -ENOMEM;
 
         rc = simple_write_to_buffer(wmi, len, ppos, buf, len);
-        if (rc < 0)
+        if (rc < 0) {
+                kfree(wmi);
                 return rc;
+        }
 
         cmd = &wmi[1];
         cmdid = le16_to_cpu(wmi->id);
diff --git a/drivers/net/wireless/ath/wil6210/fw.c b/drivers/net/wireless/ath/wil6210/fw.c
index 8c6f3b041f77..93c5cc16c515 100644
--- a/drivers/net/wireless/ath/wil6210/fw.c
+++ b/drivers/net/wireless/ath/wil6210/fw.c
@@ -15,7 +15,6 @@
  */
 #include <linux/firmware.h>
 #include <linux/module.h>
-#include <linux/pci.h>
 #include <linux/crc32.h>
 #include "wil6210.h"
 #include "fw.h"
diff --git a/drivers/net/wireless/ath/wil6210/fw_inc.c b/drivers/net/wireless/ath/wil6210/fw_inc.c
index 44cb71f5ea5b..d4acf93a9a02 100644
--- a/drivers/net/wireless/ath/wil6210/fw_inc.c
+++ b/drivers/net/wireless/ath/wil6210/fw_inc.c
@@ -446,7 +446,7 @@ static int wil_fw_load(struct wil6210_priv *wil, const void *data, size_t size)
                 if (size >= sizeof(*hdr)) {
                         wil_err_fw(wil, "Stop at offset %ld"
                                    " record type %d [%zd bytes]\n",
-                                   (const void *)hdr - data,
+                                   (long)((const void *)hdr - data),
                                    le16_to_cpu(hdr->type), hdr_sz);
                 }
                 return -EINVAL;
@@ -471,7 +471,7 @@ int wil_request_firmware(struct wil6210_priv *wil, const char *name)
         size_t sz;
         const void *d;
 
-        rc = request_firmware(&fw, name, wil_to_pcie_dev(wil));
+        rc = request_firmware(&fw, name, wil_to_dev(wil));
         if (rc) {
                 wil_err_fw(wil, "Failed to load firmware %s\n", name);
                 return rc;
diff --git a/drivers/net/wireless/ath/wil6210/interrupt.c b/drivers/net/wireless/ath/wil6210/interrupt.c
index 90f416f239bd..4bcbd6297b3e 100644
--- a/drivers/net/wireless/ath/wil6210/interrupt.c
+++ b/drivers/net/wireless/ath/wil6210/interrupt.c
@@ -36,7 +36,8 @@
  */
 
 #define WIL6210_IRQ_DISABLE     (0xFFFFFFFFUL)
-#define WIL6210_IMC_RX          BIT_DMA_EP_RX_ICR_RX_DONE
+#define WIL6210_IMC_RX          (BIT_DMA_EP_RX_ICR_RX_DONE | \
+                                 BIT_DMA_EP_RX_ICR_RX_HTRSH)
 #define WIL6210_IMC_TX          (BIT_DMA_EP_TX_ICR_TX_DONE | \
                                 BIT_DMA_EP_TX_ICR_TX_DONE_N(0))
 #define WIL6210_IMC_MISC        (ISR_MISC_FW_READY | \
@@ -171,6 +172,7 @@ static irqreturn_t wil6210_irq_rx(int irq, void *cookie)
         u32 isr = wil_ioread32_and_clear(wil->csr +
                                          HOSTADDR(RGF_DMA_EP_RX_ICR) +
                                          offsetof(struct RGF_ICR, ICR));
+        bool need_unmask = true;
 
         trace_wil6210_irq_rx(isr);
         wil_dbg_irq(wil, "ISR RX 0x%08x\n", isr);
@@ -182,12 +184,24 @@ static irqreturn_t wil6210_irq_rx(int irq, void *cookie)
 
         wil6210_mask_irq_rx(wil);
 
-        if (isr & BIT_DMA_EP_RX_ICR_RX_DONE) {
+        /* RX_DONE and RX_HTRSH interrupts are the same if interrupt
+         * moderation is not used. Interrupt moderation may cause RX
+         * buffer overflow while RX_DONE is delayed. The required
+         * action is always the same - should empty the accumulated
+         * packets from the RX ring.
+         */
+        if (isr & (BIT_DMA_EP_RX_ICR_RX_DONE | BIT_DMA_EP_RX_ICR_RX_HTRSH)) {
                 wil_dbg_irq(wil, "RX done\n");
-                isr &= ~BIT_DMA_EP_RX_ICR_RX_DONE;
+
+                if (isr & BIT_DMA_EP_RX_ICR_RX_HTRSH)
+                        wil_err_ratelimited(wil, "Received \"Rx buffer is in risk "
+                                "of overflow\" interrupt\n");
+
+                isr &= ~(BIT_DMA_EP_RX_ICR_RX_DONE | BIT_DMA_EP_RX_ICR_RX_HTRSH);
                 if (test_bit(wil_status_reset_done, &wil->status)) {
                         if (test_bit(wil_status_napi_en, &wil->status)) {
                                 wil_dbg_txrx(wil, "NAPI(Rx) schedule\n");
+                                need_unmask = false;
                                 napi_schedule(&wil->napi_rx);
                         } else {
                                 wil_err(wil, "Got Rx interrupt while "
@@ -204,6 +218,10 @@ static irqreturn_t wil6210_irq_rx(int irq, void *cookie)
         /* Rx IRQ will be enabled when NAPI processing finished */
 
         atomic_inc(&wil->isr_count_rx);
+
+        if (unlikely(need_unmask))
+                wil6210_unmask_irq_rx(wil);
+
         return IRQ_HANDLED;
 }
 
@@ -213,6 +231,7 @@ static irqreturn_t wil6210_irq_tx(int irq, void *cookie)
         u32 isr = wil_ioread32_and_clear(wil->csr +
                                          HOSTADDR(RGF_DMA_EP_TX_ICR) +
                                          offsetof(struct RGF_ICR, ICR));
+        bool need_unmask = true;
 
         trace_wil6210_irq_tx(isr);
         wil_dbg_irq(wil, "ISR TX 0x%08x\n", isr);
@@ -231,6 +250,7 @@ static irqreturn_t wil6210_irq_tx(int irq, void *cookie)
                 isr &= ~(BIT(25) - 1UL);
                 if (test_bit(wil_status_reset_done, &wil->status)) {
                         wil_dbg_txrx(wil, "NAPI(Tx) schedule\n");
+                        need_unmask = false;
                         napi_schedule(&wil->napi_tx);
                 } else {
                         wil_err(wil, "Got Tx interrupt while in reset\n");
@@ -243,6 +263,10 @@ static irqreturn_t wil6210_irq_tx(int irq, void *cookie)
         /* Tx IRQ will be enabled when NAPI processing finished */
 
         atomic_inc(&wil->isr_count_tx);
+
+        if (unlikely(need_unmask))
+                wil6210_unmask_irq_tx(wil);
+
         return IRQ_HANDLED;
 }
 
diff --git a/drivers/net/wireless/ath/wil6210/main.c b/drivers/net/wireless/ath/wil6210/main.c
index 6212983fede2..8ff3fe34fe05 100644
--- a/drivers/net/wireless/ath/wil6210/main.c
+++ b/drivers/net/wireless/ath/wil6210/main.c
@@ -67,6 +67,36 @@ static struct kernel_param_ops mtu_max_ops = {
 module_param_cb(mtu_max, &mtu_max_ops, &mtu_max, S_IRUGO);
 MODULE_PARM_DESC(mtu_max, " Max MTU value.");
 
+static uint rx_ring_order = WIL_RX_RING_SIZE_ORDER_DEFAULT;
+static uint tx_ring_order = WIL_TX_RING_SIZE_ORDER_DEFAULT;
+
+static int ring_order_set(const char *val, const struct kernel_param *kp)
+{
+        int ret;
+        uint x;
+
+        ret = kstrtouint(val, 0, &x);
+        if (ret)
+                return ret;
+
+        if ((x < WIL_RING_SIZE_ORDER_MIN) || (x > WIL_RING_SIZE_ORDER_MAX))
+                return -EINVAL;
+
+        *((uint *)kp->arg) = x;
+
+        return 0;
+}
+
+static struct kernel_param_ops ring_order_ops = {
+        .set = ring_order_set,
+        .get = param_get_uint,
+};
+
+module_param_cb(rx_ring_order, &ring_order_ops, &rx_ring_order, S_IRUGO);
+MODULE_PARM_DESC(rx_ring_order, " Rx ring order; size = 1 << order");
+module_param_cb(tx_ring_order, &ring_order_ops, &tx_ring_order, S_IRUGO);
+MODULE_PARM_DESC(tx_ring_order, " Tx ring order; size = 1 << order");
+
 #define RST_DELAY (20) /* msec, for loop in @wil_target_reset */
 #define RST_COUNT (1 + 1000/RST_DELAY) /* round up to be above 1 sec total */
 
@@ -104,7 +134,7 @@ void wil_memcpy_toio_32(volatile void __iomem *dst, const void *src,
 }
 
 static void wil_disconnect_cid(struct wil6210_priv *wil, int cid,
-                               bool from_event)
+                               u16 reason_code, bool from_event)
 {
         uint i;
         struct net_device *ndev = wil_to_ndev(wil);
@@ -117,8 +147,7 @@ static void wil_disconnect_cid(struct wil6210_priv *wil, int cid,
         sta->data_port_open = false;
         if (sta->status != wil_sta_unused) {
                 if (!from_event)
-                        wmi_disconnect_sta(wil, sta->addr,
-                                           WLAN_REASON_DEAUTH_LEAVING);
+                        wmi_disconnect_sta(wil, sta->addr, reason_code);
 
                 switch (wdev->iftype) {
                 case NL80211_IFTYPE_AP:
@@ -152,7 +181,7 @@ static void wil_disconnect_cid(struct wil6210_priv *wil, int cid,
 }
 
 static void _wil6210_disconnect(struct wil6210_priv *wil, const u8 *bssid,
-                                bool from_event)
+                                u16 reason_code, bool from_event)
 {
         int cid = -ENOENT;
         struct net_device *ndev = wil_to_ndev(wil);
@@ -167,10 +196,10 @@ static void _wil6210_disconnect(struct wil6210_priv *wil, const u8 *bssid,
         }
 
         if (cid >= 0) /* disconnect 1 peer */
-                wil_disconnect_cid(wil, cid, from_event);
+                wil_disconnect_cid(wil, cid, reason_code, from_event);
         else /* disconnect all */
                 for (cid = 0; cid < WIL6210_MAX_CID; cid++)
-                        wil_disconnect_cid(wil, cid, from_event);
+                        wil_disconnect_cid(wil, cid, reason_code, from_event);
 
         /* link state */
         switch (wdev->iftype) {
@@ -179,8 +208,7 @@ static void _wil6210_disconnect(struct wil6210_priv *wil, const u8 *bssid,
                 wil_link_off(wil);
                 if (test_bit(wil_status_fwconnected, &wil->status)) {
                         clear_bit(wil_status_fwconnected, &wil->status);
-                        cfg80211_disconnected(ndev,
-                                              WLAN_STATUS_UNSPECIFIED_FAILURE,
+                        cfg80211_disconnected(ndev, reason_code,
                                               NULL, 0, GFP_KERNEL);
                 } else if (test_bit(wil_status_fwconnecting, &wil->status)) {
                         cfg80211_connect_result(ndev, bssid, NULL, 0, NULL, 0,
@@ -200,7 +228,7 @@ static void wil_disconnect_worker(struct work_struct *work)
                         struct wil6210_priv, disconnect_worker);
 
         mutex_lock(&wil->mutex);
-        _wil6210_disconnect(wil, NULL, false);
+        _wil6210_disconnect(wil, NULL, WLAN_REASON_UNSPECIFIED, false);
         mutex_unlock(&wil->mutex);
 }
 
@@ -222,6 +250,7 @@ static void wil_scan_timer_fn(ulong x)
 
         clear_bit(wil_status_fwready, &wil->status);
         wil_err(wil, "Scan timeout detected, start fw error recovery\n");
+        wil->recovery_state = fw_recovery_pending;
         schedule_work(&wil->fw_error_worker);
 }
 
@@ -333,7 +362,7 @@ static void wil_connect_worker(struct work_struct *work)
 
         wil_dbg_wmi(wil, "Configure for connection CID %d\n", cid);
 
-        rc = wil_vring_init_tx(wil, ringid, WIL6210_TX_RING_SIZE, cid, 0);
+        rc = wil_vring_init_tx(wil, ringid, 1 << tx_ring_order, cid, 0);
         wil->pending_connect_cid = -1;
         if (rc == 0) {
                 wil->sta[cid].status = wil_sta_connected;
@@ -392,18 +421,19 @@ int wil_priv_init(struct wil6210_priv *wil)
  * wil6210_disconnect - disconnect one connection
  * @wil: driver context
  * @bssid: peer to disconnect, NULL to disconnect all
+ * @reason_code: Reason code for the Disassociation frame
  * @from_event: whether is invoked from FW event handler
  *
  * Disconnect and release associated resources. If invoked not from the
  * FW event handler, issue WMI command(s) to trigger MAC disconnect.
  */
 void wil6210_disconnect(struct wil6210_priv *wil, const u8 *bssid,
-                        bool from_event)
+                        u16 reason_code, bool from_event)
 {
         wil_dbg_misc(wil, "%s()\n", __func__);
 
         del_timer_sync(&wil->connect_timer);
-        _wil6210_disconnect(wil, bssid, from_event);
+        _wil6210_disconnect(wil, bssid, reason_code, from_event);
 }
 
 void wil_priv_deinit(struct wil6210_priv *wil)
@@ -415,7 +445,7 @@ void wil_priv_deinit(struct wil6210_priv *wil)
         cancel_work_sync(&wil->disconnect_worker);
         cancel_work_sync(&wil->fw_error_worker);
         mutex_lock(&wil->mutex);
-        wil6210_disconnect(wil, NULL, false);
+        wil6210_disconnect(wil, NULL, WLAN_REASON_DEAUTH_LEAVING, false);
         mutex_unlock(&wil->mutex);
         wmi_event_flush(wil);
         destroy_workqueue(wil->wmi_wq_conn);
@@ -463,6 +493,9 @@ static int wil_target_reset(struct wil6210_priv *wil)
 
         wil_halt_cpu(wil);
 
+        /* Clear Fw Download notification */
+        C(RGF_USER_USAGE_6, BIT(0));
+
         if (is_sparrow) {
                 S(RGF_CAF_OSC_CONTROL, BIT_CAF_OSC_XTAL_EN);
                 /* XTAL stabilization should take about 3ms */
@@ -600,7 +633,7 @@ int wil_reset(struct wil6210_priv *wil)
         WARN_ON(test_bit(wil_status_napi_en, &wil->status));
 
         cancel_work_sync(&wil->disconnect_worker);
-        wil6210_disconnect(wil, NULL, false);
+        wil6210_disconnect(wil, NULL, WLAN_REASON_DEAUTH_LEAVING, false);
 
         wil->status = 0; /* prevent NAPI from being scheduled */
 
@@ -705,7 +738,7 @@ int __wil_up(struct wil6210_priv *wil)
                 return rc;
 
         /* Rx VRING. After MAC and beacon */
-        rc = wil_rx_init(wil);
+        rc = wil_rx_init(wil, 1 << rx_ring_order);
         if (rc)
                 return rc;
 
diff --git a/drivers/net/wireless/ath/wil6210/txrx.c b/drivers/net/wireless/ath/wil6210/txrx.c
index c680906bc0dc..e3f8bdce5abc 100644
--- a/drivers/net/wireless/ath/wil6210/txrx.c
+++ b/drivers/net/wireless/ath/wil6210/txrx.c
@@ -210,8 +210,6 @@ static int wil_vring_alloc_skb(struct wil6210_priv *wil, struct vring *vring,
         struct vring_rx_desc dd, *d = &dd;
         volatile struct vring_rx_desc *_d = &vring->va[i].rx;
         dma_addr_t pa;
-
-        /* TODO align */
         struct sk_buff *skb = dev_alloc_skb(sz + headroom);
 
         if (unlikely(!skb))
@@ -596,7 +594,7 @@ void wil_rx_handle(struct wil6210_priv *wil, int *quota)
         wil_rx_refill(wil, v->size);
 }
 
-int wil_rx_init(struct wil6210_priv *wil)
+int wil_rx_init(struct wil6210_priv *wil, u16 size)
 {
         struct vring *vring = &wil->vring_rx;
         int rc;
@@ -608,7 +606,7 @@ int wil_rx_init(struct wil6210_priv *wil)
                 return -EINVAL;
         }
 
-        vring->size = WIL6210_RX_RING_SIZE;
+        vring->size = size;
         rc = wil_vring_alloc(wil, vring);
         if (rc)
                 return rc;
@@ -928,8 +926,9 @@ static int wil_tx_vring(struct wil6210_priv *wil, struct vring *vring,
         wil_dbg_txrx(wil, "%s()\n", __func__);
 
         if (avail < 1 + nr_frags) {
-                wil_err(wil, "Tx ring full. No space for %d fragments\n",
-                        1 + nr_frags);
+                wil_err_ratelimited(wil,
+                                    "Tx ring full. No space for %d fragments\n",
+                                    1 + nr_frags);
                 return -ENOMEM;
         }
         _d = &vring->va[i].tx;
diff --git a/drivers/net/wireless/ath/wil6210/wil6210.h b/drivers/net/wireless/ath/wil6210/wil6210.h
index 95d3a062d35c..c6ec5b99ac7d 100644
--- a/drivers/net/wireless/ath/wil6210/wil6210.h
+++ b/drivers/net/wireless/ath/wil6210/wil6210.h
@@ -49,8 +49,11 @@ static inline u32 WIL_GET_BITS(u32 x, int b0, int b1)
 
 #define WIL6210_MEM_SIZE (2*1024*1024UL)
 
-#define WIL6210_RX_RING_SIZE    (128)
-#define WIL6210_TX_RING_SIZE    (512)
+#define WIL_RX_RING_SIZE_ORDER_DEFAULT  (9)
+#define WIL_TX_RING_SIZE_ORDER_DEFAULT  (9)
+/* limit ring size in range [32..32k] */
+#define WIL_RING_SIZE_ORDER_MIN (5)
+#define WIL_RING_SIZE_ORDER_MAX (15)
 #define WIL6210_MAX_TX_RINGS    (24) /* HW limit */
 #define WIL6210_MAX_CID         (8) /* HW limit */
 #define WIL6210_NAPI_BUDGET     (16) /* arbitrary */
@@ -126,6 +129,7 @@ struct RGF_ICR {
         #define BIT_DMA_EP_TX_ICR_TX_DONE_N(n)  BIT(n+1) /* n = [0..23] */
 #define RGF_DMA_EP_RX_ICR               (0x881bd0) /* struct RGF_ICR */
         #define BIT_DMA_EP_RX_ICR_RX_DONE       BIT(0)
+        #define BIT_DMA_EP_RX_ICR_RX_HTRSH      BIT(1)
 #define RGF_DMA_EP_MISC_ICR             (0x881bec) /* struct RGF_ICR */
         #define BIT_DMA_EP_MISC_ICR_RX_HTRSH    BIT(0)
         #define BIT_DMA_EP_MISC_ICR_TX_NO_ACT   BIT(1)
@@ -468,13 +472,14 @@ struct wil6210_priv {
 #define wdev_to_wil(w) (struct wil6210_priv *)(wdev_priv(w))
 #define wil_to_ndev(i) (wil_to_wdev(i)->netdev)
 #define ndev_to_wil(n) (wdev_to_wil(n->ieee80211_ptr))
-#define wil_to_pcie_dev(i) (&i->pdev->dev)
 
 __printf(2, 3)
 void wil_dbg_trace(struct wil6210_priv *wil, const char *fmt, ...);
 __printf(2, 3)
 void wil_err(struct wil6210_priv *wil, const char *fmt, ...);
 __printf(2, 3)
+void wil_err_ratelimited(struct wil6210_priv *wil, const char *fmt, ...);
+__printf(2, 3)
 void wil_info(struct wil6210_priv *wil, const char *fmt, ...);
 #define wil_dbg(wil, fmt, arg...) do { \
         netdev_dbg(wil_to_ndev(wil), fmt, ##arg); \
@@ -586,9 +591,9 @@ int wmi_set_mac_address(struct wil6210_priv *wil, void *addr);
 int wmi_pcp_start(struct wil6210_priv *wil, int bi, u8 wmi_nettype, u8 chan);
 int wmi_pcp_stop(struct wil6210_priv *wil);
 void wil6210_disconnect(struct wil6210_priv *wil, const u8 *bssid,
-                        bool from_event);
+                        u16 reason_code, bool from_event);
 
-int wil_rx_init(struct wil6210_priv *wil);
+int wil_rx_init(struct wil6210_priv *wil, u16 size);
 void wil_rx_fini(struct wil6210_priv *wil);
 
 /* TX API */
diff --git a/drivers/net/wireless/ath/wil6210/wmi.c b/drivers/net/wireless/ath/wil6210/wmi.c
index bb1e066f756a..63476c86cd0e 100644
--- a/drivers/net/wireless/ath/wil6210/wmi.c
+++ b/drivers/net/wireless/ath/wil6210/wmi.c
@@ -478,15 +478,15 @@ static void wmi_evt_disconnect(struct wil6210_priv *wil, int id,
                                void *d, int len)
 {
         struct wmi_disconnect_event *evt = d;
+        u16 reason_code = le16_to_cpu(evt->protocol_reason_status);
 
-        wil_dbg_wmi(wil, "Disconnect %pM reason %d proto %d wmi\n",
-                    evt->bssid,
-                    evt->protocol_reason_status, evt->disconnect_reason);
+        wil_dbg_wmi(wil, "Disconnect %pM reason [proto %d wmi %d]\n",
+                    evt->bssid, reason_code, evt->disconnect_reason);
 
         wil->sinfo_gen++;
 
         mutex_lock(&wil->mutex);
-        wil6210_disconnect(wil, evt->bssid, true);
+        wil6210_disconnect(wil, evt->bssid, reason_code, true);
         mutex_unlock(&wil->mutex);
 }