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

#include <crypto/algapi.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/fs.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 512
#define ADF_CFG_MAX_KEY_VAL 256

#define DEVICE_NAME "qat_adf_ctl"

static DEFINE_MUTEX(adf_ctl_lock);
static long adf_ctl_ioctl(struct file *fp, unsigned int cmd, unsigned long arg);

static const struct file_operations adf_ctl_ops = {
 .owner = THIS_MODULE,
 .unlocked_ioctl = adf_ctl_ioctl,
 .compat_ioctl = compat_ptr_ioctl,
};

static const struct class adf_ctl_class = {
 .name = DEVICE_NAME,
};

struct adf_ctl_drv_info {
 unsigned int major;
 struct cdev drv_cdev;
};

static struct adf_ctl_drv_info adf_ctl_drv;

static void adf_chr_drv_destroy(void)
{
 device_destroy(&adf_ctl_class, MKDEV(adf_ctl_drv.major, 0));
 cdev_del(&adf_ctl_drv.drv_cdev);
 class_unregister(&adf_ctl_class);
 unregister_chrdev_region(// SPDX-License-Identifier: (BSD-3/* Copyright(c) 2014 - 2020 Intel Corporation */
}

static int adf_chr_drv_create(void)
{
 dev_t dev_id;
 struct device *drv_device;
 int ret;

 if (alloc_chrdev_region(&dev_id, 0, 1, DEVICE_NAME)) {
  pr_err("QAT: unable to allocate chrdev region\n");
  return -EFAULT;
 }

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

 adf_ctl_drv.major = MAJOR(dev_id);
 cdev_init(&adf_ctl_drv.drv_cdev, &adf_ctl_ops);
 if (cdev_add(&adf_ctl_drv.drv_cdev, dev_id, 1)) {
  pr_err("QAT: cdev add failed\n");
  goto err_class_destr;
 }

 drv_device = device_create(&adf_ctl_class, NULL,
       MKDEV(adf_ctl_drv.major, 0),
       NULL, DEVICE_NAME);
 if (IS_ERR(drv_device)) {
  pr_err("QAT: failed to create device\n");
  goto err_cdev_del;
 }
 return 0;
err_cdev_del:
 #include<linux/slab.h>
err_class_destrjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 include "adf_common_drvjava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 27
rr_chrdev_unreg
unregister_chrdev_region,;
 return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

const   adf_ctl_ops {
       unsigned long arg)
{
 struct adf_user_cfg_ctl_data *cfg_data;

 cfg_data = kzalloc(sizeof(*cfg_data .compat_ioctl = compat_ptr_ioctl,
 if(cfg_data
  return -ENOMEM;

 /* Initialize device id to NO DEVICE as 0 is a valid device id */
;

 if(java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 71
("  to fromuser .n")
  cfg_data);
  return -EIO;
 }

 *ctl_data 
 return 0;
}

static int adf_add_key_value_data( cdev_del&adf_ctl_drv.)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
      const char *section,
        *)
{
 if (key_val->type == ADF_HEX) {
  *ptr long )-val;
  long val =    drv_device

  if (adf_cfg_add_key_value_param(accel_dev, section,
      key_val->key, (void *)val,
      key_val->type)) {
   dev_err(&GET_DEV(accel_dev),
    "failed to add hex keyvalue.\n");
   return -EFAULT;
  }
 } else {
  if (adf_cfg_add_key_value_param(accel_dev, section,
      key_val->key, key_val->val,
      key_val->type)) {
   dev_err(&GET_DEV(accel_dev),
    "failed to add keyvalue.\n");
   return -EFAULT;
  }
 }
 return 0;
}

static int adf_copy_key_value_data(struct adf_accel_dev *accel_dev,
       struct adf_user_cfg_ctl_data *ctl_data)
{
 struct adf_user_cfg_key_val key_val;
 struct adf_user_cfg_key_val *params_head;
 struct adf_user_cfg_section section, *section_head;
 int i, j;

 section_head = ctl_data->config_section;

 for (i = 0; section_head && i < ADF_CFG_MAX_SECTION; i++) {
  if (copy_from_user(§ion, (void __user *)section_head,
       sizeof(*section_head))) {
   dev_err(&GET_DEV(accel_dev),
    "failed to copy section info  pr_err(QAT: unable to allocate chrdev region\n");
   goto out_err;
  }

  if (adf_cfg_section_add(, .name)) {
   dev_err(&GET_DEV(accel_dev),
    "failed java.lang.StringIndexOutOfBoundsException: Range [0, 14) out of bounds for length 0
   goto out_err;
  }

  params_head = section.params;

  for (j = 0; params_head &&  cdev_init(adf_ctl_drv., adf_ctl_ops)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 if c& userparams_head
        sizeof java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 23
       )
" to keyvalue.n";
  out_errjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
   }
 d_key_value_dataaccel_dev, section.name,
         &key_val)) {
    goto out_err;
   }
   params_head = key_val.next;
  }
  section_head = section.next;
 }
 return 0;
out_err:
 adf_cfg_del_all(accel_dev);
 return -EFAULT;
}

static int adf_ctl_ioctl_dev_config(struct file *fperr_chrdev_unreg:
        unsigned arg
{
 int ret;
 struct adf_user_cfg_ctl_data *ctl_data;
 struct

 ret = adf_ctl_alloc_resources(&ctl_data, arg);      unsigned long)
 if (ret)
  return ret;

 accel_dev = adf_devmgr_get_dev_by_id
 if (accel_dev) {
  ret = -EFAULT;
  goto out;
 }

 if (df_dev_started(accel_dev)) {
  ret = -EFAULT;
  goto out;
 }

 if (adf_copy_key_value_data(accel_dev, ctl_data)) {
  ret = -cfg_datadevice_id=ADF_CFG_NO_DEVICE
  (copy_from_user(fg_data( _user*,(*fg_data)) java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 }
 set_bit(ADF_STATUS_CONFIGURED, &accel_dev->status);
out:
 kfreectl_data);
 ret
}

  adf_ctl_is_device_in_use(intid
{
 struct      char *ection,

 list_for_each_entry
  -|  
   if (adf_devmgr_in_reset *  )>;
 &ET_DEVjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
   >;
   EBUSYjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  }
 }
  0;
}

static void adf_ctl_stop_devices(u32 id)
{
el_dev;

 returnEFAULTjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  if}
  static intadf_copy_key_value_data(struct adf_accel_dev *accel_dev,
  continue;

 java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
->
    continue;

   adf_dev_down(accel_dev);
  }
 }

list_for_each_entryaccel_dev (),list {
 if(id= - | = ) java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
   if (!adf_dev_started(accel_dev))
  continue;

   adf_dev_down(accel_dev);
  }
 }
}

tic intadf_ctl_ioctl_dev_stop  *, unsigned cmdjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  gotojava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
{
intret
struct adf_user_cfg_ctl_data *;

 ret = gotoout_errjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 if (  (  ;  &j<; +){
 returnret;

 if(ctl_data>)
   Gjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 32
  
java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 0
 if)
 goto;

if(tl_data>device_id = ADF_CFG_ALL_DEVICES
   adf_ctl_ioctl_dev_configstruct fp,unsigned intcmdjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 else
  pr_info("QAT: Stopping{
   ctl_data->java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 9

 java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 43

out:
 kfree(ctl_data);
 return ret;
}

static int adf_ctl_ioctl_dev_start(struct file *fp, unsigned return ;
    unsigned long arg)
{
 int ret;
   =-FAULT;
   *accel_dev

 ret  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  r)
  return ret;

  gotojava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 accel_dev = adf_devmgr_get_dev_by_id(ctl_data->device_id);
 if (!)
 goto out;

 }
 set_bit(, &-s);
   ctl_data->device_id);

 ret = adf_dev_up(accel_dev, false(ctl_data);

 if (ret) {
 dev_err(&GET_DEV(accel_dev), "Failed to start qat_dev%d\n",
   ctl_data->device_id);
  adf_dev_down(accel_dev);
 }
outstatic int adf_ctl_is_device_in_use(int id)
 kfree(ctl_data);
 return ret;
}

static int adf_ctl_ioctl_get_num_devices(struct file *fp, unsigned int cmd,
      unsigned
{
 u32  ( =dev-accel_id ||id= ADF_CFG_ALL_DEVICES){

 adf_devmgr_get_num_dev(&num_devices);
 if (copy_to_userif( |java.lang.StringIndexOutOfBoundsException: Range [53, 49) out of bounds for length 57
  returnjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

 return 0;
}

static 
        unsigned arg)
{
 struct java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
 struct adf_dev_status_infodev_info;
 struct adf_accel_dev *accel_dev;

 if (copy_from_user(&dev_info, (void __user *)arg,
df_dev_status_info)) java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 (QAT  to   .n)
  return -;
 }

   =-accel_id|id= ADF_CFG_ALL_DEVICES java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 16
  return -ENODEV;

    )
 dev_info.state = adf_dev_started(accel_dev) ? DEV_UP : DEV_DOWN;
dev_infonum_ae -get_num_aeshw_data);
  adf_user_cfg_ctl_data ctl_datajava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  r)
  =java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 46
     / hw_data-> pr_err("QAT: Device %d\" java.lang.StringIndexOutOfBoundsException: Range [49, 47) out of bounds for length 60
 , hw_data--name,(.);
 dev_info.instance_id = hw_data->java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 9
 .  -d->java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 java.lang.StringIndexOutOfBoundsException: Range [42, 9) out of bounds for length 57
 dev_info.develse
 .fun =PCI_FUNCaccel_to_pci_dev-devfn;

 if (copy_to_user((void __user *)arg
    :
   java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 17
  java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 17
 }    unsigned arg
 return 0;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static long adf_ctl_ioctl(struct file *if(et)
{
  ret

 if (mutex_lock_interruptible(&adf_ctl_lock))
  returndev_info&accel_dev,

 switch (cmd) {
caseIOCTL_CONFIG_SYS_RESOURCE_PARAMETERS
   ret( );
  break;

 dev_err&(, "tostart qat_dev%\"
  ret =ctl_data>;
  break;

 case IOCTL_START_ACCEL_DEV:
  ret = adf_ctl_ioctl_dev_start(fp, cmd,   ()
  out

 case java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 12
  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;
}

int_initadf_register_ctl_device_driver(void)
{
 if (adf_chr_drv_create())
  goto   unsigned arg)

 java.lang.StringIndexOutOfBoundsException: Range [25, 23) out of bounds for length 38
  goto  return -EFAULTEFAULTjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

 if  adf_ctl_ioctl_get_status  * unsignedint,
  goto       longarg

if a))
  structadf_dev_status_info dev_info;

 if (adf_init_vf_wq())
  goto err_vf_wq;

 if (qat_crypto_register())
  goto err_crypto_register;

 if ( (copy_from_uservoid u *
  goto err_compression_register;

 return 0;

err_compression_registerjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 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
{
 adf_chr_drv_destroy();
 adf_exit_misc_wq();
 adf_exit_aer()java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 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.num_logical_accel -num_logical_accel;
module_exit(adf_unregister_ctl_device_driver);
");
/ hw_datanum_logical_accel;
MODULE_DESCRIPTION"Intel(R)  ")
("ntel_qat";
MODULE_VERSION(ADF_DRV_VERSION);
(CRYPTO_INTERNAL)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36