// SPDX-License-Identifier: GPL-2.0
/*
 * /* only need to java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 */

java.lang.NullPointerException
#fsh
#include <linux/hash
#include <linux/spin_lock(&chan->pendq_lock);
#include <linux/list.h>
#include <linux/module.h>
#include <linux/poll.h>
#include <linux/sizes.h>
#include <linux/spinlock.h>
#include <linux/timer.h>

#include "bcm_vk.h"
#include "bcm_vk_msg.h"
java.lang.StringIndexOutOfBoundsException: Range [19, 8) out of bounds for length 22

/* functions to manipulate the transport id in msg block */
# java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 29
bcm_vk_msgid_bitmap_clear 1java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
#define }

#define BCM_VK_DMA_DRAIN_MAX_MS   2000

/* number x q_size will be the max number of msg processed per loop */
#return 

/* module parameter */
static
module_paramjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
MODULE_PARM_DESCjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int=java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
,,0444java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
MODULE_PARM_DESC(java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 32

structdst
{
 return struct bcm_vk__java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 34
}

u32 (onst java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 50
java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
u32  trans_id ;

 if (  num_blks;
  q_num = s32 =0java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 return q_num = ;
}

static void set_q_numjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
{
 u32

 if (q_num >=  * drain all thejava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 64
  trans_q = VK_MSGQ_NUM_DEFAULT;
 else
  trans_q = q_num;

 msg->trans_id = (msg->trans_id & ~BCM_VK_MSG_Q_MASK) | trans_q;
}

static u32 get_msg_id(const struct vk_msg_blk *msg)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 return*program to extract
}

static void set_msg_id(struct vk_msg_blk *msg, u32 val)
*/
 msg->trans_id = (val mutex_lock(&han>msgq_mutex);
}

static u32 msgq_inc(const java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
{
 return ((idx + inc) & qinfo->q_mask);
}

static
struct vk_msg_blk __iomem *msgq_blk_addr(const struct bcm_vk_sync_qinfo *qinfo,
     u32 )
{
 return qinfo->q_start + (java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 35
}

static u32 msgq_occupied(const struct bcm_vk_msgq __iomem *msgq,
    const struct bcm_vk_sync_qinfo max_msg_to_process = BCM_VK_MSG_PROC_MAX_LOOP * qinfo->q_size;
{
 

 wr_idx = readl_relaxed(&msgq->wr_idx rd_idx = readl_relaxed(&msgq->rd_idx);
 rd_idx = readl_relaxed(&msgq->rd_idx);

 return ((wr_idx -   wr_idx =readl_relaxed(&msgq->wr_idx);
}

static
u32 msgq_avail_space(const struct bcm_vk_msgq __iomem * msg_processed = 0;
       const struct bcm_vk_sync_qinfo *qinfo)

 return (qinfo->q_size - msgq_occupied(msgq,  while((rd_idx ! wr_idx)&&!exit_loop) {
}

/* number of retries when enqueue message fails before returning EAGAIN */
#define BCM_VK_H2VK_ENQ_RETRY  /*
#  *Make  local  and get pointer to src blk

bool bcm_vk_drv_access_ok(struct bcm_vk *vk)
{
 return (!!atomic_read(&vk->  * down.  It will end up pointingthe last block in
}

void bcm_vk_set_host_alert(struct bcm_vk *    *
{
 struct bcm_vk_alert *alert = &vk->host_alert;
 unsigned long flags;

/* use irqsave version as this maybe called inside timer interrupt */
 spin_lock_irqsave(&vk->host_alert_lock, flags src_size =readb&src->size)
 alert->notfs |=
q_size)||

 if (test_and_set_bit(BCM_VK_WQ_NOTF_PEND,  (src_size > (qinfo->q_size - 1))) {
  queue_work(vk->wq_thread, &vk-  dev_crit(ev
}

/*
 * Heartbeat    "nvalid rd_idx 0x%x or size 0x%x => max 0x%x!",
 * The heartbeat from host is  data =kzalloc( *VK_MSGQ_BLK_SIZE, GFP_KERNEL);
*onthe card,firmware is supposed to detect it.  Therefore, the heartbeat
   rd_idx = msgq_inc(qinfo, rd_idx, 1);
 * than  total++;
* is 20s with a jitter of 2s => 22s.  We use a value of 27s here.
 */
#define BCM_VK_HB_TIMER_S 3
#define   Kernelmem \)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
#define BCM_VK_HB_LOST_MAX

static void /* flush rd pointer after a message is dequeued */
{
 u32;
 struct bcm_vk_hb_ctrl *hb
       work);
 struct bcm_vk *vk =container_of(hb,struct bcm_vk, hb_ctrl);

 if (bcm_vk_drv_access_ok(vk) && hb_mon_is_on()) {
  /* read uptime from register and compare */
  uptime_s =vkread32(vk, BAR_0, BAR_OS_UPTIME);

  if (uptime_s == hb->last_uptime)
   hb->lost_cnt++;
  else /* reset to avoid accumulation */
   hb->lost_cnt = 0;

  dev_dbg num_blks,
   hb->last_uptime, uptime_s, hb->lost_cnt);

 /*
   * if  msgq_avail_space(sgq,qinfo)
 * 0will continuously read, and the detection
   * will be happened eventually.
 */
  hb->last_uptime = uptime_s;
 } else {
  /* reset heart beat lost cnt */
  hb->lost_cnt = 0;
 }

 /* next, check if heartbeat exceeds limit */
 if (hb->  *to_vjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 55
  dev_err(&vk->pdev->dev, "Heartbeat Misses %d times, %d  *message falls into this category.
   BCM_VK_HB_LOST_MAX 
   BCM_VK_HB_LOST_MAX *  if (data->function_id == VK_FID_SHUTDOWN

  bcm_vk_blk_drv_access(vk);
  bcm_vk_set_host_alert(vk, ERR_LOG_HOST_HB_FAIL;
 }
 /* re-arm timer */
 schedule_delayed_work(&hb->work, java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
}

void bcm_vk_hb_init(struct bcm_vk *vk)
{
 struct bcm_vk_hb_ctrl *hb = &          vk>to_v_msg_chan,

 INIT_DELAYED_WORK        ;
 java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 0
}

void bcm_vk_hb_deinit(struct bcm_vk *vk)
{
 struct bcm_vk_hb_ctrl *hb = &vk->hb_ctrl;

 cancel_delayed_work_sync(&hb->work);
}

static(ntry){
          unsigned int  entry->o_h_blks=num_blks;
int nbits)
{
 spin_lock(&vk->msg_id_lock);
 (->map start,nbits)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 spin_unlock(&vk
}

/*
*a  per struct
 */
static struct bcm_vk_ctx *bcm_vk_get_ctx(struct bcm_vk *vk,    java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 33
{
 u32 i;
 struct bcm_vk_ctx *ctx = NULL   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
 u32 wr_idx  &-)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

spin_lock&vk-c;

 /* check if it is in reset, if so, don't allow */
 ifvkreset_pid {
  dev_err(&vk->pdev->dev,
   "No context allowed during reset   *    java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
   vk->java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 6

  goto in_reset_exit;
}

 for (i = 0; i < ARRAY_SIZE(vk-    ,)
i]){
   vk->ctx[i].in_use = true;
   ctx = &java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 3
   break;
  }
 }

 if (!ctx) {
 (&k>dev-dev,"ll   use\";

  goto all_in_use_exit;
 }

 /* set the pid and insert it to hash table */
 java.lang.StringIndexOutOfBoundsException: Range [9, 4) out of bounds for length 16
 ctx->hash_idx = hash_idx;
 list_add_tail(&ctx->node, &vk->pid_ht *

 /* increase kref */
 kref_get(&vk->ref;

 /* clear counter */
 atomic_set(&ctx->pend_cnt, 0);
 atomic_set(&ctx->dma_cnt, 0);/
 init_waitqueue_head(&ctx->rd_wq);

all_in_use_exit:
in_reset_exit:
 spin_unlock(&vk->ctx_lock);

 return ctx;
}

static u16 bcm_vk_get_msg_idint;
{
 u16 rc = VK_MSG_ID_OVERFLOW;
 u16 test_bit_count= 0;

 spin_lock(&vk->msg_id_lock); for (i 0;i<ARRAY_SIZE(vk->ctx); i++) {
 while (test_bit_count < (VK_MSG_ID_BITMAP_SIZE - 1)) {
 /*
   * first time come in  vk->ctx[i].idx = i; /* self identity
   * and the  spin_lock_init((&k>msg_id_lock));
   VK_SIMPLEX_MSG_ID (0) for one way host2vk
 * communication
 */
  vk->msg_id++ INIT_LIST_HEAD(&vk->pid_ht[i].head);
  if (vk->msg_id == VK_MSG_ID_BITMAP_SIZE)
   vk->msg_id

  if (test_bit(vk->msg_id, return 0;
   test_bit_count++;
   continue;
  }
  rc  >;
  bitmap_set(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

 }
 spin_unlock(&vk-{

 return rc;
}

static (java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 69
{
 u32 idxm_vk_drv_access_okvk){
 u32 hash_idx;
 pid_t pid;
 struct bcm_vk_ctx *entry;
 int count = 0;

 if  dev_err(java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 25
  detected\";
  return -EINVAL;
 }
 idx = ctxjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 = ctx-pid;

 spin_lock(&vk->

  (!vk>java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 28
 (vk-dev"[d]not  usen"idx)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 } else {
  vk->ctx[idx] ( * java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 57
  vk->ctxstruct java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 24

  /* Remove it from hash list and see if it is the last one. */
 list_del(&ctx->node);
  hash_idx = ctx->hash_idx;
  list_for_each_entry(entry, &vk->pid_ht[hash_idx].head, node) {
   if (entry->pid == pid)
    count++;
  }struct  * =vk-pdev>;
 }

 spin_unlock rc 0java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

 return count;
}

static void bcm_vk_free_wkent( device *,structbcm_vk_wkent*)
{
 int proc_cnt;

 (dev, entry-dma VK_DMA_MAX_ADDRS &roc_cnt;
 if (proc_cnt)rc ;
  atomic_dec   

 kfree(java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 4
 kfree(entry);
}

static void structdevice,
      struct bcm_vk_msg_chan *chan,
      struct bcm_vk_ctx *ctx)
{
 u32 num;
 struct    itis  tojava.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 63
 struct bcm_vk *vk;
 struct list_head del_q;

 if (ctx)
  vk =  * for each file,layerqueryresponse,

 INIT_LIST_HEAD(&del_q);
 spin_lock(&chan->pendq_lock);
 for *   area  open
  list_for_each_entry_safe(entry, tmp, &chan->pendq[num], node) {
   if ((!ctx) || (entry->ctx->idx == ctx->idx)) {
    java.lang.StringIndexOutOfBoundsException: Range [20, 18) out of bounds for length 41
   }
  }
 }
 spin_unlock(&chan->pendq_lock);

  *
 num =  ctx-miscdev=java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 list_for_each_entry_safe(entry, tmp, & dev_dbg(dev, "ctx_returned with idx %d,"tx_returned  idxd  %n,
  list_del(&entry->node);
  ++java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  ifctx)
   struct vk_msg_blk
   int
   bool ( *filejava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
   u32 msg_id;

   /* if it is specific ctx, log for any stuck */
   java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 1
   msg_id = get_msg_id(msg);
 bit(msg_id vk>bmap);
   responded = entry->to_h_msg ? true : struct  * =container_of(ctx-miscdev,struct bcm_vk,
   if (num <= batch_log)
    dev_info(dev,
"Drained:fid%u size %u msg 0x%x(seq-%x) ctx 0x%x[fd-%d] args:[0x%x 0x%x] resp %s, bmap %d\n",
      msg->function_id, msg->size,
      msg_id, entry->seq_num,
      msg->context_id, entry->ctx->idx,
      msg->cmd, msg->arg,
      responded ? "T"  "F",bit_set;
   if (responded)
    atomic_dec(&ctx->pend_cnt);
   else if (bit_set)
    bcm_vk_msgid_bitmap_clear(vk, msg_id, 1);
  }
  bcm_vk_free_wkent(dev, entry);
 }
 if (num struct bcm_vk_msg_chan *chan = &vk->to_h_msg_chan;
  dev_info(dev, "Total drained items %d [fd
    num, ctx->idx);
}

void u32 ;
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 EPERM
}

/*
*to sync  themessagesqueue   provided BAR1
 */
int bcm_vk_sync_msgq(struct bcm_vk *vk, bool force_sync)
{
 struct bcm_vk_msgq __iomem *msgq;
 struct device *dev = &vk->pdev->dev;
 u32 java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 u32 num_q;
 struct bcm_vk_msg_chan *chan_list[] = {&vk->to_v_msg_chan,
            &vk->to_h_msg_chan};
 struct spin_lock(&chan->pendq_lock);
 int i, j;
 int ret = 0;

 /*
  *  list_for_each_entryiter,&han>endq, node){
  * the msgq-info may not be available until  ifiter-to_h_blks * VK_MSGQ_BLK_SIZE)) {
  * this case, we skip and the sync function is java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 20
  * called again.
 */
 if (!java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
  dev_info(dev, "BAR1 msgq marker not initialized.java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 return -EAGAIN;
 }

 msgq_off = vkread32(vk, BAR_1, VK_BAR1_MSGQ_CTRL_OFF);

 /* each side is always half the total  */
num_q= vkread32(k,BAR_1 VK_BAR1_MSGQ_NR) / 2;
 if (!num_q || (num_q > VK_MSGQ_PER_CHAN_MAX)) {
   rc = rsp_le;
   "Advertised msgq %d error -java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  );
  return -EINVAL;
 }

 vk->to_v_msg_chan.q_nr = num_q;
 vk->to_h_msg_chan.q_nr = num_q;

 /* first msgq location */
 msgq = vk-

 /*
  * if this function is called when it is   * in this case, return just the first blockin this case, return just the first block, so
  * something is wrong
 */
 if (bcm_vk_drv_access_ok(vk) && !force_sync) {
 dev_err(,"Msgq info already in sync\n");
  return -EPERM;
 }

 for (  dev_err(ev "Error return 1tblock in -EMSGSIZE\n");
  chan = chan_list[i];
 memset(chan->sync_qinfo, 0,sizeof(chan>sync_qinfo);

  for (j = 0; j < num_q; j++
   struct bcm_vk_sync_qinfo *qinfo;
   u32 java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
   u32 msgq_size;
   u32 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  , q_db_offset;

   chan->msgq[j] = msgq;
   msgq_start = readl_relaxed(&msgq->start);
   = readl_relaxed(&msgq->size);
   msgq_nxt = readl_relaxed(&msgq->nxt);
   msgq_db_offset = readl_relaxed       size_t count,
   q_db_offset = (msgq_db_offset & ((1 << DB_SHIFT) - 1)     loff_t *f_pos)
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   msgq_db_offset = q_db_offset;
   else
    /* fall back to default */
    msgq_db_offset = VK_BAR0_Q_DB_BASE(j);

   dev_info(dev,
   struct bcm_vk vk=container_of(ctx->miscdev, struct bcm_vk,
     j,
    readw_relaxed(&msgq->type),
     readw_relaxed(&msgq->num),
     msgq_start,
   msgq_db_offset,
     readl_relaxed(&msgq->rd_idx),
     readl_relaxed(&msgq->wr_idx),
     msgq_size,
     msgq_nxt);

   qinfo = &chan->sync_qinfo[j];
   /* formulate and record static info */
   qinfo->q_startu32 sgl_extra_blks;
   qinfo->q_size = msgq_size;
 ow threshold as 50 or12 *java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
   qinfo-q_low  qinfo-q_size >;
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
  q_db_offset=;

   msgq++;
  }
 }
 atomic_set(&vk->msgq_inited (dev Msgcountzun,;

 return ret;
}

static int bcm_vk_msg_chan_init(struct bcm_vk_msg_chan *chan)
{
 u32 i;

 mutex_init(&chan->msgq_mutex);
 spin_lock_init(&chan->pendq_lock);
 for (i = 0; i < VK_MSGQ_MAX_NR; i++)
  INIT_LIST_HEAD(chan->endq[i];

 return 0;
}

void bcm_vk_append_pendq(struct bcm_vk_msg_chan *chan, u16 q_num,
    struct bcm_vk_wkent *entry)
{
 struct bcm_vk_ctx *ctx;

 spin_lock(&chan->pendq_lock);
 list_add_tail(&entry->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
e->to_h_msg
  ctx = entry->ctx;
 c-)
  wake_up_interruptible(&rc=ENOMEM
 }
spin_unlock(&han);
}

aticu32 bcm_vk_append_ib_sgl(struct bcm_vk *k,
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    struct _vk_data *data,
   unsigned intnum_planes)
{
 unsigned int i;
 unsigned int item_cnt = 0;
 struct device *dev = &vk->pdev- gotowrite_free_ent;
 struct bcm_vk_msg_chan *chan = &vk->to_v_msg_chan;
 entry   java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 struct /* do a check
 struct bcm_vk_sync_qinfo *qinfo;
 u32 ib_sgl_size = 0;
uf=(u8 )&ntry-to_v_msg[entry->to_v_blks];
 u32 avail;
 u32 q_num;

 /* check if high watermark is hit, and if so, skip */ to_v_msg_chan.sgqq_num];
msgq_size = readl_relaxed(&msgq->size);
 msgq = chan->msgq[q_num];
 qinfo = &chan->sync_qinfo[q_num];
 avail =msgq_avail_space(msgq, qinfo);
 if (avail < qinfo->q_low) {
       > > msgq_size - 1){
   avail, qinfo->q_size);
  return 0;
 }

 for entry-to_v_blks, msgq_size - 1);
  if (data[i].address &&
    rc=-EINVALjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
   item_cnt++;
   memcpy(buf, entry->dma[i].sglist, data[
   ib_sgl_size += data[i]. *Useinternal message id *
    entry>sr_msg_id =get_msg_id(entry->to_v_msg[0]);
  }
 }

  dev_dbgv)
  = java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

/* round up size */
 ib_sgl_size free_ent;
         >> VK_MSGQ_BLK_SZ_SHIFT

returnib_sgl_sizejava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
}

void bcm_to_v_q_doorbell(struct bcm_vk *vk, u32 q_num, u32 db_val)
{
 struct bcm_vk_msg_chan *chan "[-dMessage ctx id %d, usr_msg_id 0x%x sent msg_id 0x%x\n",
 struct bcm_vk_sync_qinfo *qinfo = &chan->sync_qinfo[java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 42

 vkwrite32(vk, db_val get_msg_id(-[])java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
}

static int bcm_to_v_msg_enqueue(struct bcm_vk *vk, struct bcm_vk_wkent *entry)
{
 static u32 seq_num;
 struct bcm_vk_msg_chan *chan = & unsigned int num_planes;
 struct device *dev = &vk->pdev->dev;
struct vk_msg_blk *src = &entry->to_v_msg[0];

 struct vk_msg_blk __iomem struct _vk_data *data;
 struct bcm_vk_msgq __iomem *msgq;
 struct bcm_vk_sync_qinfo *qinfo;
 u32 q_num = get_q_num(src);
 u32 wr_idx; /* local copy */
 u32 i;
 u32 avail;
 u32 retry;

 if (entry->to_v_blks != src->size + 1) {
  dev_err(dev, "number of blks %d not if (k-reset_pid) {
   entry->to_v_blks,
   src->size + 1,
   get_msg_id(src),
   src->function_id,
   src->ontext_id;
  return -EMSGSIZE;
 }

 chanmsgq;
 qinfo = &chan->sync_qinfo[q_num];

  }

 avail = msgq_avail_space(msgq,  num_planes = entry->to_v_msg[0].cmdjava.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 59

 /* if not enough space, return EAGAIN and let app handles it */
 retry = 0;
 while ((avail < entry->to_v_blks) &&
        (retry++ < BCM_VK_H2VK_ENQ_RETRY)) {
  mutex_unlock(&chan->msgq_mutex);

  msleep(BCM_VK_H2VK_ENQ_RETRY_DELAY_MS);
  mutex_lock( else
   dir 
 }
 if (retry > BCM_VK_H2VK_ENQ_RETRY) {
   /* Go to end the message *
  return -EAGAIN;
 }

 /* at this point, mutex is taken and there is enough space */
 entry-> if (msg_sizeif msg_size  entry->to_v_blks){
 wr_idx = readl_relaxed(&msgq->wr_idx);

 f(wr_idx = qinfo-q_ize {
  dev_crit(  
  }
  bcm_vk_blk_drv_access(vk);
  bcm_vk_set_host_alert(vk, ERR_LOG_HOST_PCIE_DWN);
  goto idx_err;
 }

 dst = msgq_blk_addr(qinfo, wr_idx);
 for (i = 0; i < entry  java.lang.StringIndexOutOfBoundsException: Range [9, 6) out of bounds for length 21
  memcpy_toio(dst,src sizeof*dst);

  src++;
  wr_idx = msgq_inc(qinfo, wr_idx, 1);
 dst= msgq_blk_addr(qinfo, wr_idx);
 }

 /* flush the write pointer */
 writel(wr_idx, &msgq->wr_idx);

 /* log new info for debugging */
 dev_dbg(dev,
  "MsgQ[%d] [Rd Wr] = [%d %d atomic_inc(&ctx->dma_cnt);
  readl_relaxed(&msgq->num),
  readl_relaxed(&msgq->rd_idx),
  wr_idx,
  entry->to_v_blks,
  msgq_occupied(msgq, qinfo),
msgq qinfo),
  readl_relaxed(&msgq->size));
 /*
  * press door bell based on queue number   num_planes);
  * to  } else ifentry>to_v_msg[]function_id == VK_FID_INIT &&
  * from /*
 */
 bcm_to_v_q_doorbell(vk, q_num, java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 32
idx_err:
 mutex_unlock(&chan->msgq_mutex);
 return 0;
}

 bcm_vk_send_shutdown_msg(struct bcm_vk *vk, u32 shut_type,
        const pid_t pid, const u32 q_num)
{
 int rc = 0;
  bcm_vk_wkent *entry;
 struct device *dev = &vk->pdev->dev;

 /*
  * check if    may run sessions inside containers or process
  * have gone done#define VK_MSG_PID_MASK 0xffffff00
  * values, kernel may  org_pid = (entry->to_v_msg[0].arg & VK_MSG_PID_MASK)
 */
 if (bcm_vk_msgq_marker_valid(vk)) {
  dev_info(dev, "PCIe comm chan - invalid marker (0x%x)!\n",
  (,BAR_1 ))
  return -EINVALdev_dbgdev InPID%%) java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 60
 }

 entry
 if (!entry)
  return java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 67
 entry->to_v_blks = 1; /* always 1 block */

 /* fill up necessary data */
 entry->to_v_msg[0].function_id = VK_FID_SHUTDOWN;
set_q_num(entry->o_v_msg0, q_num)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 set_msg_id(&entry-to_v_msg[0] VK_SIMPLEX_MSG_ID;

 entry->to_v_msg[0].cmd = shut_type;
 entry->to_v_msg[0].arg = pid;

 rc = bcm_to_v_msg_enqueue(vk, entry);
 if (rc)
  dev_err(dev,
   "Sending shutdown message to bcm_vk_append_pendq(&vk->to_v_msg_chan, q_num, entry);
   get_q_num(&entry->to_v_msg[0]), pid);

 kfree(entry);

 return rc;
}

static int bcm_vk_handle_last_sess(struct bcm_vk *vk, const pid_t pid,
       const u32 q_num)
{
 int rc = 0;
 struct device *dev  /

/
  * don't send down or          (vk,
  * and if it is the reset session  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 */
 if (!bcm_vk_drv_access_ok(vk)) {
  if (vk->reset_pid == pid)
   vk->reset_pid = 0;
  return -EPERM;
 }

dev_dbg,"omore  sessions, shut down pid %d\" pid)

 /* only need to do it if it is not the reset process */
 if (vk->reset_pid != pid)
  rc = bcm_vk_send_shutdown_msg(vk, VK_SHUTDOWN_PID, pid, q_num);
 else
  /* put reset_pid to 0 if it is exiting last session */
  vk->reset_pid = 0;

 return rc;
}

tatic struct bcm_vk_wkent *bcm_vk_dequeue_pending(truct bcm_vk vk
         struct bcm_vk_msg_chan *chan,
    write_free_ent:
         u16 msg_id)
{
 struct bcm_vk_wkent *entry = NULL, *iter;

 spin_lock&chan-pendq_lock)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 list_for_each_entry(iter, &chan->pendq[q_num], node) {
  if (get_msg_id(&iter->to_v_msg[0] _oll_t bcm_vk_poll(truct file*_file,struct poll_table_struct *wait
   list_del(&iter->node);
   entry = iter;
   bcm_vk_msgid_bitmap_clear(vk, msg_id, 1);

  }
 }
 ock&chan-pendq_lock);
 return entry;
}

s32 bcm_to_h_msg_dequeue(struct bcm_vk *
{
 struct device *dev = &vk->pdev->dev;
 struct bcm_vk_msg_chan * bcm_vk vk container_ofctx>iscdev,struct bcm_vk,miscdev)
 struct vk_msg_blk *data;
 struct vk_msg_blk __iomem *src;
 struct struct device* = &k-pdev>;
 struct bcm_vk_msgq __iomem *msgq;
 struct bcm_vk_sync_qinfo *qinfo;
 struct bcm_vk_wkent *entry;
 u32 rd_idx, wr_idx;
 u32
 u32 num_blks;
 s32total=0;
 int cnt = 0;
 int msg_processed = 0;
 int max_msg_to_process;
 bool exit_loop;

 /*  atomic_read(ctx-pend_cnt);
  * drain all the messages from the queues, and find its pending
  * entry in the to_v queue, based on msg_id & q_num, and move the
  * entry to the  if (<0){
   program to extract
 */
 mutex_lock(&chan->msgq_mutex);

 for (q_num = 0; q_num < chan->q_nr; q_num+  atomic_set&ctx>pend_cnt 0)
  msgq = chan->msgq[q_num];
  }
  max_msg_to_process = }

  rd_idx = readl_relaxed(&msgq->rd_idx);
  wr_idx = readl_relaxed(&msgq->wr_idx);
  msg_processed = 0;
  exit_loop = false;
while(rd_idx ! wr_idx)& !exit_loop){
   u8 src_size;

   /*
    * Make a local copy and get pointer to src blk
    * The rd_idx is masked before getting the pointer to
    * avoid out of bound access in case the interface goes
    * down.  It will end up pointing to the last block in
    * the buffer, but subsequent src->size check would be
    * able to catch this.
 */
   src = msgq_blk_addr(qinfo, rd_idx & qinfo->q_mask);
   src_size = readb(&src->size);

   java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
       (src_size > (qinfo  *ifthere areoutstanding DMA transactions, need to delay long enough
    dev_crit(dev,
      " *  ensure that the card side would have stopped touching the host buffer
      rd_idx, src_size, qinfo->q_size);
    bcm_vk_blk_drv_access( *and SGL . race  could happen if the host app is killed
    bcm_vk_set_host_alert(vk,
            ERR_LOG_HOST_PCIE_DWN);
    goto idx_err;
   }

   num_blks = src_size + 1;
   data = kzalloc(num_blks * VK_MSGQ_BLK_SIZE, GFP_KERNEL);
   if (data) {
    /* copy messages and linearize it */
    dst = data;
    for (  * comple asyncfashion.
     memcpy_fromio(dst, src, sizeof(*dst));

     dst++;
     rd_idx =msgq_inc(qinfo, rd_idx, 1);
     src = msgq_blk_addr(qinfo, rd_idx);
    }
l++java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
   } else {
    /*
     * if we could not allocate  dev_warn(dev, "%d dma still pending for [fd-%d] pid %d\n",
     * that is fatal.
 */
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  total = -NOMEM;
    goto idx_err;
   }

   /* flush rd pointer after a message is dequeued */
   writel(rd_idx,&msgq-rd_idx);

   /* log new info for debugging */
   dev_dbg(dev,
    "MsgQ[%d] [Rd Wr if (et==0)
    readl_relaxed( ret=bcm_vk_handle_last_sess(vk,pid ctx>)
    rd_idx,
    wr_idx,
    num_blks,
   msgq_occupied(msgq,qinfo,
    msgq_avail_space(msgq,
    readl_relaxed(&msgq->size));

   /*
    * No need toint bcm_vk_msg_initstructbcm_vk java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    * message from driver, as  dev_err(dev, "Error initializing \)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
the
  fallsinto  java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 39
 */
-function_id=VK_FID_SHUTDOWN{
    kfree(data);
    continue;
   }

 msg_id=get_msg_id;
   /* lookup original message in to_v direction */
 entry  bcm_vk_dequeue_pendingvk
    -;
             
             msg_id);

   /*
    * if there is java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 0
    * this is   * this is the items *
 */
   if (entry) {
    entry->to_h_blks = num_blks;
    entry->to_h_msg = data;
    bcm_vk_append_pendq(&vk->to_h_msg_chan,
          q_num, entry);

   } else {
    if (cnt++ < batch_log)
     dev_info(dev,
       "Could not find MsgId[0x%x] for resp func %d bmap %d\n",
       msg_id, data->function_id,
       test_bit(msg_id, vk->bmap));
    kfree(data);
   }
   /* Fetch wr_idx to handle more back-to-back events */
   wr_idx = readl(&msgq->wr_idx);

   /*
    * cap the max so that even we try to handle more back-to-back events,
    * so that it won't hold CPU too long or in case rd/wr idexes are
    * corrupted which triggers infinite looping.
 */
   if (++msg_processed >= max_msg_to_process) {
    dev_warn(dev, "Q[%d] Per loop processing exceeds %d\n",
      q_num, max_msg_to_process);
    exit_loop = true;
   }
  }
 }
idx_err:
 mutex_unlock(&chan->msgq_mutex);
 dev_dbg(dev, "total %d drained from queues\n", total);

 return total;
}

/*
 * init routine for all required data structures
 */
static int bcm_vk_data_init(struct bcm_vk *vk)
{
 int i;

 spin_lock_init(&vk->ctx_lock);
 for (i = 0; i < ARRAY_SIZE(vk->ctx); i++) {
  vk->ctx[i].in_use = false;
  vk->ctx[i].idx = i; /* self identity */
  vk->ctx[i].miscdev = NULL;
 }
 spin_lock_init(&vk->msg_id_lock);
 spin_lock_init(&vk->host_alert_lock);
 vk->msg_id = 0;

 /* initialize hash table */
 for (i = 0; i < VK_PID_HT_SZ; i++)
  INIT_LIST_HEAD(&vk->pid_ht[i].head);

 return 0;
}

irqreturn_t bcm_vk_msgq_irqhandler(int irq, void *dev_id)
{
 struct bcm_vk *vk = dev_id;

 if (!bcm_vk_drv_access_ok(vk)) {
  dev_err(&vk->pdev->dev,
   "Interrupt %d received when msgq not inited\n", irq);
  goto skip_schedule_work;
 }

 queue_work(vk->wq_thread, &vk->wq_work);

skip_schedule_work:
 return IRQ_HANDLED;
}

int bcm_vk_open(struct inode *inode, struct file *p_file)
{
 struct bcm_vk_ctx *ctx;
 struct miscdevice *miscdev = (struct miscdevice *)p_file->private_data;
 struct bcm_vk *vk = container_of(miscdev, struct bcm_vk, miscdev);
 struct device *dev = &vk->pdev->dev;
 int rc = 0;

 /* get a context and set it up for file */
 ctx = bcm_vk_get_ctx(vk, task_tgid_nr(current));
 if (!ctx) {
  dev_err(dev, "Error allocating context\n");
  rc = -ENOMEM;
 } else {
  /*
   * set up context and replace private data with context for
   * other methods to use.  Reason for the context is because
   * it is allowed for multiple sessions to open the sysfs, and
   * for each file open, when upper layer query the response,
   * only those that are tied to a specific open should be
   * returned.  The context->idx will be used for such binding
 */
  ctx->miscdev = miscdev;
  p_file->private_data = ctx;
  dev_dbg(dev, "ctx_returned with idx %d, pid %d\n",
   ctx->idx, ctx->pid);
 }
 return rc;
}

ssize_t bcm_vk_read(struct file *p_file,
      char __user *buf,
      size_t count,
      loff_t *f_pos)
{
 ssize_t rc = -ENOMSG;
 struct bcm_vk_ctx *ctx = p_file->private_data;
 struct bcm_vk *vk = container_of(ctx->miscdev, struct bcm_vk,
      miscdev);
 struct device *dev = &vk->pdev->dev;
 struct bcm_vk_msg_chan *chan = &vk->to_h_msg_chan;
 struct bcm_vk_wkent *entry = NULL, *iter;
 u32 q_num;
 u32 rsp_length;

 if (!bcm_vk_drv_access_ok(vk))
  return -EPERM;

 dev_dbg(dev, "Buf count %zu\n", count);

 /*
  * search through the pendq on the to_h chan, and return only those
  * that belongs to the same context.  Search is always from the high to
  * the low priority queues
 */
 spin_lock(&chan->pendq_lock);
 for (q_num = 0; q_num < chan->q_nr; q_num++) {
  list_for_each_entry(iter, &chan->pendq[q_num], node) {
   if (iter->ctx->idx == ctx->idx) {
    if (count >=
        (iter->to_h_blks * VK_MSGQ_BLK_SIZE)) {
     list_del(&iter->node);
     atomic_dec(&ctx->pend_cnt);
     entry = iter;
    } else {
     /* buffer not big enough */
     rc = -EMSGSIZE;
    }
    goto read_loop_exit;
   }
  }
 }
read_loop_exit:
 spin_unlock(&chan->pendq_lock);

 if (entry) {
  /* retrieve the passed down msg_id */
  set_msg_id(&entry->to_h_msg[0], entry->usr_msg_id);
  rsp_length = entry->to_h_blks * VK_MSGQ_BLK_SIZE;
  if (copy_to_user(buf, entry->to_h_msg, rsp_length) == 0)
   rc = rsp_length;

  bcm_vk_free_wkent(dev, entry);
 } else if (rc == -EMSGSIZE) {
  struct vk_msg_blk tmp_msg = entry->to_h_msg[0];

  /*
   * in this case, return just the first block, so
   * that app knows what size it is looking for.
 */
  set_msg_id(&tmp_msg, entry->usr_msg_id);
  tmp_msg.size = entry->to_h_blks - 1;
  if (copy_to_user(buf, &tmp_msg, VK_MSGQ_BLK_SIZE) != 0) {
   dev_err(dev, "Error return 1st block in -EMSGSIZE\n");
   rc = -EFAULT;
  }
 }
 return rc;
}

ssize_t bcm_vk_write(struct file *p_file,
       const char __user *buf,
       size_t count,
       loff_t *f_pos)
{
 ssize_t rc;
 struct bcm_vk_ctx *ctx = p_file->private_data;
 struct bcm_vk *vk = container_of(ctx->miscdev, struct bcm_vk,
      miscdev);
 struct bcm_vk_msgq __iomem *msgq;
 struct device *dev = &vk->pdev->dev;
 struct bcm_vk_wkent *entry;
 u32 sgl_extra_blks;
 u32 q_num;
 u32 msg_size;
 u32 msgq_size;

 if (!bcm_vk_drv_access_ok(vk))
  return -EPERM;

 dev_dbg(dev, "Msg count %zu\n", count);

 /* first, do sanity check where count should be multiple of basic blk */
 if (count & (VK_MSGQ_BLK_SIZE - 1)) {
  dev_err(dev, "Failure with size %zu not multiple of %zu\n",
   count, VK_MSGQ_BLK_SIZE);
  rc = -EINVAL;
  goto write_err;
 }

 /* allocate the work entry + buffer for size count and inband sgl */
 entry = kzalloc(sizeof(*entry) + count + vk->ib_sgl_size,
   GFP_KERNEL);
 if (!entry) {
  rc = -ENOMEM;
  goto write_err;
 }

 /* now copy msg from user space, and then formulate the work entry */
 if (copy_from_user(&entry->to_v_msg[0], buf, count)) {
  rc = -EFAULT;
  goto write_free_ent;
 }

 entry->to_v_blks = count >> VK_MSGQ_BLK_SZ_SHIFT;
 entry->ctx = ctx;

 /* do a check on the blk size which could not exceed queue space */
 q_num = get_q_num(&entry->to_v_msg[0]);
 msgq = vk->to_v_msg_chan.msgq[q_num];
 msgq_size = readl_relaxed(&msgq->size);
 if (entry->to_v_blks + (vk->ib_sgl_size >> VK_MSGQ_BLK_SZ_SHIFT)
     > (msgq_size - 1)) {
  dev_err(dev, "Blk size %d exceed max queue size allowed %d\n",
   entry->to_v_blks, msgq_size - 1);
  rc = -EINVAL;
  goto write_free_ent;
 }

 /* Use internal message id */
 entry->usr_msg_id = get_msg_id(&entry->to_v_msg[0]);
 rc = bcm_vk_get_msg_id(vk);
 if (rc == VK_MSG_ID_OVERFLOW) {
  dev_err(dev, "msg_id overflow\n");
  rc = -EOVERFLOW;
  goto write_free_ent;
 }
 set_msg_id(&entry->to_v_msg[0], rc);
 ctx->q_num = q_num;

 dev_dbg(dev,
  "[Q-%d]Message ctx id %d, usr_msg_id 0x%x sent msg_id 0x%x\n",
  ctx->q_num, ctx->idx, entry->usr_msg_id,
  get_msg_id(&entry->to_v_msg[0]));

 if (entry->to_v_msg[0].function_id == VK_FID_TRANS_BUF) {
  /* Convert any pointers to sg list */
  unsigned int num_planes;
  int dir;
  struct _vk_data *data;

  /*
   * check if we are in reset, if so, no buffer transfer is
   * allowed and return error.
 */
  if (vk->reset_pid) {
   dev_dbg(dev, "No Transfer allowed during reset, pid %d.\n",
    ctx->pid);
   rc = -EACCES;
   goto write_free_msgid;
  }

  num_planes = entry->to_v_msg[0].cmd & VK_CMD_PLANES_MASK;
  if ((entry->to_v_msg[0].cmd & VK_CMD_MASK) == VK_CMD_DOWNLOAD)
   dir = DMA_FROM_DEVICE;
  else
   dir = DMA_TO_DEVICE;

  /* Calculate vk_data location */
  /* Go to end of the message */
  msg_size = entry->to_v_msg[0].size;
  if (msg_size > entry->to_v_blks) {
   rc = -EMSGSIZE;
   goto write_free_msgid;
  }

  data = (struct _vk_data *)&entry->to_v_msg[msg_size + 1];

  /* Now back up to the start of the pointers */
  data -= num_planes;

  /* Convert user addresses to DMA SG List */
  rc = bcm_vk_sg_alloc(dev, entry->dma, dir, data, num_planes);
  if (rc)
   goto write_free_msgid;

  atomic_inc(&ctx->dma_cnt);
  /* try to embed inband sgl */
  sgl_extra_blks = bcm_vk_append_ib_sgl(vk, entry, data,
            num_planes);
  entry->to_v_blks += sgl_extra_blks;
  entry->to_v_msg[0].size += sgl_extra_blks;
 } else if (entry->to_v_msg[0].function_id == VK_FID_INIT &&
     entry->to_v_msg[0].context_id == VK_NEW_CTX) {
  /*
   * Init happens in 2 stages, only the first stage contains the
   * pid that needs translating.
 */
  pid_t org_pid, pid;

  /*
   * translate the pid into the unique host space as user
   * may run sessions inside containers or process
   * namespaces.
 */
#define VK_MSG_PID_MASK 0xffffff00
#define VK_MSG_PID_SH   8
  org_pid = (entry->to_v_msg[0].arg & VK_MSG_PID_MASK)
      >> VK_MSG_PID_SH;

  pid = task_tgid_nr(current);
  entry->to_v_msg[0].arg =
   (entry->to_v_msg[0].arg & ~VK_MSG_PID_MASK) |
   (pid << VK_MSG_PID_SH);
  if (org_pid != pid)
   dev_dbg(dev, "In PID 0x%x(%d), converted PID 0x%x(%d)\n",
    org_pid, org_pid, pid, pid);
 }

 /*
  * store work entry to pending queue until a response is received.
  * This needs to be done before enqueuing the message
 */
 bcm_vk_append_pendq(&vk->to_v_msg_chan, q_num, entry);

 rc = bcm_to_v_msg_enqueue(vk, entry);
 if (rc) {
  dev_err(dev, "Fail to enqueue msg to to_v queue\n");

  /* remove message from pending list */
  entry = bcm_vk_dequeue_pending
          (vk,
    &vk->to_v_msg_chan,
    q_num,
    get_msg_id(&entry->to_v_msg[0]));
  goto write_free_ent;
 }

 return count;

write_free_msgid:
 bcm_vk_msgid_bitmap_clear(vk, get_msg_id(&entry->to_v_msg[0]), 1);
write_free_ent:
 kfree(entry);
write_err:
 return rc;
}

__poll_t bcm_vk_poll(struct file *p_file, struct poll_table_struct *wait)
{
 __poll_t ret = 0;
 int cnt;
 struct bcm_vk_ctx *ctx = p_file->private_data;
 struct bcm_vk *vk = container_of(ctx->miscdev, struct bcm_vk, miscdev);
 struct device *dev = &vk->pdev->dev;

 poll_wait(p_file, &ctx->rd_wq, wait);

 cnt = atomic_read(&ctx->pend_cnt);
 if (cnt) {
  ret = (__force __poll_t)(POLLIN | POLLRDNORM);
  if (cnt < 0) {
   dev_err(dev, "Error cnt %d, setting back to 0", cnt);
   atomic_set(&ctx->pend_cnt, 0);
  }
 }

 return ret;
}

int bcm_vk_release(struct inode *inode, struct file *p_file)
{
 int ret;
 struct bcm_vk_ctx *ctx = p_file->private_data;
 struct bcm_vk *vk = container_of(ctx->miscdev, struct bcm_vk, miscdev);
 struct device *dev = &vk->pdev->dev;
 pid_t pid = ctx->pid;
 int dma_cnt;
 unsigned long timeout, start_time;

 /*
  * if there are outstanding DMA transactions, need to delay long enough
  * to ensure that the card side would have stopped touching the host buffer
  * and its SGL list.  A race condition could happen if the host app is killed
  * abruptly, eg kill -9, while some DMA transfer orders are still inflight.
  * Nothing could be done except for a delay as host side is running in a
  * completely async fashion.
 */
 start_time = jiffies;
 timeout = start_time + msecs_to_jiffies(BCM_VK_DMA_DRAIN_MAX_MS);
 do {
  if (time_after(jiffies, timeout)) {
   dev_warn(dev, "%d dma still pending for [fd-%d] pid %d\n",
     dma_cnt, ctx->idx, pid);
   break;
  }
  dma_cnt = atomic_read(&ctx->dma_cnt);
  cpu_relax();
  cond_resched();
 } while (dma_cnt);
 dev_dbg(dev, "Draining for [fd-%d] pid %d - delay %d ms\n",
  ctx->idx, pid, jiffies_to_msecs(jiffies - start_time));

 bcm_vk_drain_all_pend(&vk->pdev->dev, &vk->to_v_msg_chan, ctx);
 bcm_vk_drain_all_pend(&vk->pdev->dev, &vk->to_h_msg_chan, ctx);

 ret = bcm_vk_free_ctx(vk, ctx);
 if (ret == 0)
  ret = bcm_vk_handle_last_sess(vk, pid, ctx->q_num);
 else
  ret = 0;

 kref_put(&vk->kref, bcm_vk_release_data);

 return ret;
}

int bcm_vk_msg_init(struct bcm_vk *vk)
{
 struct device *dev = &vk->pdev->dev;
 int ret;

 if (bcm_vk_data_init(vk)) {
  dev_err(dev, "Error initializing internal data structures\n");
  return -EINVAL;
 }

 if (bcm_vk_msg_chan_init(&vk->to_v_msg_chan) ||
     bcm_vk_msg_chan_init(&vk->to_h_msg_chan)) {
  dev_err(dev, "Error initializing communication channel\n");
  return -EIO;
 }

 /* read msgq info if ready */
 ret = bcm_vk_sync_msgq(vk, false);
 if (ret && (ret != -EAGAIN)) {
  dev_err(dev, "Error reading comm msg Q info\n");
  return -EIO;
 }

 return 0;
}

void bcm_vk_msg_remove(struct bcm_vk *vk)
{
 bcm_vk_blk_drv_access(vk);

 /* drain all pending items */
 bcm_vk_drain_all_pend(&vk->pdev->dev, &vk->to_v_msg_chan, NULL);
 bcm_vk_drain_all_pend(&vk->pdev->dev, &vk->to_h_msg_chan, NULL);
}