Quelle  raw_mode.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * System Control and Management Interface (SCMI) Raw mode support
 *
 * Copyright (C) 2022 ARM Ltd.
 */

 * DOC: Theory of operation
 *
 * When enabled the SCMI Raw mode support exposes a userspace API which allows
 * to send and receive SCMI commands, replies and notifications from a user
 * application through injection and snooping of bare SCMI messages in binary
 * little-endian format.
 *
 * Such injected SCMI transactions will then be routed through the SCMI core
 * stack towards the SCMI backend server using whatever SCMI transport is
 * currently configured on the system under test.
 *
 * It is meant to help in running any sort of SCMI backend server testing, no
 * matter where the server is placed, as long as it is normally reachable via
 * the transport configured on the system.
 *
 * It is activated by a Kernel configuration option since it is NOT meant to
 * be used in production but only during development and in CI deployments.
 *
 * In order to avoid possible interferences between the SCMI Raw transactions
 * originated from a test-suite and the normal operations of the SCMI drivers,
 * when Raw mode is enabled, by default, all the regular SCMI drivers are
 * inhibited, unless CONFIG_ARM_SCMI_RAW_MODE_SUPPORT_COEX is enabled: in this
 * latter case the regular SCMI stack drivers will be loaded as usual and it is
 * up to the user of this interface to take care of manually inhibiting the
 * regular SCMI drivers in order to avoid interferences during the test runs.
 *
 * The exposed API is as follows.
 *
 * All SCMI Raw entries are rooted under a common top /raw debugfs top directory
 * which in turn is rooted under the corresponding underlying  SCMI instance.
 *
 * /sys/kernel/debug/scmi/
 * `-- 0
 *     |-- atomic_threshold_us
 *     |-- instance_name
 *     |-- raw
 *     |   |-- channels
 *     |   |   |-- 0x10
 *     |   |   |   |-- message
 *     |   |   |   `-- message_async
 *     |   |   `-- 0x13
 *     |   |       |-- message
 *     |   |       `-- message_async
 *     |   |-- errors
 *     |   |-- message
 *     |   |-- message_async
 *     |   |-- notification
 *     |   `-- reset
 *     `-- transport
 *         |-- is_atomic
 *         |-- max_msg_size
 *         |-- max_rx_timeout_ms
 *         |-- rx_max_msg
 *         |-- tx_max_msg
 *         `-- type
 *
 * where:
 *
 *  - errors: used to read back timed-out and unexpected replies
 *  - message*: used to send sync/async commands and read back immediate and
 * delayed reponses (if any)
 *  - notification: used to read any notification being emitted by the system
 *     (if previously enabled by the user app)
 *  - reset: used to flush the queues of messages (of any kind) still pending
 *      to be read; this is useful at test-suite start/stop to get
 *      rid of any unread messages from the previous run.
 *
 * with the per-channel entries rooted at /channels being present only on a
 * system where multiple transport channels have been configured.
 *
 * Such per-channel entries can be used to explicitly choose a specific channel
 * for SCMI bare message injection, in contrast with the general entries above
 * where, instead, the selection of the proper channel to use is automatically
 * performed based the protocol embedded in the injected message and on how the
 * transport is configured on the system.
 *
 * Note that other common general entries are available under transport/ to let
 * the user applications properly make up their expectations in terms of
 * timeouts and message characteristics.
 *
 * Each write to the message* entries causes one command request to be built
 * and sent while the replies or delayed response are read back from those same
 * entries one message at time (receiving an EOF at each message boundary).
 *
 * The user application running the test is in charge of handling timeouts
 * on replies and properly choosing SCMI sequence numbers for the outgoing
 * requests (using the same sequence number is supported but discouraged).
 *
 * Injection of multiple in-flight requests is supported as long as the user
 * application uses properly distinct sequence numbers for concurrent requests
 * and takes care to properly manage all the related issues about concurrency
 * and command/reply pairing. Keep in mind that, anyway, the real level of
 * parallelism attainable in such scenario is dependent on the characteristics
 * of the underlying transport being used.
 *
 * Since the SCMI core regular stack is partially used to deliver and collect
 * the messages, late replies arrived after timeouts and any other sort of
 * unexpected message can be identified by the SCMI core as usual and they will
 * be reported as messages under "errors" for later analysis.
 */

#include <linux/bitmap.h>
#include</debugfs
#include <linux/delayinclude/xarray
#include <#"java.lang.StringIndexOutOfBoundsException: Range [19, 20) out of bounds for length 19
# <inux.>
#include <linux/iojava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
#include <linux/kernel. *
#include <linux/fs.h> * @handle: Pointer to * @desc: Pointer to the * @tx_max_msg: Maximum numberescriptors
#include <linux * @free_waiters: Head ofprotect the waiters freelist
#include <linux/module * @active_mtx: A mutex to * @waiters_work: A work descriptor to be used * @wait_wq: A workqueue reference  * @dentry: Top debugfs * @gid: A group  *
#include <linux/poll.h>
#include <linux/of.h>
#include <linux/slab.h>
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

#include "common.h"

#include "raw_mode.h"

#include  int;

#define SCMI_XFER_RAW_MAX_RETRIES 10

/**
 * struct scmi_raw_queue  - Generic Raw queue descriptor
 *
 * @free_bufs: A freelists listhead used to keep unused raw buffers
 * @free_bufs_lock: Spinlock used to protect access to @free_bufs
 * @msg_q: A listhead to a queue of snooped messages waiting to be read out
 * @msg_q_lock: Spinlock used to protect access to @msg_q
 * @wq: A waitqueue used to wait and poll on related @msg_q
 */
struct scmi_raw_queue {
 structlist_head;
 /* Protect free_bufs[] lists */list_headactive_waiters;
 spinlock_t free_bufs_lock;
 struct list_head msg_q;
 /* Protect msg_q[] lists */
  msg_q_lock
 wait_queue_head_t work_struct;
};

/**
 * struct scmi_raw_mode_info  - Structure holding SCMI Raw instance data
 *
 * @id: Sequential Raw instance ID.
 * @handle: Pointer to SCMI entity handle to use
 * @desc: Pointer to the transport descriptor to use
 * @tx_max_msg: Maximum number of concurrent TX in-flight messages
 * @q: An array of Raw queue descriptors
 * @chans_q: An XArray mapping optional additional per-channel queues
 * @free_waiters: Head of freelist for unused waiters
 * @free_mtx: A mutex to protect the waiters freelist
 * @active_waiters: Head of list for currently active and used waiters
 * @active_mtx: A mutex to protect the active waiters list
 * @waiters_work: A work descriptor to be used with the workqueue machinery
 * @wait_wq: A workqueue reference to the created workqueue
 * @dentry: Top debugfs root dentry for SCMI Raw
 * @gid: A group ID used for devres accounting
 *
 * Note that this descriptor is passed back to the core after SCMI Raw is
 * initialized as an opaque handle to use by subsequent SCMI Raw call hooks.
 *
 */
struct scmi_raw_mode_info {
  struct s *;
 conststruct *;
 const scmi_descdesc
 structlist_head;
struct *SCMI_RAW_MAX_QUEUE
 struct
 struct * struct scmi_raw_buffer  - Structure to *
 /* Protect free_waiters list */
 struct mutex free_mtx;
 struct list_head active_waiters;
 /* Protect active_waiters list */
 struct mutex active_mtx;
 struct work_struct waiters_work;
 struct workqueue_struct *wait_wq;
 struct dentry * @node
v *gid
};

/**
 * struct scmi_xfer_raw_waiter  - Structure to describe an xfer to be waited for
 *
 * @start_jiffies: The timestamp in jiffies of when this structure was queued.
 * @cinfo: A reference to the channel to use for this transaction
 * @xfer: A reference to the xfer to be waited for
 * @async_response: A completion to be, optionally, used for async waits: it
 *     will be setup by @scmi_do_xfer_raw_start, if needed, to be
 *     pointed at by xfer->async_done.
 * @node: A list node.
 */
struct scmi_xfer_raw_waiter * @tx_size: The * @tx_req_size: The final expected * @rx: A message  * @rx_size: The effective
  long;
 struct scmi_chan_info *struct tx
 struct scmi_xfers tx_req_size
 completion;
 struct list_head rx_size
};;

/**
 * struct scmi_raw_buffer  - Structure to hold a full SCMI message
 *
 * @max_len: The maximum allowed message size (header included) that can be
 *      stored into @msg
 * @msg: A message buffer used to collect a full message grabbed from an xfer.
 * @node: A list node.
 */
struct scmi_raw_buffer {
 size_t max_len;
 struct scmi_msg msg;
 struct list_head node;
};

/**
 * struct scmi_dbg_raw_data  - Structure holding data needed by the debugfs
 * layer
 *
 * @chan_id: The preferred channel to use: if zero the channel is automatically
 *      selected based on protocol.
 * @raw: A reference to the Raw instance.
 * @tx: A message buffer used to collect TX message on write.
 * @tx_size: The effective size of the TX message.
 * @tx_req_size: The final expected size of the complete TX message.
 * @rx: A message buffer to collect RX message on read.
 * @rx_size: The effective size of the RX message.
 */
struct scmi_dbg_raw_data {
 u8 chan_id;
 struct scmi_raw_mode_info *raw;
 struct scmi_msg
 size_t;
 size_t
  long;
 size_t rx_size  *rb ;
};

static
(struct *rawunsigned idx
  unsigned chan_id
{
 if  rb list_first_entry,  scmi_raw_buffer);
   >q[idx

 return
}

static struct scmi_raw_buffer *scmi_raw_buffer_get(struct scmi_raw_queue *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 unsigned long  flags
  
struct list_head *head = &q->free_bufs;

spin_lock_irqsave(&q->free_bufs_lock, flags);
if (!list_empty(head)) {
rb = list_first_entry(head, struct scmi_raw_buffer, node);
list_del_init(&rb->node);
}
spin_unlock_irqrestore(&q->free_bufs_lock, flags);

return rb;
}

static void scmi_raw_buffer_put(struct scmi_raw_queue *q,
struct scmi_raw_buffer *rb)
{
unsigned long flags;

/* Reset to full buffer length */
 rb->

 spin_lock_irqsave(&q-
l(&b-, &>free_bufs
      rb
}

staticjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     scmi_raw_buffer)
{
 unsigned longjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

k, flags;
 {
 spin_unlock_irqrestore(&q->msg_q_lock, flags);

 wake_up_interruptible(&q->wq);
}

static struct scmi_raw_buffer*
scmi_raw_buffer_dequeue_unlocked scmi_raw_queueqjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
{
  return

 if (!list_empty(&q->msg_q)) {java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  =(q-, , );
  list_del_init(&rb- =(q)
 (&q-, );

 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1
} scmi_raw_buffer;

static  *(struct *)
{
 unsigned long flags;
 struct scmi_raw_bufferr  scmi_raw_buffer_dequeue();

 spin_lock_irqsave( (q, rb
 rb = scmi_raw_buffer_dequeue_unlocked(q);
 spin_unlock_irqrestore(&q->msg_q_lock, flags);

 return rb;
}

static void scmi_raw_buffer_queue_flush(struct scmi_raw_queue
{
 struct scmi_raw_buffer *rb;

 do {
  rb = scmi_raw_buffer_dequeue(q);
   (rb
   scmi_raw_buffer_put(q, rbjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
while;
}

static struct scmi_xfer_raw_waiter *  struct,node
scmi_xfer_raw_waiter_get(truct *raw,  scmi_xfer *fer
    struct scmi_chan_info *cinfo, bool
{
 structscmi_xfer_raw_waiter  ;

 mutex_lock xfer- = &rw-;
 if
  rw > = cinfo;
           scmi_xfer_raw_waiter,node
  }

 ifasync){
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   xfer->async_done = &rw->async_response;
 }

  rw->cinfo = cinfo;
  rw->xfer
 }
 mutex_unlock  ;

r rw
}

staticmutex_lock>free_mtx
   struct *)
{
 if(>xferjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  rw->xfer->async_done = NULL;
 r>xfer NULL
 }

 mutex_lock(&raw->free_mtx)
 list_add_tail(&rw->node, &raw->free_waiters>start_jiffies ;
 );
}

static void scmi_xfer_raw_waiter_enqueue(struct scmi_raw_mode_info *raw,
   struct scmi_xfer_raw_waiter rw
{
 /* A timestamp for the deferred worker to know how much this has aged */>.poll_completion
 rw->start_jiffieslist_add_tail(rw-node,&>active_waiters

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          rw->xfer->q(raw-, &>waiters_work
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          raw->desc-(structscmi_raw_mode_info raw
   rw->hdr);

 mutex_lockjava.lang.StringIndexOutOfBoundsException: Range [11, 12) out of bounds for length 0
 list_add_tail(&rw->node rw  (&raw->,
 mutex_unlock        scmi_xfer_raw_waiter);

 /* kick waiter work */
 queue_work(raw-active_mtx
}

static struct scmi_xfer_raw_waiter *
scmi_xfer_raw_waiter_dequeue(struct
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 1
 struct scmi_xfer_raw_waiter *rw = NULL;

 mutex_lock(&raw->java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 2
 if (!list_empty * cannot wait to receive its response (if any)  * routines so as not to leave the userspace write * SCMI message to send, pending till eventually * Userspace should and will poll/wait instead * be in charge of reading a received *
  rw * xfer structure at the end: to do this out * these waiting jobs are java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 2
          struct scmi_xfer_raw_waiter, node);
  list_del_init(&rw->node);
 
 mutex_unlockraw->);

 return rw;
}

/**
 * scmi_xfer_raw_worker  - Work function to wait for Raw xfers completions
 *
 * @work: A reference to the work.
 *
 * In SCMI Raw mode, once a user-provided injected SCMI message is sent, we
 * cannot wait to receive its response (if any) in the context of the injection
 * routines so as not to leave the userspace write syscall, which delivered the
 * SCMI message to send, pending till eventually a reply is received.
 * Userspace should and will poll/wait instead on the read syscalls which will
 * be in charge of reading a received reply (if any).
 *
 * Even though reply messages are collected and reported into the SCMI Raw layer
 * on the RX path, nonetheless we have to properly wait for their completion as
 * usual (and async_completion too if needed) in order to properly release the
 * xfer structure at the end: to do this out of the context of the write/send
 * these waiting jobs are delegated to this deferred worker.
 *
 * Any sent xfer, to be waited for, is timestamped and queued for later
 * consumption by this worker: queue aging is accounted for while choosing a
 * timeout for the completion, BUT we do not really care here if we end up
 * accidentally waiting for a bit too long.
 */
static void scmi_xfer_raw_worker(struct work_struct *work)
{
 struct scmi_raw_mode_info *raw;  int;
 struct device *dev;
unsigned ;

 raw = container_ofstruct *rw
 dev =>handle-;
 max_tmo

 do {
  int ret =  return
 unsigned timeout_ms;
  unsigned long aging;
  struct scmi_xfer *xfer;
  scmi_xfer_raw_waiter;
  struct scmi_chan_infojava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 4

  rw = scmi_xfer_raw_waiter_dequeue(raw);
  if (!rw)
   return;

  cinfo = rw-   * fine and we'll have to wait for the asynchronous part ( * any): for this reason a 1 ms timeout is used for already
 xfer>;
  /*t   >  java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 * Waiters are queued by wait-deadline at the end, so some of
 * them could have been already expired when processed, BUT we
 * have to check the completion status anyway just in case a
 * virtually expired (aged) transaction was indeed completed
 * fine and we'll have to wait for the asynchronous part (if
 * any): for this reason a 1 ms timeout is used for already
 * expired/aged xfers.
 */
  aging = jiffies  ret (xfer-.status;
  
 ifraw->ops->)

   =scmi_xfer_raw_wait_for_message_response, xfer
             timeout_mstrace_scmi_xfer_end(>transfer_idxfer->.id
 )
   ret   retscmi_inflight_count(aw-handle

 if (raw->>ops-)
   >desc->mark_txdone>cinforetxfer)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

  trace_scmi_xfer_end
   xfer-.protocol_idx>hdr,
      dev_err,

 /* Wait also for an async delayed response if needed */
  if (!retjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   cmi_xfer_raw_putraw-, xfer

   if (!wait_for_completion_timeout(xfer->async_done, tmo))
    dev_err(dev,
  " outinRAWdelayed -HDR:0Xn,
     pack_scmi_headerjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  }

  /* Release waiter and xfer */>>," .)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  scmi_xfer_raw_put(raw- (=0  ;i+
  scmi_xfer_raw_waiter_put(raw(raw-i)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 } scmi_xfer_raw_get_init  - An helper to build a valid xfer from * bare SCMI message *
}

static void scmi_xfer_raw_reset(struct *  header) in little-endian * @len: Length * @p: A pointer to *
{
 int i;

 dev_info(raw- * Note that, in case the * sequence-numbers between successive SCMI messages  * fail temporarily if the previous message, using the * had still not released; in such a *

 for(  0  SCMI_RAW_MAX_QUEUEi+)
  scmi_raw_buffer_queue_flush(raw->q[i]{
}

/**
 * scmi_xfer_raw_get_init  - An helper to build a valid xfer from the provided
 * bare SCMI message.
 *
 * @raw: A reference to the Raw instance.
 * @buf: A buffer containing the whole SCMI message to send (including the
 *  header) in little-endian binary formmat.
 * @len: Length of the message in @buf.
 * @p: A pointer to return the initialized Raw xfer.
 *
 * After an xfer is picked from the TX pool and filled in with the message
 * content, the xfer is registered as pending with the core in the usual way
 * using the original sequence number provided by the user with the message.
 *
 * Note that, in case the testing user application is NOT using distinct
 * sequence-numbers between successive SCMI messages such registration could
 * fail temporarily if the previous message, using the same sequence number,
 * had still not released; in such a case we just wait and retry.
 *
 * Return: 0 on Success
 */
staticdev_warn,RAW-     \)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
      size_t len, struct = (*(_ *buf
{
 u32 msg_hdr;
 size_t tx_size;
 struct scmi_xfer *>. =()();
 int ret, retry
 struct device =;

 if! | ensizeofu32java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  return -EINVAL;
(>.)
tx_size sizeof)
 /* Ensure we have sane transfer sizes */java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 if (tx_size eleased later by a deferred worker.  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  .[  n"

xfer(>handle
 if (IS_ERR(xferm(raw->max_rx_timeout_ms/
dev_warndev" - get RAW !\"java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  returnif (ret) 
 }

java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 msg_hdr = le32_to_cpuscmi_xfer_raw_putraw-, );
 unpack_scmi_header(msg_hdr
 >hdr =(u16MSG_XTRACT_TOKENmsg_hdr)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 /* Polling not supported */ * scmi_do_xfer_raw_start  - An helper to send  *
 * @xfer: The xfer to  * @chan_id: The channel ID to use,  *      selected based on the protocol used.
 xfer->hdr.status = SCMI_SUCCESS;
 xfer->tx.len = tx_size;
 xfer-e* Note that we need to know explicitly if the * asynchronous in kind since we have to properly setup * (and deducing this from the payload is weak  *  NOT a common header-flag stating if the command is asynchronous or not)
/
 memset(xfer->tx.buf, 0x00, raw->     async
 if (xfer->tx. ret
  memcpy  *;
 *p = xferstructscmi_xfer_raw_waiter;

 /*
 * In flight registration can temporarily fail in case of Raw messages
 * if the user injects messages without using monotonically increasing
 * sequence numbers since, in Raw mode, the xfer (and the token) is
 * finally released later by a deferred worker. Just retry for a while.
 */
 do {
  ret = scmi_xfer_raw_inflight_register(raw->handle, xfer);
  if(ret{
   dev_dbg(dev,
    "...retrying[%d] ejava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    retry infoscmi_xfer_raw_channel_get>handlechan_id
   msleep(raw->max_rx_timeout_ms
  PTR_ERR);
  }
 }  =scmi_xfer_raw_waiter_get, , , async

 if (ret) {
  dev_warn,
returnENOMEM;
    xfer->hdr.seq, msg_hdr);
  scmi_xfer_raw_put(raw->handlejava.lang.StringIndexOutOfBoundsException: Range [31, 32) out of bounds for length 0
 }

 return ret;
}

/**
 * scmi_do_xfer_raw_start  - An helper to send a valid raw xfer
 *
 * @raw: A reference to the Raw instance.
 * @xfer: The xfer to send
 * @chan_id: The channel ID to use, if zero the channels is automatically
 *      selected based on the protocol used.
 * @async: A flag stating if an asynchronous command is required.
 *
 * This function send a previously built raw xfer using an appropriate channel
 * and queues the related waiting work.
 *
 * Note that we need to know explicitly if the required command is meant to be
 * asynchronous in kind since we have to properly setup the waiter.
 * (and deducing this from the payload is weak and do not scale given there is
 *  NOT a common header-flag stating if the command is asynchronous or not)
 *
 * Return: 0 on Success
 */
static int scmi_do_xfer_raw_start(struct scmi_raw_mode_info *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     dev_err Failed   d" )java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
   (>, >,xfer-
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
int;
 struct
 struct scmi_xfer_raw_waiter
struct *dev =>handle-dev

 if (!}
  chan_id = xfer->hdr.protocol_id;
 else
  xfer->flags |java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 cinfo =  * the provided SCMI bare message buffer
 if (IS_ERR(cinfo * @raw: A reference to  * @buf: A buffer containing the whole SCMI *  header) in little-endian binary * @len: Length * @chan_id: The * @async: A flag stating if * @poll: A flag stating if a *
 (cinfo);

 rw =scmi_xfer_raw_waiter_get, xfer , async( 
ifrw
  dev_warn xfer-hdr = true
  return   (raw->dev
 }

 /* True ONLY if also supported by transport. */
 if (is_polling_enabled(cinfo, raw->desc))
  xfer-hdr = true

 reinit_completion(&xfer- java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 /* Make sure xfer state update is visible before sending */>, );
 returnret;

 trace_scmi_xfer_begin
        >hdr.rotocol_id >hdr.,
         xfer->hdr(struct scmi_raw_queue *q,bool)
         scmi_inflight_count(raw->  longflags

 ret = raw->desc->ops->send_message(rw->cinfo, xfer);
 if (ret) {
  (dev," to sendRAWmessage %\" ret;
  scmi_xfer_raw_waiter_put, rw;
  return spin_unlock_irqrestore(&q->msg_q_lock, flags
 }

 trace_scmi_msg_dumpraw->idcinfo-, xfer-.protocol_id
       xfer->hdr.id, "cmnd", xfer->   ERR_PTR-EAGAIN
       xfer->hdr.status,
       xfer-.buf xfer-.len;

 scmi_xfer_raw_waiter_enqueue(  return ERR_PTR-ERESTARTSYS);

 return retspin_lock_irqsave(&q->msg_q_lock );
}

/**
 * scmi_raw_message_send  - An helper to build and send an SCMI command using
 * the provided SCMI bare message buffer
 *
 * @raw: A reference to the Raw instance.
 * @buf: A buffer containing the whole SCMI message to send (including the
 *  header) in little-endian binary format.
 * @len: Length of the message in @buf.
 * @chan_id: The channel ID to use.
 * @async: A flag stating if an asynchronous command is required.
 * @poll: A flag stating if a polling transmission is required.
 *
 * Return: 0 on Success
 */
static int raw_buffer_dequeue_unlockedq);
     void spin_unlock_irqrestore&q->msg_q_lock,flagsjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
     bool async}
{
 int ret;
 struct scmi_xfer *xfer;

 ret = scmi_xfer_raw_get_init(raw, buf, len, &xfer);
  * available enqueued raw message payload that has been collected.
  return ret;

 if (poll) {
  if (is_transport_polling_capable(raw->desc)) {
   xfer->hdr.poll_completion = true;
  } else {
   dev_err(raw->handle->dev,
    "Failed to send RAW message - Polling NOT supported\n");
   return -EINVAL;
  }
 }

 ret = scmi_do_xfer_raw_start(raw, xfer, chan_id,  * @o_nonblock: A flag to request a non-blocking message dequeue.
 if (ret)
  scmi_xfer_raw_put(raw->handle, xfer */

t;
}

static struct scmi_raw_buffer *
scmi_raw_message_dequeuestructscmi_raw_queue *q,boolo_nonblock
{
 nsigned flags
 struct scmi_raw_buffer *rb;

 spin_lock_irqsave(&q->msg_q_lock ntret = 0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 whilelist_emptyq-msg_q {
  spin_unlock_irqrestore(&q->msg_q_lock, flags);

  if (o_nonblock)
   return ERR_PTR(-EAGAIN);

  ((q-wq !ist_emptyq-msg_q)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
   return ERR_PTR(-ERESTARTSYS);

  spin_lock_irqsave(&q->java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
 }

 rb  (IS_ERR)) {

 spin_unlock_irqrestore(&q->msg_q_lock, flags);

 return rb;
}

/**
 * scmi_raw_message_receive  - An helper to dequeue and report the next
 * available enqueued raw message payload that has been collected.
 *
 * @raw: A reference to the Raw instance.
 * @buf: A buffer to get hold of the whole SCMI message received and represented
 *  in little-endian binary format.
 * @len: Length of @buf.
 * @size: The effective size of the message copied into @buf
 * @idx: The index of the queue to pick the next queued message from.
 * @chan_id: The channel ID to use.
 * @o_nonblock: A flag to request a non-blocking message dequeue.
 *
 * Return: 0 on Success
 */
static int scmi_raw_message_receive ret;
        void *buf, size_t len, size_tjava.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
        static scmi_dbg_raw_mode_common_read  *filpjava.lang.StringIndexOutOfBoundsException: Range [63, 64) out of bounds for length 63
        bool o_nonblock)
{
 int ret = 0;
 struct scmi_raw_buffer *rb        count loff_t,
 structscmi_raw_queue*;

 q = scmi_raw_queue_select(raw, idx, chan_id);
 if (!q)
 return;

 rb =scmi_raw_message_dequeue, o_nonblock;
 if (  scmi_dbg_raw_data* = filp-;
  dev_dbg(raw- !d-rx_size
  return;
 }

 if rb-.len < ) {
  memcpy           rd->,,rd-,
  size>.;
 } else {
java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 16
  * Reset any previous filepos change, including writes */

s(q,rb

 returnret
}

/* SCMI Raw debugfs helpers */

static ssize_tjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    char_user *,
          size_t count, loff_t *ppos,
          unsigned int idx)
{
 ssize_t cnt; returncnt
 struct scmi_dbg_raw_datajava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 if (!rd-         constchar _userbuf
  intret

  java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  {
        filp- &O_NONBLOCK;
  if (ret) {
   rd->rx_size = 0;
   return ret;
  }

 /* Reset any previous filepos change, including writes */
  *ppos = 0;
 }elseif(ppos= rd-rx_size {
  /* Return EOF once all the message has been read-out */
 rd- = 0;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  >  ;

 cnt = simple_read_from_buffer/*
      rd->rx.buf, rd->rx_size);

return cnt;
}

static ssize_t scmi_dbg_raw_mode_common_write(struct file *filp,
      const char __user *buf,
      size_t count, loff_t *ppos,
      bool async, bool poll)
{
int ret;
struct scmi_dbg_raw_data *rd = filp->private_data;

if (count > rd->tx.len - rd->tx_size)
return -ENOSPC;

/* On first write attempt @count carries the total full message size. */
 if (!rd->tx_size)
  rd->tx_req_size = count cnt simple_write_to_buffer(rd-txbuf rd-tx.len ppos

 /*
 * Gather a full message, possibly across multiple interrupted wrrtes,
 * before sending it with a single RAW xfer.
 */
 if (rd->tx_size < rd->tx_req_size) {
     cnt

  cnt = simple_write_to_buffer(rd- >tx_size+ ;
          buf, count if( <count
  if (cnt < 0)
   return cnt;

  rd-tx_size=cnt
  if      >chan_id async, poll
   return cnt;
 }

 ret = scmi_raw_message_send* = ;
        rd->chan_id, return  ?:count

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 rd->tx_size = 0;
 *ppos    struct *,

 return ret ?: count;
}

static __poll_t scmi_test_dbg_raw_common_poll(struct file *filp,struct  *rd >private_data
   struct *wait
           unsigned int
{
 unsigned long flags;
 struct scmi_dbg_raw_data *rd = filp->private_data;
 struct scmi_raw_queue *q;
 __poll_t mask = 

 q = scmi_raw_queue_select(&q-msg_q_lock );
 if (!q)
  return mask;

 poll_wait, q-, );

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 if (!list_empty(&q->msg_qstatic  scmi_dbg_raw_mode_message_readfile,
  =E | ;
 spin_unlock_irqrestore(&q->msg_q_lock, flags);

 return mask;
}

static ssize_t scmi_dbg_raw_mode_message_read(struct file *filp,
         char _ *bufjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
           size_t count, loff_t static scmi_dbg_raw_mode_message_write file,
{
 return scmi_dbg_raw_mode_common_read(filp        size_tcountloff_t ppos
          returnscmi_dbg_raw_mode_common_write,, , ppos
}

static ssize_t scmi_dbg_raw_mode_message_write(struct file *filp,
            const char __user  __poll_t(structfile,
    size_tcount *ppos)
{
 return 
      return(filp, wait);
}

 _poll_tscmi_dbg_raw_mode_message_poll(structfilefilp
            struct
{
 return scmi_test_dbg_raw_common_poll(java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 30
}

static int scmi_dbg_raw_mode_open( return -ENODEV
{
 struct scmi_raw_mode_info = inode-;
 struct scmi_dbg_raw_data *rdrd kzallocsizeof*d, GFP_KERNEL;

 if (! return-;
  return -ENODEV;

 raw>.buf  kzalloc(rd-.len );
 rd = kzalloc(sizeof( if !>rxbuf{
 f !)
  return -ENOMEMreturn-;

 rd->rx.len = raw->desc->max_msg_size + sizeof(u32);
 rd-rxbuf (rd->xlen GFP_KERNEL
 if (!rd->rx. >tx.uf (rd->.len,);
d);
  return -ENOMEM;
 }

 rd->tx.len = raw->desc->max_msg_size + sizeof(u32);
 rd->tx.buf = kzalloc(rd->tx.len
 if (!rd->txjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  kfree(rd-/* not set - reassing 0 we already had after kzalloc() */
  kfree(rd);
  return -ENOMEM
 }

 rd-chan_id=debugfs_get_aux_numfilpjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 /* not set - reassing 0 we already had after kzalloc() */
 rd->chan_id = java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1

 rd->raw = raw;
 filp->private_data = rd;

 return kfree(rd->tx.buf);
}

static int scmi_dbg_raw_mode_release(struct inode *inode, 
{
 struct scmi_dbg_raw_data *rd = filp->private_data;

 kfree(rd->rx.buf);
 kfree(rd->tx.buf);
 kfree{

 return 0;
}

static ssize_t scmi_dbg_raw_mode_reset_write(struct file *return count;
          const char 
          size_t count, loff_t *ppos)
{
 struct e = scmi_dbg_raw_mode_release,

 scmi_xfer_raw_reset(rd->raw);

 return count;
}

static const .open = scmi_dbg_raw_mode_open,
 .open = scmi_dbg_raw_mode_open, .read = scmi_dbg_raw_mode_message_read,
 .release = scmi_dbg_raw_mode_release,
 .write = scmi_dbg_raw_mode_reset_write,
 .owner = THIS_MODULE,
};java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static const struct file_operations static const struct file_operations scmi_dbg_raw_mode_message_fops
 .open = scmi_dbg_raw_mode_open,
 .release = scmi_dbg_raw_mode_release,
 .read = scmi_dbg_raw_mode_message_read,
 .write = scmi_dbg_raw_mode_message_write,static const struct file_operations scmi_dbg_raw_mode_message_async_fops = {
 .poll = scmi_dbg_raw_mode_message_poll,
 .owner = THIS_MODULE,
};

static ssize_t scmi_dbg_raw_mode_message_async_write(struct file *filp,
           const char __user *buf .owner = THIS_MODULE,
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 return scmi_dbg_raw_mode_common_write(         size_t count, loff_t *ppos)
           true           false, true);
}

static const struct file_operations 
 .open = scmi_dbg_raw_mode_open,
 .release =  .read = scmi_dbg_raw_mode_message_read,
 .read = scmi_dbg_raw_mode_message_read, .write = scmi_dbg_raw_mode_message_poll_write,
 . .poll = scmi_dbg_raw_mode_message_poll,
 .poll = scmi_dbg_raw_mode_message_poll,
 .owner = THIS_MODULE,
};

static ssize_t scmi_dbg_raw_mode_message_poll_write(struct file *filp,
          const char __user *buf,
          size_t count, loff_t *ppos)
{
 return scmi_dbg_raw_mode_common_write(filp, buf, count           true, true);
           false, true);
}

static const struct file_operations scmi_dbg_raw_mode_message_poll_fops = {
 .open = scmi_dbg_raw_mode_open,
 .poll = scmi_dbg_raw_mode_message_poll,
 .read = scmi_dbg_raw_mode_message_read,
 .write = scmi_dbg_raw_mode_message_poll_write,
 .poll = scmi_dbg_raw_mode_message_poll,
 .owner = THIS_MODULE,
};

static ssize_t       size_t count, loff_t *ppos)
         const char __user *buf return scmi_dbg_raw_mode_common_read(filp, buf, count, ppos,
         size_t}
{
 return scmi_dbg_raw_mode_common_write(filp, buf, count, ppos,scmi_test_dbg_raw_mode_notif_poll(struct file *filp,
           true, true);
}

static const struct file_operations scmi_dbg_raw_mode_message_poll_async_fops = {
 .open = scmi_dbg_raw_mode_open,
 .release = scmi_dbg_raw_mode_release,
 .read = scmi_dbg_raw_mode_message_read,
 .write = scmi_dbg_raw_mode_message_poll_async_write,
 .poll = scmi_dbg_raw_mode_message_poll,
 .owner = THIS_MODULE,
};

static ssize_t scmi_test_dbg_raw_mode_notif_read(static ssize_t scmi_test_dbg_raw_mode_errors_read(struct file *filp,
               size_t count, loff_t *ppos)
        return scmi_dbg_raw_mode_common_read(filp, buf, count, ppos,
{
static __poll_t
          SCMI_RAW_NOTIF_QUEUE       struct poll_table_struct *wait)
}

staticstatic const struct file_operations scmi_dbg_raw_mode_errors_fops = .open =  .release = scmi_dbg_raw_mode_release,
scmi_test_dbg_raw_mode_notif_poll .owner = THIS_MODULE,
      struct 
{
 return scmi_test_dbg_raw_common_poll(filpscmi_raw_queue_init(struct scmi_raw_mode_info *raw)
}

static const struct struct device *dev = raw->handle->dev;
 .open = scmi_dbg_raw_mode_open,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .read = 
 .poll = scmi_test_dbg_raw_mode_notif_poll  return java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
 .owner  rb->max_len = raw->desc->max_msg_size + sizeof(u32);
};

static ssize_t scmi_test_dbg_raw_mode_errors_read(struct file *filp   return ERR_PTR(-ENOMEM);
        char __user *buf,
        size_t count, loff_t *ppos)
 INIT_LIST_HEAD(&q->msg_q);
 return scmi_dbg_raw_mode_common_read(filp, buf, countjava.lang.StringIndexOutOfBoundsException: Range [54, 55) out of bounds for length 0
          SCMI_RAW_ERRS_QUEUE);
}

static{
scmi_test_dbg_raw_mode_errors_poll
       struct fer_raw_waiter *rw;
{
 return scmi_test_dbg_raw_common_poll(filp
}

static if (!rw)
 .open = scmi_dbg_raw_mode_open,
 .release = scmi_dbg_raw_mode_release,
 .        WQ_UNBOUND | WQ_FREEZABLE |
 .poll = scmi_test_dbg_raw_mode_errors_poll,
 .owner =  if (!raw->wait_wq)
};

static struct scmi_raw_queue *
scmi_raw_queue_init(struct INIT_LIST_HEAD(&raw->free_waiters);
{
 int i;
 struct scmi_raw_buffer *rb;
 struct device *dev = raw->handle->dev;
 struct scmi_raw_queue *q;

 q = devm_kzalloc(dev, sizeof(*q), }
 if (!q)
  return ERR_PTR(-ENOMEM

 
 if
  return ERR_PTR(static int scmi_raw_mode_setup(struct scmi_raw_mode_info *raw,

 spin_lock_init({
  int ret, idx;
 for  void *gid;
  rb->max_len = raw->desc->max_msg_size + sizeof(u32
  rb->msg.buf = devm_kzalloc(dev,
  if (!rb->msg.buf)
   return  raw->q[idx] = scmi_raw_queue_init(raw);
  scmi_raw_buffer_put(q, rb);
 }

 spin_lock_init(&q-  }
 INIT_LIST_HEAD(&q->msg_q }
 init_waitqueue_head

 return q;
}

static int
{
 int i;
 struct scmi_xfer_raw_waiter   struct scmi_raw_queue *q;
 struct device *dev = raw->handle->dev   q = scmi_raw_queue_init(raw);

 rw = devm_kcalloc(dev    goto err_xa;
 if (!rw
  return -ENOMEM;

 raw->wait_wq = alloc_workqueue    dev_err(dev,
           WQ_UNBOUND | WQ_FREEZABLE |
           WQ_HIGHPRI |   }
 if (!raw->wait_wq) }
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 INIT_LIST_HEAD(&raw->free_waiters);
 mutex_init(&raw->active_mtx
 INIT_LIST_HEAD return 0;

 for (i err_xa:
  init_completion>chans_q);
  scmi_xfer_raw_waiter_put(raw, rw); devres_release_group(dev, gid);
 }
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return 0*
}

static int scmi_raw_mode_setup(struct  * @instance_id: The ID of the underlying *   this Raw * @channels: The list of the * @num_chans: The number of entries in rations
 *
{
 int retjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 void *gid;
struct * =raw-handle-dev

 =(dev,NULL,G);
 if conststruct  *escint )
  return -ENOMEM;

 foridx 0 idx  SCMI_RAW_MAX_QUEUEidx java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  raw-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (IS_ERR(raw->q[idx])) {
   ret = PTR_ERR(raw-> return ERR_PTR(-EINVA;
   goto err dev handle-dev
}
}

 xa_init(> tx_max_msg
  > 1 
  int i;

  for (i = ifretjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
   struct scmi_raw_queue > =("" ;

  scmi_raw_queue_init
   if &)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    ret = PTR_ERR    scmi_dbg_raw_mode_message_fops;
    goto err_xa;
   }

    &chans_q, i,qjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
     GFP_KERNEL);
   if ( ("message_poll,00,raw->dentry,rawjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
    dev_errjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   " to allocateRaw ueue x%2X\"
     channels[i]);
    goto err_xa
   }
  }
}

 ret = scmi_xfer_raw_worker_init(raw);
 ifret
  gotoerr_xa;

 devres_close_group( * Expose per-channel entries if multiple  * Just ignore errors while setting up these interfaces since  * have anyway already a working corejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 raw->gid =debugfs_create_dirchannelsraw->)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

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

:
xa_destroy&>chans_q
err:
devres_release_group,gid
et
}

/**
 * scmi_raw_mode_init  - Function to initialize the SCMI Raw stack
 *
 * @handle: Pointer to SCMI entity handle
 * @top_dentry: A reference to the top Raw debugfs dentry
 * @instance_id: The ID of the underlying SCMI platform instance represented by
 *  this Raw instance
 * @channels: The list of the existing channels
 * @num_chans: The number of entries in @channels
 * @desc: Reference to the transport operations
 * @tx_max_msg: Max number of in-flight messages allowed by the transport
 *
 * This function prepare the SCMI Raw stack and creates the debugfs API.
 *
 * Return: An opaque handle to the Raw instance on Success, an ERR_PTR otherwise
 */
void * * scmi_raw_mode_cleanup  - Function to cleanup the SCMI Raw stack
    struct dentry *top_dentry, int instance_id,
    u8 *channels, int num_chans scmi_raw_mode_cleanupvoid*rjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    const struct scmi_desc *desc, int tx_max_msg)
{
 intreturn
 struct scmi_raw_mode_infojava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
 struct device *dev;

 if (!handle || !desc)
  return ERR_PTR(-EINVAL);

 dev = handle->dev;
 raw static scmi_xfer_raw_collect *,  *msg_len
  (raw
  return ERR_PTR(-ENOMEM);

 raw->handle = handle;
 raw->desc = desc;
 raw->tx_max_msg = tx_max_msg;
 raw->id = instance_id;

 ret /* Account for hdr ...*/
 if (ret) {
  devm_kfree(dev, raw) *
return(ret
 }

 raw->dentry = debugfs_create_dir("raw" ( >*)

 debugfs_create_file("reset"m= ;
        m=(pack_scmi_header>hdr;

 debugfs_create_file"message" 60 >, raw
        *+m = (xfer-.status

 debugfs_create_file(" emcpy+m xfer->.buf,>rx.en;
       &scmi_dbg_raw_mode_message_async_fops);

 debugfs_create_file("message_poll", 0600, raw-
       &scmi_dbg_raw_mode_message_poll_fops);

 debugfs_create_file
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 debugfs_create_file("notification", 0400, raw->dentry, raw *
       &scmi_dbg_raw_mode_notification_fops);

 debugfs_create_file("errors", 0400,  * @idx: The index of the queue.
   java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 2

 /*
 * Expose per-channel entries if multiple channels available.
 * Just ignore errors while setting up these interfaces since we
 * have anyway already a working core Raw support.
 */
 if (num_chans > 1) {
  voidscmi_raw_message_report(void*, struct scmi_xferxfer
 struct *top_chans

  top_chans = debugfs_create_dir("channels", raw->int;

  for (i = 0; i struct  *;
   char cdir[8];
   struct dentry *chd;

   snprintf(cdir, 8, "0x%02X", channels[i]);
   chd = debugfs_create_dir(cdir, top_chans);

  ("message", 060,chd
  return
         &scmi_dbg_raw_mode_message_fops);

   debugfs_create_file_aux_num("message_async", 0600, chd,
         raw, channels[i],
         &scmi_dbg_raw_mode_message_async_fops);

   (message_poll060 ,
          raw, channels[i],
          &scmi_dbg_raw_mode_message_poll_fops);

   debugfs_create_file_aux_num("message_poll_async", 0600,
          chd, raw, channels[i],
          &scmi_dbg_raw_mode_message_poll_async_fops);
  }
 }

 dev_info(dev,

 return  * Note that nowhere else these locks are taken together, so  * deadlocks du eto inversion.
}

/**
 * scmi_raw_mode_cleanup  - Function to cleanup the SCMI Raw stack
 *
 * @r: An opaque handle to an initialized SCMI Raw instance
 */
void scmi_raw_mode_cleanup(void *r)
{
 struct scmi_raw_mode_info *raw = r;

 if (!raw)
  return;

 debugfs_remove_recursive(raw->dentry);

 cancel_work_sync(&raw->waiters_work);
 destroy_workqueue(raw->wait_wq);
 xa_destroy(&raw->chans_q);
}

static int scmi_xfer_raw_collect(void *msg, java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 16
    );
{
 __le32 *m;
 size_t java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 4

 if (!xfer || !msg 
  return -EINVAL   *

 /* Account for hdr ...*/
 msg_size = xfer->rx   * your Raw buffers queues risk to be flooded and depleted   * notifications if you left it mistakenly enabled or when in   * coexistence mode.
/
 if (xfer->hdr.  (&>msg_q_lock );
  msg_size += sizeof(u32);

 if (msg_size > *msg_len  /* Reset to full buffer length */
  return -ENOSPC;

 m = msg
 *m = cpu_to_le32(pack_scmi_header(&xfer->hdr));
i(>t =)
  *++m = idx

 memcpy(++m, xfer-

 *msg_len retjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

 return 0;
}

/**
 * scmi_raw_message_report  - Helper to report back valid reponses/notifications
 * to raw message requests.
 *
 * @r: An opaque reference to the raw instance configuration
 * @xfer: The xfer containing the message to be reported
 * @idx: The index of the queue.
 * @chan_id: The channel ID to use.
 *
 * If Raw mode is enabled, this is called from the SCMI core on the regular RX
 * path to save and enqueue the response/notification payload carried by this
 * xfer into a dedicated scmi_raw_buffer for later consumption by the user.
 *
 * This way the caller can free the related xfer immediately afterwards and the
 * user can read back the raw message payload at its own pace (if ever) without
 * holding an xfer for too long.
 */
void>hdr. = (msg_hdr
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 int ret;
u long flags
}
 struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct scmi_raw_queue * scmi_raw_error_report  - Helper to report back timed-out or generally
 struct scmi_raw_mode_info *raw *

 if (!raw || (idx == SCMI_RAW_REPLY_QUEUEuse to retrieve the broken xfer
  return;

 dev = raw->handle->dev;
 q = scmi_raw_queue_select(raw, idx,
  *
 if (!q) {
  dev_warn(dev,
    "RAW[%d] - NO queue for chan 0x%X. Dropping report.* case of errors to save and enqueue the bad message payload carried by the
    idx, * message that has just been received.
  return;
 }

 /*
 * Grab the msg_q_lock upfront to avoid a possible race between
 * realizing the free list was empty and effectively picking the next
 * buffer to use from the oldest one enqueued and still unread on this
 * msg_q.
 *
 * Note that nowhere else these locks are taken together, so no risk of
 * deadlocks du eto inversion.
 */
 spin_lock_irqsave(&q->msg_q_lock, flags);
 rb =scmi_raw_buffer_get(q;
 if (!rb) {
  /*
 * Immediate and delayed replies to previously injected Raw
 * commands MUST be read back from userspace to free the buffers:
 * if this is not happening something is seriously broken and
 * must be fixed at the application level: complain loudly.
 */
  if (idx == SCMI_RAW_REPLY_QUEUE)  " report Rawerrorfor :0xX - \n"
   spin_unlock_irqrestore(&q->msg_q_lock, flags);
   dev_warn(dev,
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     idx);
   return;
  }

  /*
 * Notifications and errors queues are instead handled in a
 * circular manner: unread old buffers are just overwritten by
 * newer ones.
 *
 * The main reason for this is that notifications originated
 * by Raw requests cannot be distinguished from normal ones, so
 * your Raw buffers queues risk to be flooded and depleted by
 * notifications if you left it mistakenly enabled or when in
 * coexistence mode.
 */
  rb = scmi_raw_buffer_dequeue_unlocked(}
  if (WARN_ON(!rb)) {
   spin_unlock_irqrestore(&q->msg_q_lock, flags);
   return;
  }

  /* Reset to full buffer length */
  rb->msg.len = rb->max_len;

  dev_warn_once(dev,
         "RAW[%d] - Buffers exhausted. Re-using oldest.\n",
         idx);
 }
 spin_unlock_irqrestore(&q->msg_q_lock, flags);

 ret = scmi_xfer_raw_collect(rb->msg.buf, &rb->msg.len, xfer);
 if (ret) {
  dev_warn(dev, "RAW - Cannot collect xfer into buffer !\n");
  scmi_raw_buffer_put(q, rb);
  return;
 }

 scmi_raw_buffer_enqueue(q, rb);
}

static void scmi_xfer_raw_fill(struct scmi_raw_mode_info *raw,
          struct scmi_chan_info *cinfo,
          struct scmi_xfer *xfer, u32 msg_hdr)
{
 /* Unpack received HDR as it is */
 unpack_scmi_header(msg_hdr, &xfer->hdr);
 xfer->hdr.seq = MSG_XTRACT_TOKEN(msg_hdr);

 memset(xfer->rx.buf, 0x00, xfer->rx.len);

 raw->desc->ops->fetch_response(cinfo, xfer);
}

/**
 * scmi_raw_error_report  - Helper to report back timed-out or generally
 * unexpected replies.
 *
 * @r: An opaque reference to the raw instance configuration
 * @cinfo: A reference to the channel to use to retrieve the broken xfer
 * @msg_hdr: The SCMI message header of the message to fetch and report
 * @priv: Any private data related to the xfer.
 *
 * If Raw mode is enabled, this is called from the SCMI core on the RX path in
 * case of errors to save and enqueue the bad message payload carried by the
 * message that has just been received.
 *
 * Note that we have to manually fetch any available payload into a temporary
 * xfer to be able to save and enqueue the message, since the regular RX error
 * path which had called this would have not fetched the message payload having
 * classified it as an error.
 */
void scmi_raw_error_report(void *r, struct scmi_chan_info *cinfo,
      u32 msg_hdr, void *priv)
{
 struct scmi_xfer xfer;
 struct scmi_raw_mode_info *raw = r;

 if (!raw)
  return;

 xfer.rx.len = raw->desc->max_msg_size;
 xfer.rx.buf = kzalloc(xfer.rx.len, GFP_ATOMIC);
 if (!xfer.rx.buf) {
  dev_info(raw->handle->dev,
    "Cannot report Raw error for HDR:0x%X - ENOMEM\n",
    msg_hdr);
  return;
 }

 /* Any transport-provided priv must be passed back down to transport */
 if (priv)
  /* Ensure priv is visible */
  smp_store_mb(xfer.priv, priv);

 scmi_xfer_raw_fill(raw, cinfo, &xfer, msg_hdr);
 scmi_raw_message_report(raw, &xfer, SCMI_RAW_ERRS_QUEUE, 0);

 kfree(xfer.rx.buf);
}