rsi: Clean up loop in the interrupt handler

The inner do { ... } while loop is completely useless, all it does
is iterate over a switch-case statement, one bit at a time. This
can easily be replaced by simple if (status & bit) { ... } tests
for each bit. No functional change.

Signed-off-by: Marek Vasut <marex@denx.de>
Cc: Angus Ainslie <angus@akkea.ca>
Cc: David S. Miller <davem@davemloft.net>
Cc: Jakub Kicinski <kuba@kernel.org>
Cc: Kalle Valo <kvalo@codeaurora.org>
Cc: Lee Jones <lee.jones@linaro.org>
Cc: Martin Kepplinger <martink@posteo.de>
Cc: Sebastian Krzyszkowiak <sebastian.krzyszkowiak@puri.sm>
Cc: Siva Rebbagondla <siva8118@gmail.com>
Cc: linux-wireless@vger.kernel.org
Cc: netdev@vger.kernel.org
Signed-off-by: Kalle Valo <kvalo@codeaurora.org>
Link: https://lore.kernel.org/r/20201103180941.443528-2-marex@denx.de

diff --git a/drivers/net/wireless/rsi/rsi_91x_sdio_ops.c b/drivers/net/wireless/rsi/rsi_91x_sdio_ops.c
index 23e709aabd1f7b4991e388ac8d3a181bd2f7b67b..8ace1874e5cb1fe83cb65f58a37dd3b584cd4602 100644 (file)
--- a/drivers/net/wireless/rsi/rsi_91x_sdio_ops.c
+++ b/drivers/net/wireless/rsi/rsi_91x_sdio_ops.c
@@ -236,7 +236,6 @@ static void rsi_rx_handler(struct rsi_hw *adapter)
        struct rsi_91x_sdiodev *dev =
                (struct rsi_91x_sdiodev *)adapter->rsi_dev;
        int status;
-       enum sdio_interrupt_type isr_type;
        u8 isr_status = 0;
        u8 fw_status = 0;
 
@@ -267,73 +266,69 @@ static void rsi_rx_handler(struct rsi_hw *adapter)
                        __func__, isr_status, (1 << MSDU_PKT_PENDING),
                        (1 << FW_ASSERT_IND));
 
-               do {
-                       RSI_GET_SDIO_INTERRUPT_TYPE(isr_status, isr_type);
-
-                       switch (isr_type) {
-                       case BUFFER_AVAILABLE:
-                               status = rsi_sdio_check_buffer_status(adapter,
-                                                                     0);
-                               if (status < 0)
-                                       rsi_dbg(ERR_ZONE,
-                                               "%s: Failed to check buffer status\n",
-                                               __func__);
-                               rsi_sdio_ack_intr(common->priv,
-                                                 (1 << PKT_BUFF_AVAILABLE));
-                               rsi_set_event(&common->tx_thread.event);
-
-                               rsi_dbg(ISR_ZONE,
-                                       "%s: ==> BUFFER_AVAILABLE <==\n",
-                                       __func__);
-                               dev->buff_status_updated = true;
-                               break;
-
-                       case FIRMWARE_ASSERT_IND:
+               if (isr_status & BIT(PKT_BUFF_AVAILABLE)) {
+                       status = rsi_sdio_check_buffer_status(adapter, 0);
+                       if (status < 0)
                                rsi_dbg(ERR_ZONE,
-                                       "%s: ==> FIRMWARE Assert <==\n",
+                                       "%s: Failed to check buffer status\n",
                                        __func__);
-                               status = rsi_sdio_read_register(common->priv,
+                       rsi_sdio_ack_intr(common->priv,
+                                         BIT(PKT_BUFF_AVAILABLE));
+                       rsi_set_event(&common->tx_thread.event);
+
+                       rsi_dbg(ISR_ZONE, "%s: ==> BUFFER_AVAILABLE <==\n",
+                               __func__);
+                       dev->buff_status_updated = true;
+
+                       isr_status &= ~BIT(PKT_BUFF_AVAILABLE);
+               }
+
+               if (isr_status & BIT(FW_ASSERT_IND)) {
+                       rsi_dbg(ERR_ZONE, "%s: ==> FIRMWARE Assert <==\n",
+                               __func__);
+                       status = rsi_sdio_read_register(common->priv,
                                                        SDIO_FW_STATUS_REG,
                                                        &fw_status);
-                               if (status) {
-                                       rsi_dbg(ERR_ZONE,
-                                               "%s: Failed to read f/w reg\n",
-                                               __func__);
-                               } else {
-                                       rsi_dbg(ERR_ZONE,
-                                               "%s: Firmware Status is 0x%x\n",
-                                               __func__ , fw_status);
-                                       rsi_sdio_ack_intr(common->priv,
-                                                         (1 << FW_ASSERT_IND));
-                               }
-
-                               common->fsm_state = FSM_CARD_NOT_READY;
-                               break;
-
-                       case MSDU_PACKET_PENDING:
-                               rsi_dbg(ISR_ZONE, "Pkt pending interrupt\n");
-                               dev->rx_info.total_sdio_msdu_pending_intr++;
-
-                               status = rsi_process_pkt(common);
-                               if (status) {
-                                       rsi_dbg(ERR_ZONE,
-                                               "%s: Failed to read pkt\n",
-                                               __func__);
-                                       mutex_unlock(&common->rx_lock);
-                                       return;
-                               }
-                               break;
-                       default:
-                               rsi_sdio_ack_intr(common->priv, isr_status);
-                               dev->rx_info.total_sdio_unknown_intr++;
-                               isr_status = 0;
-                               rsi_dbg(ISR_ZONE,
-                                       "Unknown Interrupt %x\n",
-                                       isr_status);
-                               break;
+                       if (status) {
+                               rsi_dbg(ERR_ZONE,
+                                       "%s: Failed to read f/w reg\n",
+                                       __func__);
+                       } else {
+                               rsi_dbg(ERR_ZONE,
+                                       "%s: Firmware Status is 0x%x\n",
+                                       __func__, fw_status);
+                               rsi_sdio_ack_intr(common->priv,
+                                                 BIT(FW_ASSERT_IND));
                        }
-                       isr_status ^= BIT(isr_type - 1);
-               } while (isr_status);
+
+                       common->fsm_state = FSM_CARD_NOT_READY;
+
+                       isr_status &= ~BIT(FW_ASSERT_IND);
+               }
+
+               if (isr_status & BIT(MSDU_PKT_PENDING)) {
+                       rsi_dbg(ISR_ZONE, "Pkt pending interrupt\n");
+                       dev->rx_info.total_sdio_msdu_pending_intr++;
+
+                       status = rsi_process_pkt(common);
+                       if (status) {
+                               rsi_dbg(ERR_ZONE, "%s: Failed to read pkt\n",
+                                       __func__);
+                               mutex_unlock(&common->rx_lock);
+                               return;
+                       }
+
+                       isr_status &= ~BIT(MSDU_PKT_PENDING);
+               }
+
+               if (isr_status) {
+                       rsi_sdio_ack_intr(common->priv, isr_status);
+                       dev->rx_info.total_sdio_unknown_intr++;
+                       isr_status = 0;
+                       rsi_dbg(ISR_ZONE, "Unknown Interrupt %x\n",
+                               isr_status);
+               }
+
                mutex_unlock(&common->rx_lock);
        } while (1);
 }