Quelle  command_submission.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0

/*
 * Copyright 2016-2021 HabanaLabs, Ltd.
 * All Rights Reserved.
 */

#include <uapi/drm/habanalabs_accel.h>
#include "habanalabs.h"

#include <linux/uaccess.h>
#include <linux/slab.h>

#define HL_CS_FLAGS_TYPE_MASK (HL_CS_FLAGS_SIGNAL | HL_CS_FLAGS_WAIT | \
   HL_CS_FLAGS_COLLECTIVE_WAIT | HL_CS_FLAGS_RESERVE_SIGNALS_ONLY | \
   HL_CS_FLAGS_UNRESERVE_SIGNALS_ONLY | HL_CS_FLAGS_ENGINE_CORE_COMMAND | \
   HL_CS_FLAGS_ENGINES_COMMAND | HL_CS_FLAGS_FLUSH_PCI_HBW_WRITES)


#define MAX_TS_ITER_NUM 100

/**
 * enum hl_cs_wait_status - cs wait status
 * @CS_WAIT_STATUS_BUSY: cs was not completed yet
 * @CS_WAIT_STATUS_COMPLETED: cs completed
 * @CS_WAIT_STATUS_GONE: cs completed but fence is already gone
 */
enum hl_cs_wait_status {
 CS_WAIT_STATUS_BUSY,
 CS_WAIT_STATUS_COMPLETED,
 CS_WAIT_STATUS_GONE
};

/*
 * Data used while handling wait/timestamp nodes.
 * The purpose of this struct is to store the needed data for both operations
 * in one variable instead of passing large number of arguments to functions.
 */
struct wait_interrupt_data {
 struct hl_user_interrupt *interrupt;
 struct hl_mmap_mem_buf *buf;
 struct hl_mem_mgr *mmg;
 struct hl_cb *cq_cb;
 u64 ts_handle;
 u64 ts_offset;
 u64 cq_handle;
 u64 cq_offset;
 u64 target_value;
 u64 intr_timeout_us;
};

static void job_wq_completion(struct work_struct *work);
static int _hl_cs_wait_ioctl(struct hl_device *hdev, struct hl_ctx *ctx, u64 timeout_us, u64 seq,
    enum hl_cs_wait_status *status, s64 *timestamp);
static void cs_do_release(struct kref *ref);

static void hl_push_cs_outcome(struct hl_device *hdev,
          struct hl_cs_outcome_store *outcome_store,
          u64 seq, ktime_t ts, int error)
{
 struct hl_cs_outcome *node;
 unsigned long flags;

 /*
 * CS outcome store supports the following operations:
 * push outcome - store a recent CS outcome in the store
 * pop outcome - retrieve a SPECIFIC (by seq) CS outcome from the store
 * It uses 2 lists: used list and free list.
 * It has a pre-allocated amount of nodes, each node stores
 * a single CS outcome.
 * Initially, all the nodes are in the free list.
 * On push outcome, a node (any) is taken from the free list, its
 * information is filled in, and the node is moved to the used list.
 * It is possible, that there are no nodes left in the free list.
 * In this case, we will lose some information about old outcomes. We
 * will pop the OLDEST node from the used list, and make it free.
 * On pop, the node is searched for in the used list (using a search
 * index).
 * If found, the node is then removed from the used list, and moved
 * back to the free list. The outcome data that the node contained is
 * returned back to the user.
 */

 spin_lock_irqsave(&outcome_store->db_lock, flags);

 if (list_empty(&outcome_store->free_list)) {
  node = list_last_entry(&outcome_store->used_list,
           struct hl_cs_outcome, list_link);
  hash_del(&node->map_link);
  dev_dbg(hdev->dev, "CS %llu outcome was lost\n", node->seq);
 } else {
  node = list_last_entry(&outcome_store->free_list,
           struct hl_cs_outcome, list_link);
 }

 list_del_init(&node->list_link);

 node->seq = seq;
 node->ts = ts;
 node->error = error;

 list_add(&node->list_link, &outcome_store->used_list);
 hash_add(outcome_store->outcome_map, &node->map_link, node->seq);

 spin_unlock_irqrestore(&outcome_store->db_lock, flags);
}

static bool hl_pop_cs_outcome(struct hl_cs_outcome_store *outcome_store,
          u64 seq, ktime_t *ts, int *error)
{
 struct hl_cs_outcome *node;
 unsigned long flags;

 spin_lock_irqsave(&outcome_store->db_lock, flags);

 hash_for_each_possible(outcome_store->outcome_map, node, map_link, seq)
  if (node->seq == seq) {
   *ts = node->ts;
   *error = node->error;

   hash_del(&node->map_link);
   list_del_init(&node->list_link);
   list_add(&node->list_link, &outcome_store->free_list);

   spin_unlock_irqrestore(&outcome_store->db_lock, flags);

   return true;
  }

 spin_unlock_irqrestore(&outcome_store->db_lock, flags);

 return false;
}

static void hl_sob_reset(struct kref *ref)
{
 struct hl_hw_sob *hw_sob = container_of(ref, struct hl_hw_sob,
       kref);
 struct hl_device *hdev = hw_sob->hdev;

 dev_dbg(hdev->dev, "reset sob id %u\n", hw_sob->sob_id);

 hdev->asic_funcs->reset_sob(hdev, hw_sob);

 hw_sob->need_reset = false;
}

void hl_sob_reset_error(struct kref *ref)
{
 struct hl_hw_sob *hw_sob = container_of(ref, struct hl_hw_sob,
       kref);
 struct hl_device *hdev = hw_sob->hdev;

 dev_crit(hdev->dev,
  "SOB release shouldn't be called here, q_idx: %d, sob_id: %d\n",
  hw_sob->q_idx, hw_sob->sob_id);
}

void hw_sob_put(struct hl_hw_sob *hw_sob)
{
 if (hw_sob)
  kref_put(&hw_sob->kref, hl_sob_reset);
}

static void hw_sob_put_err(struct hl_hw_sob *hw_sob)
{
 if (hw_sob)
  kref_put(&hw_sob->kref, hl_sob_reset_error);
}

void hw_sob_get(struct hl_hw_sob *hw_sob)
{
 if (hw_sob)
  kref_get(&hw_sob->kref);
}

/**
 * hl_gen_sob_mask() - Generates a sob mask to be used in a monitor arm packet
 * @sob_base: sob base id
 * @sob_mask: sob user mask, each bit represents a sob offset from sob base
 * @mask: generated mask
 *
 * Return: 0 if given parameters are valid
 */
int hl_gen_sob_mask(u16 sob_base, u8 sob_mask, u8 *mask)
{
 int i;

 if (sob_mask == 0)
  return -EINVAL;

 if (sob_mask == 0x1) {
  *mask = ~(1 << (sob_base & 0x7));
 } else {
  /* find msb in order to verify sob range is valid */
  for (i = BITS_PER_BYTE - 1 ; i >= 0 ; i--)
   if (BIT(i) & sob_mask)
    break;

  if (i > (HL_MAX_SOBS_PER_MONITOR - (sob_base & 0x7) - 1))
   return -EINVAL;

  *mask = ~sob_mask;
 }

 return 0;
}

static void hl_fence_release(struct kref *kref)
{
 struct hl_fence *fence =
  container_of(kref, struct hl_fence, refcount);
 struct hl_cs_compl *hl_cs_cmpl =
  container_of(fence, struct hl_cs_compl, base_fence);

 kfree(hl_cs_cmpl);
}

void hl_fence_put(struct hl_fence *fence)
{
 if (IS_ERR_OR_NULL(fence))
  return;
 kref_put(&fence->refcount, hl_fence_release);
}

void hl_fences_put(struct hl_fence **fence, int len)
{
 int i;

 for (i = 0; i < len; i++, fence++)
  hl_fence_put(*fence);
}

void hl_fence_get(struct hl_fence *fence)
{
 if (fence)
  kref_get(&fence->refcount);
}

static void hl_fence_init(struct hl_fence *fence, u64 sequence)
{
 kref_init(&fence->refcount);
 fence->cs_sequence = sequence;
 fence->error = 0;
 fence->timestamp = ktime_set(0, 0);
 fence->mcs_handling_done = false;
 init_completion(&fence->completion);
}

void cs_get(struct hl_cs *cs)
{
 kref_get(&cs->refcount);
}

static int cs_get_unless_zero(struct hl_cs *cs)
{
 return kref_get_unless_zero(&cs->refcount);
}

static void cs_put(struct hl_cs *cs)
{
 kref_put(&cs->refcount, cs_do_release);
}

static void cs_job_do_release(struct kref *ref)
{
 struct hl_cs_job *job = container_of(ref, struct hl_cs_job, refcount);

 kfree(job);
}

static void hl_cs_job_put(struct hl_cs_job *job)
{
 kref_put(&job->refcount, cs_job_do_release);
}

bool cs_needs_completion(struct hl_cs *cs)
{
 /* In case this is a staged CS, only the last CS in sequence should
 * get a completion, any non staged CS will always get a completion
 */
 if (cs->staged_cs && !cs->staged_last)
  return false;

 return true;
}

bool cs_needs_timeout(struct hl_cs *cs)
{
 /* In case this is a staged CS, only the first CS in sequence should
 * get a timeout, any non staged CS will always get a timeout
 */
 if (cs->staged_cs && !cs->staged_first)
  return false;

 return true;
}

static bool is_cb_patched(struct hl_device *hdev, struct hl_cs_job *job)
{
 /* Patched CB is created for external queues jobs */
 return (job->queue_type == QUEUE_TYPE_EXT);
}

/*
 * cs_parser - parse the user command submission
 *
 * @hpriv : pointer to the private data of the fd
 * @job        : pointer to the job that holds the command submission info
 *
 * The function parses the command submission of the user. It calls the
 * ASIC specific parser, which returns a list of memory blocks to send
 * to the device as different command buffers
 *
 */
static int cs_parser(struct hl_fpriv *hpriv, struct hl_cs_job *job)
{
 struct hl_device *hdev = hpriv->hdev;
 struct hl_cs_parser parser;
 int rc;

 parser.ctx_id = job->cs->ctx->asid;
 parser.cs_sequence = job->cs->sequence;
 parser.job_id = job->id;

 parser.hw_queue_id = job->hw_queue_id;
 parser.job_userptr_list = &job->userptr_list;
 parser.patched_cb = NULL;
 parser.user_cb = job->user_cb;
 parser.user_cb_size = job->user_cb_size;
 parser.queue_type = job->queue_type;
 parser.is_kernel_allocated_cb = job->is_kernel_allocated_cb;
 job->patched_cb = NULL;
 parser.completion = cs_needs_completion(job->cs);

 rc = hdev->asic_funcs->cs_parser(hdev, &parser);

 if (is_cb_patched(hdev, job)) {
  if (!rc) {
   job->patched_cb = parser.patched_cb;
   job->job_cb_size = parser.patched_cb_size;
   job->contains_dma_pkt = parser.contains_dma_pkt;
   atomic_inc(&job->patched_cb->cs_cnt);
  }

  /*
 * Whether the parsing worked or not, we don't need the
 * original CB anymore because it was already parsed and
 * won't be accessed again for this CS
 */
  atomic_dec(&job->user_cb->cs_cnt);
  hl_cb_put(job->user_cb);
  job->user_cb = NULL;
 } else if (!rc) {
  job->job_cb_size = job->user_cb_size;
 }

 return rc;
}

static void hl_complete_job(struct hl_device *hdev, struct hl_cs_job *job)
{
 struct hl_cs *cs = job->cs;

 if (is_cb_patched(hdev, job)) {
  hl_userptr_delete_list(hdev, &job->userptr_list);

  /*
 * We might arrive here from rollback and patched CB wasn't
 * created, so we need to check it's not NULL
 */
  if (job->patched_cb) {
   atomic_dec(&job->patched_cb->cs_cnt);
   hl_cb_put(job->patched_cb);
  }
 }

 /* For H/W queue jobs, if a user CB was allocated by driver,
 * the user CB isn't released in cs_parser() and thus should be
 * released here. This is also true for INT queues jobs which were
 * allocated by driver.
 */
 if (job->is_kernel_allocated_cb &&
   (job->queue_type == QUEUE_TYPE_HW || job->queue_type == QUEUE_TYPE_INT)) {
  atomic_dec(&job->user_cb->cs_cnt);
  hl_cb_put(job->user_cb);
 }

 /*
 * This is the only place where there can be multiple threads
 * modifying the list at the same time
 */
 spin_lock(&cs->job_lock);
 list_del(&job->cs_node);
 spin_unlock(&cs->job_lock);

 hl_debugfs_remove_job(hdev, job);

 /* We decrement reference only for a CS that gets completion
 * because the reference was incremented only for this kind of CS
 * right before it was scheduled.
 *
 * In staged submission, only the last CS marked as 'staged_last'
 * gets completion, hence its release function will be called from here.
 * As for all the rest CS's in the staged submission which do not get
 * completion, their CS reference will be decremented by the
 * 'staged_last' CS during the CS release flow.
 * All relevant PQ CI counters will be incremented during the CS release
 * flow by calling 'hl_hw_queue_update_ci'.
 */
 if (cs_needs_completion(cs) &&
   (job->queue_type == QUEUE_TYPE_EXT || job->queue_type == QUEUE_TYPE_HW)) {

  /* In CS based completions, the timestamp is already available,
 * so no need to extract it from job
 */
  if (hdev->asic_prop.completion_mode == HL_COMPLETION_MODE_JOB)
   cs->completion_timestamp = job->timestamp;

  cs_put(cs);
 }

 hl_cs_job_put(job);
}

/*
 * hl_staged_cs_find_first - locate the first CS in this staged submission
 *
 * @hdev: pointer to device structure
 * @cs_seq: staged submission sequence number
 *
 * @note: This function must be called under 'hdev->cs_mirror_lock'
 *
 * Find and return a CS pointer with the given sequence
 */
struct hl_cs *hl_staged_cs_find_first(struct hl_device *hdev, u64 cs_seq)
{
 struct hl_cs *cs;

 list_for_each_entry_reverse(cs, &hdev->cs_mirror_list, mirror_node)
  if (cs->staged_cs && cs->staged_first &&
    cs->sequence == cs_seq)
   return cs;

 return NULL;
}

/*
 * is_staged_cs_last_exists - returns true if the last CS in sequence exists
 *
 * @hdev: pointer to device structure
 * @cs: staged submission member
 *
 */
bool is_staged_cs_last_exists(struct hl_device *hdev, struct hl_cs *cs)
{
 struct hl_cs *last_entry;

 last_entry = list_last_entry(&cs->staged_cs_node, struct hl_cs,
        staged_cs_node);

 if (last_entry->staged_last)
  return true;

 return false;
}

/*
 * staged_cs_get - get CS reference if this CS is a part of a staged CS
 *
 * @hdev: pointer to device structure
 * @cs: current CS
 * @cs_seq: staged submission sequence number
 *
 * Increment CS reference for every CS in this staged submission except for
 * the CS which get completion.
 */
static void staged_cs_get(struct hl_device *hdev, struct hl_cs *cs)
{
 /* Only the last CS in this staged submission will get a completion.
 * We must increment the reference for all other CS's in this
 * staged submission.
 * Once we get a completion we will release the whole staged submission.
 */
 if (!cs->staged_last)
  cs_get(cs);
}

/*
 * staged_cs_put - put a CS in case it is part of staged submission
 *
 * @hdev: pointer to device structure
 * @cs: CS to put
 *
 * This function decrements a CS reference (for a non completion CS)
 */
static void staged_cs_put(struct hl_device *hdev, struct hl_cs *cs)
{
 /* We release all CS's in a staged submission except the last
 * CS which we have never incremented its reference.
 */
 if (!cs_needs_completion(cs))
  cs_put(cs);
}

static void cs_handle_tdr(struct hl_device *hdev, struct hl_cs *cs)
{
 struct hl_cs *next = NULL, *iter, *first_cs;

 if (!cs_needs_timeout(cs))
  return;

 spin_lock(&hdev->cs_mirror_lock);

 /* We need to handle tdr only once for the complete staged submission.
 * Hence, we choose the CS that reaches this function first which is
 * the CS marked as 'staged_last'.
 * In case single staged cs was submitted which has both first and last
 * indications, then "cs_find_first" below will return NULL, since we
 * removed the cs node from the list before getting here,
 * in such cases just continue with the cs to cancel it's TDR work.
 */
 if (cs->staged_cs && cs->staged_last) {
  first_cs = hl_staged_cs_find_first(hdev, cs->staged_sequence);
  if (first_cs)
   cs = first_cs;
 }

 spin_unlock(&hdev->cs_mirror_lock);

 /* Don't cancel TDR in case this CS was timedout because we might be
 * running from the TDR context
 */
 if (cs->timedout || hdev->timeout_jiffies == MAX_SCHEDULE_TIMEOUT)
  return;

 if (cs->tdr_active)
  cancel_delayed_work_sync(&cs->work_tdr);

 spin_lock(&hdev->cs_mirror_lock);

 /* queue TDR for next CS */
 list_for_each_entry(iter, &hdev->cs_mirror_list, mirror_node)
  if (cs_needs_timeout(iter)) {
   next = iter;
   break;
  }

 if (next && !next->tdr_active) {
  next->tdr_active = true;
  schedule_delayed_work(&next->work_tdr, next->timeout_jiffies);
 }

 spin_unlock(&hdev->cs_mirror_lock);
}

/*
 * force_complete_multi_cs - complete all contexts that wait on multi-CS
 *
 * @hdev: pointer to habanalabs device structure
 */
static void force_complete_multi_cs(struct hl_device *hdev)
{
 int i;

 for (i = 0; i < MULTI_CS_MAX_USER_CTX; i++) {
  struct multi_cs_completion *mcs_compl;

  mcs_compl = &hdev->multi_cs_completion[i];

  spin_lock(&mcs_compl->lock);

  if (!mcs_compl->used) {
   spin_unlock(&mcs_compl->lock);
   continue;
  }

  /* when calling force complete no context should be waiting on
 * multi-cS.
 * We are calling the function as a protection for such case
 * to free any pending context and print error message
 */
  dev_err(hdev->dev,
    "multi-CS completion context %d still waiting when calling force completion\n",
    i);
  complete_all(&mcs_compl->completion);
  spin_unlock(&mcs_compl->lock);
 }
}

/*
 * complete_multi_cs - complete all waiting entities on multi-CS
 *
 * @hdev: pointer to habanalabs device structure
 * @cs: CS structure
 * The function signals a waiting entity that has an overlapping stream masters
 * with the completed CS.
 * For example:
 * - a completed CS worked on stream master QID 4, multi CS completion
 *   is actively waiting on stream master QIDs 3, 5. don't send signal as no
 *   common stream master QID
 * - a completed CS worked on stream master QID 4, multi CS completion
 *   is actively waiting on stream master QIDs 3, 4. send signal as stream
 *   master QID 4 is common
 */
static void complete_multi_cs(struct hl_device *hdev, struct hl_cs *cs)
{
 struct hl_fence *fence = cs->fence;
 int i;

 /* in case of multi CS check for completion only for the first CS */
 if (cs->staged_cs && !cs->staged_first)
  return;

 for (i = 0; i < MULTI_CS_MAX_USER_CTX; i++) {
  struct multi_cs_completion *mcs_compl;

  mcs_compl = &hdev->multi_cs_completion[i];
  if (!mcs_compl->used)
   continue;

  spin_lock(&mcs_compl->lock);

  /*
 * complete if:
 * 1. still waiting for completion
 * 2. the completed CS has at least one overlapping stream
 *    master with the stream masters in the completion
 */
  if (mcs_compl->used &&
    (fence->stream_master_qid_map &
     mcs_compl->stream_master_qid_map)) {
   /* extract the timestamp only of first completed CS */
   if (!mcs_compl->timestamp)
    mcs_compl->timestamp = ktime_to_ns(fence->timestamp);

   complete_all(&mcs_compl->completion);

   /*
 * Setting mcs_handling_done inside the lock ensures
 * at least one fence have mcs_handling_done set to
 * true before wait for mcs finish. This ensures at
 * least one CS will be set as completed when polling
 * mcs fences.
 */
   fence->mcs_handling_done = true;
  }

  spin_unlock(&mcs_compl->lock);
 }
 /* In case CS completed without mcs completion initialized */
 fence->mcs_handling_done = true;
}

static inline void cs_release_sob_reset_handler(struct hl_device *hdev,
     struct hl_cs *cs,
     struct hl_cs_compl *hl_cs_cmpl)
{
 /* Skip this handler if the cs wasn't submitted, to avoid putting
 * the hw_sob twice, since this case already handled at this point,
 * also skip if the hw_sob pointer wasn't set.
 */
 if (!hl_cs_cmpl->hw_sob || !cs->submitted)
  return;

 spin_lock(&hl_cs_cmpl->lock);

 /*
 * we get refcount upon reservation of signals or signal/wait cs for the
 * hw_sob object, and need to put it when the first staged cs
 * (which contains the encaps signals) or cs signal/wait is completed.
 */
 if ((hl_cs_cmpl->type == CS_TYPE_SIGNAL) ||
   (hl_cs_cmpl->type == CS_TYPE_WAIT) ||
   (hl_cs_cmpl->type == CS_TYPE_COLLECTIVE_WAIT) ||
   (!!hl_cs_cmpl->encaps_signals)) {
  dev_dbg(hdev->dev,
    "CS 0x%llx type %d finished, sob_id: %d, sob_val: %u\n",
    hl_cs_cmpl->cs_seq,
    hl_cs_cmpl->type,
    hl_cs_cmpl->hw_sob->sob_id,
    hl_cs_cmpl->sob_val);

  hw_sob_put(hl_cs_cmpl->hw_sob);

  if (hl_cs_cmpl->type == CS_TYPE_COLLECTIVE_WAIT)
   hdev->asic_funcs->reset_sob_group(hdev,
     hl_cs_cmpl->sob_group);
 }

 spin_unlock(&hl_cs_cmpl->lock);
}

static void cs_do_release(struct kref *ref)
{
 struct hl_cs *cs = container_of(ref, struct hl_cs, refcount);
 struct hl_device *hdev = cs->ctx->hdev;
 struct hl_cs_job *job, *tmp;
 struct hl_cs_compl *hl_cs_cmpl =
   container_of(cs->fence, struct hl_cs_compl, base_fence);

 cs->completed = true;

 /*
 * Although if we reached here it means that all external jobs have
 * finished, because each one of them took refcnt to CS, we still
 * need to go over the internal jobs and complete them. Otherwise, we
 * will have leaked memory and what's worse, the CS object (and
 * potentially the CTX object) could be released, while the JOB
 * still holds a pointer to them (but no reference).
 */
 list_for_each_entry_safe(job, tmp, &cs->job_list, cs_node)
  hl_complete_job(hdev, job);

 if (!cs->submitted) {
  /*
 * In case the wait for signal CS was submitted, the fence put
 * occurs in init_signal_wait_cs() or collective_wait_init_cs()
 * right before hanging on the PQ.
 */
  if (cs->type == CS_TYPE_WAIT ||
    cs->type == CS_TYPE_COLLECTIVE_WAIT)
   hl_fence_put(cs->signal_fence);

  goto out;
 }

 /* Need to update CI for all queue jobs that does not get completion */
 hl_hw_queue_update_ci(cs);

 /* remove CS from CS mirror list */
 spin_lock(&hdev->cs_mirror_lock);
 list_del_init(&cs->mirror_node);
 spin_unlock(&hdev->cs_mirror_lock);

 cs_handle_tdr(hdev, cs);

 if (cs->staged_cs) {
  /* the completion CS decrements reference for the entire
 * staged submission
 */
  if (cs->staged_last) {
   struct hl_cs *staged_cs, *tmp_cs;

   list_for_each_entry_safe(staged_cs, tmp_cs,
     &cs->staged_cs_node, staged_cs_node)
    staged_cs_put(hdev, staged_cs);
  }

  /* A staged CS will be a member in the list only after it
 * was submitted. We used 'cs_mirror_lock' when inserting
 * it to list so we will use it again when removing it
 */
  if (cs->submitted) {
   spin_lock(&hdev->cs_mirror_lock);
   list_del(&cs->staged_cs_node);
   spin_unlock(&hdev->cs_mirror_lock);
  }

  /* decrement refcount to handle when first staged cs
 * with encaps signals is completed.
 */
  if (hl_cs_cmpl->encaps_signals)
   kref_put(&hl_cs_cmpl->encaps_sig_hdl->refcount,
     hl_encaps_release_handle_and_put_ctx);
 }

 if ((cs->type == CS_TYPE_WAIT || cs->type == CS_TYPE_COLLECTIVE_WAIT) && cs->encaps_signals)
  kref_put(&cs->encaps_sig_hdl->refcount, hl_encaps_release_handle_and_put_ctx);

out:
 /* Must be called before hl_ctx_put because inside we use ctx to get
 * the device
 */
 hl_debugfs_remove_cs(cs);

 hdev->shadow_cs_queue[cs->sequence & (hdev->asic_prop.max_pending_cs - 1)] = NULL;

 /* We need to mark an error for not submitted because in that case
 * the hl fence release flow is different. Mainly, we don't need
 * to handle hw_sob for signal/wait
 */
 if (cs->timedout)
  cs->fence->error = -ETIMEDOUT;
 else if (cs->aborted)
  cs->fence->error = -EIO;
 else if (!cs->submitted)
  cs->fence->error = -EBUSY;

 if (unlikely(cs->skip_reset_on_timeout)) {
  dev_err(hdev->dev,
   "Command submission %llu completed after %llu (s)\n",
   cs->sequence,
   div_u64(jiffies - cs->submission_time_jiffies, HZ));
 }

 if (cs->timestamp) {
  cs->fence->timestamp = cs->completion_timestamp;
  hl_push_cs_outcome(hdev, &cs->ctx->outcome_store, cs->sequence,
       cs->fence->timestamp, cs->fence->error);
 }

 hl_ctx_put(cs->ctx);

 complete_all(&cs->fence->completion);
 complete_multi_cs(hdev, cs);

 cs_release_sob_reset_handler(hdev, cs, hl_cs_cmpl);

 hl_fence_put(cs->fence);

 kfree(cs->jobs_in_queue_cnt);
 kfree(cs);
}

static void cs_timedout(struct work_struct *work)
{
 struct hl_cs *cs = container_of(work, struct hl_cs, work_tdr.work);
 bool skip_reset_on_timeout, device_reset = false;
 struct hl_device *hdev;
 u64 event_mask = 0x0;
 uint timeout_sec;
 int rc;

 skip_reset_on_timeout = cs->skip_reset_on_timeout;

 rc = cs_get_unless_zero(cs);
 if (!rc)
  return;

 if ((!cs->submitted) || (cs->completed)) {
  cs_put(cs);
  return;
 }

 hdev = cs->ctx->hdev;

 if (likely(!skip_reset_on_timeout)) {
  if (hdev->reset_on_lockup)
   device_reset = true;
  else
   hdev->reset_info.needs_reset = true;

  /* Mark the CS is timed out so we won't try to cancel its TDR */
  cs->timedout = true;
 }

 /* Save only the first CS timeout parameters */
 rc = atomic_cmpxchg(&hdev->captured_err_info.cs_timeout.write_enable, 1, 0);
 if (rc) {
  hdev->captured_err_info.cs_timeout.timestamp = ktime_get();
  hdev->captured_err_info.cs_timeout.seq = cs->sequence;
  event_mask |= HL_NOTIFIER_EVENT_CS_TIMEOUT;
 }

 timeout_sec = jiffies_to_msecs(hdev->timeout_jiffies) / 1000;

 switch (cs->type) {
 case CS_TYPE_SIGNAL:
  dev_err(hdev->dev,
   "Signal command submission %llu has not finished in %u seconds!\n",
   cs->sequence, timeout_sec);
  break;

 case CS_TYPE_WAIT:
  dev_err(hdev->dev,
   "Wait command submission %llu has not finished in %u seconds!\n",
   cs->sequence, timeout_sec);
  break;

 case CS_TYPE_COLLECTIVE_WAIT:
  dev_err(hdev->dev,
   "Collective Wait command submission %llu has not finished in %u seconds!\n",
   cs->sequence, timeout_sec);
  break;

 default:
  dev_err(hdev->dev,
   "Command submission %llu has not finished in %u seconds!\n",
   cs->sequence, timeout_sec);
  break;
 }

 rc = hl_state_dump(hdev);
 if (rc)
  dev_err(hdev->dev, "Error during system state dump %d\n", rc);

 cs_put(cs);

 if (device_reset) {
  event_mask |= HL_NOTIFIER_EVENT_DEVICE_RESET;
  hl_device_cond_reset(hdev, HL_DRV_RESET_TDR, event_mask);
 } else if (event_mask) {
  hl_notifier_event_send_all(hdev, event_mask);
 }
}

static int allocate_cs(struct hl_device *hdev, struct hl_ctx *ctx,
   enum hl_cs_type cs_type, u64 user_sequence,
   struct hl_cs **cs_new, u32 flags, u32 timeout)
{
 struct hl_cs_counters_atomic *cntr;
 struct hl_fence *other = NULL;
 struct hl_cs_compl *cs_cmpl;
 struct hl_cs *cs;
 int rc;

 cntr = &hdev->aggregated_cs_counters;

 cs = kzalloc(sizeof(*cs), GFP_ATOMIC);
 if (!cs)
  cs = kzalloc(sizeof(*cs), GFP_KERNEL);

 if (!cs) {
  atomic64_inc(&ctx->cs_counters.out_of_mem_drop_cnt);
  atomic64_inc(&cntr->out_of_mem_drop_cnt);
  return -ENOMEM;
 }

 /* increment refcnt for context */
 hl_ctx_get(ctx);

 cs->ctx = ctx;
 cs->submitted = false;
 cs->completed = false;
 cs->type = cs_type;
 cs->timestamp = !!(flags & HL_CS_FLAGS_TIMESTAMP);
 cs->encaps_signals = !!(flags & HL_CS_FLAGS_ENCAP_SIGNALS);
 cs->timeout_jiffies = timeout;
 cs->skip_reset_on_timeout =
  hdev->reset_info.skip_reset_on_timeout ||
  !!(flags & HL_CS_FLAGS_SKIP_RESET_ON_TIMEOUT);
 cs->submission_time_jiffies = jiffies;
 INIT_LIST_HEAD(&cs->job_list);
 INIT_DELAYED_WORK(&cs->work_tdr, cs_timedout);
 kref_init(&cs->refcount);
 spin_lock_init(&cs->job_lock);

 cs_cmpl = kzalloc(sizeof(*cs_cmpl), GFP_ATOMIC);
 if (!cs_cmpl)
  cs_cmpl = kzalloc(sizeof(*cs_cmpl), GFP_KERNEL);

 if (!cs_cmpl) {
  atomic64_inc(&ctx->cs_counters.out_of_mem_drop_cnt);
  atomic64_inc(&cntr->out_of_mem_drop_cnt);
  rc = -ENOMEM;
  goto free_cs;
 }

 cs->jobs_in_queue_cnt = kcalloc(hdev->asic_prop.max_queues,
   sizeof(*cs->jobs_in_queue_cnt), GFP_ATOMIC);
 if (!cs->jobs_in_queue_cnt)
  cs->jobs_in_queue_cnt = kcalloc(hdev->asic_prop.max_queues,
    sizeof(*cs->jobs_in_queue_cnt), GFP_KERNEL);

 if (!cs->jobs_in_queue_cnt) {
  atomic64_inc(&ctx->cs_counters.out_of_mem_drop_cnt);
  atomic64_inc(&cntr->out_of_mem_drop_cnt);
  rc = -ENOMEM;
  goto free_cs_cmpl;
 }

 cs_cmpl->hdev = hdev;
 cs_cmpl->type = cs->type;
 spin_lock_init(&cs_cmpl->lock);
 cs->fence = &cs_cmpl->base_fence;

 spin_lock(&ctx->cs_lock);

 cs_cmpl->cs_seq = ctx->cs_sequence;
 other = ctx->cs_pending[cs_cmpl->cs_seq &
    (hdev->asic_prop.max_pending_cs - 1)];

 if (other && !completion_done(&other->completion)) {
  /* If the following statement is true, it means we have reached
 * a point in which only part of the staged submission was
 * submitted and we don't have enough room in the 'cs_pending'
 * array for the rest of the submission.
 * This causes a deadlock because this CS will never be
 * completed as it depends on future CS's for completion.
 */
  if (other->cs_sequence == user_sequence)
   dev_crit_ratelimited(hdev->dev,
    "Staged CS %llu deadlock due to lack of resources",
    user_sequence);

  dev_dbg_ratelimited(hdev->dev,
   "Rejecting CS because of too many in-flights CS\n");
  atomic64_inc(&ctx->cs_counters.max_cs_in_flight_drop_cnt);
  atomic64_inc(&cntr->max_cs_in_flight_drop_cnt);
  rc = -EAGAIN;
  goto free_fence;
 }

 /* init hl_fence */
 hl_fence_init(&cs_cmpl->base_fence, cs_cmpl->cs_seq);

 cs->sequence = cs_cmpl->cs_seq;

 ctx->cs_pending[cs_cmpl->cs_seq &
   (hdev->asic_prop.max_pending_cs - 1)] =
       &cs_cmpl->base_fence;
 ctx->cs_sequence++;

 hl_fence_get(&cs_cmpl->base_fence);

 hl_fence_put(other);

 spin_unlock(&ctx->cs_lock);

 *cs_new = cs;

 return 0;

free_fence:
 spin_unlock(&ctx->cs_lock);
 kfree(cs->jobs_in_queue_cnt);
free_cs_cmpl:
 kfree(cs_cmpl);
free_cs:
 kfree(cs);
 hl_ctx_put(ctx);
 return rc;
}

static void cs_rollback(struct hl_device *hdev, struct hl_cs *cs)
{
 struct hl_cs_job *job, *tmp;

 staged_cs_put(hdev, cs);

 list_for_each_entry_safe(job, tmp, &cs->job_list, cs_node)
  hl_complete_job(hdev, job);
}

/*
 * release_reserved_encaps_signals() - release reserved encapsulated signals.
 * @hdev: pointer to habanalabs device structure
 *
 * Release reserved encapsulated signals which weren't un-reserved, or for which a CS with
 * encapsulated signals wasn't submitted and thus weren't released as part of CS roll-back.
 * For these signals need also to put the refcount of the H/W SOB which was taken at the
 * reservation.
 */
static void release_reserved_encaps_signals(struct hl_device *hdev)
{
 struct hl_ctx *ctx = hl_get_compute_ctx(hdev);
 struct hl_cs_encaps_sig_handle *handle;
 struct hl_encaps_signals_mgr *mgr;
 u32 id;

 if (!ctx)
  return;

 mgr = &ctx->sig_mgr;

 idr_for_each_entry(&mgr->handles, handle, id)
  if (handle->cs_seq == ULLONG_MAX)
   kref_put(&handle->refcount, hl_encaps_release_handle_and_put_sob_ctx);

 hl_ctx_put(ctx);
}

void hl_cs_rollback_all(struct hl_device *hdev, bool skip_wq_flush)
{
 int i;
 struct hl_cs *cs, *tmp;

 if (!skip_wq_flush) {
  flush_workqueue(hdev->ts_free_obj_wq);

  /* flush all completions before iterating over the CS mirror list in
 * order to avoid a race with the release functions
 */
  for (i = 0 ; i < hdev->asic_prop.completion_queues_count ; i++)
   flush_workqueue(hdev->cq_wq[i]);

  flush_workqueue(hdev->cs_cmplt_wq);
 }

 /* Make sure we don't have leftovers in the CS mirror list */
 list_for_each_entry_safe(cs, tmp, &hdev->cs_mirror_list, mirror_node) {
  cs_get(cs);
  cs->aborted = true;
  dev_warn_ratelimited(hdev->dev, "Killing CS %d.%llu\n",
     cs->ctx->asid, cs->sequence);
  cs_rollback(hdev, cs);
  cs_put(cs);
 }

 force_complete_multi_cs(hdev);

 release_reserved_encaps_signals(hdev);
}

static void
wake_pending_user_interrupt_threads(struct hl_user_interrupt *interrupt)
{
 struct hl_user_pending_interrupt *pend, *temp;
 unsigned long flags;

 spin_lock_irqsave(&interrupt->wait_list_lock, flags);
 list_for_each_entry_safe(pend, temp, &interrupt->wait_list_head, list_node) {
  pend->fence.error = -EIO;
  complete_all(&pend->fence.completion);
 }
 spin_unlock_irqrestore(&interrupt->wait_list_lock, flags);

 spin_lock_irqsave(&interrupt->ts_list_lock, flags);
 list_for_each_entry_safe(pend, temp, &interrupt->ts_list_head, list_node) {
  list_del(&pend->list_node);
  hl_mmap_mem_buf_put(pend->ts_reg_info.buf);
  hl_cb_put(pend->ts_reg_info.cq_cb);
 }
 spin_unlock_irqrestore(&interrupt->ts_list_lock, flags);
}

void hl_release_pending_user_interrupts(struct hl_device *hdev)
{
 struct asic_fixed_properties *prop = &hdev->asic_prop;
 struct hl_user_interrupt *interrupt;
 int i;

 if (!prop->user_interrupt_count)
  return;

 /* We iterate through the user interrupt requests and waking up all
 * user threads waiting for interrupt completion. We iterate the
 * list under a lock, this is why all user threads, once awake,
 * will wait on the same lock and will release the waiting object upon
 * unlock.
 */

 for (i = 0 ; i < prop->user_interrupt_count ; i++) {
  interrupt = &hdev->user_interrupt[i];
  wake_pending_user_interrupt_threads(interrupt);
 }

 interrupt = &hdev->common_user_cq_interrupt;
 wake_pending_user_interrupt_threads(interrupt);

 interrupt = &hdev->common_decoder_interrupt;
 wake_pending_user_interrupt_threads(interrupt);
}

static void force_complete_cs(struct hl_device *hdev)
{
 struct hl_cs *cs;

 spin_lock(&hdev->cs_mirror_lock);

 list_for_each_entry(cs, &hdev->cs_mirror_list, mirror_node) {
  cs->fence->error = -EIO;
  complete_all(&cs->fence->completion);
 }

 spin_unlock(&hdev->cs_mirror_lock);
}

void hl_abort_waiting_for_cs_completions(struct hl_device *hdev)
{
 force_complete_cs(hdev);
 force_complete_multi_cs(hdev);
}

static void job_wq_completion(struct work_struct *work)
{
 struct hl_cs_job *job = container_of(work, struct hl_cs_job,
      finish_work);
 struct hl_cs *cs = job->cs;
 struct hl_device *hdev = cs->ctx->hdev;

 /* job is no longer needed */
 hl_complete_job(hdev, job);
}

static void cs_completion(struct work_struct *work)
{
 struct hl_cs *cs = container_of(work, struct hl_cs, finish_work);
 struct hl_device *hdev = cs->ctx->hdev;
 struct hl_cs_job *job, *tmp;

 list_for_each_entry_safe(job, tmp, &cs->job_list, cs_node)
  hl_complete_job(hdev, job);
}

u32 hl_get_active_cs_num(struct hl_device *hdev)
{
 u32 active_cs_num = 0;
 struct hl_cs *cs;

 spin_lock(&hdev->cs_mirror_lock);

 list_for_each_entry(cs, &hdev->cs_mirror_list, mirror_node)
  if (!cs->completed)
   active_cs_num++;

 spin_unlock(&hdev->cs_mirror_lock);

 return active_cs_num;
}

static int validate_queue_index(struct hl_device *hdev,
    struct hl_cs_chunk *chunk,
    enum hl_queue_type *queue_type,
    bool *is_kernel_allocated_cb)
{
 struct asic_fixed_properties *asic = &hdev->asic_prop;
 struct hw_queue_properties *hw_queue_prop;

 /* This must be checked here to prevent out-of-bounds access to
 * hw_queues_props array
 */
 if (chunk->queue_index >= asic->max_queues) {
  dev_err(hdev->dev, "Queue index %d is invalid\n",
   chunk->queue_index);
  return -EINVAL;
 }

 hw_queue_prop = &asic->hw_queues_props[chunk->queue_index];

 if (hw_queue_prop->type == QUEUE_TYPE_NA) {
  dev_err(hdev->dev, "Queue index %d is not applicable\n",
   chunk->queue_index);
  return -EINVAL;
 }

 if (hw_queue_prop->binned) {
  dev_err(hdev->dev, "Queue index %d is binned out\n",
   chunk->queue_index);
  return -EINVAL;
 }

 if (hw_queue_prop->driver_only) {
  dev_err(hdev->dev,
   "Queue index %d is restricted for the kernel driver\n",
   chunk->queue_index);
  return -EINVAL;
 }

 /* When hw queue type isn't QUEUE_TYPE_HW,
 * USER_ALLOC_CB flag shall be referred as "don't care".
 */
 if (hw_queue_prop->type == QUEUE_TYPE_HW) {
  if (chunk->cs_chunk_flags & HL_CS_CHUNK_FLAGS_USER_ALLOC_CB) {
   if (!(hw_queue_prop->cb_alloc_flags & CB_ALLOC_USER)) {
    dev_err(hdev->dev,
     "Queue index %d doesn't support user CB\n",
     chunk->queue_index);
    return -EINVAL;
   }

   *is_kernel_allocated_cb = false;
  } else {
   if (!(hw_queue_prop->cb_alloc_flags &
     CB_ALLOC_KERNEL)) {
    dev_err(hdev->dev,
     "Queue index %d doesn't support kernel CB\n",
     chunk->queue_index);
    return -EINVAL;
   }

   *is_kernel_allocated_cb = true;
  }
 } else {
  *is_kernel_allocated_cb = !!(hw_queue_prop->cb_alloc_flags
      & CB_ALLOC_KERNEL);
 }

 *queue_type = hw_queue_prop->type;
 return 0;
}

static struct hl_cb *get_cb_from_cs_chunk(struct hl_device *hdev,
     struct hl_mem_mgr *mmg,
     struct hl_cs_chunk *chunk)
{
 struct hl_cb *cb;

 cb = hl_cb_get(mmg, chunk->cb_handle);
 if (!cb) {
  dev_err(hdev->dev, "CB handle 0x%llx invalid\n", chunk->cb_handle);
  return NULL;
 }

 if ((chunk->cb_size < 8) || (chunk->cb_size > cb->size)) {
  dev_err(hdev->dev, "CB size %u invalid\n", chunk->cb_size);
  goto release_cb;
 }

 atomic_inc(&cb->cs_cnt);

 return cb;

release_cb:
 hl_cb_put(cb);
 return NULL;
}

struct hl_cs_job *hl_cs_allocate_job(struct hl_device *hdev,
  enum hl_queue_type queue_type, bool is_kernel_allocated_cb)
{
 struct hl_cs_job *job;

 job = kzalloc(sizeof(*job), GFP_ATOMIC);
 if (!job)
  job = kzalloc(sizeof(*job), GFP_KERNEL);

 if (!job)
  return NULL;

 kref_init(&job->refcount);
 job->queue_type = queue_type;
 job->is_kernel_allocated_cb = is_kernel_allocated_cb;

 if (is_cb_patched(hdev, job))
  INIT_LIST_HEAD(&job->userptr_list);

 if (job->queue_type == QUEUE_TYPE_EXT)
  INIT_WORK(&job->finish_work, job_wq_completion);

 return job;
}

static enum hl_cs_type hl_cs_get_cs_type(u32 cs_type_flags)
{
 if (cs_type_flags & HL_CS_FLAGS_SIGNAL)
  return CS_TYPE_SIGNAL;
 else if (cs_type_flags & HL_CS_FLAGS_WAIT)
  return CS_TYPE_WAIT;
 else if (cs_type_flags & HL_CS_FLAGS_COLLECTIVE_WAIT)
  return CS_TYPE_COLLECTIVE_WAIT;
 else if (cs_type_flags & HL_CS_FLAGS_RESERVE_SIGNALS_ONLY)
  return CS_RESERVE_SIGNALS;
 else if (cs_type_flags & HL_CS_FLAGS_UNRESERVE_SIGNALS_ONLY)
  return CS_UNRESERVE_SIGNALS;
 else if (cs_type_flags & HL_CS_FLAGS_ENGINE_CORE_COMMAND)
  return CS_TYPE_ENGINE_CORE;
 else if (cs_type_flags & HL_CS_FLAGS_ENGINES_COMMAND)
  return CS_TYPE_ENGINES;
 else if (cs_type_flags & HL_CS_FLAGS_FLUSH_PCI_HBW_WRITES)
  return CS_TYPE_FLUSH_PCI_HBW_WRITES;
 else
  return CS_TYPE_DEFAULT;
}

static int hl_cs_sanity_checks(struct hl_fpriv *hpriv, union hl_cs_args *args)
{
 struct hl_device *hdev = hpriv->hdev;
 struct hl_ctx *ctx = hpriv->ctx;
 u32 cs_type_flags, num_chunks;
 enum hl_device_status status;
 enum hl_cs_type cs_type;
 bool is_sync_stream;
 int i;

 for (i = 0 ; i < sizeof(args->in.pad) ; i++)
  if (args->in.pad[i]) {
   dev_dbg(hdev->dev, "Padding bytes must be 0\n");
   return -EINVAL;
  }

 if (!hl_device_operational(hdev, &status))
  return -EBUSY;

 if ((args->in.cs_flags & HL_CS_FLAGS_STAGED_SUBMISSION) &&
   !hdev->supports_staged_submission) {
  dev_err(hdev->dev, "staged submission not supported");
  return -EPERM;
 }

 cs_type_flags = args->in.cs_flags & HL_CS_FLAGS_TYPE_MASK;

 if (unlikely(cs_type_flags && !is_power_of_2(cs_type_flags))) {
  dev_err(hdev->dev,
   "CS type flags are mutually exclusive, context %d\n",
   ctx->asid);
  return -EINVAL;
 }

 cs_type = hl_cs_get_cs_type(cs_type_flags);
 num_chunks = args->in.num_chunks_execute;

 is_sync_stream = (cs_type == CS_TYPE_SIGNAL || cs_type == CS_TYPE_WAIT ||
   cs_type == CS_TYPE_COLLECTIVE_WAIT);

 if (unlikely(is_sync_stream && !hdev->supports_sync_stream)) {
  dev_err(hdev->dev, "Sync stream CS is not supported\n");
  return -EINVAL;
 }

 if (cs_type == CS_TYPE_DEFAULT) {
  if (!num_chunks) {
   dev_err(hdev->dev, "Got execute CS with 0 chunks, context %d\n", ctx->asid);
   return -EINVAL;
  }
 } else if (is_sync_stream && num_chunks != 1) {
  dev_err(hdev->dev,
   "Sync stream CS mandates one chunk only, context %d\n",
   ctx->asid);
  return -EINVAL;
 }

 return 0;
}

static int hl_cs_copy_chunk_array(struct hl_device *hdev,
     struct hl_cs_chunk **cs_chunk_array,
     void __user *chunks, u32 num_chunks,
     struct hl_ctx *ctx)
{
 u32 size_to_copy;

 if (num_chunks > HL_MAX_JOBS_PER_CS) {
  atomic64_inc(&ctx->cs_counters.validation_drop_cnt);
  atomic64_inc(&hdev->aggregated_cs_counters.validation_drop_cnt);
  dev_err(hdev->dev,
   "Number of chunks can NOT be larger than %d\n",
   HL_MAX_JOBS_PER_CS);
  return -EINVAL;
 }

 *cs_chunk_array = kmalloc_array(num_chunks, sizeof(**cs_chunk_array),
     GFP_ATOMIC);
 if (!*cs_chunk_array)
  *cs_chunk_array = kmalloc_array(num_chunks,
     sizeof(**cs_chunk_array), GFP_KERNEL);
 if (!*cs_chunk_array) {
  atomic64_inc(&ctx->cs_counters.out_of_mem_drop_cnt);
  atomic64_inc(&hdev->aggregated_cs_counters.out_of_mem_drop_cnt);
  return -ENOMEM;
 }

 size_to_copy = num_chunks * sizeof(struct hl_cs_chunk);
 if (copy_from_user(*cs_chunk_array, chunks, size_to_copy)) {
  atomic64_inc(&ctx->cs_counters.validation_drop_cnt);
  atomic64_inc(&hdev->aggregated_cs_counters.validation_drop_cnt);
  dev_err(hdev->dev, "Failed to copy cs chunk array from user\n");
  kfree(*cs_chunk_array);
  return -EFAULT;
 }

 return 0;
}

static int cs_staged_submission(struct hl_device *hdev, struct hl_cs *cs,
    u64 sequence, u32 flags,
    u32 encaps_signal_handle)
{
 if (!(flags & HL_CS_FLAGS_STAGED_SUBMISSION))
  return 0;

 cs->staged_last = !!(flags & HL_CS_FLAGS_STAGED_SUBMISSION_LAST);
 cs->staged_first = !!(flags & HL_CS_FLAGS_STAGED_SUBMISSION_FIRST);

 if (cs->staged_first) {
  /* Staged CS sequence is the first CS sequence */
  INIT_LIST_HEAD(&cs->staged_cs_node);
  cs->staged_sequence = cs->sequence;

  if (cs->encaps_signals)
   cs->encaps_sig_hdl_id = encaps_signal_handle;
 } else {
  /* User sequence will be validated in 'hl_hw_queue_schedule_cs'
 * under the cs_mirror_lock
 */
  cs->staged_sequence = sequence;
 }

 /* Increment CS reference if needed */
 staged_cs_get(hdev, cs);

 cs->staged_cs = true;

 return 0;
}

static u32 get_stream_master_qid_mask(struct hl_device *hdev, u32 qid)
{
 int i;

 for (i = 0; i < hdev->stream_master_qid_arr_size; i++)
  if (qid == hdev->stream_master_qid_arr[i])
   return BIT(i);

 return 0;
}

static int cs_ioctl_default(struct hl_fpriv *hpriv, void __user *chunks,
    u32 num_chunks, u64 *cs_seq, u32 flags,
    u32 encaps_signals_handle, u32 timeout,
    u16 *signal_initial_sob_count)
{
 bool staged_mid, int_queues_only = true, using_hw_queues = false;
 struct hl_device *hdev = hpriv->hdev;
 struct hl_cs_chunk *cs_chunk_array;
 struct hl_cs_counters_atomic *cntr;
 struct hl_ctx *ctx = hpriv->ctx;
 struct hl_cs_job *job;
 struct hl_cs *cs;
 struct hl_cb *cb;
 u64 user_sequence;
 u8 stream_master_qid_map = 0;
 int rc, i;

 cntr = &hdev->aggregated_cs_counters;
 user_sequence = *cs_seq;
 *cs_seq = ULLONG_MAX;

 rc = hl_cs_copy_chunk_array(hdev, &cs_chunk_array, chunks, num_chunks,
   hpriv->ctx);
 if (rc)
  goto out;

 if ((flags & HL_CS_FLAGS_STAGED_SUBMISSION) &&
   !(flags & HL_CS_FLAGS_STAGED_SUBMISSION_FIRST))
  staged_mid = true;
 else
  staged_mid = false;

 rc = allocate_cs(hdev, hpriv->ctx, CS_TYPE_DEFAULT,
   staged_mid ? user_sequence : ULLONG_MAX, &cs, flags,
   timeout);
 if (rc)
  goto free_cs_chunk_array;

 *cs_seq = cs->sequence;

 hl_debugfs_add_cs(cs);

 rc = cs_staged_submission(hdev, cs, user_sequence, flags,
      encaps_signals_handle);
 if (rc)
  goto free_cs_object;

 /* If this is a staged submission we must return the staged sequence
 * rather than the internal CS sequence
 */
 if (cs->staged_cs)
  *cs_seq = cs->staged_sequence;

 /* Validate ALL the CS chunks before submitting the CS */
 for (i = 0 ; i < num_chunks ; i++) {
  struct hl_cs_chunk *chunk = &cs_chunk_array[i];
  enum hl_queue_type queue_type;
  bool is_kernel_allocated_cb;

  rc = validate_queue_index(hdev, chunk, &queue_type,
      &is_kernel_allocated_cb);
  if (rc) {
   atomic64_inc(&ctx->cs_counters.validation_drop_cnt);
   atomic64_inc(&cntr->validation_drop_cnt);
   goto free_cs_object;
  }

  if (is_kernel_allocated_cb) {
   cb = get_cb_from_cs_chunk(hdev, &hpriv->mem_mgr, chunk);
   if (!cb) {
    atomic64_inc(
     &ctx->cs_counters.validation_drop_cnt);
    atomic64_inc(&cntr->validation_drop_cnt);
    rc = -EINVAL;
    goto free_cs_object;
   }
  } else {
   cb = (struct hl_cb *) (uintptr_t) chunk->cb_handle;
  }

  if (queue_type == QUEUE_TYPE_EXT ||
      queue_type == QUEUE_TYPE_HW) {
   int_queues_only = false;

   /*
 * store which stream are being used for external/HW
 * queues of this CS
 */
   if (hdev->supports_wait_for_multi_cs)
    stream_master_qid_map |=
     get_stream_master_qid_mask(hdev,
       chunk->queue_index);
  }

  if (queue_type == QUEUE_TYPE_HW)
   using_hw_queues = true;

  job = hl_cs_allocate_job(hdev, queue_type,
      is_kernel_allocated_cb);
  if (!job) {
   atomic64_inc(&ctx->cs_counters.out_of_mem_drop_cnt);
   atomic64_inc(&cntr->out_of_mem_drop_cnt);
   dev_err(hdev->dev, "Failed to allocate a new job\n");
   rc = -ENOMEM;
   if (is_kernel_allocated_cb)
    goto release_cb;

   goto free_cs_object;
  }

  job->id = i + 1;
  job->cs = cs;
  job->user_cb = cb;
  job->user_cb_size = chunk->cb_size;
  job->hw_queue_id = chunk->queue_index;

  cs->jobs_in_queue_cnt[job->hw_queue_id]++;
  cs->jobs_cnt++;

  list_add_tail(&job->cs_node, &cs->job_list);

  /*
 * Increment CS reference. When CS reference is 0, CS is
 * done and can be signaled to user and free all its resources
 * Only increment for JOB on external or H/W queues, because
 * only for those JOBs we get completion
 */
  if (cs_needs_completion(cs) &&
   (job->queue_type == QUEUE_TYPE_EXT ||
    job->queue_type == QUEUE_TYPE_HW))
   cs_get(cs);

  hl_debugfs_add_job(hdev, job);

  rc = cs_parser(hpriv, job);
  if (rc) {
   atomic64_inc(&ctx->cs_counters.parsing_drop_cnt);
   atomic64_inc(&cntr->parsing_drop_cnt);
   dev_err(hdev->dev,
    "Failed to parse JOB %d.%llu.%d, err %d, rejecting the CS\n",
    cs->ctx->asid, cs->sequence, job->id, rc);
   goto free_cs_object;
  }
 }

 /* We allow a CS with any queue type combination as long as it does
 * not get a completion
 */
 if (int_queues_only && cs_needs_completion(cs)) {
  atomic64_inc(&ctx->cs_counters.validation_drop_cnt);
  atomic64_inc(&cntr->validation_drop_cnt);
  dev_err(hdev->dev,
   "Reject CS %d.%llu since it contains only internal queues jobs and needs completion\n",
   cs->ctx->asid, cs->sequence);
  rc = -EINVAL;
  goto free_cs_object;
 }

 if (using_hw_queues)
  INIT_WORK(&cs->finish_work, cs_completion);

 /*
 * store the (external/HW queues) streams used by the CS in the
 * fence object for multi-CS completion
 */
 if (hdev->supports_wait_for_multi_cs)
  cs->fence->stream_master_qid_map = stream_master_qid_map;

 rc = hl_hw_queue_schedule_cs(cs);
 if (rc) {
  if (rc != -EAGAIN)
   dev_err(hdev->dev,
    "Failed to submit CS %d.%llu to H/W queues, error %d\n",
    cs->ctx->asid, cs->sequence, rc);
  goto free_cs_object;
 }

 *signal_initial_sob_count = cs->initial_sob_count;

 rc = HL_CS_STATUS_SUCCESS;
 goto put_cs;

release_cb:
 atomic_dec(&cb->cs_cnt);
 hl_cb_put(cb);
free_cs_object:
 cs_rollback(hdev, cs);
 *cs_seq = ULLONG_MAX;
 /* The path below is both for good and erroneous exits */
put_cs:
 /* We finished with the CS in this function, so put the ref */
 cs_put(cs);
free_cs_chunk_array:
 kfree(cs_chunk_array);
out:
 return rc;
}

static int hl_cs_ctx_switch(struct hl_fpriv *hpriv, union hl_cs_args *args,
    u64 *cs_seq)
{
 struct hl_device *hdev = hpriv->hdev;
 struct hl_ctx *ctx = hpriv->ctx;
 bool need_soft_reset = false;
 int rc = 0, do_ctx_switch = 0;
 void __user *chunks;
 u32 num_chunks, tmp;
 u16 sob_count;
 int ret;

 if (hdev->supports_ctx_switch)
  do_ctx_switch = atomic_cmpxchg(&ctx->thread_ctx_switch_token, 1, 0);

 if (do_ctx_switch || (args->in.cs_flags & HL_CS_FLAGS_FORCE_RESTORE)) {
  mutex_lock(&hpriv->restore_phase_mutex);

  if (do_ctx_switch) {
   rc = hdev->asic_funcs->context_switch(hdev, ctx->asid);
   if (rc) {
    dev_err_ratelimited(hdev->dev,
     "Failed to switch to context %d, rejecting CS! %d\n",
     ctx->asid, rc);
    /*
 * If we timedout, or if the device is not IDLE
 * while we want to do context-switch (-EBUSY),
 * we need to soft-reset because QMAN is
 * probably stuck. However, we can't call to
 * reset here directly because of deadlock, so
 * need to do it at the very end of this
 * function
 */
    if ((rc == -ETIMEDOUT) || (rc == -EBUSY))
     need_soft_reset = true;
    mutex_unlock(&hpriv->restore_phase_mutex);
    goto out;
   }
  }

  hdev->asic_funcs->restore_phase_topology(hdev);

  chunks = (void __user *) (uintptr_t) args->in.chunks_restore;
  num_chunks = args->in.num_chunks_restore;

  if (!num_chunks) {
   dev_dbg(hdev->dev,
    "Need to run restore phase but restore CS is empty\n");
   rc = 0;
  } else {
   rc = cs_ioctl_default(hpriv, chunks, num_chunks,
     cs_seq, 0, 0, hdev->timeout_jiffies, &sob_count);
  }

  mutex_unlock(&hpriv->restore_phase_mutex);

  if (rc) {
   dev_err(hdev->dev,
    "Failed to submit restore CS for context %d (%d)\n",
    ctx->asid, rc);
   goto out;
  }

  /* Need to wait for restore completion before execution phase */
  if (num_chunks) {
   enum hl_cs_wait_status status;

   ret = _hl_cs_wait_ioctl(hdev, ctx,
     jiffies_to_usecs(hdev->timeout_jiffies),
     *cs_seq, &status, NULL);
   if (ret) {
    dev_err(hdev->dev,
     "Restore CS for context %d failed to complete %d\n",
     ctx->asid, ret);
    rc = -ENOEXEC;
    goto out;
   }
  }

  if (hdev->supports_ctx_switch)
   ctx->thread_ctx_switch_wait_token = 1;

 } else if (hdev->supports_ctx_switch && !ctx->thread_ctx_switch_wait_token) {
  rc = hl_poll_timeout_memory(hdev,
   &ctx->thread_ctx_switch_wait_token, tmp, (tmp == 1),
   100, jiffies_to_usecs(hdev->timeout_jiffies), false);

  if (rc == -ETIMEDOUT) {
   dev_err(hdev->dev,
    "context switch phase timeout (%d)\n", tmp);
   goto out;
  }
 }

out:
 if ((rc == -ETIMEDOUT || rc == -EBUSY) && (need_soft_reset))
  hl_device_reset(hdev, 0);

 return rc;
}

/*
 * hl_cs_signal_sob_wraparound_handler: handle SOB value wrapaound case.
 * if the SOB value reaches the max value move to the other SOB reserved
 * to the queue.
 * @hdev: pointer to device structure
 * @q_idx: stream queue index
 * @hw_sob: the H/W SOB used in this signal CS.
 * @count: signals count
 * @encaps_sig: tells whether it's reservation for encaps signals or not.
 *
 * Note that this function must be called while hw_queues_lock is taken.
 */
int hl_cs_signal_sob_wraparound_handler(struct hl_device *hdev, u32 q_idx,
   struct hl_hw_sob **hw_sob, u32 count, bool encaps_sig)

{
 struct hl_sync_stream_properties *prop;
 struct hl_hw_sob *sob = *hw_sob, *other_sob;
 u8 other_sob_offset;

 prop = &hdev->kernel_queues[q_idx].sync_stream_prop;

 hw_sob_get(sob);

 /* check for wraparound */
 if (prop->next_sob_val + count >= HL_MAX_SOB_VAL) {
  /*
 * Decrement as we reached the max value.
 * The release function won't be called here as we've
 * just incremented the refcount right before calling this
 * function.
 */
  hw_sob_put_err(sob);

  /*
 * check the other sob value, if it still in use then fail
 * otherwise make the switch
 */
  other_sob_offset = (prop->curr_sob_offset + 1) % HL_RSVD_SOBS;
  other_sob = &prop->hw_sob[other_sob_offset];

  if (kref_read(&other_sob->kref) != 1) {
   dev_err(hdev->dev, "error: Cannot switch SOBs q_idx: %d\n",
        q_idx);
   return -EINVAL;
  }

  /*
 * next_sob_val always points to the next available signal
 * in the sob, so in encaps signals it will be the next one
 * after reserving the required amount.
 */
  if (encaps_sig)
   prop->next_sob_val = count + 1;
  else
   prop->next_sob_val = count;

  /* only two SOBs are currently in use */
  prop->curr_sob_offset = other_sob_offset;
  *hw_sob = other_sob;

  /*
 * check if other_sob needs reset, then do it before using it
 * for the reservation or the next signal cs.
 * we do it here, and for both encaps and regular signal cs
 * cases in order to avoid possible races of two kref_put
 * of the sob which can occur at the same time if we move the
 * sob reset(kref_put) to cs_do_release function.
 * in addition, if we have combination of cs signal and
 * encaps, and at the point we need to reset the sob there was
 * no more reservations and only signal cs keep coming,
 * in such case we need signal_cs to put the refcount and
 * reset the sob.
 */
  if (other_sob->need_reset)
   hw_sob_put(other_sob);

  if (encaps_sig) {
   /* set reset indication for the sob */
   sob->need_reset = true;
   hw_sob_get(other_sob);
  }

  dev_dbg(hdev->dev, "switched to SOB %d, q_idx: %d\n",
    prop->curr_sob_offset, q_idx);
 } else {
  prop->next_sob_val += count;
 }

 return 0;
}

static int cs_ioctl_extract_signal_seq(struct hl_device *hdev,
  struct hl_cs_chunk *chunk, u64 *signal_seq, struct hl_ctx *ctx,
  bool encaps_signals)
{
 u64 *signal_seq_arr = NULL;
 u32 size_to_copy, signal_seq_arr_len;
 int rc = 0;

 if (encaps_signals) {
  *signal_seq = chunk->encaps_signal_seq;
  return 0;
 }

 signal_seq_arr_len = chunk->num_signal_seq_arr;

 /* currently only one signal seq is supported */
 if (signal_seq_arr_len != 1) {
  atomic64_inc(&ctx->cs_counters.validation_drop_cnt);
  atomic64_inc(&hdev->aggregated_cs_counters.validation_drop_cnt);
  dev_err(hdev->dev,
   "Wait for signal CS supports only one signal CS seq\n");
  return -EINVAL;
 }

 signal_seq_arr = kmalloc_array(signal_seq_arr_len,
     sizeof(*signal_seq_arr),
     GFP_ATOMIC);
 if (!signal_seq_arr)
  signal_seq_arr = kmalloc_array(signal_seq_arr_len,
     sizeof(*signal_seq_arr),
     GFP_KERNEL);
 if (!signal_seq_arr) {
  atomic64_inc(&ctx->cs_counters.out_of_mem_drop_cnt);
  atomic64_inc(&hdev->aggregated_cs_counters.out_of_mem_drop_cnt);
  return -ENOMEM;
 }

 size_to_copy = signal_seq_arr_len * sizeof(*signal_seq_arr);
 if (copy_from_user(signal_seq_arr,
    u64_to_user_ptr(chunk->signal_seq_arr),
    size_to_copy)) {
  atomic64_inc(&ctx->cs_counters.validation_drop_cnt);
  atomic64_inc(&hdev->aggregated_cs_counters.validation_drop_cnt);
  dev_err(hdev->dev,
   "Failed to copy signal seq array from user\n");
  rc = -EFAULT;
  goto out;
 }

 /* currently it is guaranteed to have only one signal seq */
 *signal_seq = signal_seq_arr[0];

out:
 kfree(signal_seq_arr);

 return rc;
}

static int cs_ioctl_signal_wait_create_jobs(struct hl_device *hdev,
  struct hl_ctx *ctx, struct hl_cs *cs,
  enum hl_queue_type q_type, u32 q_idx, u32 encaps_signal_offset)
{
 struct hl_cs_counters_atomic *cntr;
 struct hl_cs_job *job;
 struct hl_cb *cb;
 u32 cb_size;

 cntr = &hdev->aggregated_cs_counters;

 job = hl_cs_allocate_job(hdev, q_type, true);
 if (!job) {
  atomic64_inc(&ctx->cs_counters.out_of_mem_drop_cnt);
  atomic64_inc(&cntr->out_of_mem_drop_cnt);
  dev_err(hdev->dev, "Failed to allocate a new job\n");
  return -ENOMEM;
 }

 if (cs->type == CS_TYPE_WAIT)
  cb_size = hdev->asic_funcs->get_wait_cb_size(hdev);
 else
  cb_size = hdev->asic_funcs->get_signal_cb_size(hdev);

 cb = hl_cb_kernel_create(hdev, cb_size, q_type == QUEUE_TYPE_HW);
 if (!cb) {
  atomic64_inc(&ctx->cs_counters.out_of_mem_drop_cnt);
  atomic64_inc(&cntr->out_of_mem_drop_cnt);
  kfree(job);
  return -EFAULT;
 }

 job->id = 0;
 job->cs = cs;
 job->user_cb = cb;
 atomic_inc(&job->user_cb->cs_cnt);
 job->user_cb_size = cb_size;
 job->hw_queue_id = q_idx;

 if ((cs->type == CS_TYPE_WAIT || cs->type == CS_TYPE_COLLECTIVE_WAIT)
   && cs->encaps_signals)
  job->encaps_sig_wait_offset = encaps_signal_offset;
 /*
 * No need in parsing, user CB is the patched CB.
 * We call hl_cb_destroy() out of two reasons - we don't need the CB in
 * the CB idr anymore and to decrement its refcount as it was
 * incremented inside hl_cb_kernel_create().
 */
 job->patched_cb = job->user_cb;
 job->job_cb_size = job->user_cb_size;
 hl_cb_destroy(&hdev->kernel_mem_mgr, cb->buf->handle);

 /* increment refcount as for external queues we get completion */
 cs_get(cs);

 cs->jobs_in_queue_cnt[job->hw_queue_id]++;
 cs->jobs_cnt++;

 list_add_tail(&job->cs_node, &cs->job_list);

 hl_debugfs_add_job(hdev, job);

 return 0;
}

static int cs_ioctl_reserve_signals(struct hl_fpriv *hpriv,
    u32 q_idx, u32 count,
    u32 *handle_id, u32 *sob_addr,
    u32 *signals_count)
{
 struct hw_queue_properties *hw_queue_prop;
 struct hl_sync_stream_properties *prop;
 struct hl_device *hdev = hpriv->hdev;
 struct hl_cs_encaps_sig_handle *handle;
 struct hl_encaps_signals_mgr *mgr;
 struct hl_hw_sob *hw_sob;
 int hdl_id;
 int rc = 0;

 if (count >= HL_MAX_SOB_VAL) {
  dev_err(hdev->dev, "signals count(%u) exceeds the max SOB value\n",
      count);
  rc = -EINVAL;
  goto out;
 }

 if (q_idx >= hdev->asic_prop.max_queues) {
  dev_err(hdev->dev, "Queue index %d is invalid\n",
   q_idx);
  rc = -EINVAL;
  goto out;
 }

 hw_queue_prop = &hdev->asic_prop.hw_queues_props[q_idx];

 if (!hw_queue_prop->supports_sync_stream) {
  dev_err(hdev->dev,
   "Queue index %d does not support sync stream operations\n",
         q_idx);
  rc = -EINVAL;
  goto out;
 }

 prop = &hdev->kernel_queues[q_idx].sync_stream_prop;

 handle = kzalloc(sizeof(*handle), GFP_KERNEL);
 if (!handle) {
  rc = -ENOMEM;
  goto out;
 }

 handle->count = count;

 hl_ctx_get(hpriv->ctx);
 handle->ctx = hpriv->ctx;
 mgr = &hpriv->ctx->sig_mgr;

 spin_lock(&mgr->lock);
 hdl_id = idr_alloc(&mgr->handles, handle, 1, 0, GFP_ATOMIC);
 spin_unlock(&mgr->lock);

 if (hdl_id < 0) {
  dev_err(hdev->dev, "Failed to allocate IDR for a new signal reservation\n");
  rc = -EINVAL;
  goto put_ctx;
 }

 handle->id = hdl_id;
 handle->q_idx = q_idx;
 handle->hdev = hdev;
 kref_init(&handle->refcount);

 hdev->asic_funcs->hw_queues_lock(hdev);

 hw_sob = &prop->hw_sob[prop->curr_sob_offset];

 /*
 * Increment the SOB value by count by user request
 * to reserve those signals
 * check if the signals amount to reserve is not exceeding the max sob
 * value, if yes then switch sob.
 */
 rc = hl_cs_signal_sob_wraparound_handler(hdev, q_idx, &hw_sob, count,
        true);
 if (rc) {
  dev_err(hdev->dev, "Failed to switch SOB\n");
  hdev->asic_funcs->hw_queues_unlock(hdev);
  rc = -EINVAL;
  goto remove_idr;
 }
 /* set the hw_sob to the handle after calling the sob wraparound handler
 * since sob could have changed.
 */
 handle->hw_sob = hw_sob;

 /* store the current sob value for unreserve validity check, and
 * signal offset support
 */
 handle->pre_sob_val = prop->next_sob_val - handle->count;

 handle->cs_seq = ULLONG_MAX;

 *signals_count = prop->next_sob_val;
 hdev->asic_funcs->hw_queues_unlock(hdev);

 *sob_addr = handle->hw_sob->sob_addr;
 *handle_id = hdl_id;

 dev_dbg(hdev->dev,
  "Signals reserved, sob_id: %d, sob addr: 0x%x, last sob_val: %u, q_idx: %d, hdl_id: %d\n",
   hw_sob->sob_id, handle->hw_sob->sob_addr,
   prop->next_sob_val - 1, q_idx, hdl_id);
 goto out;

remove_idr:
 spin_lock(&mgr->lock);
 idr_remove(&mgr->handles, hdl_id);
 spin_unlock(&mgr->lock);

put_ctx:
 hl_ctx_put(handle->ctx);
 kfree(handle);

out:
 return rc;
}

static int cs_ioctl_unreserve_signals(struct hl_fpriv *hpriv, u32 handle_id)
{
 struct hl_cs_encaps_sig_handle *encaps_sig_hdl;
 struct hl_sync_stream_properties *prop;
 struct hl_device *hdev = hpriv->hdev;
 struct hl_encaps_signals_mgr *mgr;
 struct hl_hw_sob *hw_sob;
 u32 q_idx, sob_addr;
 int rc = 0;

 mgr = &hpriv->ctx->sig_mgr;

 spin_lock(&mgr->lock);
 encaps_sig_hdl = idr_find(&mgr->handles, handle_id);
 if (encaps_sig_hdl) {
  dev_dbg(hdev->dev, "unreserve signals, handle: %u, SOB:0x%x, count: %u\n",
    handle_id, encaps_sig_hdl->hw_sob->sob_addr,
     encaps_sig_hdl->count);

  hdev->asic_funcs->hw_queues_lock(hdev);

  q_idx = encaps_sig_hdl->q_idx;
  prop = &hdev->kernel_queues[q_idx].sync_stream_prop;
  hw_sob = &prop->hw_sob[prop->curr_sob_offset];
  sob_addr = hdev->asic_funcs->get_sob_addr(hdev, hw_sob->sob_id);

  /* Check if sob_val got out of sync due to other
 * signal submission requests which were handled
 * between the reserve-unreserve calls or SOB switch
 * upon reaching SOB max value.
 */
  if (encaps_sig_hdl->pre_sob_val + encaps_sig_hdl->count
    != prop->next_sob_val ||
    sob_addr != encaps_sig_hdl->hw_sob->sob_addr) {
   dev_err(hdev->dev, "Cannot unreserve signals, SOB val ran out of sync, expected: %u, actual val: %u\n",
    encaps_sig_hdl->pre_sob_val,
    (prop->next_sob_val - encaps_sig_hdl->count));

   hdev->asic_funcs->hw_queues_unlock(hdev);
   rc = -EINVAL;
   goto out_unlock;
  }

  /*
 * Decrement the SOB value by count by user request
 * to unreserve those signals
 */
  prop->next_sob_val -= encaps_sig_hdl->count;

  hdev->asic_funcs->hw_queues_unlock(hdev);

  hw_sob_put(hw_sob);

  /* Release the id and free allocated memory of the handle */
  idr_remove(&mgr->handles, handle_id);

  /* unlock before calling ctx_put, where we might sleep */
  spin_unlock(&mgr->lock);
  hl_ctx_put(encaps_sig_hdl->ctx);
  kfree(encaps_sig_hdl);
  goto out;
 } else {
  rc = -EINVAL;
  dev_err(hdev->dev, "failed to unreserve signals, cannot find handler\n");
 }

out_unlock:
 spin_unlock(&mgr->lock);

out:
 return rc;
}

static int cs_ioctl_signal_wait(struct hl_fpriv *hpriv, enum hl_cs_type cs_type,
    void __user *chunks, u32 num_chunks,
    u64 *cs_seq, u32 flags, u32 timeout,
    u32 *signal_sob_addr_offset, u16 *signal_initial_sob_count)
{
 struct hl_cs_encaps_sig_handle *encaps_sig_hdl = NULL;
 bool handle_found = false, is_wait_cs = false,
   wait_cs_submitted = false,
   cs_encaps_signals = false;
 struct hl_cs_chunk *cs_chunk_array, *chunk;
 bool staged_cs_with_encaps_signals = false;
 struct hw_queue_properties *hw_queue_prop;
 struct hl_device *hdev = hpriv->hdev;
 struct hl_cs_compl *sig_waitcs_cmpl;
 u32 q_idx, collective_engine_id = 0;
 struct hl_cs_counters_atomic *cntr;
 struct hl_fence *sig_fence = NULL;
 struct hl_ctx *ctx = hpriv->ctx;
 enum hl_queue_type q_type;
 struct hl_cs *cs;
 u64 signal_seq;
 int rc;

 cntr = &hdev->aggregated_cs_counters;
 *cs_seq = ULLONG_MAX;

 rc = hl_cs_copy_chunk_array(hdev, &cs_chunk_array, chunks, num_chunks,
   ctx);
 if (rc)
  goto out;

 /* currently it is guaranteed to have only one chunk */
 chunk = &cs_chunk_array[0];

 if (chunk->queue_index >= hdev->asic_prop.max_queues) {
  atomic64_inc(&ctx->cs_counters.validation_drop_cnt);
  atomic64_inc(&cntr->validation_drop_cnt);
  dev_err(hdev->dev, "Queue index %d is invalid\n",
   chunk->queue_index);
  rc = -EINVAL;
  goto free_cs_chunk_array;
 }

 q_idx = chunk->queue_index;
 hw_queue_prop = &hdev->asic_prop.hw_queues_props[q_idx];
 q_type = hw_queue_prop->type;

 if (!hw_queue_prop->supports_sync_stream) {
  atomic64_inc(&ctx->cs_counters.validation_drop_cnt);
  atomic64_inc(&cntr->validation_drop_cnt);
  dev_err(hdev->dev,
   "Queue index %d does not support sync stream operations\n",
   q_idx);
  rc = -EINVAL;
  goto free_cs_chunk_array;
 }

 if (cs_type == CS_TYPE_COLLECTIVE_WAIT) {
  if (!(hw_queue_prop->collective_mode == HL_COLLECTIVE_MASTER)) {
   atomic64_inc(&ctx->cs_counters.validation_drop_cnt);
   atomic64_inc(&cntr->validation_drop_cnt);
   dev_err(hdev->dev,
    "Queue index %d is invalid\n", q_idx);
   rc = -EINVAL;
   goto free_cs_chunk_array;
  }

  if (!hdev->nic_ports_mask) {
   atomic64_inc(&ctx->cs_counters.validation_drop_cnt);
   atomic64_inc(&cntr->validation_drop_cnt);
   dev_err(hdev->dev,
    "Collective operations not supported when NIC ports are disabled");
   rc = -EINVAL;
   goto free_cs_chunk_array;
  }

  collective_engine_id = chunk->collective_engine_id;
 }

 is_wait_cs = !!(cs_type == CS_TYPE_WAIT ||
   cs_type == CS_TYPE_COLLECTIVE_WAIT);

 cs_encaps_signals = !!(flags & HL_CS_FLAGS_ENCAP_SIGNALS);

 if (is_wait_cs) {
  rc = cs_ioctl_extract_signal_seq(hdev, chunk, &signal_seq,
    ctx, cs_encaps_signals);
  if (rc)
   goto free_cs_chunk_array;

  if (cs_encaps_signals) {
   /* check if cs sequence has encapsulated
 * signals handle
 */
   struct idr *idp;
   u32 id;

   spin_lock(&ctx->sig_mgr.lock);
   idp = &ctx->sig_mgr.handles;
   idr_for_each_entry(idp, encaps_sig_hdl, id) {
    if (encaps_sig_hdl->cs_seq == signal_seq) {
     /* get refcount to protect removing this handle from idr,
 * needed when multiple wait cs are used with offset
 * to wait on reserved encaps signals.
 * Since kref_put of this handle is executed outside the
 * current lock, it is possible that the handle refcount
 * is 0 but it yet to be removed from the list. In this
 * case need to consider the handle as not valid.
 */
     if (kref_get_unless_zero(&encaps_sig_hdl->refcount))
      handle_found = true;
     break;
    }
   }
   spin_unlock(&ctx->sig_mgr.lock);

   if (!handle_found) {
    /* treat as signal CS already finished */
    dev_dbg(hdev->dev, "Cannot find encapsulated signals handle for seq 0x%llx\n",
      signal_seq);
    rc = 0;
    goto free_cs_chunk_array;
   }

   /* validate also the signal offset value */
   if (chunk->encaps_signal_offset >
     encaps_sig_hdl->count) {
    dev_err(hdev->dev, "offset(%u) value exceed max reserved signals count(%u)!\n",
      chunk->encaps_signal_offset,
      encaps_sig_hdl->count);
    rc = -EINVAL;
    goto free_cs_chunk_array;
   }
  }

  sig_fence = hl_ctx_get_fence(ctx, signal_seq);
  if (IS_ERR(sig_fence)) {
   atomic64_inc(&ctx->cs_counters.validation_drop_cnt);
   atomic64_inc(&cntr->validation_drop_cnt);
   dev_err(hdev->dev,
    "Failed to get signal CS with seq 0x%llx\n",
    signal_seq);
   rc = PTR_ERR(sig_fence);
   goto free_cs_chunk_array;
  }

  if (!sig_fence) {
   /* signal CS already finished */
   rc = 0;
   goto free_cs_chunk_array;
  }

  sig_waitcs_cmpl =
   container_of(sig_fence, struct hl_cs_compl, base_fence);

  staged_cs_with_encaps_signals = !!
    (sig_waitcs_cmpl->type == CS_TYPE_DEFAULT &&
    (flags & HL_CS_FLAGS_ENCAP_SIGNALS));

  if (sig_waitcs_cmpl->type != CS_TYPE_SIGNAL &&
    !staged_cs_with_encaps_signals) {
   atomic64_inc(&ctx->cs_counters.validation_drop_cnt);
   atomic64_inc(&cntr->validation_drop_cnt);
   dev_err(hdev->dev,
    "CS seq 0x%llx is not of a signal/encaps-signal CS\n",
    signal_seq);
   hl_fence_put(sig_fence);
   rc = -EINVAL;
   goto free_cs_chunk_array;
  }

  if (completion_done(&sig_fence->completion)) {
   /* signal CS already finished */
   hl_fence_put(sig_fence);
   rc = 0;
   goto free_cs_chunk_array;
  }
 }

 rc = allocate_cs(hdev, ctx, cs_type, ULLONG_MAX, &cs, flags, timeout);
 if (rc) {
  if (is_wait_cs)
   hl_fence_put(sig_fence);

  goto free_cs_chunk_array;
 }

 /*
 * Save the signal CS fence for later initialization right before
 * hanging the wait CS on the queue.
 * for encaps signals case, we save the cs sequence and handle pointer
 * for later initialization.
 */
 if (is_wait_cs) {
  cs->signal_fence = sig_fence;
  /* store the handle pointer, so we don't have to
 * look for it again, later on the flow
 * when we need to set SOB info in hw_queue.
 */
  if (cs->encaps_signals)
   cs->encaps_sig_hdl = encaps_sig_hdl;
 }

 hl_debugfs_add_cs(cs);

 *cs_seq = cs->sequence;

 if (cs_type == CS_TYPE_WAIT || cs_type == CS_TYPE_SIGNAL)
  rc = cs_ioctl_signal_wait_create_jobs(hdev, ctx, cs, q_type,
    q_idx, chunk->encaps_signal_offset);
 else if (cs_type == CS_TYPE_COLLECTIVE_WAIT)
  rc = hdev->asic_funcs->collective_wait_create_jobs(hdev, ctx,
--> --------------------

--> maximum size reached

--> --------------------