[linux-2.6-block.git] / drivers / crypto / qat / qat_common / adf_ctl_drv.c

/*
  This file is provided under a dual BSD/GPLv2 license.  When using or
  redistributing this file, you may do so under either license.

  GPL LICENSE SUMMARY
  Copyright(c) 2014 Intel Corporation.
  This program is free software; you can redistribute it and/or modify
  it under the terms of version 2 of the GNU General Public License as
  published by the Free Software Foundation.

  This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

  Contact Information:
  qat-linux@intel.com

  BSD LICENSE
  Copyright(c) 2014 Intel Corporation.
  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions
  are met:

    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in
      the documentation and/or other materials provided with the
      distribution.
    * Neither the name of Intel Corporation nor the names of its
      contributors may be used to endorse or promote products derived
      from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#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 <linux/crypto.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 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 = adf_ctl_ioctl,
};

struct adf_ctl_drv_info {
	unsigned int major;
	struct cdev drv_cdev;
	struct class *drv_class;
};

static struct adf_ctl_drv_info adf_ctl_drv;

static void adf_chr_drv_destroy(void)
{
	device_destroy(adf_ctl_drv.drv_class, MKDEV(adf_ctl_drv.major, 0));
	cdev_del(&adf_ctl_drv.drv_cdev);
	class_destroy(adf_ctl_drv.drv_class);
	unregister_chrdev_region(MKDEV(adf_ctl_drv.major, 0), 1);
}

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

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

	adf_ctl_drv.drv_class = class_create(THIS_MODULE, DEVICE_NAME);
	if (IS_ERR(adf_ctl_drv.drv_class)) {
		pr_err("QAT: class_create failed for adf_ctl\n");
		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_drv.drv_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:
	cdev_del(&adf_ctl_drv.drv_cdev);
err_class_destr:
	class_destroy(adf_ctl_drv.drv_class);
err_chrdev_unreg:
	unregister_chrdev_region(dev_id, 1);
	return -EFAULT;
}

static int adf_ctl_alloc_resources(struct adf_user_cfg_ctl_data **ctl_data,
				   unsigned long arg)
{
	struct adf_user_cfg_ctl_data *cfg_data;

	cfg_data = kzalloc(sizeof(*cfg_data), GFP_KERNEL);
	if (!cfg_data)
		return -ENOMEM;

	/* Initialize device id to NO DEVICE as 0 is a valid device id */
	cfg_data->device_id = ADF_CFG_NO_DEVICE;

	if (copy_from_user(cfg_data, (void __user *)arg, sizeof(*cfg_data))) {
		pr_err("QAT: failed to copy from user cfg_data.\n");
		kfree(cfg_data);
		return -EIO;
	}

	*ctl_data = cfg_data;
	return 0;
}

static int adf_add_key_value_data(struct adf_accel_dev *accel_dev,
				  const char *section,
				  const struct adf_user_cfg_key_val *key_val)
{
	if (key_val->type == ADF_HEX) {
		long *ptr = (long *)key_val->val;
		long val = *ptr;

		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;

	section_head = ctl_data->config_section;

	while (section_head) {
		if (copy_from_user(&section, (void __user *)section_head,
				   sizeof(*section_head))) {
			dev_err(&GET_DEV(accel_dev),
				"failed to copy section info\n");
			goto out_err;
		}

		if (adf_cfg_section_add(accel_dev, section.name)) {
			dev_err(&GET_DEV(accel_dev),
				"failed to add section.\n");
			goto out_err;
		}

		params_head = section_head->params;

		while (params_head) {
			if (copy_from_user(&key_val, (void __user *)params_head,
					   sizeof(key_val))) {
				dev_err(&GET_DEV(accel_dev),
					"Failed to copy keyvalue.\n");
				goto out_err;
			}
			if (adf_add_key_value_data(accel_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 *fp, unsigned int cmd,
				    unsigned long arg)
{
	int ret;
	struct adf_user_cfg_ctl_data *ctl_data;
	struct adf_accel_dev *accel_dev;

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

	accel_dev = adf_devmgr_get_dev_by_id(ctl_data->device_id);
	if (!accel_dev) {
		ret = -EFAULT;
		goto out;
	}

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

	if (adf_copy_key_value_data(accel_dev, ctl_data)) {
		ret = -EFAULT;
		goto out;
	}
	set_bit(ADF_STATUS_CONFIGURED, &accel_dev->status);
out:
	kfree(ctl_data);
	return ret;
}

static int adf_ctl_is_device_in_use(int id)
{
	struct list_head *itr, *head = adf_devmgr_get_head();

	list_for_each(itr, head) {
		struct adf_accel_dev *dev =
				list_entry(itr, struct adf_accel_dev, list);

		if (id == dev->accel_id || id == ADF_CFG_ALL_DEVICES) {
			if (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;
}

static int adf_ctl_stop_devices(uint32_t id)
{
	struct list_head *itr, *head = adf_devmgr_get_head();
	int ret = 0;

	list_for_each(itr, head) {
		struct adf_accel_dev *accel_dev =
				list_entry(itr, struct adf_accel_dev, list);
		if (id == accel_dev->accel_id || id == ADF_CFG_ALL_DEVICES) {
			if (!adf_dev_started(accel_dev))
				continue;

			if (adf_dev_stop(accel_dev)) {
				dev_err(&GET_DEV(accel_dev),
					"Failed to stop qat_dev%d\n", id);
				ret = -EFAULT;
			} else {
				adf_dev_shutdown(accel_dev);
			}
		}
	}
	return ret;
}

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

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

	if (adf_devmgr_verify_id(ctl_data->device_id)) {
		pr_err("QAT: Device %d not found\n", ctl_data->device_id);
		ret = -ENODEV;
		goto out;
	}

	ret = adf_ctl_is_device_in_use(ctl_data->device_id);
	if (ret)
		goto out;

	if (ctl_data->device_id == ADF_CFG_ALL_DEVICES)
		pr_info("QAT: Stopping all acceleration devices.\n");
	else
		pr_info("QAT: Stopping acceleration device qat_dev%d.\n",
			ctl_data->device_id);

	ret = adf_ctl_stop_devices(ctl_data->device_id);
	if (ret)
		pr_err("QAT: failed to stop device.\n");
out:
	kfree(ctl_data);
	return ret;
}

static int adf_ctl_ioctl_dev_start(struct file *fp, unsigned int cmd,
				   unsigned long arg)
{
	int ret;
	struct adf_user_cfg_ctl_data *ctl_data;
	struct adf_accel_dev *accel_dev;

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

	accel_dev = adf_devmgr_get_dev_by_id(ctl_data->device_id);
	if (!accel_dev) {
		pr_err("QAT: Device %d not found\n", ctl_data->device_id);
		ret = -ENODEV;
		goto out;
	}

	if (!adf_dev_started(accel_dev)) {
		dev_info(&GET_DEV(accel_dev),
			 "Starting acceleration device qat_dev%d.\n",
			 ctl_data->device_id);
		ret = adf_dev_init(accel_dev);
		if (!ret)
			ret = adf_dev_start(accel_dev);
	} else {
		dev_info(&GET_DEV(accel_dev),
			 "Acceleration device qat_dev%d already started.\n",
			 ctl_data->device_id);
	}
	if (ret) {
		dev_err(&GET_DEV(accel_dev), "Failed to start qat_dev%d\n",
			ctl_data->device_id);
		adf_dev_stop(accel_dev);
		adf_dev_shutdown(accel_dev);
	}
out:
	kfree(ctl_data);
	return ret;
}

static int adf_ctl_ioctl_get_num_devices(struct file *fp, unsigned int cmd,
					 unsigned long arg)
{
	uint32_t 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;
}

static int adf_ctl_ioctl_get_status(struct file *fp, unsigned int cmd,
				    unsigned long arg)
{
	struct adf_hw_device_data *hw_data;
	struct adf_dev_status_info dev_info;
	struct adf_accel_dev *accel_dev;

	if (copy_from_user(&dev_info, (void __user *)arg,
			   sizeof(struct adf_dev_status_info))) {
		pr_err("QAT: failed to copy from user.\n");
		return -EFAULT;
	}

	accel_dev = adf_devmgr_get_dev_by_id(dev_info.accel_id);
	if (!accel_dev)
		return -ENODEV;

	hw_data = accel_dev->hw_device;
	dev_info.state = adf_dev_started(accel_dev) ? DEV_UP : DEV_DOWN;
	dev_info.num_ae = hw_data->get_num_aes(hw_data);
	dev_info.num_accel = hw_data->get_num_accels(hw_data);
	dev_info.num_logical_accel = hw_data->num_logical_accel;
	dev_info.banks_per_accel = hw_data->num_banks
					/ hw_data->num_logical_accel;
	strlcpy(dev_info.name, hw_data->dev_class->name, sizeof(dev_info.name));
	dev_info.instance_id = hw_data->instance_id;
	dev_info.type = hw_data->dev_class->type;
	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("QAT: Invalid ioctl\n");
		ret = -EFAULT;
		break;
	}
	mutex_unlock(&adf_ctl_lock);
	return ret;
}

static int __init adf_register_ctl_device_driver(void)
{
	mutex_init(&adf_ctl_lock);

	if (qat_algs_init())
		goto err_algs_init;

	if (adf_chr_drv_create())
		goto err_chr_dev;

	if (adf_init_aer())
		goto err_aer;

	if (qat_crypto_register())
		goto err_crypto_register;

	return 0;

err_crypto_register:
	adf_exit_aer();
err_aer:
	adf_chr_drv_destroy();
err_chr_dev:
	qat_algs_exit();
err_algs_init:
	mutex_destroy(&adf_ctl_lock);
	return -EFAULT;
}

static void __exit adf_unregister_ctl_device_driver(void)
{
	adf_chr_drv_destroy();
	adf_exit_aer();
	qat_crypto_unregister();
	qat_algs_exit();
	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);
Commit	Line	Data
d8cba25d TS	1	/*
	2	This file is provided under a dual BSD/GPLv2 license. When using or
	3	redistributing this file, you may do so under either license.
	4
	5	GPL LICENSE SUMMARY
	6	Copyright(c) 2014 Intel Corporation.
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of version 2 of the GNU General Public License as
	9	published by the Free Software Foundation.
	10
	11	This program is distributed in the hope that it will be useful, but
	12	WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	General Public License for more details.
	15
	16	Contact Information:
	17	qat-linux@intel.com
	18
	19	BSD LICENSE
	20	Copyright(c) 2014 Intel Corporation.
	21	Redistribution and use in source and binary forms, with or without
	22	modification, are permitted provided that the following conditions
	23	are met:
	24
	25	* Redistributions of source code must retain the above copyright
	26	notice, this list of conditions and the following disclaimer.
	27	* Redistributions in binary form must reproduce the above copyright
	28	notice, this list of conditions and the following disclaimer in
	29	the documentation and/or other materials provided with the
	30	distribution.
	31	* Neither the name of Intel Corporation nor the names of its
	32	contributors may be used to endorse or promote products derived
	33	from this software without specific prior written permission.
	34
	35	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	36	"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	37	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	38	A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	39	OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	40	SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	41	LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	42	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	43	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	44	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	45	OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	46	*/
	47	#include <linux/module.h>
	48	#include <linux/mutex.h>
	49	#include <linux/slab.h>
	50	#include <linux/fs.h>
	51	#include <linux/bitops.h>
	52	#include <linux/pci.h>
	53	#include <linux/cdev.h>
	54	#include <linux/uaccess.h>
5d26a105	55	#include <linux/crypto.h>
d8cba25d TS	56
	57	#include "adf_accel_devices.h"
	58	#include "adf_common_drv.h"
	59	#include "adf_cfg.h"
	60	#include "adf_cfg_common.h"
	61	#include "adf_cfg_user.h"
	62
	63	#define DEVICE_NAME "qat_adf_ctl"
	64
	65	static DEFINE_MUTEX(adf_ctl_lock);
	66	static long adf_ctl_ioctl(struct file *fp, unsigned int cmd, unsigned long arg);
	67
	68	static const struct file_operations adf_ctl_ops = {
	69	.owner = THIS_MODULE,
	70	.unlocked_ioctl = adf_ctl_ioctl,
	71	.compat_ioctl = adf_ctl_ioctl,
	72	};
	73
	74	struct adf_ctl_drv_info {
	75	unsigned int major;
	76	struct cdev drv_cdev;
	77	struct class *drv_class;
	78	};
	79
754a90d3	80	static struct adf_ctl_drv_info adf_ctl_drv;
d8cba25d TS	81
	82	static void adf_chr_drv_destroy(void)
	83	{
754a90d3 AB	84	device_destroy(adf_ctl_drv.drv_class, MKDEV(adf_ctl_drv.major, 0));
	85	cdev_del(&adf_ctl_drv.drv_cdev);
	86	class_destroy(adf_ctl_drv.drv_class);
	87	unregister_chrdev_region(MKDEV(adf_ctl_drv.major, 0), 1);
d8cba25d TS	88	}
	89
	90	static int adf_chr_drv_create(void)
	91	{
	92	dev_t dev_id;
	93	struct device *drv_device;
	94
	95	if (alloc_chrdev_region(&dev_id, 0, 1, DEVICE_NAME)) {
	96	pr_err("QAT: unable to allocate chrdev region\n");
	97	return -EFAULT;
	98	}
	99
754a90d3 AB	100	adf_ctl_drv.drv_class = class_create(THIS_MODULE, DEVICE_NAME);
754a90d3 AB	101	if (IS_ERR(adf_ctl_drv.drv_class)) {
d8cba25d TS	102	pr_err("QAT: class_create failed for adf_ctl\n");
	103	goto err_chrdev_unreg;
	104	}
754a90d3 AB	105	adf_ctl_drv.major = MAJOR(dev_id);
	106	cdev_init(&adf_ctl_drv.drv_cdev, &adf_ctl_ops);
	107	if (cdev_add(&adf_ctl_drv.drv_cdev, dev_id, 1)) {
d8cba25d TS	108	pr_err("QAT: cdev add failed\n");
	109	goto err_class_destr;
	110	}
	111
754a90d3 AB	112	drv_device = device_create(adf_ctl_drv.drv_class, NULL,
754a90d3 AB	113	MKDEV(adf_ctl_drv.major, 0),
d8cba25d	114	NULL, DEVICE_NAME);
65fafbe9	115	if (IS_ERR(drv_device)) {
d8cba25d TS	116	pr_err("QAT: failed to create device\n");
	117	goto err_cdev_del;
	118	}
	119	return 0;
	120	err_cdev_del:
754a90d3	121	cdev_del(&adf_ctl_drv.drv_cdev);
d8cba25d	122	err_class_destr:
754a90d3	123	class_destroy(adf_ctl_drv.drv_class);
d8cba25d TS	124	err_chrdev_unreg:
	125	unregister_chrdev_region(dev_id, 1);
	126	return -EFAULT;
	127	}
	128
	129	static int adf_ctl_alloc_resources(struct adf_user_cfg_ctl_data **ctl_data,
	130	unsigned long arg)
	131	{
	132	struct adf_user_cfg_ctl_data *cfg_data;
	133
	134	cfg_data = kzalloc(sizeof(*cfg_data), GFP_KERNEL);
	135	if (!cfg_data)
	136	return -ENOMEM;
	137
	138	/* Initialize device id to NO DEVICE as 0 is a valid device id */
	139	cfg_data->device_id = ADF_CFG_NO_DEVICE;
	140
	141	if (copy_from_user(cfg_data, (void __user )arg, sizeof(cfg_data))) {
	142	pr_err("QAT: failed to copy from user cfg_data.\n");
	143	kfree(cfg_data);
	144	return -EIO;
	145	}
	146
	147	*ctl_data = cfg_data;
	148	return 0;
	149	}
	150
	151	static int adf_add_key_value_data(struct adf_accel_dev *accel_dev,
	152	const char *section,
	153	const struct adf_user_cfg_key_val *key_val)
	154	{
	155	if (key_val->type == ADF_HEX) {
	156	long ptr = (long )key_val->val;
	157	long val = *ptr;
	158
	159	if (adf_cfg_add_key_value_param(accel_dev, section,
	160	key_val->key, (void *)val,
	161	key_val->type)) {
66550304 AB	162	dev_err(&GET_DEV(accel_dev),
66550304 AB	163	"failed to add hex keyvalue.\n");
d8cba25d TS	164	return -EFAULT;
	165	}
	166	} else {
	167	if (adf_cfg_add_key_value_param(accel_dev, section,
	168	key_val->key, key_val->val,
	169	key_val->type)) {
66550304 AB	170	dev_err(&GET_DEV(accel_dev),
66550304 AB	171	"failed to add keyvalue.\n");
d8cba25d TS	172	return -EFAULT;
	173	}
	174	}
	175	return 0;
	176	}
	177
	178	static int adf_copy_key_value_data(struct adf_accel_dev *accel_dev,
	179	struct adf_user_cfg_ctl_data *ctl_data)
	180	{
	181	struct adf_user_cfg_key_val key_val;
	182	struct adf_user_cfg_key_val *params_head;
	183	struct adf_user_cfg_section section, *section_head;
	184
	185	section_head = ctl_data->config_section;
	186
	187	while (section_head) {
	188	if (copy_from_user(&section, (void __user *)section_head,
	189	sizeof(*section_head))) {
66550304 AB	190	dev_err(&GET_DEV(accel_dev),
66550304 AB	191	"failed to copy section info\n");
d8cba25d TS	192	goto out_err;
	193	}
	194
	195	if (adf_cfg_section_add(accel_dev, section.name)) {
66550304 AB	196	dev_err(&GET_DEV(accel_dev),
66550304 AB	197	"failed to add section.\n");
d8cba25d TS	198	goto out_err;
	199	}
	200
	201	params_head = section_head->params;
	202
	203	while (params_head) {
	204	if (copy_from_user(&key_val, (void __user *)params_head,
	205	sizeof(key_val))) {
66550304 AB	206	dev_err(&GET_DEV(accel_dev),
66550304 AB	207	"Failed to copy keyvalue.\n");
d8cba25d TS	208	goto out_err;
	209	}
	210	if (adf_add_key_value_data(accel_dev, section.name,
	211	&key_val)) {
	212	goto out_err;
	213	}
	214	params_head = key_val.next;
	215	}
	216	section_head = section.next;
	217	}
	218	return 0;
	219	out_err:
	220	adf_cfg_del_all(accel_dev);
	221	return -EFAULT;
	222	}
	223
	224	static int adf_ctl_ioctl_dev_config(struct file *fp, unsigned int cmd,
	225	unsigned long arg)
	226	{
	227	int ret;
	228	struct adf_user_cfg_ctl_data *ctl_data;
	229	struct adf_accel_dev *accel_dev;
	230
	231	ret = adf_ctl_alloc_resources(&ctl_data, arg);
	232	if (ret)
	233	return ret;
	234
	235	accel_dev = adf_devmgr_get_dev_by_id(ctl_data->device_id);
	236	if (!accel_dev) {
	237	ret = -EFAULT;
	238	goto out;
	239	}
	240
	241	if (adf_dev_started(accel_dev)) {
	242	ret = -EFAULT;
	243	goto out;
	244	}
	245
	246	if (adf_copy_key_value_data(accel_dev, ctl_data)) {
	247	ret = -EFAULT;
	248	goto out;
	249	}
	250	set_bit(ADF_STATUS_CONFIGURED, &accel_dev->status);
	251	out:
	252	kfree(ctl_data);
	253	return ret;
	254	}
	255
	256	static int adf_ctl_is_device_in_use(int id)
	257	{
	258	struct list_head itr, head = adf_devmgr_get_head();
	259
	260	list_for_each(itr, head) {
	261	struct adf_accel_dev *dev =
	262	list_entry(itr, struct adf_accel_dev, list);
	263
	264	if (id == dev->accel_id \|\| id == ADF_CFG_ALL_DEVICES) {
	265	if (adf_devmgr_in_reset(dev) \|\| adf_dev_in_use(dev)) {
66550304 AB	266	dev_info(&GET_DEV(dev),
	267	"device qat_dev%d is busy\n",
	268	dev->accel_id);
d8cba25d TS	269	return -EBUSY;
	270	}
	271	}
	272	}
	273	return 0;
	274	}
	275
	276	static int adf_ctl_stop_devices(uint32_t id)
	277	{
	278	struct list_head itr, head = adf_devmgr_get_head();
	279	int ret = 0;
	280
	281	list_for_each(itr, head) {
	282	struct adf_accel_dev *accel_dev =
	283	list_entry(itr, struct adf_accel_dev, list);
	284	if (id == accel_dev->accel_id \|\| id == ADF_CFG_ALL_DEVICES) {
	285	if (!adf_dev_started(accel_dev))
	286	continue;
	287
	288	if (adf_dev_stop(accel_dev)) {
66550304 AB	289	dev_err(&GET_DEV(accel_dev),
66550304 AB	290	"Failed to stop qat_dev%d\n", id);
d8cba25d	291	ret = -EFAULT;
22e4dda0 AB	292	} else {
22e4dda0 AB	293	adf_dev_shutdown(accel_dev);
d8cba25d TS	294	}
	295	}
	296	}
	297	return ret;
	298	}
	299
	300	static int adf_ctl_ioctl_dev_stop(struct file *fp, unsigned int cmd,
	301	unsigned long arg)
	302	{
	303	int ret;
	304	struct adf_user_cfg_ctl_data *ctl_data;
	305
	306	ret = adf_ctl_alloc_resources(&ctl_data, arg);
	307	if (ret)
	308	return ret;
	309
	310	if (adf_devmgr_verify_id(ctl_data->device_id)) {
	311	pr_err("QAT: Device %d not found\n", ctl_data->device_id);
	312	ret = -ENODEV;
	313	goto out;
	314	}
	315
	316	ret = adf_ctl_is_device_in_use(ctl_data->device_id);
	317	if (ret)
	318	goto out;
	319
	320	if (ctl_data->device_id == ADF_CFG_ALL_DEVICES)
	321	pr_info("QAT: Stopping all acceleration devices.\n");
	322	else
	323	pr_info("QAT: Stopping acceleration device qat_dev%d.\n",
	324	ctl_data->device_id);
	325
	326	ret = adf_ctl_stop_devices(ctl_data->device_id);
	327	if (ret)
	328	pr_err("QAT: failed to stop device.\n");
	329	out:
	330	kfree(ctl_data);
	331	return ret;
	332	}
	333
	334	static int adf_ctl_ioctl_dev_start(struct file *fp, unsigned int cmd,
	335	unsigned long arg)
	336	{
	337	int ret;
	338	struct adf_user_cfg_ctl_data *ctl_data;
	339	struct adf_accel_dev *accel_dev;
	340
	341	ret = adf_ctl_alloc_resources(&ctl_data, arg);
	342	if (ret)
	343	return ret;
	344
	345	accel_dev = adf_devmgr_get_dev_by_id(ctl_data->device_id);
	346	if (!accel_dev) {
	347	pr_err("QAT: Device %d not found\n", ctl_data->device_id);
	348	ret = -ENODEV;
	349	goto out;
	350	}
	351
	352	if (!adf_dev_started(accel_dev)) {
66550304 AB	353	dev_info(&GET_DEV(accel_dev),
	354	"Starting acceleration device qat_dev%d.\n",
	355	ctl_data->device_id);
22e4dda0 AB	356	ret = adf_dev_init(accel_dev);
	357	if (!ret)
	358	ret = adf_dev_start(accel_dev);
d8cba25d	359	} else {
66550304 AB	360	dev_info(&GET_DEV(accel_dev),
	361	"Acceleration device qat_dev%d already started.\n",
	362	ctl_data->device_id);
d8cba25d TS	363	}
d8cba25d TS	364	if (ret) {
66550304 AB	365	dev_err(&GET_DEV(accel_dev), "Failed to start qat_dev%d\n",
66550304 AB	366	ctl_data->device_id);
d8cba25d	367	adf_dev_stop(accel_dev);
22e4dda0	368	adf_dev_shutdown(accel_dev);
d8cba25d TS	369	}
	370	out:
	371	kfree(ctl_data);
	372	return ret;
	373	}
	374
	375	static int adf_ctl_ioctl_get_num_devices(struct file *fp, unsigned int cmd,
	376	unsigned long arg)
	377	{
	378	uint32_t num_devices = 0;
	379
	380	adf_devmgr_get_num_dev(&num_devices);
	381	if (copy_to_user((void __user *)arg, &num_devices, sizeof(num_devices)))
	382	return -EFAULT;
	383
	384	return 0;
	385	}
	386
	387	static int adf_ctl_ioctl_get_status(struct file *fp, unsigned int cmd,
	388	unsigned long arg)
	389	{
	390	struct adf_hw_device_data *hw_data;
	391	struct adf_dev_status_info dev_info;
	392	struct adf_accel_dev *accel_dev;
	393
	394	if (copy_from_user(&dev_info, (void __user *)arg,
	395	sizeof(struct adf_dev_status_info))) {
	396	pr_err("QAT: failed to copy from user.\n");
	397	return -EFAULT;
	398	}
	399
	400	accel_dev = adf_devmgr_get_dev_by_id(dev_info.accel_id);
ed8ccaef	401	if (!accel_dev)
d8cba25d	402	return -ENODEV;
ed8ccaef	403
d8cba25d TS	404	hw_data = accel_dev->hw_device;
	405	dev_info.state = adf_dev_started(accel_dev) ? DEV_UP : DEV_DOWN;
	406	dev_info.num_ae = hw_data->get_num_aes(hw_data);
	407	dev_info.num_accel = hw_data->get_num_accels(hw_data);
	408	dev_info.num_logical_accel = hw_data->num_logical_accel;
	409	dev_info.banks_per_accel = hw_data->num_banks
	410	/ hw_data->num_logical_accel;
	411	strlcpy(dev_info.name, hw_data->dev_class->name, sizeof(dev_info.name));
	412	dev_info.instance_id = hw_data->instance_id;
	413	dev_info.type = hw_data->dev_class->type;
	414	dev_info.bus = accel_to_pci_dev(accel_dev)->bus->number;
	415	dev_info.dev = PCI_SLOT(accel_to_pci_dev(accel_dev)->devfn);
	416	dev_info.fun = PCI_FUNC(accel_to_pci_dev(accel_dev)->devfn);
	417
	418	if (copy_to_user((void __user *)arg, &dev_info,
	419	sizeof(struct adf_dev_status_info))) {
66550304	420	dev_err(&GET_DEV(accel_dev), "failed to copy status.\n");
d8cba25d TS	421	return -EFAULT;
	422	}
	423	return 0;
	424	}
	425
	426	static long adf_ctl_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
	427	{
	428	int ret;
	429
	430	if (mutex_lock_interruptible(&adf_ctl_lock))
	431	return -EFAULT;
	432
	433	switch (cmd) {
	434	case IOCTL_CONFIG_SYS_RESOURCE_PARAMETERS:
	435	ret = adf_ctl_ioctl_dev_config(fp, cmd, arg);
	436	break;
	437
	438	case IOCTL_STOP_ACCEL_DEV:
	439	ret = adf_ctl_ioctl_dev_stop(fp, cmd, arg);
	440	break;
	441
	442	case IOCTL_START_ACCEL_DEV:
	443	ret = adf_ctl_ioctl_dev_start(fp, cmd, arg);
	444	break;
	445
	446	case IOCTL_GET_NUM_DEVICES:
	447	ret = adf_ctl_ioctl_get_num_devices(fp, cmd, arg);
	448	break;
	449
	450	case IOCTL_STATUS_ACCEL_DEV:
	451	ret = adf_ctl_ioctl_get_status(fp, cmd, arg);
	452	break;
	453	default:
1a84db56	454	pr_err("QAT: Invalid ioctl\n");
d8cba25d TS	455	ret = -EFAULT;
	456	break;
	457	}
	458	mutex_unlock(&adf_ctl_lock);
	459	return ret;
	460	}
	461
	462	static int __init adf_register_ctl_device_driver(void)
	463	{
	464	mutex_init(&adf_ctl_lock);
	465
	466	if (qat_algs_init())
	467	goto err_algs_init;
	468
	469	if (adf_chr_drv_create())
	470	goto err_chr_dev;
	471
	472	if (adf_init_aer())
	473	goto err_aer;
	474
	475	if (qat_crypto_register())
	476	goto err_crypto_register;
	477
	478	return 0;
	479
	480	err_crypto_register:
	481	adf_exit_aer();
	482	err_aer:
	483	adf_chr_drv_destroy();
	484	err_chr_dev:
	485	qat_algs_exit();
	486	err_algs_init:
	487	mutex_destroy(&adf_ctl_lock);
	488	return -EFAULT;
	489	}
	490
	491	static void __exit adf_unregister_ctl_device_driver(void)
	492	{
	493	adf_chr_drv_destroy();
	494	adf_exit_aer();
	495	qat_crypto_unregister();
	496	qat_algs_exit();
ed8ccaef	497	adf_clean_vf_map(false);
d8cba25d TS	498	mutex_destroy(&adf_ctl_lock);
	499	}
	500
	501	module_init(adf_register_ctl_device_driver);
	502	module_exit(adf_unregister_ctl_device_driver);
	503	MODULE_LICENSE("Dual BSD/GPL");
	504	MODULE_AUTHOR("Intel");
	505	MODULE_DESCRIPTION("Intel(R) QuickAssist Technology");
5d26a105	506	MODULE_ALIAS_CRYPTO("intel_qat");
551d7ed2	507	MODULE_VERSION(ADF_DRV_VERSION);