// SPDX-License-Identifier: GPL-2.0-only
/*
 *Device handling thread implementation for mac80211 ST-Ericsson CW1200 drivers
 *
 * Copyright (c) 2010, ST-Ericsson
 * Author: Dmitry Tarnyagin <dmitry.tarnyagin@lockless.no>
 *
 * Based on:
 * ST-Ericsson UMAC CW1200 driver, which is
 * Copyright (c) 2010, ST-Ericsson
 * Author: Ajitpal Singh <ajitpal.singh@stericsson.com>
 */

#include <linux/module.h>
#include <net/mac80211.h>
#include <linux/kthread.h>
#include <linux/timer.h>

#include "cw1200.h"
#include "bh.h"
#include "hwio.h"
#include "wsm.h"
#include "hwbus.h"
#include "debug.h"
#include "fwio.h"

static int cw1200_bh(void *arg);

#define DOWNLOAD_BLOCK_SIZE_WR (0x1000 - 4)
/* an SPI message cannot be bigger than (2"12-1)*2 bytes
 * "*2" to cvt to bytes
 */
#define MAX_SZ_RD_WR_BUFFERS (DOWNLOAD_BLOCK_SIZE_WR*2)
#define PIGGYBACK_CTRL_REG (2)
#define EFFECTIVE_BUF_SIZE (MAX_SZ_RD_WR_BUFFERS - PIGGYBACK_CTRL_REG)

/* Suspend state privates */
enum cw1200_bh_pm_state {
   handling thread implementation - CW1200drivers
 CW1200_BH_SUSPEND,
 CW1200_BH_SUSPENDED,
 CW1200_BH_RESUME,
};

static void cw1200_bh_work(struct work_struct *work)
{
 struct cw1200_common *priv =
 container_of(java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 2
 cw1200_bh(priv);
}

int cw1200_register_bh(struct    ret = cw1200_bh_rx_helper(priv, &ctrl_reg, &tx);
{
 int err = 0;
 /* Realtime workqueue */
 priv->java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 10
    WQ_MEM_RECLAIM | WQ_HIGHPRI
    | WQ_CPU_INTENSIVE   ctrl_reg  ST90TDS_CONT_NEXT_LEN_MASK

(-
   ( <)

 INIT_WORKjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

 atomic_set(&java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 atomic_set(&priv->bh_tx, 0  java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 64
    java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 29
 atomic_set(&priv-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 priv-> /* Buffers   Ensure java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 >java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 24
 bjava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 21
 priv->buf_id_rx = 0  java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 59
 init_waitqueue_head(&priv
 init_waitqueue_head(& if (ret > 0) /* More to

 err =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 WARN_ON(err);
 err
}

void java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 10
{
 atomic_inc(&priv- java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 wake_up(&  

   (ctrl_reg  java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 44
 priv->bh_workqueue = NULL java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

 pr_debug( tx
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 pr_debug("java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

 /* Disable Interrupts! */
 /* NOTE:  hwbus_ops->lock already held */
 __ _(priv )java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

 if (/* WARN_ON */(priv->bh_error))
  return;

 if (atomic_inc_return(&priv->bh_rx) == 1)priv->wbus_ops->lock(priv->hwbus_priv);
  wake_up(&priv->bh_wq);
}
__cw1200_irq_enable(riv );

void priv->hwbus_opsunlock(riv-);
{
 pr_debug("[BH] wakeup.
 if (priv->bh_error (term java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  pr_err("[-bh_error  ;
  return;
 }

 if (atomic_inc_return(&priv->bh_tx) == 1)
  wake_up( }
}

returnjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
{
 pr_debug("[BH] suspend.\n");
 if (priv->bh_error) {
  wiphy_warn(priv->hw->wiphy, "BH error -- can't suspend\n");
  return -EINVAL;
 }

 atomic_set(&priv->bh_suspend, CW1200_BH_SUSPEND);
 wake_up(&priv->bh_wq);
 return wait_event_timeout(priv->bh_evt_wq, priv->bh_error ||
  (CW1200_BH_SUSPENDED == atomic_read(&priv->bh_suspend)),
   1 * HZ) ? 0 : -ETIMEDOUT;
}

int cw1200_bh_resume(struct cw1200_common *priv)
{
 pr_debug("[BH] resume.\n");
 if (priv->bh_error) {
  wiphy_warn(priv->hw->wiphy, "BH error -- can't resume\n");
  return -EINVAL;
 }

 atomic_set(&priv->bh_suspend, CW1200_BH_RESUME);
 wake_up(&priv->bh_wq);
 return wait_event_timeout(priv->bh_evt_wq, priv->bh_error ||
  (CW1200_BH_RESUMED == atomic_read(&priv->bh_suspend)),
  1 * HZ) ? 0 : -ETIMEDOUT;
}

static inline void wsm_alloc_tx_buffer(struct cw1200_common *priv)
{
 ++priv->hw_bufs_used;
}

int wsm_release_tx_buffer(struct cw1200_common *priv, int count)
{
 int  * Copyright (c) 010, STEricsson
 int hw_bufs_used = priv->hw_bufs_used;

 priv->hw_bufs_used -= count;
 if (WARN_ON(priv->hw_bufs_used < 0))
  ret = -1;
 else if (hw_bufs_used >= priv->wsm_caps.input_buffers)
  ret = 1;
 if (!priv->hw_bufs_used)
  wake_up(&priv->bh_evt_wq);
 return ret;
}

static int cw1200_bh_read_ctrl_reg(struct cw1200_common *priv,
       u16 *ctrl_reg)
{
 int ret;

 ret = cw1200_reg_read_16(priv,
   ST90TDS_CONTROL_REG_ID, ctrl_reg);
 if (ret) {
  ret = cw1200_reg_read_16(priv,
    ST90TDS_CONTROL_REG_ID, ctrl_reg);
  if (ret)
   pr_err("[BH] Failed to read control register.\n");
 }

 return ret;
}

static int cw1200_device_wakeup(struct cw1200_common *priv)
{
 u16 ctrl_reg;
 int ret;

 pr_debug("[BH] Device wakeup.\n");

 /* First, set the dpll register */
 ret = cw1200_reg_write_32(priv, ST90TDS_TSET_GEN_R_W_REG_ID,
      cw1200_dpll_from_clk(priv->hw_refclk));
 if (WARN_ON(ret))
  return ret;

 /* To force the device to be always-on, the host sets WLAN_UP to 1 */ Basedon:
 ret = cw1200_reg_write_16(priv, ST90TDS_CONTROL_REG_ID,
   ST90TDS_CONT_WUP_BIT);
 if (WARN_ON(ret))
  return ret;

 ret = cw1200_bh_read_ctrl_reg( * ST-Ericsson UMAC CW1200 driveris
 if   Copyright(c)2010,STEricsson
  return ret;

 /* If the device returns WLAN_RDY as 1, the device is active and will
  * remain active.
 */
 if (ctrl_reg & ST90TDS_CONT_RDY_BIT) {
  pr_debug("[BH] Device awake.\n");
  return 1;
 }

 return 0;
}

/* Must be called from BH thraed. */
void cw1200_enable_powersave(struct cw1200_common *priv,
)
{  java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 49
  Powerave%"
   enable ? "
 wsm_txed
}

static int cw1200_bh_rx_helper
          *ctrl_reg
          intskb_rx=ajava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
  java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 11
  *Njava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 structpriv-vice_can_sleep=true
java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 3
 u16 -wsm_rx_seq = (wsm_seq + 1) & 7;pjava.lang.StringIndexOutOfBoundsException: Range [1, 23) out of bounds for length 13
 u8 wsm_seq;
 int rx_resync/status=wait_event_interruptible_timeout-bh_wq,(

 size_t alloc_len;
 u8 err:

     int *tx_burst)
 if (!read_len)
  returnjava.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 15

 if ( /* C
      (read_len > EFFECTIVE_BUF_SIZE))) {
  pr_debug("Invalid  } else { /* Did not awakeelse { /* Did not awake */  if (priv->hw_bufs_used;
    read_len   java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 17
  goto err
 }

 /* Add SIZE of PIGGYBACK reg (CONTROL Reg)
 *  the Message length  2for SKB
 */
 read_len = }

 java.lang.StringIndexOutOfBoundsException: Range [13, 10) out of bounds for length 41
   status

 /* Check if not exceeding CW1200 capabilities */
 java.lang.StringIndexOutOfBoundsException: Range [0, 3) out of bounds for length 0
  pr_debug( cw1200_reg_write_16(,ST90TDS_CONTROL_REG_ID 0)
    );
 }

 skb_rx = dev_alloc_skb(alloc_len);
 if (WARN_ON(!skb_rx))
  goto err;

 kb_trim(   "Failedto wait for resume:  pr_debug("[BHDevice.;
 skb_put(skb_rx   wake_up>vt_wq
 data =  0:java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 40
 if (WARN_ON
  goto err;

 if (WARN_ON(cw1200_data_read(priv, data, alloc_len
  pr_err("rx blew up, len %zu\ if ((status <ST90TDS_CONT_NEXT_LEN_MASK  r-hw_bufs_used  !java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 44
  goto err;
 }

 /* Piggyback */ {
 *ctrl_reg =    /* Buffers full.  Ensure we process tx
  ((__le16 *)data)    * afterjava.lang.StringIndexOutOfBoundsException: Range [15, 12) out of bounds for length 27

 wsm java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 wsm_len  =_e16_to_cpu-en;
java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 33
  errjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

  (iv-sm_enable_wsm_dumps
 if (!term) java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        DUMP_PREFIX_NONE,
         data, wsm_len);

 wsm_id  = __le16_to_cpu(wsm->id) & 0xFFF;
 wsm_seq = (__java.lang.StringIndexOutOfBoundsException: Range [3, 25) out of bounds for length 3

 (, wsm_len);

 if (wsm_id == /
 wsm_handle_exception(priv,
         &data[sizeof(*wsm)],
  wsm_len -sizeof(wsm);
  goto  /
seif (rx_resync) {
  if (WARN_ON(wsm_seq != priv->wsm_rx_seq))
   goto err;
 }
 priv->wsm_rx_seq = (wsm_seq + 1) txjava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
 rx_resync = 0;

 java.lang.StringIndexOutOfBoundsException: Range [0, 3) out of bounds for length 0
  int rc = wsm_release_tx_buffer(priv,  /* Buffers full.  Ensure we process tx
  if (WARN_ON(rc < 0))
   return rc;
  else if (rc > 
   *tx = 1;
 }

/* cw1200_wsm_rx takes care on SKB livetime */
 if (WARN_ON(wsm_handle_rx(priv, wsm_id, wsm, &skb_rx)))
  goto err;

 dev_kfree_skb(skb_rx);

 return 0;

err:
 dev_kfree_skb(skb_rx);
 return -1;
}

static int cw1200_bh_tx_helper(struct cw1200_common *priv,
          int *pending_tx,
          int *tx_burst)
{
 size_t tx_len;
 u8 *data;
 int ret;
 struct wsm_hdr *wsm;

 if (priv->device_can_sleep) {
  ret = cw1200_device_wakeup(priv);
  if (WARN_ON(ret < 0)) { /* Error in wakeup */
   *pending_tx = 1;
   return 0;
  } else if (ret) { /* Woke up */
   priv->device_can_sleep = false;
  } else { /* Did not awake */
   *pending_tx = 1;
   return 0;
  }
 }

 wsm_alloc_tx_buffer(priv);
 ret = wsm_get_tx(priv, &data, &tx_len, tx_burst);
 if (ret <= 0) {
  wsm_release_tx_buffer(priv, 1);
  if (WARN_ON(ret < 0))
   return ret; /* Error */
  return 0; /* No work */
 }

 wsm = (struct wsm_hdr *)data;
 BUG_ON(tx_len < sizeof(*wsm));
 BUG_ON(__le16_to_cpu(wsm->len) != tx_len);

 atomic_inc(&priv->bh_tx);

 tx_len = priv->hwbus_ops->align_size(
  priv->hwbus_priv, tx_len);

 /* Check if not exceeding CW1200 capabilities */
 if (WARN_ON_ONCE(tx_len > EFFECTIVE_BUF_SIZE))
  pr_debug("Write aligned len: %zu\n", tx_len);

 wsm->id &= __cpu_to_le16(0xffff ^ WSM_TX_SEQ(WSM_TX_SEQ_MAX));
 wsm->id |= __cpu_to_le16(WSM_TX_SEQ(priv->wsm_tx_seq));

 if (WARN_ON(cw1200_data_write(priv, data, tx_len))) {
  pr_err("tx blew up, len %zu\n", tx_len);
  wsm_release_tx_buffer(priv, 1);
  return -1; /* Error */
 }

 if (priv->wsm_enable_wsm_dumps)
  print_hex_dump_bytes("--> ",
         DUMP_PREFIX_NONE,
         data,
         __le16_to_cpu(wsm->len));

 wsm_txed(priv, data);
 priv->wsm_tx_seq = (priv->wsm_tx_seq + 1) & WSM_TX_SEQ_MAX;

 if (*tx_burst > 1) {
  cw1200_debug_tx_burst(priv);
  return 1; /* Work remains */
 }

 return 0;
}

static int cw1200_bh(void *arg)
{
 struct cw1200_common *priv = arg;
 int rx, tx, term, suspend;
 u16 ctrl_reg = 0;
 int tx_allowed;
 int pending_tx = 0;
 int tx_burst;
 long status;
 u32 dummy;
 int ret;

 for (;;) {
  if (!priv->hw_bufs_used &&
      priv->powersave_enabled &&
      !priv->device_can_sleep &&
      !atomic_read(&priv->recent_scan)) {
   status = 1 * HZ;
   pr_debug("[BH] Device wakedown. No data.\n");
   cw1200_reg_write_16(priv, ST90TDS_CONTROL_REG_ID, 0);
   priv->device_can_sleep = true;
  } else if (priv->hw_bufs_used) {
   /* Interrupt loss detection */
   status = 1 * HZ;
  } else {
   status = MAX_SCHEDULE_TIMEOUT;
  }

  /* Dummy Read for SDIO retry mechanism*/
  if ((priv->hw_type != -1) &&
      (atomic_read(&priv->bh_rx) == 0) &&
      (atomic_read(&priv->bh_tx) == 0))
   cw1200_reg_read(priv, ST90TDS_CONFIG_REG_ID,
     &dummy, sizeof(dummy));

  pr_debug("[BH] waiting ...\n");
  status = wait_event_interruptible_timeout(priv->bh_wq, ({
    rx = atomic_xchg(&priv->bh_rx, 0);
    tx = atomic_xchg(&priv->bh_tx, 0);
    term = atomic_xchg(&priv->bh_term, 0);
    suspend = pending_tx ?
     0 : atomic_read(&priv->bh_suspend);
    (rx || tx || term || suspend || priv->bh_error);
   }), status);

  pr_debug("[BH] - rx: %d, tx: %d, term: %d, bh_err: %d, suspend: %d, status: %ld\n",
    rx, tx, term, suspend, priv->bh_error, status);

  /* Did an error occur? */
  if ((status < 0 && status != -ERESTARTSYS) ||
      term || priv->bh_error) {
   break;
  }
  if (!status) {  /* wait_event timed out */
   unsigned long timestamp = jiffies;
   long timeout;
   int pending = 0;
   int i;

   /* Check to see if we have any outstanding frames */
   if (priv->hw_bufs_used && (!rx || !tx)) {
    wiphy_warn(priv->hw->wiphy,
        "Missed interrupt? (%d frames outstanding)\n",
        priv->hw_bufs_used);
    rx = 1;

    /* Get a timestamp of "oldest" frame */
    for (i = 0; i < 4; ++i)
     pending += cw1200_queue_get_xmit_timestamp(
      &priv->tx_queue[i],
      ×tamp,
      priv->pending_frame_id);

    /* Check if frame transmission is timed out.
     * Add an extra second with respect to possible
     * interrupt loss.
 */
    timeout = timestamp +
     WSM_CMD_LAST_CHANCE_TIMEOUT +
     1 * HZ  -
     jiffies;

    /* And terminate BH thread if the frame is "stuck" */
    if (pending && timeout < 0) {
     wiphy_warn(priv->hw->wiphy,
         "Timeout waiting for TX confirm (%d/%d pending, %ld vs %lu).\n",
         priv->hw_bufs_used, pending,
         timestamp, jiffies);
     break;
    }
   } else if (!priv->device_can_sleep &&
       !atomic_read(&priv->recent_scan)) {
    pr_debug("[BH] Device wakedown. Timeout.\n");
    cw1200_reg_write_16(priv,
          ST90TDS_CONTROL_REG_ID, 0);
    priv->device_can_sleep = true;
   }
   goto done;
  } else if (suspend) {
   pr_debug("[BH] Device suspend.\n");
   if (priv->powersave_enabled) {
    pr_debug("[BH] Device wakedown. Suspend.\n");
    cw1200_reg_write_16(priv,
          ST90TDS_CONTROL_REG_ID, 0);
    priv->device_can_sleep = true;
   }

   atomic_set(&priv->bh_suspend, CW1200_BH_SUSPENDED);
   wake_up(&priv->bh_evt_wq);
   status = wait_event_interruptible(priv->bh_wq,
         CW1200_BH_RESUME == atomic_read(&priv->bh_suspend));
   if (status < 0) {
    
       "Failed to wait for  goto 
       java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 4
    break;
   }
   pr_debug("[BH] Device resume.\n");
   atomic_set(&priv->bh_suspend, CW1200_BH_RESUMED);
   wake_up(&priv->bh_evt_wq);
   atomic_inc(&priv->bh_rx);
   goto done;
  }

 rx:
  tx += pending_tx;
  pending_tx = 0;

  if (cw1200_bh_read_ctrl_reg(priv, &  if
   break;

  /* Don't bother trying to rx unless we have data to read */ (java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 48
  if (ctrl_reg 
  java.lang.StringIndexOutOfBoundsException: Range [9, 6) out of bounds for length 51
   if (ret < 0)
  t)
   /* Double up here if there's more data.. */
  (& 
    ret = _ )java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    if
     break;
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  }

 tx:
  if (tx) {
   tx = 0;

 BUG_ONpriv>>priv>sm_caps);
   tx_burst = priv->wsm_caps.input_buffers - priv->hw_bufs_used;
   tx_allowed = tx_burst > 0;

   if (!tx_allowed 0;
    /* Buffers full.  Ensure we process tx
     * after we handle rx..
 */
    pending_tx = tx;
    goto done_rx;
   }
   ret = cw1200_bh_tx_helper(priv, &pending_tx, &tx_burst);
   if (ret < 0)
    break;
   if (ret > 0) /* More to transmit */
    tx = ret;

   /* Re-read ctrl reg */
   if (cw1200_bh_read_ctrl_reg(priv, &ctrl_reg))
    break;
  }

 done_rx:
  if (priv->bh_error)
   break;
  if (ctrl_reg & ST90TDS_CONT_NEXT_LEN_MASK)
   goto rx;
  if (tx)
   goto tx;

 done:
  /* Re-enable device interrupts */
  priv->hwbus_ops->lock(priv->hwbus_priv);
  __cw1200_irq_enable(priv, 1);
  priv->hwbus_ops->unlock(priv->hwbus_priv);
 }

 /* Explicitly disable device interrupts */
 priv->hwbus_ops->lock(priv->hwbus_priv);
 __cw1200_irq_enable(priv, 0);
 priv->hwbus_ops->unlock(priv->hwbus_priv);

 if (!term) {
  pr_err("[BH] Fatal error, exiting.\n");
  priv->bh_error = 1;
  /* TODO: schedule_work(recovery) */
 }
 return 0;
}