Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 4a488a7a authored by Oded Gabbay's avatar Oded Gabbay
Browse files

amdkfd: Add amdkfd skeleton driver 



This patch adds the amdkfd skeleton driver. The driver does nothing except
define a /dev/kfd device.

It returns -ENODEV on all amdkfd IOCTLs.

v3: Move bool field to the end of structure, removed the pmc ioctls and added
a meaningful error message for ioctl error.

v5:

Create a new folder drm/amd and move amdkfd from drm/radeon/ to drm/amd/
Remove scheduler_class from kfd_priv.h as it was never used
Add skeleton implementation of the Get Version IOCTL

v6:
Update module version to the correct number and remove the "default m" from the
Kconfig file

Signed-off-by: default avatarOded Gabbay <oded.gabbay@amd.com>
parent b7facbae

drivers/gpu/drm/Kconfig

+2 −0
Original line number Diff line number Diff line
@@ -200,3 +200,5 @@ source "drivers/gpu/drm/tegra/Kconfig" 
source "drivers/gpu/drm/panel/Kconfig"



source "drivers/gpu/drm/sti/Kconfig"



source "drivers/gpu/drm/amd/amdkfd/Kconfig"

drivers/gpu/drm/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -65,3 +65,4 @@ obj-$(CONFIG_DRM_STI) += sti/ 
obj-y			+= i2c/

obj-y			+= panel/

obj-y			+= bridge/

obj-$(CONFIG_HSA_AMD) += amd/amdkfd/

drivers/gpu/drm/amd/amdkfd/Kconfig

0 → 100644
+9 −0
Original line number Diff line number Diff line 
#

# Heterogenous system architecture configuration

#



config HSA_AMD

	tristate "HSA kernel driver for AMD GPU devices"

	depends on (DRM_RADEON || DRM_AMDGPU) && AMD_IOMMU_V2 && X86_64

	help

	  Enable this if you want to use HSA features on AMD GPU devices.

drivers/gpu/drm/amd/amdkfd/Makefile

0 → 100644
+9 −0
Original line number Diff line number Diff line 
#

# Makefile for Heterogenous System Architecture support for AMD GPU devices

#



ccflags-y := -Iinclude/drm -Idrivers/gpu/drm/amd/include/



amdkfd-y	:= kfd_module.o kfd_device.o kfd_chardev.o



obj-$(CONFIG_HSA_AMD)	+= amdkfd.o

drivers/gpu/drm/amd/amdkfd/kfd_chardev.c

0 → 100644
+210 −0
Original line number Diff line number Diff line 
/*

 * 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/device.h>

#include <linux/export.h>

#include <linux/err.h>

#include <linux/fs.h>

#include <linux/sched.h>

#include <linux/slab.h>

#include <linux/uaccess.h>

#include <linux/compat.h>

#include <uapi/linux/kfd_ioctl.h>

#include <linux/time.h>

#include <linux/mm.h>

#include <linux/uaccess.h>

#include <uapi/asm-generic/mman-common.h>

#include <asm/processor.h>

#include "kfd_priv.h"



static long kfd_ioctl(struct file *, unsigned int, unsigned long);

static int kfd_open(struct inode *, struct file *);



static const char kfd_dev_name[] = "kfd";



static const struct file_operations kfd_fops = {

	.owner = THIS_MODULE,

	.unlocked_ioctl = kfd_ioctl,

	.compat_ioctl = kfd_ioctl,

	.open = kfd_open,

};



static int kfd_char_dev_major = -1;

static struct class *kfd_class;

struct device *kfd_device;



int kfd_chardev_init(void)

{

	int err = 0;



	kfd_char_dev_major = register_chrdev(0, kfd_dev_name, &kfd_fops);

	err = kfd_char_dev_major;

	if (err < 0)

		goto err_register_chrdev;



	kfd_class = class_create(THIS_MODULE, kfd_dev_name);

	err = PTR_ERR(kfd_class);

	if (IS_ERR(kfd_class))

		goto err_class_create;



	kfd_device = device_create(kfd_class, NULL,

					MKDEV(kfd_char_dev_major, 0),

					NULL, kfd_dev_name);

	err = PTR_ERR(kfd_device);

	if (IS_ERR(kfd_device))

		goto err_device_create;



	return 0;



err_device_create:

	class_destroy(kfd_class);

err_class_create:

	unregister_chrdev(kfd_char_dev_major, kfd_dev_name);

err_register_chrdev:

	return err;

}



void kfd_chardev_exit(void)

{

	device_destroy(kfd_class, MKDEV(kfd_char_dev_major, 0));

	class_destroy(kfd_class);

	unregister_chrdev(kfd_char_dev_major, kfd_dev_name);

}



struct device *kfd_chardev(void)

{

	return kfd_device;

}





static int kfd_open(struct inode *inode, struct file *filep)

{

	if (iminor(inode) != 0)

		return -ENODEV;



	return 0;

}



static long kfd_ioctl_get_version(struct file *filep, struct kfd_process *p,

					void __user *arg)

{

	return -ENODEV;

}



static long kfd_ioctl_create_queue(struct file *filep, struct kfd_process *p,

					void __user *arg)

{

	return -ENODEV;

}



static int kfd_ioctl_destroy_queue(struct file *filp, struct kfd_process *p,

					void __user *arg)

{

	return -ENODEV;

}



static int kfd_ioctl_update_queue(struct file *filp, struct kfd_process *p,

					void __user *arg)

{

	return -ENODEV;

}



static long kfd_ioctl_set_memory_policy(struct file *filep,

				struct kfd_process *p, void __user *arg)

{

	return -ENODEV;

}



static long kfd_ioctl_get_clock_counters(struct file *filep,

				struct kfd_process *p, void __user *arg)

{

	return -ENODEV;

}





static int kfd_ioctl_get_process_apertures(struct file *filp,

				struct kfd_process *p, void __user *arg)

{

	return -ENODEV;

}



static long kfd_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)

{

	struct kfd_process *process;

	long err = -EINVAL;



	dev_dbg(kfd_device,

		"ioctl cmd 0x%x (#%d), arg 0x%lx\n",

		cmd, _IOC_NR(cmd), arg);



	/* TODO: add function that retrieves process */

	process = NULL;



	switch (cmd) {

	case KFD_IOC_GET_VERSION:

		err = kfd_ioctl_get_version(filep, process, (void __user *)arg);

		break;

	case KFD_IOC_CREATE_QUEUE:

		err = kfd_ioctl_create_queue(filep, process,

						(void __user *)arg);

		break;



	case KFD_IOC_DESTROY_QUEUE:

		err = kfd_ioctl_destroy_queue(filep, process,

						(void __user *)arg);

		break;



	case KFD_IOC_SET_MEMORY_POLICY:

		err = kfd_ioctl_set_memory_policy(filep, process,

						(void __user *)arg);

		break;



	case KFD_IOC_GET_CLOCK_COUNTERS:

		err = kfd_ioctl_get_clock_counters(filep, process,

						(void __user *)arg);

		break;



	case KFD_IOC_GET_PROCESS_APERTURES:

		err = kfd_ioctl_get_process_apertures(filep, process,

						(void __user *)arg);

		break;



	case KFD_IOC_UPDATE_QUEUE:

		err = kfd_ioctl_update_queue(filep, process,

						(void __user *)arg);

		break;



	default:

		dev_err(kfd_device,

			"unknown ioctl cmd 0x%x, arg 0x%lx)\n",

			cmd, arg);

		err = -EINVAL;

		break;

	}



	if (err < 0)

		dev_err(kfd_device,

			"ioctl error %ld for ioctl cmd 0x%x (#%d)\n",

			err, cmd, _IOC_NR(cmd));



	return err;

}