drm/amdgpu: Remove wrapper layer of cgs irq handling (160b8e75) · Commits · e / devices / android_kernel_oneplus_sm7250

drivers/gpu/drm/amd/acp/include/acp_gfx_if.h

+0 −1

Original line number	Diff line number	Diff line
		@@ -25,7 +25,6 @@
		#define _ACP_GFX_IF_H

		#include <linux/types.h>
		#include "cgs_linux.h"
		#include "cgs_common.h"

		int amd_acp_hw_init(struct cgs_device *cgs_device,

drivers/gpu/drm/amd/amdgpu/amdgpu_cgs.c

+0 −111

Original line number	Diff line number	Diff line
		@@ -28,7 +28,6 @@
		#include <linux/firmware.h>
		#include <drm/amdgpu_drm.h>
		#include "amdgpu.h"
		#include "cgs_linux.h"
		#include "atom.h"
		#include "amdgpu_ucode.h"

		@@ -182,109 +181,6 @@ static int amdgpu_cgs_atom_exec_cmd_table(struct cgs_device *cgs_device, unsigne
		adev->mode_info.atom_context, table, args);
		}

		struct cgs_irq_params {
		unsigned src_id;
		cgs_irq_source_set_func_t set;
		cgs_irq_handler_func_t handler;
		void *private_data;
		};

		static int cgs_set_irq_state(struct amdgpu_device *adev,
		struct amdgpu_irq_src *src,
		unsigned type,
		enum amdgpu_interrupt_state state)
		{
		struct cgs_irq_params *irq_params =
		(struct cgs_irq_params *)src->data;
		if (!irq_params)
		return -EINVAL;
		if (!irq_params->set)
		return -EINVAL;
		return irq_params->set(irq_params->private_data,
		irq_params->src_id,
		type,
		(int)state);
		}

		static int cgs_process_irq(struct amdgpu_device *adev,
		struct amdgpu_irq_src *source,
		struct amdgpu_iv_entry *entry)
		{
		struct cgs_irq_params *irq_params =
		(struct cgs_irq_params *)source->data;
		if (!irq_params)
		return -EINVAL;
		if (!irq_params->handler)
		return -EINVAL;
		return irq_params->handler(irq_params->private_data,
		irq_params->src_id,
		entry->iv_entry);
		}

		static const struct amdgpu_irq_src_funcs cgs_irq_funcs = {
		.set = cgs_set_irq_state,
		.process = cgs_process_irq,
		};

		static int amdgpu_cgs_add_irq_source(void *cgs_device,
		unsigned client_id,
		unsigned src_id,
		unsigned num_types,
		cgs_irq_source_set_func_t set,
		cgs_irq_handler_func_t handler,
		void *private_data)
		{
		CGS_FUNC_ADEV;
		int ret = 0;
		struct cgs_irq_params *irq_params;
		struct amdgpu_irq_src *source =
		kzalloc(sizeof(struct amdgpu_irq_src), GFP_KERNEL);
		if (!source)
		return -ENOMEM;
		irq_params =
		kzalloc(sizeof(struct cgs_irq_params), GFP_KERNEL);
		if (!irq_params) {
		kfree(source);
		return -ENOMEM;
		}
		source->num_types = num_types;
		source->funcs = &cgs_irq_funcs;
		irq_params->src_id = src_id;
		irq_params->set = set;
		irq_params->handler = handler;
		irq_params->private_data = private_data;
		source->data = (void *)irq_params;
		ret = amdgpu_irq_add_id(adev, client_id, src_id, source);
		if (ret) {
		kfree(irq_params);
		kfree(source);
		}

		return ret;
		}

		static int amdgpu_cgs_irq_get(void *cgs_device, unsigned client_id,
		unsigned src_id, unsigned type)
		{
		CGS_FUNC_ADEV;

		if (!adev->irq.client[client_id].sources)
		return -EINVAL;

		return amdgpu_irq_get(adev, adev->irq.client[client_id].sources[src_id], type);
		}

		static int amdgpu_cgs_irq_put(void *cgs_device, unsigned client_id,
		unsigned src_id, unsigned type)
		{
		CGS_FUNC_ADEV;

		if (!adev->irq.client[client_id].sources)
		return -EINVAL;

		return amdgpu_irq_put(adev, adev->irq.client[client_id].sources[src_id], type);
		}

		static int amdgpu_cgs_set_clockgating_state(struct cgs_device *cgs_device,
		enum amd_ip_block_type block_type,
		enum amd_clockgating_state state)
		@@ -795,12 +691,6 @@ static const struct cgs_ops amdgpu_cgs_ops = {
		.lock_grbm_idx = amdgpu_cgs_lock_grbm_idx,
		};

		static const struct cgs_os_ops amdgpu_cgs_os_ops = {
		.add_irq_source = amdgpu_cgs_add_irq_source,
		.irq_get = amdgpu_cgs_irq_get,
		.irq_put = amdgpu_cgs_irq_put
		};

		struct cgs_device amdgpu_cgs_create_device(struct amdgpu_device adev)
		{
		struct amdgpu_cgs_device *cgs_device =
		@@ -812,7 +702,6 @@ struct cgs_device amdgpu_cgs_create_device(struct amdgpu_device adev)
		}

		cgs_device->base.ops = &amdgpu_cgs_ops;
		cgs_device->base.os_ops = &amdgpu_cgs_os_ops;
		cgs_device->adev = adev;

		return (struct cgs_device *)cgs_device;

drivers/gpu/drm/amd/display/dc/os_types.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -32,7 +32,7 @@

		#include <linux/kref.h>

		#include "cgs_linux.h"
		#include "cgs_common.h"

		#if defined(__BIG_ENDIAN) && !defined(BIGENDIAN_CPU)
		#define BIGENDIAN_CPU

drivers/gpu/drm/amd/include/cgs_common.h

+0 −1

Original line number	Diff line number	Diff line
		@@ -290,7 +290,6 @@ struct cgs_os_ops; /* To be define in OS-specific CGS header */
		struct cgs_device
		{
		const struct cgs_ops *ops;
		const struct cgs_os_ops *os_ops;
		/* to be embedded at the start of driver private structure */
		};

drivers/gpu/drm/amd/include/cgs_linux.h

deleted100644 → 0

+0 −119

Original line number	Diff line number	Diff line
		/*
		* Copyright 2015 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 _CGS_LINUX_H
		#define _CGS_LINUX_H

		#include "cgs_common.h"

		/**
		* cgs_irq_source_set_func() - Callback for enabling/disabling interrupt sources
		* @private_data: private data provided to cgs_add_irq_source
		* @src_id: interrupt source ID
		* @type: interrupt type
		* @enabled: 0 = disable source, non-0 = enable source
		*
		* Return: 0 on success, -errno otherwise
		*/
		typedef int (cgs_irq_source_set_func_t)(void private_data,
		unsigned src_id, unsigned type,
		int enabled);

		/**
		* cgs_irq_handler_func() - Interrupt handler callback
		* @private_data: private data provided to cgs_add_irq_source
		* @src_id: interrupt source ID
		* @iv_entry: pointer to raw ih ring entry
		*
		* This callback runs in interrupt context.
		*
		* Return: 0 on success, -errno otherwise
		*/
		typedef int (cgs_irq_handler_func_t)(void private_data,
		unsigned src_id, const uint32_t *iv_entry);

		/**
		* cgs_add_irq_source() - Add an IRQ source
		* @cgs_device: opaque device handle
		* @src_id: interrupt source ID
		* @num_types: number of interrupt types that can be independently enabled
		* @set: callback function to enable/disable an interrupt type
		* @handler: interrupt handler callback
		* @private_data: private data to pass to callback functions
		*
		* The same IRQ source can be added only once. Adding an IRQ source
		* indicates ownership of that IRQ source and all its IRQ types.
		*
		* Return: 0 on success, -errno otherwise
		*/
		typedef int (cgs_add_irq_source_t)(void cgs_device, unsigned client_id,
		unsigned src_id,
		unsigned num_types,
		cgs_irq_source_set_func_t set,
		cgs_irq_handler_func_t handler,
		void *private_data);

		/**
		* cgs_irq_get() - Request enabling an IRQ source and type
		* @cgs_device: opaque device handle
		* @src_id: interrupt source ID
		* @type: interrupt type
		*
		* cgs_irq_get and cgs_irq_put calls must be balanced. They count
		* "references" to IRQ sources.
		*
		* Return: 0 on success, -errno otherwise
		*/
		typedef int (cgs_irq_get_t)(void cgs_device, unsigned client_id, unsigned src_id, unsigned type);

		/**
		* cgs_irq_put() - Indicate IRQ source is no longer needed
		* @cgs_device: opaque device handle
		* @src_id: interrupt source ID
		* @type: interrupt type
		*
		* cgs_irq_get and cgs_irq_put calls must be balanced. They count
		* "references" to IRQ sources. Even after cgs_irq_put is called, the
		* IRQ handler may still be called if there are more refecences to
		* the IRQ source.
		*
		* Return: 0 on success, -errno otherwise
		*/
		typedef int (cgs_irq_put_t)(void cgs_device, unsigned client_id, unsigned src_id, unsigned type);

		struct cgs_os_ops {
		/* IRQ handling */
		cgs_add_irq_source_t add_irq_source;
		cgs_irq_get_t irq_get;
		cgs_irq_put_t irq_put;
		};

		#define cgs_add_irq_source(dev,client_id,src_id,num_types,set,handler,private_data) \
		CGS_OS_CALL(add_irq_source,dev,client_id,src_id,num_types,set,handler, \
		private_data)
		#define cgs_irq_get(dev,client_id,src_id,type) \
		CGS_OS_CALL(irq_get,dev,client_id,src_id,type)
		#define cgs_irq_put(dev,client_id,src_id,type) \
		CGS_OS_CALL(irq_put,dev,client_id,src_id,type)

		#endif /* _CGS_LINUX_H */