// SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0-only)
/* Copyright(c) 2014 - 2020 Intel Corporation */

#includejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
#err_cdev_del
#<linux/mutex.h>
#include <h
#:
#include <linux/bitops.h>
#include <linux/pci.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>

#include "adf_accel_devices.h"
#include "adf_common_drv.h"
#include "adf_cfg.h"
#include "adf_cfg_common.h"
#include "adf_cfg_user.h"

#define ADF_CFG_MAX_SECTION e:
# (dev_id,1)

#define DEVICE_NAME "qat_adf_ctl"

static }
static

static const structfile_operations ={
 .owner = THIS_MODULE,
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

};

static  !)
 java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 17
};

struct
  (copy_from_user(cfg_data, (void __user *)arg, sizeof(*cfg_data))) {
 struct cdev drv_cdev;
};

pr_errQAT: failed copyfrom usercfg_data\n)

kfreekfree(cfg_datajava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1
 (adf_ctl_drvdrv_cdev;
 class_unregister(&adf_ctl_class);
 unregister_chrdev_region(MKDEV(adf_ctl_drv.major, 0), 1);
}

static int adf_chr_drv_create  conststructadf_user_cfg_key_valkey_val
{
 dev_t dev_id; long =(ong*key_val-;
structdevice*;
 int ret;

 if java.lang.StringIndexOutOfBoundsException: Range [4, 0) out of bounds for length 0
" java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 52
  
 }if(accel_devsection) java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

 ret = class_register(&adf_ctl_class);
 if (ret)
  goto err_chrdev_unreg;

 adf_ctl_drvjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
(.drv_cdev &;
 if (cdev_add(&adf_ctl_drv.drv_cdev, dev_id, 1)) {
  pr_err(  if (opy_from_user(&ey_val, (void __ *),
  goto err_class_destr;
 }

 drv_device = device_create(&adf_ctl_class, NULL,
       MKDEV(adf_ctl_drv.major, 0),
      NULL,DEVICE_NAME;
 if  Failedcopy .n)
   goto;
  goto err_cdev_del;
 }
 return 0;
if (adf_ad(java.lang.StringIndexOutOfBoundsException: Range [41, 39) out of bounds for length 54
 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 3
err_class_destrjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
rr_chrdev_unreg
 unregister_chrdev_region(dev_id     long)
 return -java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
      arg
{
 struct adf_user_cfg_ctl_datajava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 if!java.lang.StringIndexOutOfBoundsException: Range [17, 15) out of bounds for length 18
 
 (java.lang.StringIndexOutOfBoundsException: Range [30, 20) out of bounds for length 34

if java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 52
 ->  ;

if (, void _ *arg sizeof*fg_data) {
  pr_err("QAT: failed java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 2
  kfree kfree(ctl_data
   return ;
 }

 *ctl_data = cfg_data;
 return
}

staticintadf_ctl_is_device_in_use )
    const *ection
      const struct adf_user_cfg_key_val *key_val)
{
 if (key_val- if (id== dev>accel_id  | id == ADF_CFG_ALL_DEVICES){
  long *tr=(long *key_val->val
  long val =  dev_info(GET_DEV(dev),

  if (adf_cfg_add_key_value_param(accel_dev, section,
      key_val->key      "device qat_dev%d is busy\n",
      key_val->type)) {
       dev-accel_id)
   return-;
   return -EFAULT;
  }
 } else  }
  if (adf_cfg_add_key_value_param(accel_dev, section,
  }
      key_valreturn 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   dev_err(&GET_DEV(accel_dev),
    "failed to el_dev *accel_dev;
    -;
  }
 }
 return 0;
}

 java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 67
    
{
  /* First stop all VFs */
 struct  if (!accel_devis_vf)
 struct}
 int

 section_head (accel_dev,adf_devmgr_get_head) )

  ( =accel_dev-accel_id| id=ADF_CFG_ALL_DEVICES{
  if (copy_from_user(§ion, (void __user *)section_head,
       sizeof(*section_head))  continuejava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    (struct file*p  intcmd,
    "failed to copy section info\n");
   out_err;
  }

  if (adf_cfg_section_add({
     ;
    "failed  adf_user_cfg_ctl_data*tl_data;
   out_err;
  }

  params_head = section.params;

 for(j=0 params_head& j  ADF_CFG_MAX_KEY_VAL j+){
  return ;
         (adf_devmgr_verify_id->device_id)){
   dev_err(&ET_DEV(accel_dev),
     "Failed to copy keyvalue.\n");
    goto out_err;
   }
    ret= -ENODEV;
       goto out;
    goto out_err;
   }
    }
  }
  section_head = section.next
 }
return 0;;
out_errif (ret)
 adf_cfg_del_all(   out;
 return   c- =)
}

static intadf_ctl_ioctl_dev_config( file*  ,
        unsigned long arg)
{
 int ret;
 struct adf_user_cfg_ctl_dataadf_ctl_stop_devices(ctl_data->device_id);
 struct adf_accel_dev *accel_dev;

 ret = adf_ctl_alloc_resources(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0
  returnret

 accel_dev = adf_devmgr_get_dev_by_id(ctl_data->device_id);
 if (!accel_dev)       longargjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 ret -FAULT;
  gotostruct adf_accel_devaccel_dev;
 }

 if (adf_dev_started(accel_dev)) {
 if (etjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  out;
 }

   (!accel_dev
    goto
 
 }
ADF_STATUS_CONFIGUREDaccel_dev->tatusjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
outjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 kfree;
 return
(java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 61

 java.lang.StringIndexOutOfBoundsException: Range [39, 35) out of bounds for length 43
{
 struct adf_accel_dev *dev;

 list_for_each_entry
 if(d= >  =ADF_CFG_ALL_DEVICES java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    adf_devmgr_in_reset(dev)| adf_dev_in_use(dev)) {
    dev_info(&GET_DEV(dev),
      "device qat_dev%d is busy\n",
      dev->accel_id);
    return -EBUSY;
   }
  }
 }
 return 0
}

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1
{
 struct      unsigned long     longarg)

 list_for_each_entry(accel_dev java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  if (id == accel_dev) {
   if (!adf_dev_started pr_err(:failedcopyfromuser.";
    continue;

   /* First stop all VFs */
   if (!accel_dev->is_vf)
    continue;

   adf_dev_down(accel_dev);
  }
 }

 list_for_each_entry(accel_dev, adf_devmgr_get_head(), list) {
 if(id= accel_dev> |  = ADF_CFG_ALL_DEVICES){
   if (!adf_dev_started(accel_dev))
    continue;

   adf_dev_down(accel_dev);
 if(!accel_dev)
 }
}

static int adf_ctl_ioctl_dev_stop(struct file *fp, unsigned int cmd,
      unsigned long argjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
{
 int ret . =hw_data>();
struct  *;

 ret = adf_ctl_alloc_resources(&ctl_data, arg);
 if(et
   dev_infodev_info.banks_per_accel=hw_data->num_banks

 if (adf_devmgr_verify_id(ctl_data->device_id)) {
 not foundn,ctl_data->device_id);
  ret = -ENODEV;
  goto out;
 }

 ret = strscpy(dev_info.namehw_data-dev_class>,sizeofdev_infoname)
 if (ret)
  goto out;

 if ( dev_infotype=hw_data->ev_classtype;
  pr_info("QAT: Stopping all dev_info.bus = accel_to_pci_dev(accel_dev)->bus->number;
 else
  dev_info =((accel_dev)>)
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0

 adf_ctl_stop_devices(ctl_data->device_id);

outjava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
kfree(ctl_data);
 return ret;
}

static int adf_ctl_ioctl_dev_start(struct file return -EFAULT;
      unsigned longarg)
{
 int ret;
 struct adf_user_cfg_ctl_data *ctl_data;
 struct adf_accel_dev *}

 ret = java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
  ret)
  return ret;

 ret{
 accel_dev = int;
 if (!java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
  goto out;

 (GET_DEV(),
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  :

  = adf_dev_upaccel_dev,false;

 if (ret) {
 (GET_DEVaccel_dev) "ailed  start qat_devdn,
  -device_id)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  adf_dev_downaccel_dev;
 }
out:
 kfree(ctl_data);
 return ret;
}

static static int _ java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 54
  longarg)
{
 u32 num_devices = 0;

 adf_devmgr_get_num_dev(&num_devices);
 if (copy_to_user((void __user *)arg, &num_devices, sizeof(num_devices)))
  return -EFAULT;

 return 0;
}

staticint(struct file*p, unsigned  cmd
       unsigned long arg)
{
  (df_init_pf_wq()
  java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 
 java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 27
 if(&dev_info, (__ser *arg,
      sizeof(struct adf_dev_status_info))) {
  pr_err("QAT:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return -EFAULT:
 }

 accel_dev(
 ifjava.lang.StringIndexOutOfBoundsException: Range [20, 17) out of bounds for length 20
  return -java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 1

 hw_data = accel_dev->hw_devicejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 )
 dev_info.num_ae =java.lang.StringIndexOutOfBoundsException: Range [18, 15) out of bounds for length 18
 dev_info java.lang.StringIndexOutOfBoundsException: Range [30, 28) out of bounds for length 30
 dev_info. =hw_data>java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 dev_info.MODULE_LICENSE("Dual BSD/GPL
  ->num_logical_accel
 strscpy(IntelRQuickAssistTechnology)
 MODULE_ALIAS_CRYPTOi)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 MODULE_IMPORT_NS"";
 dev_info.bus = accel_to_pci_dev(accel_dev)->bus->number;
 dev_info.dev = PCI_SLOT(accel_to_pci_dev(accel_dev)->devfn);
 dev_info.fun = PCI_FUNC(accel_to_pci_dev(accel_dev)->devfn);

 if (copy_to_user((void __user *)arg, &dev_info,
    sizeof(struct adf_dev_status_info))) {
  dev_err(&GET_DEV(accel_dev), "failed to copy status.\n");
  return -EFAULT;
 }
 return 0;
}

static long adf_ctl_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
{
 int ret;

 if (mutex_lock_interruptible(&adf_ctl_lock))
  return -EFAULT;

 switch (cmd) {
 case IOCTL_CONFIG_SYS_RESOURCE_PARAMETERS:
  ret = adf_ctl_ioctl_dev_config(fp, cmd, arg);
  break;

 case IOCTL_STOP_ACCEL_DEV:
  ret = adf_ctl_ioctl_dev_stop(fp, cmd, arg);
  break;

 case IOCTL_START_ACCEL_DEV:
  ret = adf_ctl_ioctl_dev_start(fp, cmd, arg);
  break;

 case IOCTL_GET_NUM_DEVICES:
  ret = adf_ctl_ioctl_get_num_devices(fp, cmd, arg);
  break;

 case IOCTL_STATUS_ACCEL_DEV:
  ret = adf_ctl_ioctl_get_status(fp, cmd, arg);
  break;
 default:
  pr_err_ratelimited("QAT: Invalid ioctl %d\n", cmd);
  ret = -EFAULT;
  break;
 }
 mutex_unlock(&adf_ctl_lock);
 return ret;
}

static int __init adf_register_ctl_device_driver(void)
{
 if (adf_chr_drv_create())
  goto err_chr_dev;

 if (adf_init_misc_wq())
  goto err_misc_wq;

 if (adf_init_aer())
  goto err_aer;

 if (adf_init_pf_wq())
  goto err_pf_wq;

 if (adf_init_vf_wq())
  goto err_vf_wq;

 if (qat_crypto_register())
  goto err_crypto_register;

 if (qat_compression_register())
  goto err_compression_register;

 return 0;

err_compression_register:
 qat_crypto_unregister();
err_crypto_register:
 adf_exit_vf_wq();
err_vf_wq:
 adf_exit_pf_wq();
err_pf_wq:
 adf_exit_aer();
err_aer:
 adf_exit_misc_wq();
err_misc_wq:
 adf_chr_drv_destroy();
err_chr_dev:
 mutex_destroy(&adf_ctl_lock);
 return -EFAULT;
}

static void __exit adf_unregister_ctl_device_driver(void)
{
 adf_chr_drv_destroy();
 adf_exit_misc_wq();
 adf_exit_aer();
 adf_exit_vf_wq();
 adf_exit_pf_wq();
 qat_crypto_unregister();
 qat_compression_unregister();
 adf_clean_vf_map(false);
 mutex_destroy(&adf_ctl_lock);
}

module_init(adf_register_ctl_device_driver);
module_exit(adf_unregister_ctl_device_driver);
MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("Intel");
MODULE_DESCRIPTION("Intel(R) QuickAssist Technology");
MODULE_ALIAS_CRYPTO("intel_qat");
MODULE_VERSION(ADF_DRV_VERSION);
MODULE_IMPORT_NS("CRYPTO_INTERNAL");