amdkfd: Add kernel queue module

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

		kfd_pasid.o kfd_doorbell.o kfd_flat_memory.o \

		kfd_process.o kfd_queue.o kfd_mqd_manager.o

		kfd_process.o kfd_queue.o kfd_mqd_manager.o \

		kfd_kernel_queue.o

obj-$(CONFIG_HSA_AMD)	+= amdkfd.o

/*

 * 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.

 *

 */

#ifndef KFD_DEVICE_QUEUE_MANAGER_H_

#define KFD_DEVICE_QUEUE_MANAGER_H_

#include <linux/rwsem.h>

#include <linux/list.h>

#include "kfd_priv.h"

#include "kfd_mqd_manager.h"

#define QUEUE_PREEMPT_DEFAULT_TIMEOUT_MS	(500)

#define QUEUES_PER_PIPE				(8)

#define PIPE_PER_ME_CP_SCHEDULING		(3)

#define CIK_VMID_NUM				(8)

#define KFD_VMID_START_OFFSET			(8)

#define VMID_PER_DEVICE				CIK_VMID_NUM

#define KFD_DQM_FIRST_PIPE			(0)

struct device_process_node {

	struct qcm_process_device *qpd;

	struct list_head list;

};

struct device_queue_manager {

	int	(*create_queue)(struct device_queue_manager *dqm,

				struct queue *q,

				struct qcm_process_device *qpd,

				int *allocate_vmid);

	int	(*destroy_queue)(struct device_queue_manager *dqm,

				struct qcm_process_device *qpd,

				struct queue *q);

	int	(*update_queue)(struct device_queue_manager *dqm,

				struct queue *q);

	struct mqd_manager * (*get_mqd_manager)(

					struct device_queue_manager *dqm,

					enum KFD_MQD_TYPE type);

	int	(*register_process)(struct device_queue_manager *dqm,

					struct qcm_process_device *qpd);

	int	(*unregister_process)(struct device_queue_manager *dqm,

					struct qcm_process_device *qpd);

	int	(*initialize)(struct device_queue_manager *dqm);

	int	(*start)(struct device_queue_manager *dqm);

	int	(*stop)(struct device_queue_manager *dqm);

	void	(*uninitialize)(struct device_queue_manager *dqm);

	int	(*create_kernel_queue)(struct device_queue_manager *dqm,

					struct kernel_queue *kq,

					struct qcm_process_device *qpd);

	void	(*destroy_kernel_queue)(struct device_queue_manager *dqm,

					struct kernel_queue *kq,

					struct qcm_process_device *qpd);

	bool	(*set_cache_memory_policy)(struct device_queue_manager *dqm,

					   struct qcm_process_device *qpd,

					   enum cache_policy default_policy,

					   enum cache_policy alternate_policy,

					   void __user *alternate_aperture_base,

					   uint64_t alternate_aperture_size);

	struct mqd_manager	*mqds[KFD_MQD_TYPE_MAX];

	struct packet_manager	packets;

	struct kfd_dev		*dev;

	struct mutex		lock;

	struct list_head	queues;

	unsigned int		processes_count;

	unsigned int		queue_count;

	unsigned int		next_pipe_to_allocate;

	unsigned int		*allocated_queues;

	unsigned int		vmid_bitmap;

	uint64_t		pipelines_addr;

	struct kfd_mem_obj	*pipeline_mem;

	uint64_t		fence_gpu_addr;

	unsigned int		*fence_addr;

	struct kfd_mem_obj	*fence_mem;

	bool			active_runlist;

};

#endif /* KFD_DEVICE_QUEUE_MANAGER_H_ */

/*

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

#include <linux/mutex.h>

#include <linux/slab.h>

#include <linux/printk.h>

#include "kfd_kernel_queue.h"

#include "kfd_priv.h"

#include "kfd_device_queue_manager.h"

#include "kfd_pm4_headers.h"

#include "kfd_pm4_opcodes.h"

#define PM4_COUNT_ZERO (((1 << 15) - 1) << 16)

static bool initialize(struct kernel_queue *kq, struct kfd_dev *dev,

		enum kfd_queue_type type, unsigned int queue_size)

{

	struct queue_properties prop;

	int retval;

	union PM4_MES_TYPE_3_HEADER nop;

	BUG_ON(!kq || !dev);

	BUG_ON(type != KFD_QUEUE_TYPE_DIQ && type != KFD_QUEUE_TYPE_HIQ);

	pr_debug("kfd: In func %s initializing queue type %d size %d\n",

			__func__, KFD_QUEUE_TYPE_HIQ, queue_size);

	nop.opcode = IT_NOP;

	nop.type = PM4_TYPE_3;

	nop.u32all |= PM4_COUNT_ZERO;

	kq->dev = dev;

	kq->nop_packet = nop.u32all;

	switch (type) {

	case KFD_QUEUE_TYPE_DIQ:

	case KFD_QUEUE_TYPE_HIQ:

		kq->mqd = dev->dqm->get_mqd_manager(dev->dqm,

						KFD_MQD_TYPE_CIK_HIQ);

		break;

	default:

		BUG();

		break;

	}

	if (kq->mqd == NULL)

		return false;

	prop.doorbell_ptr =

		(uint32_t *)kfd_get_kernel_doorbell(dev, &prop.doorbell_off);

	if (prop.doorbell_ptr == NULL)

		goto err_get_kernel_doorbell;

	retval = kfd2kgd->allocate_mem(dev->kgd,

					queue_size,

					PAGE_SIZE,

					KFD_MEMPOOL_SYSTEM_WRITECOMBINE,

					(struct kgd_mem **) &kq->pq);

	if (retval != 0)

		goto err_pq_allocate_vidmem;

	kq->pq_kernel_addr = kq->pq->cpu_ptr;

	kq->pq_gpu_addr = kq->pq->gpu_addr;

	retval = kfd2kgd->allocate_mem(dev->kgd,

					sizeof(*kq->rptr_kernel),

					32,

					KFD_MEMPOOL_SYSTEM_WRITECOMBINE,

					(struct kgd_mem **) &kq->rptr_mem);

	if (retval != 0)

		goto err_rptr_allocate_vidmem;

	kq->rptr_kernel = kq->rptr_mem->cpu_ptr;

	kq->rptr_gpu_addr = kq->rptr_mem->gpu_addr;

	retval = kfd2kgd->allocate_mem(dev->kgd,

					sizeof(*kq->wptr_kernel),

					32,

					KFD_MEMPOOL_SYSTEM_WRITECOMBINE,

					(struct kgd_mem **) &kq->wptr_mem);

	if (retval != 0)

		goto err_wptr_allocate_vidmem;

	kq->wptr_kernel = kq->wptr_mem->cpu_ptr;

	kq->wptr_gpu_addr = kq->wptr_mem->gpu_addr;

	memset(kq->pq_kernel_addr, 0, queue_size);

	memset(kq->rptr_kernel, 0, sizeof(*kq->rptr_kernel));

	memset(kq->wptr_kernel, 0, sizeof(*kq->wptr_kernel));

	prop.queue_size = queue_size;

	prop.is_interop = false;

	prop.priority = 1;

	prop.queue_percent = 100;

	prop.type = type;

	prop.vmid = 0;

	prop.queue_address = kq->pq_gpu_addr;

	prop.read_ptr = (uint32_t *) kq->rptr_gpu_addr;

	prop.write_ptr = (uint32_t *) kq->wptr_gpu_addr;

	if (init_queue(&kq->queue, prop) != 0)

		goto err_init_queue;

	kq->queue->device = dev;

	kq->queue->process = kfd_get_process(current);

	retval = kq->mqd->init_mqd(kq->mqd, &kq->queue->mqd,

					&kq->queue->mqd_mem_obj,

					&kq->queue->gart_mqd_addr,

					&kq->queue->properties);

	if (retval != 0)

		goto err_init_mqd;

	/* assign HIQ to HQD */

	if (type == KFD_QUEUE_TYPE_HIQ) {

		pr_debug("assigning hiq to hqd\n");

		kq->queue->pipe = KFD_CIK_HIQ_PIPE;

		kq->queue->queue = KFD_CIK_HIQ_QUEUE;

		kq->mqd->load_mqd(kq->mqd, kq->queue->mqd, kq->queue->pipe,

					kq->queue->queue, NULL);

	} else {

		/* allocate fence for DIQ */

		retval = kfd2kgd->allocate_mem(dev->kgd,

					sizeof(uint32_t),

					32,

					KFD_MEMPOOL_SYSTEM_WRITECOMBINE,

					(struct kgd_mem **) &kq->fence_mem_obj);

		if (retval != 0)

			goto err_alloc_fence;

		kq->fence_kernel_address = kq->fence_mem_obj->cpu_ptr;

		kq->fence_gpu_addr = kq->fence_mem_obj->gpu_addr;

	}

	print_queue(kq->queue);

	return true;

err_alloc_fence:

err_init_mqd:

	uninit_queue(kq->queue);

err_init_queue:

	kfd2kgd->free_mem(dev->kgd, (struct kgd_mem *) kq->wptr_mem);

err_wptr_allocate_vidmem:

	kfd2kgd->free_mem(dev->kgd, (struct kgd_mem *) kq->rptr_mem);

err_rptr_allocate_vidmem:

	kfd2kgd->free_mem(dev->kgd, (struct kgd_mem *) kq->pq);

err_pq_allocate_vidmem:

	pr_err("kfd: error init pq\n");

	kfd_release_kernel_doorbell(dev, (u32 *)prop.doorbell_ptr);

err_get_kernel_doorbell:

	pr_err("kfd: error init doorbell");

	return false;

}

static void uninitialize(struct kernel_queue *kq)

{

	BUG_ON(!kq);

	if (kq->queue->properties.type == KFD_QUEUE_TYPE_HIQ)

		kq->mqd->destroy_mqd(kq->mqd,

					NULL,

					false,

					QUEUE_PREEMPT_DEFAULT_TIMEOUT_MS,

					kq->queue->pipe,

					kq->queue->queue);

	kfd2kgd->free_mem(kq->dev->kgd, (struct kgd_mem *) kq->rptr_mem);

	kfd2kgd->free_mem(kq->dev->kgd, (struct kgd_mem *) kq->wptr_mem);

	kfd2kgd->free_mem(kq->dev->kgd, (struct kgd_mem *) kq->pq);

	kfd_release_kernel_doorbell(kq->dev,

				(u32 *)kq->queue->properties.doorbell_ptr);

	uninit_queue(kq->queue);

}

static int acquire_packet_buffer(struct kernel_queue *kq,

		size_t packet_size_in_dwords, unsigned int **buffer_ptr)

{

	size_t available_size;

	size_t queue_size_dwords;

	uint32_t wptr, rptr;

	unsigned int *queue_address;

	BUG_ON(!kq || !buffer_ptr);

	rptr = *kq->rptr_kernel;

	wptr = *kq->wptr_kernel;

	queue_address = (unsigned int *)kq->pq_kernel_addr;

	queue_size_dwords = kq->queue->properties.queue_size / sizeof(uint32_t);

	pr_debug("kfd: In func %s\nrptr: %d\nwptr: %d\nqueue_address 0x%p\n",

			__func__, rptr, wptr, queue_address);

	available_size = (rptr - 1 - wptr + queue_size_dwords) %

							queue_size_dwords;

	if (packet_size_in_dwords >= queue_size_dwords ||

			packet_size_in_dwords >= available_size)

		return -ENOMEM;

	if (wptr + packet_size_in_dwords >= queue_size_dwords) {

		while (wptr > 0) {

			queue_address[wptr] = kq->nop_packet;

			wptr = (wptr + 1) % queue_size_dwords;

		}

	}

	*buffer_ptr = &queue_address[wptr];

	kq->pending_wptr = wptr + packet_size_in_dwords;

	return 0;

}

static void submit_packet(struct kernel_queue *kq)

{

#ifdef DEBUG

	int i;

#endif

	BUG_ON(!kq);

#ifdef DEBUG

	for (i = *kq->wptr_kernel; i < kq->pending_wptr; i++) {

		pr_debug("0x%2X ", kq->pq_kernel_addr[i]);

		if (i % 15 == 0)

			pr_debug("\n");

	}

	pr_debug("\n");

#endif

	*kq->wptr_kernel = kq->pending_wptr;

	write_kernel_doorbell((u32 *)kq->queue->properties.doorbell_ptr,

				kq->pending_wptr);

}

static int sync_with_hw(struct kernel_queue *kq, unsigned long timeout_ms)

{

	unsigned long org_timeout_ms;

	BUG_ON(!kq);

	org_timeout_ms = timeout_ms;

	timeout_ms += jiffies * 1000 / HZ;

	while (*kq->wptr_kernel != *kq->rptr_kernel) {

		if (time_after(jiffies * 1000 / HZ, timeout_ms)) {

			pr_err("kfd: kernel_queue %s timeout expired %lu\n",

				__func__, org_timeout_ms);

			pr_err("kfd: wptr: %d rptr: %d\n",

				*kq->wptr_kernel, *kq->rptr_kernel);

			return -ETIME;

		}

		cpu_relax();

	}

	return 0;

}

static void rollback_packet(struct kernel_queue *kq)

{

	BUG_ON(!kq);

	kq->pending_wptr = *kq->queue->properties.write_ptr;

}

struct kernel_queue *kernel_queue_init(struct kfd_dev *dev,

					enum kfd_queue_type type)

{

	struct kernel_queue *kq;

	BUG_ON(!dev);

	kq = kzalloc(sizeof(struct kernel_queue), GFP_KERNEL);

	if (!kq)

		return NULL;

	kq->initialize = initialize;

	kq->uninitialize = uninitialize;

	kq->acquire_packet_buffer = acquire_packet_buffer;

	kq->submit_packet = submit_packet;

	kq->sync_with_hw = sync_with_hw;

	kq->rollback_packet = rollback_packet;

	if (kq->initialize(kq, dev, type, KFD_KERNEL_QUEUE_SIZE) == false) {

		pr_err("kfd: failed to init kernel queue\n");

		kfree(kq);

		return NULL;

	}

	return kq;

}

void kernel_queue_uninit(struct kernel_queue *kq)

{

	BUG_ON(!kq);

	kq->uninitialize(kq);

	kfree(kq);

}

void test_kq(struct kfd_dev *dev)

{

	struct kernel_queue *kq;

	uint32_t *buffer, i;

	int retval;

	BUG_ON(!dev);

	pr_debug("kfd: starting kernel queue test\n");

	kq = kernel_queue_init(dev, KFD_QUEUE_TYPE_HIQ);

	BUG_ON(!kq);

	retval = kq->acquire_packet_buffer(kq, 5, &buffer);

	BUG_ON(retval != 0);

	for (i = 0; i < 5; i++)

		buffer[i] = kq->nop_packet;

	kq->submit_packet(kq);

	kq->sync_with_hw(kq, 1000);

	pr_debug("kfd: ending kernel queue test\n");

}

/*

 * 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.

 *

 */

#ifndef KFD_KERNEL_QUEUE_H_

#define KFD_KERNEL_QUEUE_H_

#include <linux/list.h>

#include <linux/types.h>

#include "kfd_priv.h"

struct kernel_queue {

	/* interface */

	bool	(*initialize)(struct kernel_queue *kq, struct kfd_dev *dev,

			enum kfd_queue_type type, unsigned int queue_size);

	void	(*uninitialize)(struct kernel_queue *kq);

	int	(*acquire_packet_buffer)(struct kernel_queue *kq,

					size_t packet_size_in_dwords,

					unsigned int **buffer_ptr);

	void	(*submit_packet)(struct kernel_queue *kq);

	int	(*sync_with_hw)(struct kernel_queue *kq,

				unsigned long timeout_ms);

	void	(*rollback_packet)(struct kernel_queue *kq);

	/* data */

	struct kfd_dev		*dev;

	struct mqd_manager	*mqd;

	struct queue		*queue;

	uint32_t		pending_wptr;

	unsigned int		nop_packet;

	struct kfd_mem_obj	*rptr_mem;

	uint32_t		*rptr_kernel;

	uint64_t		rptr_gpu_addr;

	struct kfd_mem_obj	*wptr_mem;

	uint32_t		*wptr_kernel;

	uint64_t		wptr_gpu_addr;

	struct kfd_mem_obj	*pq;

	uint64_t		pq_gpu_addr;

	uint32_t		*pq_kernel_addr;

	struct kfd_mem_obj	*fence_mem_obj;

	uint64_t		fence_gpu_addr;

	void			*fence_kernel_address;

	struct list_head	list;

};

#endif /* KFD_KERNEL_QUEUE_H_ */

/*

 * 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.

 *

 */

#ifndef KFD_PM4_HEADERS_H_

#define KFD_PM4_HEADERS_H_

#ifndef PM4_MES_HEADER_DEFINED

#define PM4_MES_HEADER_DEFINED

union PM4_MES_TYPE_3_HEADER {

	struct {

		uint32_t reserved1:8;	/* < reserved */

		uint32_t opcode:8;	/* < IT opcode */

		uint32_t count:14;	/* < number of DWORDs - 1

					 * in the information body.

					 */

		uint32_t type:2;	/* < packet identifier.

					 * It should be 3 for type 3 packets

					 */

	};

	uint32_t u32all;

};

#endif /* PM4_MES_HEADER_DEFINED */

/* --------------------MES_SET_RESOURCES-------------------- */

#ifndef PM4_MES_SET_RESOURCES_DEFINED

#define PM4_MES_SET_RESOURCES_DEFINED

enum set_resources_queue_type_enum {

	queue_type__mes_set_resources__kernel_interface_queue_kiq = 0,

	queue_type__mes_set_resources__hsa_interface_queue_hiq = 1,

	queue_type__mes_set_resources__hsa_debug_interface_queue = 4

};

struct pm4_set_resources {

	union {

		union PM4_MES_TYPE_3_HEADER header;	/* header */

		uint32_t ordinal1;

	};

	union {

		struct {

			uint32_t vmid_mask:16;

			uint32_t unmap_latency:8;

			uint32_t reserved1:5;

			enum set_resources_queue_type_enum queue_type:3;

		} bitfields2;

		uint32_t ordinal2;

	};

	uint32_t queue_mask_lo;

	uint32_t queue_mask_hi;

	uint32_t gws_mask_lo;

	uint32_t gws_mask_hi;

	union {

		struct {

			uint32_t oac_mask:16;

			uint32_t reserved2:16;

		} bitfields7;

		uint32_t ordinal7;

	};

	union {

		struct {

			uint32_t gds_heap_base:6;

			uint32_t reserved3:5;

			uint32_t gds_heap_size:6;

			uint32_t reserved4:15;

		} bitfields8;

		uint32_t ordinal8;

	};

};

#endif

/*--------------------MES_RUN_LIST-------------------- */

#ifndef PM4_MES_RUN_LIST_DEFINED

#define PM4_MES_RUN_LIST_DEFINED

struct pm4_runlist {

	union {

		union PM4_MES_TYPE_3_HEADER header;	/* header */

		uint32_t ordinal1;

	};

	union {

		struct {

			uint32_t reserved1:2;

			uint32_t ib_base_lo:30;

		} bitfields2;

		uint32_t ordinal2;

	};

	union {

		struct {

			uint32_t ib_base_hi:16;

			uint32_t reserved2:16;

		} bitfields3;

		uint32_t ordinal3;

	};

	union {

		struct {

			uint32_t ib_size:20;

			uint32_t chain:1;

			uint32_t offload_polling:1;

			uint32_t reserved3:1;

			uint32_t valid:1;

			uint32_t reserved4:8;

		} bitfields4;

		uint32_t ordinal4;

	};

};

#endif

/*--------------------MES_MAP_PROCESS-------------------- */

#ifndef PM4_MES_MAP_PROCESS_DEFINED

#define PM4_MES_MAP_PROCESS_DEFINED

struct pm4_map_process {

	union {

		union PM4_MES_TYPE_3_HEADER header;	/* header */

		uint32_t ordinal1;

	};

	union {

		struct {

			uint32_t pasid:16;

			uint32_t reserved1:8;

			uint32_t diq_enable:1;

			uint32_t process_quantum:7;

		} bitfields2;

		uint32_t ordinal2;

	};

	union {

		struct {

			uint32_t page_table_base:28;

			uint32_t reserved3:4;

		} bitfields3;

		uint32_t ordinal3;

	};

	uint32_t sh_mem_bases;

	uint32_t sh_mem_ape1_base;

	uint32_t sh_mem_ape1_limit;

	uint32_t sh_mem_config;

	uint32_t gds_addr_lo;

	uint32_t gds_addr_hi;

	union {

		struct {

			uint32_t num_gws:6;

			uint32_t reserved4:2;

			uint32_t num_oac:4;

			uint32_t reserved5:4;

			uint32_t gds_size:6;

			uint32_t num_queues:10;

		} bitfields10;

		uint32_t ordinal10;

	};

};

#endif

/*--------------------MES_MAP_QUEUES--------------------*/

#ifndef PM4_MES_MAP_QUEUES_DEFINED

#define PM4_MES_MAP_QUEUES_DEFINED

enum map_queues_queue_sel_enum {

	queue_sel__mes_map_queues__map_to_specified_queue_slots = 0,

	queue_sel__mes_map_queues__map_to_hws_determined_queue_slots = 1,

	queue_sel__mes_map_queues__enable_process_queues = 2

};

enum map_queues_vidmem_enum {

	vidmem__mes_map_queues__uses_no_video_memory = 0,