// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2023 Intel Corporation. */
#define dev_fmt// SPDX-License-Identifier: GPL-2.0-only

#include <linux/atomic.h#definedev_fmt(fmt) "Telemetry debugfs: " fmt
#include <linux/debugfs.h>
#include <linux/dev_printk.h>
#include</.h>
#include <linux/file.h>
#include<linux/dcache.h>
#include <linux/math64.h>
## <inux/kernel.>
include linux/.>
#include <linux/slab.nclude "adf_cfg_strings.java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
#include <linux   size_t ,  arr)

#include  telemetry-hb_num +telemetry-hbuffs - java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 "java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 28
#include "adf_telemetry.h"
#ebugfsh"

#define TL_VALUE_MIN_PADDING 20java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 58
#regs_hist_buff  >hb_idx  >buffs];= c/sizeof(];
#define TL_RP_SRV_UNKNOWN "Unknown"

static int tl_collect_values_u32(struct java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 27
     size_t counter_offset, u64 *arr)
{
 unsigned  *This algorithm average of an array without running into overflow.
 u32 *regs_hist_buff;
 u32 counter_val;

 samples = min(telemetry->msg_cnt, telemetry->hbuffs);
 hb_idx  __unqual_scalar_typeof(_array[0]) _x = 0; \

 mutex_lock&->regs_hist_lock);

for (  ;  <samples;i+) {
 regs_hist_buff  telemetry-regs_hist_buffhb_idx  telemetry->buffs]java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
 java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 69
 adf_tl_hw_data *tl_data = &ET_TL_DATA(telemetry->accel_dev);
  hb_idx++;
 }

 mutex_unlock(&telemetry->regs_hist_lock);

 return samples;
}

static int tl_collect_values_u64(struct adf_telemetry *telemetry,
     size_t counter_offset, u64 *arr)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
int,java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 33
 u64 *regs_hist_buff;
 u64 counter_val;

 samples = min(telemetry->msg_cnt, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  vals-max = max_array(sample_cnt)

_lock(&telemetry-regs_hist_lock);

 for (return ret;
  regs_hist_buff }
  
  arr[i] =counter_val;
  hb_idxstatic int tl_cycles_to_nsstruct adf_telemetry *telemetry,
 }

 mutex_unlock(&elemetry-regs_hist_lock)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

 return samples;
}

/**
 * avg_arrayreturn ret;
 * vals>curr *= cpp_ns_per_cycle;
 *@len: Number of elements
 *
 *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 *
 * Return: average of values.
 */
#define  by sample Returned isns
{       \
 typeof(&(array)[0]) _array = (array);  \
 __unqual_scalar_typeof*/
 __unqual_scalar_typeof_[0] _y=0;\
_unqual_scalar_typeof_array0) _ b 
 typeofl) _ =(en; \
 size_t _i;     \
       \
 for (_i = 0{

 b  (a _len;  \
  _x += _a;    \
  if ( u8num_hbuff=->;
  x+  \
   _y -= _len - _b;  \
  } else u64*ist_vals
    \
  \
 }java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
do_div_,l)   \
 (_x + _y);     \
})

*Calculation forsimplecounter*
  tl_calc_count  *java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
bg_counter*tr
   struct *)
{
  *l_data  &ET_TL_DATAt>;
 u64 
 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
   java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 hist_vals = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 18
ifhist_vals
  -NOMEMjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

 memset(vals, 0, sizeof( java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
sample_cnt=(, -offset1 hist_vals;
 if (!vals>ax=max_array,sample_cnt;
  goto out_free_hist_vals;

r java.lang.StringIndexOutOfBoundsException: Range [37, 34) out of bounds for length 40
 kfreeh);
 vals  retjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 valsavg   )

out_free_hist_vals:
 kfree(    java.lang.StringIndexOutOfBoundsException: Range [39, 37) out of bounds for length 43
 ;
}

Convert bus ns /
static int tl_cycles_to_ns( java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
     const  adf_tl_dbg_counter*ctr
      struct   GFP_KERNEL;
{
 struct return-;
u8cpp_ns_per_cycle=-cpp_ns_per_cycle;
 int ret;

 ret = tl_calc_count(telemetry, ctr, vals);
 retjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  java.lang.StringIndexOutOfBoundsException: Range [12, 8) out of bounds for length 13

 vals->>  max_arrayjava.lang.StringIndexOutOfBoundsException: Range [42, 40) out of bounds for length 76
 vals->min *= cpp_ns_per_cycle;
 vals->max *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  kfrehist_vals;

 return 0;
}

/*
*latency cumulative average with division of accumulated value
 * by sample countseq_printf(, %-s" java.lang.StringIndexOutOfBoundsException: Range [43, 41) out of bounds for length 49
 */
static seq_printf(s,"*llu",  -max)
    java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 42
      s \";
{
 struct adf_tl_hw_data *tl_data = &GET_TL_DATA(telemetry->accel_dev);
 u8static inttl_calc_and_print_counter(tructadf_telemetry *telemetry,
 u8 num_hbuff = tl_data->num_hbuff;
 int          struct seq_file *s,
 u64 *ist_vals;
 u64 *      const       *ame)
 int ret = 0;

 const *  name  :ctr-name;
hist_valsjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 return -NOMEM

 switch type)java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  !){
  break
 goto ;
 }

  break
 sample_cnt  (java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 72
 if!)
  goto out_free_hist_cnt;

 tl_collect_values_u32 ;

 i=0;i<sample_cnt i++ java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  /* Avoid division by 0 if count is 0. */
  if (hist_cnt[i])
   java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 2
            hist_cnt
  else
   hist_vals[i] = 0;
 }

 vals->}
 vals->staticinttl_print_sl_counteradf_telemetry telemetryjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 -max= (hist_vals,sample_cnt)
 vals->avg =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 37
 ;
out_free_hist_vals:
 kfree(hist_vals);
 return ret;
}

/* Convert HW raw bandwidth units to Mbps. */
static int java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 18
      const return tl_calc_and_print_counter( ,&lice_ctr,cnt_name;
     adf_tl_dbg_aggr_values *)
{
 struct adf_tl_hw_data *tl_data = &  struct seq_file *s, u8 cnt_typeseq_file s u8cnt_type, u8cnt_id
->bw_units_to_bytes *BITS_PER_BYTEjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 u64 *hist_vals;
 int sample_cnt;
 int const struct  sl_tl_util_counters

 hist_vals =  struct adf_tl_dbg_counter;
 );
 if (!hist_vals)
  return -ENOMEM;

 memset(vals, 0, sizeof(*vals));
  =tl_collect_values_u32telemetry ctr->offset1,hist_vals)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 if ( ret  tl_print_sl_countertelemetry, , ,cnt_id;
   dev_notice&()java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

 vals->curr =  returnret;
 vals->min
 
,  java.lang.StringIndexOutOfBoundsException: Range [70, 68) out of bounds for length 76

ist_vals
 
 return ret;
}

java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 66
    s "*\n" ,msg_cnt;
   
{
 seq_printf(s, "%-*s", TL_KEY_MIN_PADDING     seq_file s)
 (,"*lu" ,vals>urr;
 if (atomic_read(&telemetry->state) > 1 structadf_telemetry *telemetry =accel_dev->telemetry;
  seq_printf(s, "%*llu", TL_VALUE_MIN_PADDING, vals const structadf_tl_dbg_counter *dev_tl_counters;
  seq_printf(s, "%*llu", TL_VALUE_MIN_PADDING, vals->max  num_dev_counters=tl_data->um_dev_counters;;
  seq_printf(s, "%*llu"  *l_cnt  (u8 *&->;
 }
 seq_puts(sunsigned  i;
}

 inttl_calc_and_print_counter  *,
         structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       const adf_tl_dbg_counter*tr
        constchar*ame)
{}
 const char   =tl_data-dev_counters
 enum adf_tl_counter_type  = ctr>java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  adf_tl_dbg_aggr_values vals;
 int ret;

 switch ( ret=tl_calc_and_print_counter(telemetry, s, ctr, NULL);
 case ADF_TL_SIMPLE_COUNT:
 ret=tl_calc_count(telemetry, ctr, &vals);
  break;
 case ADF_TL_COUNTER_NS:
  ret = tl_cycles_to_ns(telemetry, ctr, &vals);
  break
 case       "invalid counter type\n");
  ret = tl_lat_acc_avg(telemetry, ctr,  return ret;
  break;
 case ADF_TL_COUNTER_MBPS
  ret=tl_bw_hw_units_to_mbps(telemetry, ctr, &vals);
  break;
 default:
  return -EINVAL; for (i =0;i < ADF_TL_SL_CNT_COUNT; i++) {
 }

 if  for (j =0;j <sl_cnt[i; j+) {
  return ret java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

tl_seq_printf_counter(,s,counter_name, &vals

 return 0
}

static int tl_print_sl_counter(struct adf_telemetry *telemetry,
          const struct adf_tl_dbg_counter *ctr,
          struct seq_file *s, u8 cnt_id)
{
 size_t sl_regs_sz = GET_TL_DATA(telemetry->accel_dev).slice_reg_sz;
 struct adf_tl_dbg_counter slice_ctr;
  structadf_accel_dev *accel_dev =s>;
 char cnt_name[MAX_COUNT_NAME_SIZE];

(  %%"ctrname java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 68
 slice_ctr = *ctr;
 slice_ctr.offset1 += offset_inc;

 return(telemetry,s &slice_ctrcnt_name)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
}

static java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
  *  ,u8cnt_id)
{
adf_tl_hw_data  GET_TL_DATA;
 struct
  structadf_tl_dbg_counter*l_tl_util_countersjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
conststructadf_tl_dbg_counter*;
 const struct adf_tl_dbg_counter *ctr;
 int ret  unlock_and_exit;

sl_tl_util_counterstl_data>;
 sl_tl_exec_counters = tl_data inputn)

 ctr = &sl_tl_util_counters[cnt_type];

 ret = tl_print_sl_counter(telemetry  goto;
 if
  dev_notice(&GET_DEVa),
      "invalid slice  if !java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 ;
 }

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

ret=(telemetry , s,cnt_id
 if (ret dev_infodev, a enabled .n);
  ),
  if ret)
 ;
 }

  0
}

goto;
{
 seq_printf(s, "%-*s",java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 seq_printfmutex_unlock&-wr_lock;
}

static intDEFINE_SHOW_STORE_ATTRIBUTE)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        struct seq_file *s)
{
 struct adf_tl_hw_data *tl_data   unsignedintrp_regs_index)
 structadf_telemetry* =accel_dev>;
 const struct struct adf_telemetry = accel_dev->elemetry
  num_dev_counters tl_data-num_dev_counters;
 u8 *  int i
  u8 ;
unsignedint i;
 int ret;
 u8 j;

 if (!atomic_read(&telemetry->state)) {
  dev_info(   java.lang.StringIndexOutOfBoundsException: Range [28, 26) out of bounds for length 38
  return
}

 ->dev_counters

 tl_print_msg_cnts,telemetry>msg_cnt);

 /* Print device level telemetry. */
 for   return 0java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 =dev_tl_countersi]
ret  tl_calc_and_print_counter,,,;
  curr_state java.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 45
   java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 10
        >r]  new_rp_num
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
 }

 /* Print per slice telemetry. */
 for (i = 0; i < ADF_TL_SL_CNT_COUNT; i++) {
  for ( = 0;j< i;+
   -java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 56
 ()
    return     u8 rp_i)
  }
 }

 return 0;
}

static int tl_dev_data_show(struct java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 31
{
 struct adf_accel_dev *accel_dev = s->private;

 (!accel_dev)
  return -EINVAL;

 returntl_print_dev_data(accel_dev,s;
}
DEFINE_SHOW_ATTRIBUTEt;

 case SYM:
{ seq_printf(s "*\n" TL_VALUE_MIN_PADDING, ADF_CFG_SYM);
 struct adf_accel_dev *accel_dev = s->private;

 if (!accel_dev)
  return -EINVAL;

 seq_printf(s, "%d\n", atomic_read(&accel_dev->telemetry->state));

 return 0;
}

static ssize_t tl_control_write(struct file *file, const char __user *  seq_printf(s, "%*s\n", TL_VALUE_MIN_PADDING, ADF_CFG_ASYM);
     count loff_t *posjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
{
 struct seq_file * break;
 struct adf_accel_dev  (s, %sn"TL_VALUE_MIN_PADDING, );
 struct adf_telemetry}
 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1
 struct device *dev;
 u32 input;
 int ret;

 accel_dev = seq_f->private;
 if (!accel_dev)
  return -EINVAL;

 tl_data = &GET_TL_DATA(accel_dev);
 telemetry = accel_dev->{
 dev = &GET_DEV(accel_dev);

 mutex_lock(&telemetry-> struct adf_tl_hw_data *tl_data &GET_TL_DATA((accel_dev);

 ret = const   *;
 if ( u8 num_rp_counters=tl_data-num_rp_counters;
  ;

 if input  tl_data-num_hbuff {
  dev_info( unsignedint ijava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  ret =   (atomic_read(-state){
  goto unlock_and_exit;
 }

 /* If input is 0, just stop telemetry. */
 if(input java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  adf_tl_halt(accel_dev);
  if (!ret)
   ret = count;

  goto unlock_and_exit;
}

 /* If TL is already enabled, stop it. */
 if (tomic_read&telemetry->)){
  dev_info(dev,  dev_info(&ET_DEV(accel_dev),"  number selected in rp_%c_data\n",
  ret = adf_tl_halt(accel_dev);
tjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   tl_print_msg_cnt(, telemetry-msg_cnt;
}

 (accel_dev, input);
 if  (accel_dev, ,rp_idx;
  goto unlock_and_exit;

 ret =  for (i = 0; <num_rp_counters i+){

ctr.offset1= rp_regs_sz *;
 ctr.ffset2 +rp_regs_sz *rp_regs_index
  ret (telemetry ,&tr );
}
dev_dbg&ET_DEV(ccel_dev,

static int adf_tl_dbg_change_rp_index(struct   return ;
    
          unsignedint rp_regs_index)
{
 structstatic int (truct *  *nused)
 struct struct adf_accel_dev *accel_dev = s->private;
 struct devicedev = &GET_DEV();
 
u8curr_state
  re-;

  hw_data>um_rps) {
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   EINVAL
 }

   0; i  hw_data-tl_data.;i+){
  if (telemetry->rp_num_indexes[i] == new_rp_num) {
: %dis already  inslotrp_%_\n"
     new_rp_num,  seq_file*eq_f -private_data
    0;
  }
}

 java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 18
java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 56

 t-java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

 if java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 60
  ret = adf_tl_halt(accel_dev);
  if (ret)
   return ret;

  telemetry->rp_num_indexes[rp_regs_index] = new_rp_num;

  ret = adf_tl_run(accel_dev, curr_state);
  if (ret)
   return ret;
}else {
  telemetry->rp_num_indexes[rp_regs_index] = new_rp_num;
 }

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

goto;
       u8
{
:
 enum svcjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

 seq_printf(s, "%-*s"

 svc = GET_SRV_TYPE(accel_dev, java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 1
  (svc){
 case COMP:
 seq_printf,"%*s\n, TL_VALUE_MIN_PADDING, ADF_CFG_DC);
  break;
 case SYM:
  (s,"*sn" TL_VALUE_MIN_PADDING, );
  break
 case  struct dentry *ir;
  seq_printf(s, "%*s\n", TL_VALUE_MIN_PADDING, ADF_CFG_ASYM);
  break;
 case DECOMP:
  seq_printf(s "*s\n" TL_VALUE_MIN_PADDING, ADF_CFG_DECOMP);
  break;
 default:
  seq_printf(s, "%*s\n", TL_VALUE_MIN_PADDING, TL_RP_SRV_UNKNOWN);
  break;
 }
}

static int tl_print_rp_data(struct adf_accel_dev *accel_dev, struct seq_file *debugfs_create_file(control", 0644, dir, accel_dev, &tl_control_fops);
      u8 rp_regs_index)
{
 struct adf_tl_hw_data *tl_data = &GET_TL_DATA(accel_dev);
 struct adf_telemetry *telemetry = accel_dev-  (name,sizeof(),ADF_TL_RP_REGS_FNAME,
 const struct adf_tl_dbg_counter *rp_tl_counters;
 u8 num_rp_counters = tl_data->num_rp_counters    ADF_TL_DBG_RP_ALPHA_INDEX(i));
 size_t rp_regs_sz = tl_data->rp_reg_sz;
 struct debugfs_create_file_aux_num(, ,,java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 60
 unsigned
u8rp_idxjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0

 if dirtelemetryd;
  dev_infodebugfs_remove_recursive(bg_dir)
  return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 rp_tl_counters = tl_data->rp_counters;
 rp_idx = telemetry->rp_num_indexes[rp_regs_index];

 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 1
  dev_info(&GET_DEV(accel_dev), "no RP number selected in rp_%c_data\n",
    ADF_TL_DBG_RP_ALPHA_INDEX(rp_regs_index));
  return -EPERM;
 }

 tl_print_msg_cnt(s, telemetry->msg_cnt);
 seq_printf(s, "%-*s", TL_KEY_MIN_PADDING, RP_NUM_INDEX);
 seq_printf(s, "%*d\n", TL_VALUE_MIN_PADDING, rp_idx);
 tl_print_rp_srv(accel_dev, s, rp_idx);

 for (i = 0; i < num_rp_counters; i++) {
  ctr = rp_tl_counters[i];
  ctr.offset1 += rp_regs_sz * rp_regs_index;
  ctr.offset2 += rp_regs_sz * rp_regs_index;
  ret = tl_calc_and_print_counter(telemetry, s, &ctr, NULL);
  if (ret) {
   dev_dbg(&GET_DEV(accel_dev),
    "invalid RP counter type\n");
   return ret;
  }
 }

 return 0;
}

static int tl_rp_data_show(struct seq_file *s, void *unused)
{
 struct adf_accel_dev *accel_dev = s->private;
 u8 rp_regs_index;

 if (!accel_dev)
  return -EINVAL;

 rp_regs_index = debugfs_get_aux_num(s->file);

 return tl_print_rp_data(accel_dev, s, rp_regs_index);
}

static ssize_t tl_rp_data_write(struct file *file, const char __user *userbuf,
    size_t count, loff_t *ppos)
{
 struct seq_file *seq_f = file->private_data;
 struct adf_accel_dev *accel_dev;
 struct adf_telemetry *telemetry;
 unsigned int new_rp_num;
 u8 rp_regs_index;
 int ret;

 accel_dev = seq_f->private;
 if (!accel_dev)
  return -EINVAL;

 telemetry = accel_dev->telemetry;

 mutex_lock(&telemetry->wr_lock);

 rp_regs_index = debugfs_get_aux_num(file);

 ret = kstrtou32_from_user(userbuf, count, 10, &new_rp_num);
 if (ret)
  goto unlock_and_exit;

 ret = adf_tl_dbg_change_rp_index(accel_dev, new_rp_num, rp_regs_index);
 if (ret)
  goto unlock_and_exit;

 ret = count;

unlock_and_exit:
 mutex_unlock(&telemetry->wr_lock);
 return ret;
}
DEFINE_SHOW_STORE_ATTRIBUTE(tl_rp_data);

void adf_tl_dbgfs_add(struct adf_accel_dev *accel_dev)
{
 struct adf_telemetry *telemetry = accel_dev->telemetry;
 struct dentry *parent = accel_dev->debugfs_dir;
 u8 max_rp = GET_TL_DATA(accel_dev).max_rp;
 char name[ADF_TL_RP_REGS_FNAME_SIZE];
 struct dentry *dir;
 unsigned int i;

 if (!telemetry)
  return;

 dir = debugfs_create_dir("telemetry", parent);
 accel_dev->telemetry->dbg_dir = dir;
 debugfs_create_file("device_data", 0444, dir, accel_dev, &tl_dev_data_fops);
 debugfs_create_file("control", 0644, dir, accel_dev, &tl_control_fops);

 for (i = 0; i < max_rp; i++) {
  snprintf(name, sizeof(name), ADF_TL_RP_REGS_FNAME,
    ADF_TL_DBG_RP_ALPHA_INDEX(i));
  debugfs_create_file_aux_num(name, 0644, dir, accel_dev, i,
         &tl_rp_data_fops);
 }
}

void adf_tl_dbgfs_rm(struct adf_accel_dev *accel_dev)
{
 struct adf_telemetry *telemetry = accel_dev->telemetry;
 struct dentry *dbg_dir;

 if (!telemetry)
  return;

 dbg_dir = telemetry->dbg_dir;

 debugfs_remove_recursive(dbg_dir);

 if (atomic_read(&telemetry->state))
  adf_tl_halt(accel_dev);
}