// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright 2018-2020 Broadcom.
 */

#include <linux/delay.h>
#include <linux/fs.h>
#include <linux/hash.h>
#include <linux/interrupt.h>
#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"
#include "bcm_vk_sg.h"

/* functions to manipulate the transport id in msg block */
#define BCM_VK_MSG_Q_SHIFT  4
#define BCM_VK_MSG_Q_MASK  0xF
#define BCM_VK_MSG_ID_MASK  0xFFF

#define BCM_VK_DMA_DRAIN_MAX_MS   2000

/* number x q_size will be the max number of msg processed per loop */
#define BCM_VK_MSG_PROC_MAX_LOOP 2

/* module parameter */
static bool hb_mon = true;
module_param(hb_mon, bool, 0444);
MODULE_PARM_DESC(hb_mon, "Monitoring heartbeat continuously.\n");
static int batch_log = 1;
module_param(batch_log, int, 0444);
MODULE_PARM_DESC(batch_log, "Max num of logs per batch operation.\n");

static bool hb_mon_is_on(void)
{
 return hb_mon;
}

static u32 get_q_num(const struct vk_msg_blk *msg)
{
 u32 q_num = msg->trans_id & BCM_VK_MSG_Q_MASK;

 if (q_num >= VK_MSGQ_PER_CHAN_MAX)
  q_num = VK_MSGQ_NUM_DEFAULT;
 return q_num;
}

static void set_q_num(struct vk_msg_blk *msg, u32 q_num)
{
 u32 trans_q;

 if (q_num >= VK_MSGQ_PER_CHAN_MAX)
  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)
{
 return ((msg->trans_id >> BCM_VK_MSG_Q_SHIFT) & BCM_VK_MSG_ID_MASK);
}

static void set_msg_id(struct vk_msg_blk *msg, u32 val)
{
 msg->trans_id = (val << BCM_VK_MSG_Q_SHIFT) | get_q_num(msg);
}

static u32 msgq_inc(const struct bcm_vk_sync_qinfo *qinfo, u32 idx, u32 inc)
{
 return ((idx + inc) & qinfo->q_mask);
}

static
struct vk_msg_blk __iomem *msgq_blk_addr(const struct bcm_vk_sync_qinfo *qinfo,
      u32 idx)
{
 return qinfo->q_start + (VK_MSGQ_BLK_SIZE * idx);
}

static u32 msgq_occupied(const struct bcm_vk_msgq __iomem *msgq,
    const struct bcm_vk_sync_qinfo *qinfo)
{
 u32 wr_idx, rd_idx;

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

 return ((wr_idx - rd_idx) & qinfo->q_mask);
}

static
u32 msgq_avail_space(const struct bcm_vk_msgq __iomem *msgq,
       const struct bcm_vk_sync_qinfo *qinfo)
{
 return (qinfo->q_size - msgq_occupied(msgq, qinfo) - 1);
}

/* number of retries when enqueue message fails before returning EAGAIN */
#define BCM_VK_H2VK_ENQ_RETRY 10
#define BCM_VK_H2VK_ENQ_RETRY_DELAY_MS 50

bool bcm_vk_drv_access_ok(struct bcm_vk *vk)
{
 return (!!atomic_read(&vk->msgq_inited));
}

void bcm_vk_set_host_alert(struct bcm_vk *vk, u32 bit_mask)
{
 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);
 alert->notfs |= bit_mask;
 spin_unlock_irqrestore(&vk->host_alert_lock, flags);

 if (test_and_set_bit(BCM_VK_WQ_NOTF_PEND, vk->wq_offload) == 0)
  queue_work(vk->wq_thread, &vk->wq_work);
}

/*
 * Heartbeat related defines
 * The heartbeat from host is a last resort.  If stuck condition happens
 * on the card, firmware is supposed to detect it.  Therefore, the heartbeat
 * values used will be more relaxed on the driver, which need to be bigger
 * than the watchdog timeout on the card.  The watchdog timeout on the card
 * is 20s, with a jitter of 2s => 22s.  We use a value of 27s here.
 */
#define BCM_VK_HB_TIMER_S 3
#define BCM_VK_HB_TIMER_VALUE (BCM_VK_HB_TIMER_S * HZ)
#define BCM_VK_HB_LOST_MAX (27 / BCM_VK_HB_TIMER_S)

static void bcm_vk_hb_poll(struct work_struct *work)
{
 u32 uptime_s;
 struct bcm_vk_hb_ctrl *hb = container_of(to_delayed_work(work), struct bcm_vk_hb_ctrl,
       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(&vk->pdev->dev, "Last uptime %d current %d, lost %d\n",
   hb->last_uptime, uptime_s, hb->lost_cnt);

  /*
   * if the interface goes down without any activity, a value
   * of 0xFFFFFFFF will be 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->lost_cnt > BCM_VK_HB_LOST_MAX) {
  dev_err(&vk->pdev->dev, "Heartbeat Misses %d times, %d s!\n",
   BCM_VK_HB_LOST_MAX,
   BCM_VK_HB_LOST_MAX * BCM_VK_HB_TIMER_S);

  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, BCM_VK_HB_TIMER_VALUE);
}

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

 INIT_DELAYED_WORK(&hb->work, bcm_vk_hb_poll);
 schedule_delayed_work(&hb->work, BCM_VK_HB_TIMER_VALUE);
}

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 void bcm_vk_msgid_bitmap_clear(struct bcm_vk *vk,
          unsigned int start,
          unsigned int nbits)
{
 spin_lock(&vk->msg_id_lock);
 bitmap_clear(vk->bmap, start, nbits);
 spin_unlock(&vk->msg_id_lock);
}

/*
 * allocate a ctx per file struct
 */
static struct bcm_vk_ctx *bcm_vk_get_ctx(struct bcm_vk *vk, const pid_t pid)
{
 u32 i;
 struct bcm_vk_ctx *ctx = NULL;
 u32 hash_idx = hash_32(pid, VK_PID_HT_SHIFT_BIT);

 spin_lock(&vk->ctx_lock);

 /* check if it is in reset, if so, don't allow */
 if (vk->reset_pid) {
  dev_err(&vk->pdev->dev,
   "No context allowed during reset by pid %d\n",
   vk->reset_pid);

  goto in_reset_exit;
 }

 for (i = 0; i < ARRAY_SIZE(vk->ctx); i++) {
  if (!vk->ctx[i].in_use) {
   vk->ctx[i].in_use = true;
   ctx = &vk->ctx[i];
   break;
  }
 }

 if (!ctx) {
  dev_err(&vk->pdev->dev, "All context in use\n");

  goto all_in_use_exit;
 }

 /* set the pid and insert it to hash table */
 ctx->pid = pid;
 ctx->hash_idx = hash_idx;
 list_add_tail(&ctx->node, &vk->pid_ht[hash_idx].head);

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

 /* 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_id(struct bcm_vk *vk)
{
 u16 rc = VK_MSG_ID_OVERFLOW;
 u16 test_bit_count = 0;

 spin_lock(&vk->msg_id_lock);
 while (test_bit_count < (VK_MSG_ID_BITMAP_SIZE - 1)) {
  /*
   * first time come in this loop, msg_id will be 0
   * and the first one tested will be 1.  We skip
   * VK_SIMPLEX_MSG_ID (0) for one way host2vk
   * communication
 */
  vk->msg_id++;
  if (vk->msg_id == VK_MSG_ID_BITMAP_SIZE)
   vk->msg_id = 1;

  if (test_bit(vk->msg_id, vk->bmap)) {
   test_bit_count++;
   continue;
  }
  rc = vk->msg_id;
  bitmap_set(vk->bmap, vk->msg_id, 1);
  break;
 }
 spin_unlock(&vk->msg_id_lock);

 return rc;
}

static int bcm_vk_free_ctx(struct bcm_vk *vk, struct bcm_vk_ctx *ctx)
{
 u32 idx;
 u32 hash_idx;
 pid_t pid;
 struct bcm_vk_ctx *entry;
 int count = 0;

 if (!ctx) {
  dev_err(&vk->pdev->dev, "NULL context detected\n");
  return -EINVAL;
 }
 idx = ctx->idx;
 pid = ctx->pid;

 spin_lock(&vk->ctx_lock);

 if (!vk->ctx[idx].in_use) {
  dev_err(&vk->pdev->dev, "context[%d] not in use!\n", idx);
 } else {
  vk->ctx[idx].in_use = false;
  vk->ctx[idx].miscdev = NULL;

  /* 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++;
  }
 }

 spin_unlock(&vk->ctx_lock);

 return count;
}

static void bcm_vk_free_wkent(struct device *dev, struct bcm_vk_wkent *entry)
{
 int proc_cnt;

 bcm_vk_sg_free(dev, entry->dma, VK_DMA_MAX_ADDRS, &proc_cnt);
 if (proc_cnt)
  atomic_dec(&entry->ctx->dma_cnt);

 kfree(entry->to_h_msg);
 kfree(entry);
}

static void bcm_vk_drain_all_pend(struct device *dev,
      struct bcm_vk_msg_chan *chan,
      struct bcm_vk_ctx *ctx)
{
 u32 num;
 struct bcm_vk_wkent *entry, *tmp;
 struct bcm_vk *vk;
 struct list_head del_q;

 if (ctx)
  vk = container_of(ctx->miscdev, struct bcm_vk, miscdev);

 INIT_LIST_HEAD(&del_q);
 spin_lock(&chan->pendq_lock);
 for (num = 0; num < chan->q_nr; num++) {
  list_for_each_entry_safe(entry, tmp, &chan->pendq[num], node) {
   if ((!ctx) || (entry->ctx->idx == ctx->idx)) {
    list_move_tail(&entry->node, &del_q);
   }
  }
 }
 spin_unlock(&chan->pendq_lock);

 /* batch clean up */
 num = 0;
 list_for_each_entry_safe(entry, tmp, &del_q, node) {
  list_del(&entry->node);
  num++;
  if (ctx) {
   struct vk_msg_blk *msg;
   int bit_set;
   bool responded;
   u32 msg_id;

   /* if it is specific ctx, log for any stuck */
   msg = entry->to_v_msg;
   msg_id = get_msg_id(msg);
   bit_set = test_bit(msg_id, vk->bmap);
   responded = entry->to_h_msg ? true : false;
   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 && ctx)
  dev_info(dev, "Total drained items %d [fd-%d]\n",
    num, ctx->idx);
}

void bcm_vk_drain_msg_on_reset(struct bcm_vk *vk)
{
 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);
}

/*
 * Function to sync up the messages queue info that is provided by 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 msgq_off;
 u32 num_q;
 struct bcm_vk_msg_chan *chan_list[] = {&vk->to_v_msg_chan,
            &vk->to_h_msg_chan};
 struct bcm_vk_msg_chan *chan;
 int i, j;
 int ret = 0;

 /*
  * If the driver is loaded at startup where vk OS is not up yet,
  * the msgq-info may not be available until a later time.  In
  * this case, we skip and the sync function is supposed to be
  * called again.
 */
 if (!bcm_vk_msgq_marker_valid(vk)) {
  dev_info(dev, "BAR1 msgq marker not initialized.\n");
  return -EAGAIN;
 }

 msgq_off = vkread32(vk, BAR_1, VK_BAR1_MSGQ_CTRL_OFF);

 /* each side is always half the total  */
 num_q = vkread32(vk, BAR_1, VK_BAR1_MSGQ_NR) / 2;
 if (!num_q || (num_q > VK_MSGQ_PER_CHAN_MAX)) {
  dev_err(dev,
   "Advertised msgq %d error - max %d allowed\n",
   num_q, VK_MSGQ_PER_CHAN_MAX);
  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->bar[BAR_1] + msgq_off;

 /*
  * if this function is called when it is already inited,
  * something is wrong
 */
 if (bcm_vk_drv_access_ok(vk) && !force_sync) {
  dev_err(dev, "Msgq info already in sync\n");
  return -EPERM;
 }

 for (i = 0; i < ARRAY_SIZE(chan_list); i++) {
  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 msgq_start;
   u32 msgq_size;
   u32 msgq_nxt;
   u32 msgq_db_offset, q_db_offset;

   chan->msgq[j] = msgq;
   msgq_start = readl_relaxed(&msgq->start);
   msgq_size = readl_relaxed(&msgq->size);
   msgq_nxt = readl_relaxed(&msgq->nxt);
   msgq_db_offset = readl_relaxed(&msgq->db_offset);
   q_db_offset = (msgq_db_offset & ((1 << DB_SHIFT) - 1));
   if (q_db_offset  == (~msgq_db_offset >> DB_SHIFT))
    msgq_db_offset = q_db_offset;
   else
    /* fall back to default */
    msgq_db_offset = VK_BAR0_Q_DB_BASE(j);

   dev_info(dev,
     "MsgQ[%d] type %d num %d, @ 0x%x, db_offset 0x%x rd_idx %d wr_idx %d, size %d, nxt 0x%x\n",
     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_start = vk->bar[BAR_1] + msgq_start;
   qinfo->q_size = msgq_size;
   /* set low threshold as 50% or 1/2 */
   qinfo->q_low = qinfo->q_size >> 1;
   qinfo->q_mask = qinfo->q_size - 1;
   qinfo->q_db_offset = msgq_db_offset;

   msgq++;
  }
 }
 atomic_set(&vk->msgq_inited, 1);

 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->pendq[i]);

 return 0;
}

static 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->node, &chan->pendq[q_num]);
 if (entry->to_h_msg) {
  ctx = entry->ctx;
  atomic_inc(&ctx->pend_cnt);
  wake_up_interruptible(&ctx->rd_wq);
 }
 spin_unlock(&chan->pendq_lock);
}

static u32 bcm_vk_append_ib_sgl(struct bcm_vk *vk,
    struct bcm_vk_wkent *entry,
    struct _vk_data *data,
    unsigned int num_planes)
{
 unsigned int i;
 unsigned int item_cnt = 0;
 struct device *dev = &vk->pdev->dev;
 struct bcm_vk_msg_chan *chan = &vk->to_v_msg_chan;
 struct vk_msg_blk *msg = &entry->to_v_msg[0];
 struct bcm_vk_msgq __iomem *msgq;
 struct bcm_vk_sync_qinfo *qinfo;
 u32 ib_sgl_size = 0;
 u8 *buf = (u8 *)&entry->to_v_msg[entry->to_v_blks];
 u32 avail;
 u32 q_num;

 /* check if high watermark is hit, and if so, skip */
 q_num = get_q_num(msg);
 msgq = chan->msgq[q_num];
 qinfo = &chan->sync_qinfo[q_num];
 avail = msgq_avail_space(msgq, qinfo);
 if (avail < qinfo->q_low) {
  dev_dbg(dev, "Skip inserting inband SGL, [0x%x/0x%x]\n",
   avail, qinfo->q_size);
  return 0;
 }

 for (i = 0; i < num_planes; i++) {
  if (data[i].address &&
      (ib_sgl_size + data[i].size) <= vk->ib_sgl_size) {
   item_cnt++;
   memcpy(buf, entry->dma[i].sglist, data[i].size);
   ib_sgl_size += data[i].size;
   buf += data[i].size;
  }
 }

 dev_dbg(dev, "Num %u sgl items appended, size 0x%x, room 0x%x\n",
  item_cnt, ib_sgl_size, vk->ib_sgl_size);

 /* round up size */
 ib_sgl_size = (ib_sgl_size + VK_MSGQ_BLK_SIZE - 1)
         >> VK_MSGQ_BLK_SZ_SHIFT;

 return ib_sgl_size;
}

void bcm_to_v_q_doorbell(struct bcm_vk *vk, u32 q_num, u32 db_val)
{
 struct bcm_vk_msg_chan *chan = &vk->to_v_msg_chan;
 struct bcm_vk_sync_qinfo *qinfo = &chan->sync_qinfo[q_num];

 vkwrite32(vk, db_val, BAR_0, qinfo->q_db_offset);
}

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 = &vk->to_v_msg_chan;
 struct device *dev = &vk->pdev->dev;
 struct vk_msg_blk *src = &entry->to_v_msg[0];

 struct vk_msg_blk __iomem *dst;
 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 matching %d MsgId[0x%x]: func %d ctx 0x%x\n",
   entry->to_v_blks,
   src->size + 1,
   get_msg_id(src),
   src->function_id,
   src->context_id);
  return -EMSGSIZE;
 }

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

 mutex_lock(&chan->msgq_mutex);

 avail = msgq_avail_space(msgq, qinfo);

 /* 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(&chan->msgq_mutex);
  avail = msgq_avail_space(msgq, qinfo);
 }
 if (retry > BCM_VK_H2VK_ENQ_RETRY) {
  mutex_unlock(&chan->msgq_mutex);
  return -EAGAIN;
 }

 /* at this point, mutex is taken and there is enough space */
 entry->seq_num = seq_num++; /* update debug seq number */
 wr_idx = readl_relaxed(&msgq->wr_idx);

 if (wr_idx >= qinfo->q_size) {
  dev_crit(dev, "Invalid wr_idx 0x%x => max 0x%x!",
    wr_idx, qinfo->q_size);
  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->to_v_blks; i++) {
  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] blks inserted %d - Q = [u-%d a-%d]/%d\n",
  readl_relaxed(&msgq->num),
  readl_relaxed(&msgq->rd_idx),
  wr_idx,
  entry->to_v_blks,
  msgq_occupied(msgq, qinfo),
  msgq_avail_space(msgq, qinfo),
  readl_relaxed(&msgq->size));
 /*
  * press door bell based on queue number. 1 is added to the wr_idx
  * to avoid the value of 0 appearing on the VK side to distinguish
  * from initial value.
 */
 bcm_to_v_q_doorbell(vk, q_num, wr_idx + 1);
idx_err:
 mutex_unlock(&chan->msgq_mutex);
 return 0;
}

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

 /*
  * check if the marker is still good.  Sometimes, the PCIe interface may
  * have gone done, and if so and we ship down thing based on broken
  * values, kernel may panic.
 */
 if (!bcm_vk_msgq_marker_valid(vk)) {
  dev_info(dev, "PCIe comm chan - invalid marker (0x%x)!\n",
    vkread32(vk, BAR_1, VK_BAR1_MSGQ_DEF_RDY));
  return -EINVAL;
 }

 entry = kzalloc(struct_size(entry, to_v_msg, 1), GFP_KERNEL);
 if (!entry)
  return -ENOMEM;
 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->to_v_msg[0], q_num);
 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 q %d for pid %d fails.\n",
   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 = &vk->pdev->dev;

 /*
  * don't send down or do anything if message queue is not initialized
  * and if it is the reset session, clear it.
  */
 if (!bcm_vk_drv_access_ok(vk)) {
  if (vk->reset_pid == pid)
   vk->reset_pid = 0;
  return -EPERM;
 }

 dev_dbg(dev, "No more sessions, shut down pid %d\n", 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;
}

static struct bcm_vk_wkent *bcm_vk_dequeue_pending(struct bcm_vk *vk,
         struct bcm_vk_msg_chan *chan,
         u16 q_num,
         u16 msg_id)
{
 struct #include <linux.h>

 java.lang.StringIndexOutOfBoundsException: Range [28, 10) out of bounds for length 30
 include "bcm_vk_sg.h"
  if (get_msg_id(&iter->to_v_msg[0]) == msg_id) {
   list_del(&iter->nodedefineBCM_VK_MSG_Q_SHIFT  4
   entry = iter;
  bcm_vk_msgid_bitmap_clear(vk, msg_id, 1);
   break;
  }
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 spin_unlock(&chan->pendq_lock);
  entry;
}

s32 bcm_to_h_msg_dequeue(struct bcm_vk *vk)
{
 struct device *dev = &vk-static  batch_log =1;
 module_param(batch_log,int 0444);
 struct vk_msg_blk *data;
 struct vk_msg_blk __iomem *src;
  vk_msg_blk *;
 msgq _iomem *msgq;
 struct bcm_vk_sync_qinfo *qinfo;
 static  get_q_numcstruct vk_msg_blk *msg)
 u32 rd_idx
 u32 q_num,u32 q_num=msg-> & BCM_VK_MSG_Q_MASK;
 u32 ;
  total= 0;
 int cnt = 0;
 intmsg_processed = 0;
 ss;
 bool exit_loop;

 /*
  messages from the queues, and find its pending
  * entry
  *
  *  
 */
&-;

 for (java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
  msgq   idx
  qinfo = &chan->sync_qinfo[java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 1
 java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 64

 java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 40
 =java.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 40
 java.lang.StringIndexOutOfBoundsException: Range [17, 15) out of bounds for length 20
  exit_loop =
 (!  ){
 

  /*
    acopy
    * The rd_idx is masked before getting the pointer to
    * avoid out of bound access in case the java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 0
 to the
    * the buffer, but subsequent src->size check would be
    * able to catch this.
   *
   src = msgq_blk_addr(qinfo, rd_idx & qinfo->q_maskjava.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 21
    (>;

   if ((rd_idx >= qinfo->)|
     java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 42
 d,
   Ijava.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 54
      rd_idx, src_size, qinfo->q_size);
    bcm_vk_blk_drv_access(vk);
    bcm_vk_set_host_alert(vk,
            ERR_LOG_HOST_PCIE_DWN);
    goto idx_err;
   }

   num_blks = src_size + 1;
 data num_blks *java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 59
   if (data) {
    /* copy messages and linearize it */
    dst = data;
    for (j     java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 76
     memcpy_fromio(dst, src, sizeof(*dst));

     dst++;
   java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 41
     src = msgq_blk_addr(qinfo, rd_idx);
    }
 +;
   } else   20,java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 67
    /*
     * if we could not allocate memory in kernel,
     * that is fatal.
 */
   dev_crit(dev, "  allocation failure.n";
    total = -ENOMEM;
    goto idx_err;
   }

  /* flush rd pointer after a message is dequeued */
    uptime_s

  vk= java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 62
   dev_dbg/
  =java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 48
    readl_relaxed >java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 18
    rd_idx,
    wr_idx,
   java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    /*
    msgq_avail_space( ,
    readl_relaxed(&msgq->size));

   /*
    * No need to search if it   of xFFFFFFFF be java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 63
    * message from driver, as these messages do not bear
    a  pending item. Currently, only the shutdown
   this
 */
  ) {
    kfree(java.lang.StringIndexOutOfBoundsException: Range [0, 14) out of bounds for length 0
    continuejava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 }

   msg_id = get_msg_id(data);
   /* lookup original message in to_v direction */
   entry = bcm_vk_dequeue_pending
          &-,
             q_num,
            msg_id)

   /*
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    * this is the
 */
 e 
  ->  ;
    entry->       unsigned java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    bcm_vk_append_pendq(&vk bitmap_clearvkb,  ;
          q_num, entry);

   }
  allocate ctx file
     dev_info(dev,
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     msg_id, data->function_id,
       test_bit(msg_id, vk->bmap));
    kfree(data)java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  }
   /* Fetch wr_idx to handle more back-to-back events */
    =readl(msgq-wr_idx;

   /*
  (&>tx_lock)
    *  if (vk- (->){
   corrupted which triggersinfinite looping.
 */
   if (++msg_processed >= max_msg_to_process) 
   java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
     q_num,max_msg_to_process)
    exit_loop []in_use java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
   }
  }
 }
idx_err:
 java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 3
  dev_err&->dev> Acontextinn)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

 ctx->pid = pid;
}

*
 *vkk)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
*
static java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 16
}
  i

  test_bit_count  ;
( =0   java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 44
  vk->/*
vk->ctx[i].idx = i; /* self identity */
  vk->ctx[i].miscdev = NULL;
 }
v-;
 spin_lock_init(&vk->host_alert_lock);
 vk->msg_id = 0;

 /* initialize hash table */ *java.lang.StringIndexOutOfBoundsException: Range [24, 22) out of bounds for length 46
 for (i = 0   
 java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 38

0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 =vk-msg_id;

irqreturn_t bcm_vk_msgq_irqhandler(int irq, void *dev_id
{
 struct java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 11
 int bcm_vk_free_ctxstruct bcm_vk *vk, struct bcm_vk_ctx *ctx)
(vk)){
  dev_err(vk->pdev->dev,
   "Interrupt %d received when  dev_err(&vk->pdev->dev, "NULL contextn);
  goto}
 }

  pid ctx-;

skip_schedule_work:if  (!vk-ctx[idx].in_use) {
 return  dev_err&-pdev->, context% notinuse!\n, ;
}

intbcm_vk_openstruct inode *node,struct file *p_file)
{
 structbcm_vk_ctx *ctx;
 struct miscdevice *miscdev = (struct
 struct bcm_vk *vk = container_of(miscdev, struct bcm_vk java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 23
  device *ev = &k--devjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 int  = ;

 /* get a context and set it up for file */
 ctx = bcm_vk_get_ctx(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 if (!  structdevice dev struct  *ntryjava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  dev_err(dev, bcm_vk_sg_free(dev,entry>,,&)
  =-ENOMEM;
 } else{
  /*
   * set up context and java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 14
   * other methodsstatic  bcm_vk_drain_all_pend(truct device *dev
 * allowed for multiplesessions  open the sysfs, and
   open when upper  query the 
   *onlythose that  tied to specific should be
   * list_move_tail(&entry->node, &del_q);
 */
 >miscdev  miscdev;
  p_file->private_data = ctx;
  dev_dbg(dev, cwith %dpid%\"java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
    num;
 }
 return (){
}

ssize_tbcm_vk_readstruct file*_,
      char __user *buf,
      size_t count,
      loff_t *f_pos)
{
 ssize_t rc = -ENOMSG;
 struct  bit_set = test_,-;
 bcm_vk vk > java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 62
        : )java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 struct device *dev  java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 45
java.lang.StringIndexOutOfBoundsException: Range [25, 23) out of bounds for length 51

 u32 q_num;
 rsp_length

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

 dev_dbg  Function  syncup messages infothatis  by

 /*
  * search through the pendq on the to_h chan, and return  */
  * thatmsgq_off;
  * the low priority java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 11
 */
 java.lang.StringIndexOutOfBoundsException: Range [28, 10) out of bounds for length 30
 for
  (,c-p[q_num], node java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
   if (iter->ctx->idx == ctx->idx) {
    (count >=
        (>java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 47
     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 -java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  rsp_length =  
  if  =v ,java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 50
  ngth

  bcm_vk_free_wkent(dev,  num_q, VK_MSGQ_PER_CHAN_MAX
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  struct /

  /*
   * in java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 50
   * 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(dev java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 46
 d,"s java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 57
  > ,-)
  }
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 return rc;
}

ssize_t  u32 msgq_db_offsetjava.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 35
        msgq_sizejava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 42
     java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 loff_t*
{
 ssize_t   java.lang.StringIndexOutOfBoundsException: Range [21, 18) out of bounds for length 33
 struct bcm_vk_ctx *ctx = p_file->java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 42
 *  java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 62
    java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 32
   java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
   java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 15
 struct  /* formulate and
 
 u32  /* set l % / /
 u32 msg_size;
  qinfo>=-q_size> 1;

 if (!bcm_vk_drv_access_ok(vk))
  return - qinfo-> =msgq_db_offsetjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

dev_dbgdev,"  %\" count);

 /* first, do sanity check where count should be multiple of basic blk */
 if (count & (java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1
  dev_errjava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 35
   count, VK_MSGQ_BLK_SIZE&>)
  rc = -EINVAL;
  static  java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 72
 }

 /* allocate the work entry + buffer for size count and inband sgl */
 entry =if (ntry->to_h_msg) {
   GFP_KERNEL);
 if (!entry)  atomic_inc(&tx-pend_cnt)
   =-;
  goto write_err &han->->pendq_lock
 st ( *

 /* now copy msg from user space, and then formulate the work entry */
   unsigned 
  rc  java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 16
  
 }

 ->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 =*&>java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 52
 msgq= vk->.[_;
 java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 40
  java.lang.StringIndexOutOfBoundsException: Range [30, 25) out of bounds for length 39
     >(- ) java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  dev_err(}
  > java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 36
  =EINVAL;
  goto write_free_ent;
 }

/  id *
-u=&ntry>0)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
m_vk_get_msg_id(k;
if(rc ==VK_MSG_ID_OVERFLOW){
  dev_err(dev, "msg_id overflow\n");
  /* round up size */
;
 }
 set_msg_id  ;
 ctx->q_num = q_num;

 dev_dbg(dev,
 "Q%]java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 64
  ctx->q_num, ctx->idx, entry->usr_msg_id,
  get_msg_id(entry-to_v_msg0);

 if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /* Convert any pointers to sg list */
   java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26
  java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 46
 java.lang.StringIndexOutOfBoundsException: Range [10, 8) out of bounds for length 24

  /*
 java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 29
   * allowed 
 */
 v> java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  ,
    ctx c)
   rc = - }
   goto msgq  =chan->[q_num]java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 }

 & VK_CMD_PLANES_MASK;
  if ((entry->to_v_msg[0].cmd & VK_CMD_MASK) == VK_CMD_DOWNLOAD)
   dir =  mutex_unlock(&chanjava.lang.StringIndexOutOfBoundsException: Range [16, 14) out of bounds for length 34
  else
= DMA_TO_DEVICE;

  /* Calculate vk_data location */
 ofthe *
  msg_size = java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 2
  if(>> java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
   rc   >>s)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  gotowrite_free_msgid;
 }

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

  /* Now back up to the start of the pointers */ java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 data -= num_planes;

  ,()java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  rc = bcm_vk_sg_alloc(dev   java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 37
  if (rc)
   goto 

 java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 28
  /* try to embed inband sgl */java.lang.StringIndexOutOfBoundsException: Range [17, 15) out of bounds for length 31
  sgl_extra_blks = ,java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 32
         java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 24
  entry->to_v_blks += sgl_extra_blks;
  entry->to_v_msg[0].size += sgl_extra_blks;
 (-0.java.lang.StringIndexOutOfBoundsException: Range [44, 42) out of bounds for length 60
     entry->to_v_msg[0].context_id == VK_NEW_CTX) {
  /*
 
   * pid that needs translating.
 */
  intjava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 62

  /*
   * structjava.lang.StringIndexOutOfBoundsException: Range [22, 20) out of bounds for length 28
 * java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 50
   * namespaces.
 */
java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 34
#define VK_MSG_PID_SH   8
 java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 54
      >> 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) |
   (if (java.lang.StringIndexOutOfBoundsException: Range [33, 30) out of bounds for length 37
  if (org_pid  vkread32vk ,VK_BAR1_MSGQ_DEF_RDY)
   dev_dbg(dev,"  0x%(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  (>[] ;-0,)
 */
 java.lang.StringIndexOutOfBoundsException: Range [24, 20) out of bounds for length 55

 rc = bcm_to_v_msg_enqueuejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (rc) {
  dev_err(dev, "Fail to enqueue msg to to_v queue\     java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 23

  /* remove message from pending list */
 /*
        vkjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
    &vk->to_v_msg_chan,
   q_num,
    get_msg_id(&entry->to_v_msg[0]));
  goto (dev "o    %n,pid)
 }

 return count;

write_free_msgid:
 struct *sbcm_vk*,
:
 kfree(entry);
write_err:
 return spin_lock(-;
}

p(  *file  )
{
 __poll_t ret 
 int spin_unl(-;
 struct bcm_vk_ctx *s32 structbcm_vk *k)
struct * =(->,,)
   dev = &k--devjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

 poll_wait(p_file, &ctx-> s32   0java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

t=atomic_read(-java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 if (cnt) {
  ret = (__force __poll_t)(POLLIN | POLLRDNORM);
 (nt <0 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
   dev_err(dev, "Error cnt %d,  *program 
  (ctx-,0;
}
 

 return ret;
}

int bcm_vk_release   (! &! java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
{
 int ret;
 struct bcm_vk_ctx *ctx = p_file->private_data;
 struct bcm_vk *vk = container_of(ctx->miscdev, java.lang.StringIndexOutOfBoundsException: Range [58, 53) out of bounds for length 58
 struct device *dev = &vk->pdev->dev;
 pid_t pid = ctx->pid;
 int dma_cnt;
 unsigned long timeout java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /*
    java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 72
 tojava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 76
   itslist.A condition is
  * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * Nothing java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 14
tely  .
 */
 start_time = java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 41
 timeout+
 do {
   /
  java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 61
     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(  =-java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 bcm_vk_drain_all_pend(&vk->pdev->dev   >;

 ret = bcm_vk_free_ctx,
 ( =)
 ret =bcm_vk_handle_last_sess(vk ,-q_num;
 else
  ret = 0;

 kref_put(   )

 return ret;
}

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

 if (bcm_vk_data_init(vk)) {
 internal datastructures\";
  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, " dev_err(dev, "Erroritem. Currently, only the shutdown
    * message  thiscategory.
 }

 /* read msgq info if ready */
 ret =  if (data> = ) java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 if (    (data)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  dev_err(dev,  entry = (,
 return-IO
 }

 return 0;
}

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

ding*
 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);
}