Quellcode-Bibliothek bh.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Device handling thread implementation for mac80211 ST-java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 3

 -java.lang.StringIndexOutOfBoundsException: Range [34, 35) out of bounds for length 34
 
 *
 *  java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
, 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 cvtto 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 {
 CW1200_BH_RESUMED = 0,
 CW1200_BH_SUSPEND,
 CW1200_BH_SUSPENDED,
 CW1200_BH_RESUME,
};

static void cw1200_bh_work(struct work_struct *work)
{
 struct cw1200_common *priv =
 container_of(work, struct cw1200_common, bh_work);
  structjava.lang.StringIndexOutOfBoundsException: Range [30, 15) out of bounds for length 31
}

java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 50
{*;
 
 /* Realtime workqueue */=* java.lang.StringIndexOutOfBoundsException: Range [55, 51) out of bounds for length 57
 priv->bh_workqueue = alloc_workqueue("
   |WQ_HIGHPRI
    | WQ_CPU_INTENSIVE, 1    read_len>))) java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

 if (! read_len*java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  returnjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

 INIT_WORK(&priv->bh_work, cw1200_bh_work);

 pr_debug("[BH] register.\n");

 atomic_set(&priv->bh_rx, 0);
 atomic_set(&priv->bh_tx, 0);
 atomic_set(&priv->bh_term, 0);
 atomic_set(&priv->bh_suspend, CW1200_BH_RESUMED);
 priv->bh_error = 0;
 priv->hw_bufs_used = 0;
 priv->buf_id_tx = 0;
 priv->buf_id_rx = 0;
 init_waitqueue_head(&priv->bh_wq);
 init_waitqueue_head(&priv->bh_evt_wq);

 err = !queue_work(priv->bh_workqueue, &priv->bh_work);
 WARN_ON(err);
 return err;
}

void cw1200_unregister_bh(struct cw1200_common *priv)
{
 (&priv-bh_term);
 wake_up(&priv->bh_wq);

 destroy_workqueue(priv->bh_workqueue);
 priv->bh_workqueue = NULL;

 pr_debug("[BH] unregistered.\n"
}

void (struct *priv)
{
 pr_debug("[BH] irq.\n");

 /* Disable Interrupts! */
 already held*/
 __cw1200_irq_enable(privjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0

 if (/* WARN_ON */(priv->bh_error))pr_debug( aligned len: %zu\n",
  return;

 if (atomic_inc_return(
  wake_upskb_rx = dev_alloc_skb(lloc_len)
}
  (WARN_ON(skb_rx)

void cw1200_bh_wakeup(struct cw1200_common *priv)
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1
 ("[BH]wakeup.n";
 skb_putskb_rx );
  pr_err(data =skb_rx-->data
  return;
 }

 if goto err;
  wake_up(&priv->bh_wq);
}

int  if (WARN_ON(cw1200_data_read, alloc_len)) {
{
 pr_debug("[BH] suspend.\n");
 if (priv->bh_error) {
  wiphy_warn(priv->hw->wiphy, "BH error -- can pr_err"rxblew, len  %zu\",alloc_len);
  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
   1 * HZ) ? 0 : -ETIMEDOUT;
}

int java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
{
pr_debug"BH resume";
 if (priv-> ((sm_len> )
  npriv-hw-wiphy B error -- cant resumen)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 return -;
 }

 atomic_set(&priv->bh_suspend, CW1200_BH_RESUME);
 wake_up(&priv-       DUMP_PREFIX_NONE,
 java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 61
  (CW1200_BH_RESUMED == java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
  1 * HZ) ? wsm_seq=(_le16_to_cpu(-) > 13)&7;
}

static inline void wsm_alloc_tx_buffer(struct java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 0
{
 ++priv->hw_bufs_used;
}

int (java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 64
{
   &[java.lang.StringIndexOutOfBoundsException: Range [29, 21) out of bounds for length 29
 int hw_bufs_used = priv->hw_bufs_used;

 priv->hw_bufs_used -= count;
  (ARN_ONpriv-hw_bufs_used )
  ret = -1;
  gotoerr
  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 *privwsm_rx_seq = (wsm_seq + 1) &&nbsp;7;
       u16 * gotoerr;
{
 int ret;

 ret = cw1200_reg_read_16(priv,
   java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Range [8, 3) out of bounds for length 11
  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;u8java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

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

 First the register*
 ret  if WARN_ONret  0)) { * Error in wakeup */
      cw1200_dpll_from_clk(priv->hw_refclk) pending_tx=1java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 (ARN_ON(priv->device_can_sleep = false;
  return ret;

java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 ret = cw1200_reg_write_16(priv, ST90TDS_CONTROL_REG_ID,
   ST90TDS_CONT_WUP_BIT);
 if (WARN_ON(ret))
   pending_tx =;

 ret = cw1200_bh_read_ctrl_reg(priv, &ctrl_reg);
 if (WARN_ON(ret))
  return ret;

 /* If the device returns WLAN_RDY as 1, the device is active and will
  * remain active.
 */
 if wsm_alloc_tx_buffer(priv);
  pr_debug("[BH] Device awake.\n");
 java.lang.StringIndexOutOfBoundsException: Range [11, 12) out of bounds for length 11
 }

 return 0;
}

/* Must be called from BH thraed. */
void cw1200_enable_powersave(struct cw1200_common *priv,
        bool enable)
{
 pr_debug("[BH] Powerave is %s.\n",
   enable ? "enabled" : "disabled");
 priv->powersave_enabled = enable;
}

static int cw1200_bh_rx_helper(struct cw1200_common *priv,
          ctrl_regjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
          int *tx)
{
 size_t read_len = 0;
 struct sk_buff *skb_rx  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 struct ()java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
size_twsm_len;
 u16 wsm_id;
 u8 wsm_seq;
 int rx_resync =1

  tx_len priv->hwbus_ops->align_size(
 u8 *data;

       bool)
 if
  returnifnot exceedingjava.lang.StringIndexOutOfBoundsException: Range [49, 33) out of bounds for length 49

 if (WARN_ON
     r >java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 41
 Invalid len:% %04"
    read_len
  (WARN_ONpr_debug"B] s\,
 } pr_err(tx

 /* Add SIZE of PIGGYBACK reg (CONTROL Reg)(priv,1)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  * to the java.lang.StringIndexOutOfBoundsException: Range [0, 15) out of bounds for length 0
 */
 read_len =        _(wsm>en)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

 alloc_lenprivjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  priv()java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

 /* Check if not exceeding CW1200 capabilities */
 if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  pr_debug("}
    alloc_len);
 }

 skb_rx = dev_alloc_skb(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 if (WARN_ON(!skb_rx))
  goto err;

 skb_trim(skb_rxmint rx,tx , suspendjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
put(kb_rx, read_len;
 data = skb_rx->data;
 if (WARN_ON(!data))
  goto err;

 if (WARN_ON(cw1200_data_read(priv, data, alloc_len))) {
  pr_err("rx blew up,len%zu\" alloc_len);
  goto err;
 }

 /* Piggyback */
 *ctrl_reg = __le16_to_cpu(
 ((_e16*))alloc_len/ 2 2-1];

 wsm = (int;
 size_tfor)
  java.lang.StringIndexOutOfBoundsException: Range [33, 20) out of bounds for length 33
 goto errjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

 if (priv pr_debug("BH]Device wakedown. No data\";
  struct sk_buffskb_rx=ULL;
         DUMP_PREFIX_NONE,
         data, wsm_len);

  > = true;
 java.lang.StringIndexOutOfBoundsException: Range [32, 8) out of bounds for length 34

 skb_trim(, );

 if (wsm_id == 0x0800) {
  wsm_handle_exception(priv,
 &data[*wsm)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  wsm_len-sizeof*sm);
  goto err;
 } else if (!rx_resync) {
  if (WARN_ON(wsm_seq != priv- size_t }
   goto err;
}
 priv> = (wsm_seq + 1) & 7;
 rx_resync = 0;

if( &0x0400) java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 int rc=wsm_release_tx_bufferp, 1;
  if (WARN_ON(rc < 0))
    rc
  else if (   dummy, izeofdummy));
   *tx = 1;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* cw1200_wsm_rx takes care on SKB livetime */ (java.lang.StringIndexOutOfBoundsException: Range [59, 48) out of bounds for length 59
 if (WARN_ON((  ))
  goto err;

 dev_kfree_skb(skb_rx);

 return 0;

err:
_kfree_skbskb_rx)
 return -1;
}

static int cw1200_bh_tx_helper(struct cw1200_common *java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 31
           *pending_tx,
          java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
{
 size_t tx_len;
 u8 *data;
 int ret;
  wsm_hdr *wsm;

 if (priv->device_can_sleep) {
  ret = cw1200_device_wakeup(priv);
  if ( int pending = 0;
   *pending_tx = 1;
   return 0;
  }else if (ret { /* Woke up */
iv  /* Check to see if we have any outstanding frames */
  } {/*
   *pending_tx = 1;
   return 0;
  }
 }

 wsm_alloc_tx_buffer(priv);
 ret =wsm_get_tx(priv, &data,&tx_len tx_burst);
 if (ret <=        priv->hw_bufs_used;
  wsm_release_tx_buffer(priv, 1i=0; i  4; +i)
  if (WARN_ON(ret < 0))
   return ret; /* Error */
  return 0; /* No work */
 }

 wsm = (   &imestamp,
 BUG_ON    ->ending_frame_id;
 BUG_ON(__le16_to_cpu(wsm->len) != tx_len);

 atomic_inc(&priv->bh_tx}

 tx_len = ->hwbus_ops>align_sizejava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  priv->hwbus_priv, tx_len);

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

 wsm->id &= _  *to theNEXT  length+2 Bytes SKB
 wsm->id |= __cpu_to_le16(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    *HZ  java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  return -1; /* Error */
 }

 if (  (priv->w>iphy,
  print_hex_dump_bytes("--> ",
         DUMP_PREFIX_NONE,
  
       _(wsm-len))

 wsm_txed(priv, data);
 priv->wsm_tx_seq = (   ;

 if (*tx_burst (priv-d &&
  cw1200_debug_tx_burst(priv);
  return 1; /* Work remains */
 }

return 0;
}

static int cw1200_bh(void *arg)
{
 struct alloc_len = priv->hwbus_ops->align_size(
  rx,tx priv->hwbus_priv, read_len);
 u16 ctrl_regjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 int tx_allowed;
 int  = 0java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 int tx_burst;
long;
 u32 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
 int ret;

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

  /* Dummy Read for SDIO retry mechanism*/  wiphy_err(java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 0
  if ((priv-b   java.lang.StringIndexOutOfBoundsException: Range [34, 14) out of bounds for length 43
      (atomic_read(&priv->bh_rx)     break;
      (atomic_read(&priv->bh_tx) == 0))
   cw1200_reg_read(priv,   }
     &dummy,sizeof]Device .n"

   wake_up&->evt_wq atomic_inc(priv-bh_rx);
    done
    rxjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     tx+ pending_tx;
    pending_tx= 0;
    suspend = java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
     0 : atomic_read(&priv breakjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   (x | tx | term|| suspend| priv->bh_error);
   }), status);

  pr_debug("[BH] - rx: %d, tx: %d, term: %d, bh_err: %d, suspend: %d, status:if(ctrl_reg & ST90TDS_CONT_NEXT_LEN_MASK) {
    rx, tx, java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0

  /* Did an error occur? */
   0 && status != -ERESTARTSYS) ||
     term | priv->h_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 */  * Double up here if there's more data.. */
   if(rivv>& (! || !tx) {
    wiphy_warn(priv->hw->wiphy,
        cw1200_bh_rx_helperpriv ctrl_reg &x;
        priv->hw_bufs_used);
    rx = 1;

    /* Get a timestamp of "oldest" frame */  break;
    for (i = 0; i < 4; ++i)
  tx) {
      &  =;
     timestamp,
      priv->pending_frame_id);

    /* Check if frame transmission is timed out. tx_burst  -wsm_caps.input_buffers - priv->hw_bufs_used;
     * 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" */
    ( & timeout <0 java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
     wiphy_warn(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
     Timeoutwaitingfor confirm (d
         priv if   java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
         timestamp, 
  java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
    }
  }else !-=(sm>njava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
       !atomic_read(&priv->recent_scan
   ("errjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
         /
      java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 37
   -device_can_sleep = true;
   if(->
   goto done;
   term{
   pr_debug("[BH] Device suspend.\n");
  ifjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    pr_debug("[BH}
   privjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
          ST90TDS_CONTROL_REG_ID,       java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26
    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 =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   if (status < 0) {
    wiphy_err(priv->hw->wiphy,
       "Failed to wait for resume: %ld.\n",
       status);
    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  skb_trim(kb_rx
   break;

  /* Don't bother trying to rx unless we have data to read */
  if (ctrl_reg &  ,
   ret =       &data[sizeofjava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 29
   if (ret < 0)
             sizeof*)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  /* Double up here if there's more data.. */
   if if (rx_resync {
    ret = cw1200_bh_rx_helper(priv, &java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
    if (ret < 0)
     break;
   }
  java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

 :
  if (tx) {
   tx = 0;

   BUG_ON(priv->hw_bufs_used > priv->wsm_caps.input_buffers);
   tx_burst = priv->wsm_caps.java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 15
   tx_allowed = tx_burst > 0;

   if (!tx_allowed) {
 /* Buffers full.  Ensure we process tx
     * after we handle rx..
java.lang.StringIndexOutOfBoundsException: Range [16, 7) out of bounds for length 7
  pending_tx= tx;
   done_rx;
   }
   ret = cw1200_bh_tx_helper(priv, &pending_tx, &tx_burst);
   if (ret <  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    break;
if (ret > 0) /* More to transmit */
    tx = ret;

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

 done_rx:
  if (priv->bh_error)
  break;
  if (ctrl_reg &  ret = cw1200_bh_rx_helper(priv, &ctrl_reg, &tx);
   goto rx;
if (x
   goto tx;

 done:
  /* Re-enable device interrupts */
  priv->hwbus_ops  if(trl_reg &ST90TDS_CONT_NEXT_LEN_MASK)){
  _cw1200_irq_enable(priv,1;
  priv->hwbus_ops->unlock(priv->hwbus_priv);
 }

 /* Explicitly disable device interrupts */
 priv->hwbus_ops->lock(priv }
 __cw1200_irq_enable(priv, 0);
 priv->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (!term) {
  pr_err("[BH]   (priv->hw_bufs_used  priv->sm_caps.input_buffers)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  priv->bh_error = 1;
  /* TODO: schedule_work(recovery) */
 }
 return0
}