[linux-2.6-block.git] / drivers / gpu / drm / amd / amdkfd / kfd_module.c

/*
 * Copyright 2014 Advanced Micro Devices, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

#include <linux/module.h>
#include <linux/sched.h>
#include <linux/moduleparam.h>
#include <linux/device.h>
#include "kfd_priv.h"

#define KFD_DRIVER_AUTHOR	"AMD Inc. and others"

#define KFD_DRIVER_DESC		"Standalone HSA driver for AMD's GPUs"
#define KFD_DRIVER_DATE		"20141113"
#define KFD_DRIVER_MAJOR	0
#define KFD_DRIVER_MINOR	7
#define KFD_DRIVER_PATCHLEVEL	0

const struct kfd2kgd_calls *kfd2kgd;
static const struct kgd2kfd_calls kgd2kfd = {
	.exit		= kgd2kfd_exit,
	.probe		= kgd2kfd_probe,
	.device_init	= kgd2kfd_device_init,
	.device_exit	= kgd2kfd_device_exit,
	.interrupt	= kgd2kfd_interrupt,
	.suspend	= kgd2kfd_suspend,
	.resume		= kgd2kfd_resume,
};

int sched_policy = KFD_SCHED_POLICY_HWS;
module_param(sched_policy, int, 0444);
MODULE_PARM_DESC(sched_policy,
	"Kernel cmdline parameter that defines the amdkfd scheduling policy");

int max_num_of_queues_per_device = KFD_MAX_NUM_OF_QUEUES_PER_DEVICE_DEFAULT;
module_param(max_num_of_queues_per_device, int, 0444);
MODULE_PARM_DESC(max_num_of_queues_per_device,
	"Maximum number of supported queues per device (1 = Minimum, 4096 = default)");

bool kgd2kfd_init(unsigned interface_version,
		  const struct kfd2kgd_calls *f2g,
		  const struct kgd2kfd_calls **g2f)
{
	/*
	 * Only one interface version is supported,
	 * no kfd/kgd version skew allowed.
	 */
	if (interface_version != KFD_INTERFACE_VERSION)
		return false;

	/* Protection against multiple amd kgd loads */
	if (kfd2kgd)
		return true;

	kfd2kgd = f2g;
	*g2f = &kgd2kfd;

	return true;
}
EXPORT_SYMBOL(kgd2kfd_init);

void kgd2kfd_exit(void)
{
}

static int __init kfd_module_init(void)
{
	int err;

	kfd2kgd = NULL;

	/* Verify module parameters */
	if ((sched_policy < KFD_SCHED_POLICY_HWS) ||
		(sched_policy > KFD_SCHED_POLICY_NO_HWS)) {
		pr_err("kfd: sched_policy has invalid value\n");
		return -1;
	}

	/* Verify module parameters */
	if ((max_num_of_queues_per_device < 1) ||
		(max_num_of_queues_per_device >
			KFD_MAX_NUM_OF_QUEUES_PER_DEVICE)) {
		pr_err("kfd: max_num_of_queues_per_device must be between 1 to KFD_MAX_NUM_OF_QUEUES_PER_DEVICE\n");
		return -1;
	}

	err = kfd_pasid_init();
	if (err < 0)
		goto err_pasid;

	err = kfd_chardev_init();
	if (err < 0)
		goto err_ioctl;

	err = kfd_topology_init();
	if (err < 0)
		goto err_topology;

	kfd_process_create_wq();

	dev_info(kfd_device, "Initialized module\n");

	return 0;

err_topology:
	kfd_chardev_exit();
err_ioctl:
	kfd_pasid_exit();
err_pasid:
	return err;
}

static void __exit kfd_module_exit(void)
{
	kfd_process_destroy_wq();
	kfd_topology_shutdown();
	kfd_chardev_exit();
	kfd_pasid_exit();
	dev_info(kfd_device, "Removed module\n");
}

module_init(kfd_module_init);
module_exit(kfd_module_exit);

MODULE_AUTHOR(KFD_DRIVER_AUTHOR);
MODULE_DESCRIPTION(KFD_DRIVER_DESC);
MODULE_LICENSE("GPL and additional rights");
MODULE_VERSION(__stringify(KFD_DRIVER_MAJOR) "."
	       __stringify(KFD_DRIVER_MINOR) "."
	       __stringify(KFD_DRIVER_PATCHLEVEL));
Commit	Line	Data
4a488a7a OG	1	/*
	2	* Copyright 2014 Advanced Micro Devices, Inc.
	3	*
	4	* Permission is hereby granted, free of charge, to any person obtaining a
	5	* copy of this software and associated documentation files (the "Software"),
	6	* to deal in the Software without restriction, including without limitation
	7	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	8	* and/or sell copies of the Software, and to permit persons to whom the
	9	* Software is furnished to do so, subject to the following conditions:
	10	*
	11	* The above copyright notice and this permission notice shall be included in
	12	* all copies or substantial portions of the Software.
	13	*
	14	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	15	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	17	* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
	18	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
	19	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
	20	* OTHER DEALINGS IN THE SOFTWARE.
	21	*/
	22
	23	#include <linux/module.h>
	24	#include <linux/sched.h>
4a488a7a OG	25	#include <linux/moduleparam.h>
	26	#include <linux/device.h>
	27	#include "kfd_priv.h"
	28
	29	#define KFD_DRIVER_AUTHOR "AMD Inc. and others"
	30
	31	#define KFD_DRIVER_DESC "Standalone HSA driver for AMD's GPUs"
	32	#define KFD_DRIVER_DATE "20141113"
	33	#define KFD_DRIVER_MAJOR 0
	34	#define KFD_DRIVER_MINOR 7
	35	#define KFD_DRIVER_PATCHLEVEL 0
	36
	37	const struct kfd2kgd_calls *kfd2kgd;
	38	static const struct kgd2kfd_calls kgd2kfd = {
	39	.exit = kgd2kfd_exit,
	40	.probe = kgd2kfd_probe,
	41	.device_init = kgd2kfd_device_init,
	42	.device_exit = kgd2kfd_device_exit,
	43	.interrupt = kgd2kfd_interrupt,
	44	.suspend = kgd2kfd_suspend,
	45	.resume = kgd2kfd_resume,
	46	};
	47
31c21fec BG	48	int sched_policy = KFD_SCHED_POLICY_HWS;
	49	module_param(sched_policy, int, 0444);
	50	MODULE_PARM_DESC(sched_policy,
	51	"Kernel cmdline parameter that defines the amdkfd scheduling policy");
	52
b8cbab04 OG	53	int max_num_of_queues_per_device = KFD_MAX_NUM_OF_QUEUES_PER_DEVICE_DEFAULT;
	54	module_param(max_num_of_queues_per_device, int, 0444);
	55	MODULE_PARM_DESC(max_num_of_queues_per_device,
	56	"Maximum number of supported queues per device (1 = Minimum, 4096 = default)");
19f6d2a6	57
4a488a7a OG	58	bool kgd2kfd_init(unsigned interface_version,
	59	const struct kfd2kgd_calls *f2g,
	60	const struct kgd2kfd_calls **g2f)
	61	{
	62	/*
	63	* Only one interface version is supported,
	64	* no kfd/kgd version skew allowed.
	65	*/
	66	if (interface_version != KFD_INTERFACE_VERSION)
	67	return false;
	68
19f6d2a6 OG	69	/* Protection against multiple amd kgd loads */
	70	if (kfd2kgd)
	71	return true;
	72
4a488a7a OG	73	kfd2kgd = f2g;
	74	*g2f = &kgd2kfd;
	75
	76	return true;
	77	}
	78	EXPORT_SYMBOL(kgd2kfd_init);
	79
	80	void kgd2kfd_exit(void)
	81	{
	82	}
	83
	84	static int __init kfd_module_init(void)
	85	{
	86	int err;
	87
19f6d2a6 OG	88	kfd2kgd = NULL;
19f6d2a6 OG	89
31c21fec BG	90	/* Verify module parameters */
	91	if ((sched_policy < KFD_SCHED_POLICY_HWS) \|\|
	92	(sched_policy > KFD_SCHED_POLICY_NO_HWS)) {
	93	pr_err("kfd: sched_policy has invalid value\n");
	94	return -1;
	95	}
	96
19f6d2a6	97	/* Verify module parameters */
ca400b2a	98	if ((max_num_of_queues_per_device < 1) \|\|
b8cbab04 OG	99	(max_num_of_queues_per_device >
b8cbab04 OG	100	KFD_MAX_NUM_OF_QUEUES_PER_DEVICE)) {
ca400b2a	101	pr_err("kfd: max_num_of_queues_per_device must be between 1 to KFD_MAX_NUM_OF_QUEUES_PER_DEVICE\n");
19f6d2a6 OG	102	return -1;
	103	}
	104
	105	err = kfd_pasid_init();
	106	if (err < 0)
	107	goto err_pasid;
	108
4a488a7a OG	109	err = kfd_chardev_init();
	110	if (err < 0)
	111	goto err_ioctl;
	112
5b5c4e40 EP	113	err = kfd_topology_init();
	114	if (err < 0)
	115	goto err_topology;
	116
19f6d2a6 OG	117	kfd_process_create_wq();
19f6d2a6 OG	118
4a488a7a OG	119	dev_info(kfd_device, "Initialized module\n");
	120
	121	return 0;
	122
5b5c4e40 EP	123	err_topology:
5b5c4e40 EP	124	kfd_chardev_exit();
4a488a7a	125	err_ioctl:
19f6d2a6 OG	126	kfd_pasid_exit();
19f6d2a6 OG	127	err_pasid:
4a488a7a OG	128	return err;
	129	}
	130
	131	static void __exit kfd_module_exit(void)
	132	{
19f6d2a6	133	kfd_process_destroy_wq();
5b5c4e40	134	kfd_topology_shutdown();
4a488a7a	135	kfd_chardev_exit();
19f6d2a6	136	kfd_pasid_exit();
4a488a7a OG	137	dev_info(kfd_device, "Removed module\n");
	138	}
	139
	140	module_init(kfd_module_init);
	141	module_exit(kfd_module_exit);
	142
	143	MODULE_AUTHOR(KFD_DRIVER_AUTHOR);
	144	MODULE_DESCRIPTION(KFD_DRIVER_DESC);
	145	MODULE_LICENSE("GPL and additional rights");
	146	MODULE_VERSION(__stringify(KFD_DRIVER_MAJOR) "."
	147	__stringify(KFD_DRIVER_MINOR) "."
	148	__stringify(KFD_DRIVER_PATCHLEVEL));