From a54e52af1843cc52973e041b8f62dcf3ae5ea2e6 Mon Sep 17 00:00:00 2001 From: Lukas Rusak Date: Mon, 11 Sep 2017 12:53:28 -0700 Subject: [PATCH] gpu-sunxi: initial package --- packages/linux-drivers/gpu-sunxi/package.mk | 28 ++ .../patches/add-sunxi-platform.patch | 426 ++++++++++++++++++ .../patches/fix-building-with-4.16.patch | 155 +++++++ .../patches/fix-building-with-4.20.patch | 128 ++++++ .../patches/fix-building-with-5.0.patch | 35 ++ 5 files changed, 772 insertions(+) create mode 100644 packages/linux-drivers/gpu-sunxi/package.mk create mode 100644 packages/linux-drivers/gpu-sunxi/patches/add-sunxi-platform.patch create mode 100644 packages/linux-drivers/gpu-sunxi/patches/fix-building-with-4.16.patch create mode 100644 packages/linux-drivers/gpu-sunxi/patches/fix-building-with-4.20.patch create mode 100644 packages/linux-drivers/gpu-sunxi/patches/fix-building-with-5.0.patch diff --git a/packages/linux-drivers/gpu-sunxi/package.mk b/packages/linux-drivers/gpu-sunxi/package.mk new file mode 100644 index 0000000000..aac4417ae3 --- /dev/null +++ b/packages/linux-drivers/gpu-sunxi/package.mk @@ -0,0 +1,28 @@ +# SPDX-License-Identifier: GPL-2.0 +# Copyright (C) 2016-present Team LibreELEC (https://libreelec.tv) + +PKG_NAME="gpu-sunxi" +PKG_VERSION="r9p0-01rel0" +PKG_SHA256="7a67127341d17640c1fff5dad80258fb2a37c8a2121b81525fe2327e4532ce2b" +PKG_ARCH="arm aarch64" +PKG_LICENSE="GPL" +PKG_SITE="https://developer.arm.com/products/software/mali-drivers/utgard-kernel" +PKG_URL="https://developer.arm.com/-/media/Files/downloads/mali-drivers/kernel/mali-utgard-gpu/DX910-SW-99002-$PKG_VERSION.tgz" +PKG_DEPENDS_TARGET="toolchain linux" +PKG_NEED_UNPACK="$LINUX_DEPENDS" +PKG_LONGDESC="gpu-sunxi: Linux drivers for Mali GPUs found in Allwinner SoCs" +PKG_TOOLCHAIN="manual" +PKG_IS_KERNEL_PKG="yes" + +make_target() { + kernel_make -C $(kernel_path) M=$PKG_BUILD/driver/src/devicedrv/mali/ \ + MALI_PLATFORM_FILES=platform/sunxi/sunxi.c \ + EXTRA_CFLAGS="-DMALI_FAKE_PLATFORM_DEVICE=1 -DCONFIG_MALI_DMA_BUF_MAP_ON_ATTACH" \ + CONFIG_MALI400=m +} + +makeinstall_target() { + kernel_make -C $(kernel_path) M=$PKG_BUILD/driver/src/devicedrv/mali/ \ + INSTALL_MOD_PATH=$INSTALL/$(get_kernel_overlay_dir) INSTALL_MOD_STRIP=1 DEPMOD=: \ + modules_install +} diff --git a/packages/linux-drivers/gpu-sunxi/patches/add-sunxi-platform.patch b/packages/linux-drivers/gpu-sunxi/patches/add-sunxi-platform.patch new file mode 100644 index 0000000000..4deaa9edb1 --- /dev/null +++ b/packages/linux-drivers/gpu-sunxi/patches/add-sunxi-platform.patch @@ -0,0 +1,426 @@ +From 2b56fc78a4acbffbdebf5b690035d1ba70ef592c Mon Sep 17 00:00:00 2001 +From: Maxime Ripard +Date: Tue, 29 Nov 2016 10:18:40 +0100 +Subject: [PATCH 4/4] mali: Add sunxi platform + +Add a platform for the Mali GPU integrated in the Allwinner SoCs. + +Signed-off-by: Maxime Ripard +--- + src/devicedrv/mali/platform/sunxi/sunxi.c | 404 +++++++++++++++++++++++ + 1 file changed, 404 insertions(+) + create mode 100644 src/devicedrv/mali/platform/sunxi/sunxi.c + +--- /dev/null ++++ b/driver/src/devicedrv/mali/platform/sunxi/sunxi.c +@@ -0,0 +1,410 @@ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include ++ ++#include ++ ++#include "mali_kernel_linux.h" ++ ++struct mali { ++ struct clk *bus_clk; ++ struct clk *core_clk; ++ ++ struct reset_control *reset; ++ ++ struct platform_device *dev; ++}; ++ ++struct mali *mali; ++ ++struct resource *mali_create_mp1_resources(unsigned long address, ++ int irq_gp, int irq_gpmmu, ++ int irq_pp0, int irq_ppmmu0, ++ int *len) ++{ ++ struct resource target[] = { ++ MALI_GPU_RESOURCES_MALI400_MP1_PMU(address, ++ irq_gp, irq_gpmmu, ++ irq_pp0, irq_ppmmu0) ++ }; ++ struct resource *res; ++ ++ res = kzalloc(sizeof(target), GFP_KERNEL); ++ if (!res) ++ return NULL; ++ ++ memcpy(res, target, sizeof(target)); ++ ++ *len = ARRAY_SIZE(target); ++ ++ return res; ++} ++ ++struct resource *mali_create_mp2_resources(unsigned long address, ++ int irq_gp, int irq_gpmmu, ++ int irq_pp0, int irq_ppmmu0, ++ int irq_pp1, int irq_ppmmu1, ++ int *len) ++{ ++ struct resource target[] = { ++ MALI_GPU_RESOURCES_MALI400_MP2_PMU(address, ++ irq_gp, irq_gpmmu, ++ irq_pp0, irq_ppmmu0, ++ irq_pp1, irq_ppmmu1) ++ }; ++ struct resource *res; ++ ++ res = kzalloc(sizeof(target), GFP_KERNEL); ++ if (!res) ++ return NULL; ++ ++ memcpy(res, target, sizeof(target)); ++ ++ *len = ARRAY_SIZE(target); ++ ++ return res; ++} ++ ++struct resource *mali_create_450mp4_resources(unsigned long address, ++ int irq_gp, int irq_gpmmu, ++ int irq_pp0, int irq_ppmmu0, ++ int irq_pp1, int irq_ppmmu1, ++ int irq_pp2, int irq_ppmmu2, ++ int irq_pp3, int irq_ppmmu3, ++ int irq_pp, int *len) ++{ ++ struct resource target[] = { ++ MALI_GPU_RESOURCES_MALI450_MP4(address, ++ irq_gp, irq_gpmmu, ++ irq_pp0, irq_ppmmu0, ++ irq_pp1, irq_ppmmu1, ++ irq_pp2, irq_ppmmu2, ++ irq_pp3, irq_ppmmu3, ++ irq_pp) ++ }; ++ struct resource *res; ++ ++ res = kzalloc(sizeof(target), GFP_KERNEL); ++ if (!res) ++ return NULL; ++ ++ memcpy(res, target, sizeof(target)); ++ ++ *len = ARRAY_SIZE(target); ++ ++ return res; ++} ++ ++static const struct of_device_id mali_dt_ids[] = { ++ { .compatible = "allwinner,sun4i-a10-mali" }, ++ { .compatible = "allwinner,sun7i-a20-mali" }, ++ { .compatible = "allwinner,sun8i-h3-mali" }, ++ { .compatible = "allwinner,sun50i-a64-mali" }, ++ { .compatible = "allwinner,sun50i-h5-mali" }, ++ { .compatible = "arm,mali-400" }, ++ { .compatible = "arm,mali-450" }, ++ { /* sentinel */ }, ++}; ++MODULE_DEVICE_TABLE(of, mali_dt_ids); ++ ++static struct mali_gpu_device_data mali_gpu_data = { ++ .max_job_runtime = 60000, ++}; ++int mali_platform_device_register(void) ++{ ++ int irq_gp, irq_gpmmu; ++ int irq_pp0, irq_ppmmu0; ++ int irq_pp1 = -EINVAL, irq_ppmmu1 = -EINVAL; ++ int irq_pp2 = -EINVAL, irq_ppmmu2 = -EINVAL; ++ int irq_pp3 = -EINVAL, irq_ppmmu3 = -EINVAL; ++ int irq_pp = -EINVAL; ++ int irq_pmu; ++ struct resource *mali_res = NULL, res; ++ struct device_node *np; ++ struct device *dev; ++ int ret, len; ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,0,0) ++ mali_gpu_data.shared_mem_size = totalram_pages() * PAGE_SIZE; ++#else ++ mali_gpu_data.shared_mem_size = totalram_pages * PAGE_SIZE; ++#endif ++ ++ np = of_find_matching_node(NULL, mali_dt_ids); ++ if (!np) { ++ pr_err("Couldn't find the mali node\n"); ++ return -ENODEV; ++ } ++ ++ mali = kzalloc(sizeof(*mali), GFP_KERNEL); ++ if (!mali) { ++ ret = -ENOMEM; ++ goto err_put_node; ++ } ++ ++ ret = of_clk_set_defaults(np, false); ++ if (ret) { ++ pr_err("Couldn't set clock defaults\n"); ++ goto err_free_mem; ++ } ++ ++ mali->bus_clk = of_clk_get_by_name(np, "bus"); ++ if (IS_ERR(mali->bus_clk)) { ++ pr_err("Couldn't retrieve our bus clock\n"); ++ ret = PTR_ERR(mali->bus_clk); ++ goto err_free_mem; ++ } ++ clk_prepare_enable(mali->bus_clk); ++ ++ mali->core_clk = of_clk_get_by_name(np, "core"); ++ if (IS_ERR(mali->core_clk)) { ++ pr_err("Couldn't retrieve our module clock\n"); ++ ret = PTR_ERR(mali->core_clk); ++ goto err_put_bus; ++ } ++ clk_prepare_enable(mali->core_clk); ++ ++ if (of_device_is_compatible(np, "allwinner,sun4i-a10-mali") || ++ of_device_is_compatible(np, "allwinner,sun7i-a20-mali") || ++ of_device_is_compatible(np, "allwinner,sun8i-h3-mali") || ++ of_device_is_compatible(np, "allwinner,sun50i-a64-mali") || ++ of_device_is_compatible(np, "allwinner,sun50i-h5-mali")) { ++ mali->reset = of_reset_control_get(np, NULL); ++ if (IS_ERR(mali->reset)) { ++ pr_err("Couldn't retrieve our reset handle\n"); ++ ret = PTR_ERR(mali->reset); ++ goto err_put_mod; ++ } ++ reset_control_deassert(mali->reset); ++ } ++ ++ ret = of_address_to_resource(np, 0, &res); ++ if (ret) { ++ pr_err("Couldn't retrieve our base address\n"); ++ goto err_put_reset; ++ } ++ ++ irq_gp = of_irq_get_byname(np, "gp"); ++ if (irq_gp < 0) { ++ pr_err("Couldn't retrieve our GP interrupt\n"); ++ ret = irq_gp; ++ goto err_put_reset; ++ } ++ ++ irq_gpmmu = of_irq_get_byname(np, "gpmmu"); ++ if (irq_gpmmu < 0) { ++ pr_err("Couldn't retrieve our GP MMU interrupt\n"); ++ ret = irq_gpmmu; ++ goto err_put_reset; ++ } ++ ++ irq_pp0 = of_irq_get_byname(np, "pp0"); ++ if (irq_pp0 < 0) { ++ pr_err("Couldn't retrieve our PP0 interrupt %d\n", irq_pp0); ++ ret = irq_pp0; ++ goto err_put_reset; ++ } ++ ++ irq_ppmmu0 = of_irq_get_byname(np, "ppmmu0"); ++ if (irq_ppmmu0 < 0) { ++ pr_err("Couldn't retrieve our PP0 MMU interrupt\n"); ++ ret = irq_ppmmu0; ++ goto err_put_reset; ++ } ++ ++ irq_pp1 = of_irq_get_byname(np, "pp1"); ++ irq_ppmmu1 = of_irq_get_byname(np, "ppmmu1"); ++ if ((irq_pp1 < 0) ^ (irq_ppmmu1 < 0 )) { ++ pr_err("Couldn't retrieve our PP1 interrupts\n"); ++ ret = (irq_pp1 < 0) ? irq_pp1 : irq_ppmmu1; ++ goto err_put_reset; ++ } ++ ++ if (of_device_is_compatible(np, "allwinner,sun50i-h5-mali")) { ++ irq_pp2 = of_irq_get_byname(np, "pp2"); ++ if (irq_pp2 < 0) { ++ pr_err("Couldn't retrieve our PP2 interrupt\n"); ++ ret = irq_pp2; ++ goto err_put_reset; ++ } ++ ++ irq_ppmmu2 = of_irq_get_byname(np, "ppmmu2"); ++ if (irq_ppmmu2 < 0) { ++ pr_err("Couldn't retrieve our PP2 interrupts\n"); ++ ret = irq_ppmmu2; ++ goto err_put_reset; ++ } ++ ++ irq_pp3 = of_irq_get_byname(np, "pp3"); ++ if (irq_pp3 < 0) { ++ pr_err("Couldn't retrieve our PP3 interrupt\n"); ++ ret = irq_pp3; ++ goto err_put_reset; ++ } ++ ++ irq_ppmmu3 = of_irq_get_byname(np, "ppmmu3"); ++ if (irq_ppmmu3 < 0) { ++ pr_err("Couldn't retrieve our PP3 interrupts\n"); ++ ret = irq_ppmmu3; ++ goto err_put_reset; ++ } ++ ++ irq_pp = of_irq_get_byname(np, "pp"); ++ if (irq_pp < 0) { ++ pr_err("Couldn't retrieve our PP broadcast interrupt\n"); ++ ret = irq_pp; ++ goto err_put_reset; ++ } ++ } else { ++ irq_pmu = of_irq_get_byname(np, "pmu"); ++ if (irq_pmu < 0) { ++ pr_err("Couldn't retrieve our PMU interrupt\n"); ++ ret = irq_pmu; ++ goto err_put_reset; ++ } ++ } ++ ++ mali->dev = platform_device_alloc("mali-utgard", 0); ++ if (!mali->dev) { ++ pr_err("Couldn't create platform device\n"); ++ ret = -EINVAL; ++ goto err_put_reset; ++ } ++ dev = &mali->dev->dev; ++ dev_set_name(dev, "mali-utgard"); ++ dev->of_node = np; ++ dev->coherent_dma_mask = DMA_BIT_MASK(32); ++ dev->dma_mask = &dev->coherent_dma_mask; ++ dev->bus = &platform_bus_type; ++ ++ ret = of_reserved_mem_device_init(&mali->dev->dev); ++ if (ret && ret != -ENODEV) { ++ pr_err("Couldn't claim our reserved memory region\n"); ++ goto err_free_mem_region; ++ } ++ ++ if (of_device_is_compatible(np, "allwinner,sun50i-h5-mali")) ++ mali_res = mali_create_450mp4_resources(res.start, ++ irq_gp, irq_gpmmu, ++ irq_pp0, irq_ppmmu0, ++ irq_pp1, irq_ppmmu1, ++ irq_pp2, irq_ppmmu2, ++ irq_pp3, irq_ppmmu3, ++ irq_pp, &len); ++ else if ((irq_pp1 >= 0) && (irq_ppmmu1 >= 0)) ++ mali_res = mali_create_mp2_resources(res.start, ++ irq_gp, irq_gpmmu, ++ irq_pp0, irq_ppmmu0, ++ irq_pp1, irq_ppmmu1, ++ &len); ++ else ++ mali_res = mali_create_mp1_resources(res.start, ++ irq_gp, irq_gpmmu, ++ irq_pp0, irq_ppmmu0, ++ &len); ++ ++ if (!mali_res) { ++ pr_err("Couldn't create target resources\n"); ++ ret = -EINVAL; ++ goto err_free_mem_region; ++ } ++ ++ clk_register_clkdev(mali->core_clk, "clk_mali", NULL); ++ ++ ret = platform_device_add_resources(mali->dev, mali_res, len); ++ kfree(mali_res); ++ if (ret) { ++ pr_err("Couldn't add our resources\n"); ++ goto err_free_mem_region; ++ } ++ ++ ret = platform_device_add_data(mali->dev, &mali_gpu_data, ++ sizeof(mali_gpu_data)); ++ if (ret) { ++ pr_err("Couldn't add our platform data\n"); ++ goto err_free_mem_region; ++ } ++ ++ ret = platform_device_add(mali->dev); ++ if (ret) { ++ pr_err("Couldn't add our device\n"); ++ goto err_free_mem_region; ++ } ++ ++#ifdef CONFIG_PM_RUNTIME ++#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37)) ++ pm_runtime_set_autosuspend_delay(&mali->dev->dev, 1000); ++ pm_runtime_use_autosuspend(&mali->dev->dev); ++#endif ++ pm_runtime_enable(&mali->dev->dev); ++#endif ++ ++ pr_info("Allwinner sunXi mali glue initialized\n"); ++ ++ return 0; ++ ++err_free_mem_region: ++ of_reserved_mem_device_release(dev); ++ platform_device_put(mali->dev); ++err_put_reset: ++ if (!IS_ERR_OR_NULL(mali->reset)) { ++ reset_control_assert(mali->reset); ++ reset_control_put(mali->reset); ++ } ++err_put_mod: ++ clk_disable_unprepare(mali->core_clk); ++ clk_put(mali->core_clk); ++err_put_bus: ++ clk_disable_unprepare(mali->bus_clk); ++ clk_put(mali->bus_clk); ++err_free_mem: ++ kfree(mali); ++err_put_node: ++ of_node_put(np); ++ return ret; ++} ++ ++int mali_platform_device_unregister(void) ++{ ++ struct device *dev = &mali->dev->dev; ++ ++#ifdef CONFIG_PM_RUNTIME ++ pm_runtime_disable(dev); ++#endif ++ ++ of_reserved_mem_device_release(dev); ++ ++ platform_device_del(mali->dev); ++ of_node_put(dev->of_node); ++ platform_device_put(mali->dev); ++ ++ if (!IS_ERR_OR_NULL(mali->reset)) { ++ reset_control_assert(mali->reset); ++ reset_control_put(mali->reset); ++ } ++ ++ clk_disable_unprepare(mali->core_clk); ++ clk_put(mali->core_clk); ++ ++ clk_disable_unprepare(mali->bus_clk); ++ clk_put(mali->bus_clk); ++ ++ kfree(mali); ++ ++ return 0; ++} diff --git a/packages/linux-drivers/gpu-sunxi/patches/fix-building-with-4.16.patch b/packages/linux-drivers/gpu-sunxi/patches/fix-building-with-4.16.patch new file mode 100644 index 0000000000..5b7dfc3b7d --- /dev/null +++ b/packages/linux-drivers/gpu-sunxi/patches/fix-building-with-4.16.patch @@ -0,0 +1,155 @@ +From 246fdac477cf109c354011c1ae0a7a8d928cb504 Mon Sep 17 00:00:00 2001 +From: Jonas Karlman +Date: Mon, 12 Mar 2018 23:02:55 +0100 +Subject: [PATCH] v4.16 build fix + +--- + .../driver/src/devicedrv/mali/common/mali_control_timer.c | 2 +- + src/devicedrv/mali/common/mali_group.c | 8 ++++--- + src/devicedrv/mali/common/mali_osk_types.h | 8 ++++++- + .../devicedrv/mali/linux/mali_memory_os_alloc.c | 6 +++++ + .../driver/src/devicedrv/mali/linux/mali_memory_secure.c | 4 ++++ + src/devicedrv/mali/linux/mali_osk_timers.c | 20 +++++++++++----- + 11 files changed, 84 insertions(+), 14 deletions(-) + +diff --git a/driver/src/devicedrv/mali/common/mali_control_timer.c b/driver/src/devicedrv/mali/common/mali_control_timer.c +index 1296ffe..bfe975f 100644 +--- a/driver/src/devicedrv/mali/common/mali_control_timer.c ++++ b/driver/src/devicedrv/mali/common/mali_control_timer.c +@@ -28,7 +28,7 @@ void mali_control_timer_add(u32 timeout) + _mali_osk_timer_add(mali_control_timer, _mali_osk_time_mstoticks(timeout)); + } + +-static void mali_control_timer_callback(void *arg) ++static void mali_control_timer_callback(struct timer_list *t) + { + if (mali_utilization_enabled()) { + struct mali_gpu_utilization_data *util_data = NULL; +diff --git a/driver/src/devicedrv/mali/common/mali_group.c b/driver/src/devicedrv/mali/common/mali_group.c +index e9005e1..4a43753 100644 +--- a/driver/src/devicedrv/mali/common/mali_group.c ++++ b/driver/src/devicedrv/mali/common/mali_group.c +@@ -44,7 +44,7 @@ int mali_max_job_runtime = MALI_MAX_JOB_RUNTIME_DEFAULT; + static void mali_group_bottom_half_mmu(void *data); + static void mali_group_bottom_half_gp(void *data); + static void mali_group_bottom_half_pp(void *data); +-static void mali_group_timeout(void *data); ++static void mali_group_timeout(struct timer_list *t); + static void mali_group_reset_pp(struct mali_group *group); + static void mali_group_reset_mmu(struct mali_group *group); + +@@ -1761,9 +1761,11 @@ static void mali_group_bottom_half_pp(void *data) + 0xFFFFFFFF, 0); + } + +-static void mali_group_timeout(void *data) ++static void mali_group_timeout(struct timer_list *t) + { +- struct mali_group *group = (struct mali_group *)data; ++ _mali_osk_timer_t *tim = container_of(t, _mali_osk_timer_t, timer); ++ struct mali_group *group = container_of(&tim, struct mali_group, timeout_timer); ++ + MALI_DEBUG_ASSERT_POINTER(group); + + MALI_DEBUG_PRINT(2, ("Group: timeout handler for %s at %u\n", +diff --git a/driver/src/devicedrv/mali/common/mali_osk_types.h b/driver/src/devicedrv/mali/common/mali_osk_types.h +index 03161cf..c9d0fec 100644 +--- a/driver/src/devicedrv/mali/common/mali_osk_types.h ++++ b/driver/src/devicedrv/mali/common/mali_osk_types.h +@@ -50,6 +50,7 @@ typedef unsigned long long u64; + #include + #endif + ++#include + /** @brief Mali Boolean type which uses MALI_TRUE and MALI_FALSE + */ + typedef unsigned long mali_bool; +@@ -395,7 +396,12 @@ typedef struct _mali_osk_notification_t_struct { + * by any callers of _mali_osk_timer_del(). Otherwise, a deadlock may occur. + * + * @param arg Function-specific data */ +-typedef void (*_mali_osk_timer_callback_t)(void *arg); ++typedef void (*_mali_osk_timer_callback_t)(struct timer_list *t); ++ ++ ++struct _mali_osk_timer_t_struct { ++ struct timer_list timer; ++}; + + /** @brief Private type for Timer Callback Objects */ + typedef struct _mali_osk_timer_t_struct _mali_osk_timer_t; +diff --git a/driver/src/devicedrv/mali/linux/mali_memory_os_alloc.c b/driver/src/devicedrv/mali/linux/mali_memory_os_alloc.c +index 5fe1270..92c245a 100644 +--- a/driver/src/devicedrv/mali/linux/mali_memory_os_alloc.c ++++ b/driver/src/devicedrv/mali/linux/mali_memory_os_alloc.c +@@ -202,7 +202,9 @@ int mali_mem_os_alloc_pages(mali_mem_os_mem *os_mem, u32 size) + /* Allocate new pages, if needed. */ + for (i = 0; i < remaining; i++) { + dma_addr_t dma_addr; ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 15, 0) ++ gfp_t flags = __GFP_ZERO | __GFP_RETRY_MAYFAIL | __GFP_NOWARN; ++#elif LINUX_VERSION_CODE >= KERNEL_VERSION(4, 13, 0) +-#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 14, 0) + gfp_t flags = __GFP_ZERO | __GFP_RETRY_MAYFAIL | __GFP_NOWARN | __GFP_COLD; + #else + gfp_t flags = __GFP_ZERO | __GFP_REPEAT | __GFP_NOWARN | __GFP_COLD; +diff --git a/driver/src/devicedrv/mali/linux/mali_memory_secure.c b/driver/src/devicedrv/mali/linux/mali_memory_secure.c +index 2836b1b..4f55fa5 100644 +--- a/driver/src/devicedrv/mali/linux/mali_memory_secure.c ++++ b/driver/src/devicedrv/mali/linux/mali_memory_secure.c +@@ -13,7 +13,11 @@ + #include "mali_memory_secure.h" + #include "mali_osk.h" + #include ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 16, 0) ++#include ++#else + #include ++#endif + #include + + _mali_osk_errcode_t mali_mem_secure_attach_dma_buf(mali_mem_secure *secure_mem, u32 size, int mem_fd) +diff --git a/driver/src/devicedrv/mali/linux/mali_osk_timers.c b/driver/src/devicedrv/mali/linux/mali_osk_timers.c +index e5d7238..701051a 100644 +--- a/driver/src/devicedrv/mali/linux/mali_osk_timers.c ++++ b/driver/src/devicedrv/mali/linux/mali_osk_timers.c +@@ -18,16 +18,25 @@ + #include "mali_osk.h" + #include "mali_kernel_common.h" + +-struct _mali_osk_timer_t_struct { +- struct timer_list timer; +-}; ++#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 14, 0) ++ ++#define TIMER_DATA_TYPE unsigned long ++#define TIMER_FUNC_TYPE void (*)(TIMER_DATA_TYPE) ++ ++static inline void timer_setup(struct timer_list *timer, ++ void (*callback)(struct timer_list *), ++ unsigned int flags) ++{ ++ __setup_timer(timer, (TIMER_FUNC_TYPE)callback, ++ (TIMER_DATA_TYPE)timer, flags); ++} ++#endif + + typedef void (*timer_timeout_function_t)(unsigned long); + + _mali_osk_timer_t *_mali_osk_timer_init(void) + { + _mali_osk_timer_t *t = (_mali_osk_timer_t *)kmalloc(sizeof(_mali_osk_timer_t), GFP_KERNEL); +- if (NULL != t) init_timer(&t->timer); + return t; + } + +@@ -65,8 +74,7 @@ mali_bool _mali_osk_timer_pending(_mali_osk_timer_t *tim) + void _mali_osk_timer_setcallback(_mali_osk_timer_t *tim, _mali_osk_timer_callback_t callback, void *data) + { + MALI_DEBUG_ASSERT_POINTER(tim); +- tim->timer.data = (unsigned long)data; +- tim->timer.function = (timer_timeout_function_t)callback; ++ timer_setup(&tim->timer, callback, 0); + } + + void _mali_osk_timer_term(_mali_osk_timer_t *tim) diff --git a/packages/linux-drivers/gpu-sunxi/patches/fix-building-with-4.20.patch b/packages/linux-drivers/gpu-sunxi/patches/fix-building-with-4.20.patch new file mode 100644 index 0000000000..63c333ff20 --- /dev/null +++ b/packages/linux-drivers/gpu-sunxi/patches/fix-building-with-4.20.patch @@ -0,0 +1,128 @@ +diff -Nur a/driver/src/devicedrv/mali/linux/mali_memory_block_alloc.c b/driver/src/devicedrv/mali/linux/mali_memory_block_alloc.c +--- a/driver/src/devicedrv/mali/linux/mali_memory_block_alloc.c 2018-09-13 08:52:20.000000000 +0200 ++++ b/driver/src/devicedrv/mali/linux/mali_memory_block_alloc.c 2018-12-08 12:22:51.978513336 +0100 +@@ -309,9 +309,9 @@ + + list_for_each_entry(m_page, &block_mem->pfns, list) { + MALI_DEBUG_ASSERT(m_page->type == MALI_PAGE_NODE_BLOCK); +- ret = vm_insert_pfn(vma, addr, _mali_page_node_get_pfn(m_page)); ++ ret = vmf_insert_pfn(vma, addr, _mali_page_node_get_pfn(m_page)); + +- if (unlikely(0 != ret)) { ++ if (unlikely(ret & VM_FAULT_ERROR)) { + return -EFAULT; + } + addr += _MALI_OSK_MALI_PAGE_SIZE; +diff -Nur a/driver/src/devicedrv/mali/linux/mali_memory_cow.c b/driver/src/devicedrv/mali/linux/mali_memory_cow.c +--- a/driver/src/devicedrv/mali/linux/mali_memory_cow.c 2018-09-13 08:52:20.000000000 +0200 ++++ b/driver/src/devicedrv/mali/linux/mali_memory_cow.c 2018-12-08 12:27:17.681815893 +0100 +@@ -532,10 +532,10 @@ + * flush which makes it way slower than remap_pfn_range or vm_insert_pfn. + ret = vm_insert_page(vma, addr, page); + */ +- ret = vm_insert_pfn(vma, addr, _mali_page_node_get_pfn(m_page)); ++ ret = vmf_insert_pfn(vma, addr, _mali_page_node_get_pfn(m_page)); + +- if (unlikely(0 != ret)) { +- return ret; ++ if (unlikely(ret & VM_FAULT_ERROR)) { ++ return -EFAULT; + } + addr += _MALI_OSK_MALI_PAGE_SIZE; + } +@@ -569,9 +569,9 @@ + + list_for_each_entry(m_page, &cow->pages, list) { + if ((count >= offset) && (count < offset + num)) { +- ret = vm_insert_pfn(vma, vaddr, _mali_page_node_get_pfn(m_page)); ++ ret = vmf_insert_pfn(vma, vaddr, _mali_page_node_get_pfn(m_page)); + +- if (unlikely(0 != ret)) { ++ if (unlikely(ret & VM_FAULT_ERROR)) { + if (count == offset) { + return _MALI_OSK_ERR_FAULT; + } else { +diff -Nur a/driver/src/devicedrv/mali/linux/mali_memory_os_alloc.c b/driver/src/devicedrv/mali/linux/mali_memory_os_alloc.c +--- a/driver/src/devicedrv/mali/linux/mali_memory_os_alloc.c 2018-12-08 12:15:38.000000000 +0100 ++++ b/driver/src/devicedrv/mali/linux/mali_memory_os_alloc.c 2018-12-08 12:30:37.730811640 +0100 +@@ -376,9 +376,9 @@ + ret = vm_insert_page(vma, addr, page); + */ + page = m_page->page; +- ret = vm_insert_pfn(vma, addr, page_to_pfn(page)); ++ ret = vmf_insert_pfn(vma, addr, page_to_pfn(page)); + +- if (unlikely(0 != ret)) { ++ if (unlikely(ret & VM_FAULT_ERROR)) { + return -EFAULT; + } + addr += _MALI_OSK_MALI_PAGE_SIZE; +@@ -414,16 +414,11 @@ + + vm_end -= _MALI_OSK_MALI_PAGE_SIZE; + if (mapping_page_num > 0) { +- ret = vm_insert_pfn(vma, vm_end, page_to_pfn(m_page->page)); ++ ret = vmf_insert_pfn(vma, vm_end, page_to_pfn(m_page->page)); + +- if (unlikely(0 != ret)) { +- /*will return -EBUSY If the page has already been mapped into table, but it's OK*/ +- if (-EBUSY == ret) { +- break; +- } else { +- MALI_DEBUG_PRINT(1, ("OS Mem: mali_mem_os_resize_cpu_map_locked failed, ret = %d, offset is %d,page_count is %d\n", +- ret, offset + mapping_page_num, os_mem->count)); +- } ++ if (unlikely(ret & VM_FAULT_ERROR)) { ++ MALI_DEBUG_PRINT(1, ("OS Mem: mali_mem_os_resize_cpu_map_locked failed, ret = %d, offset is %d,page_count is %d\n", ++ ret, offset + mapping_page_num, os_mem->count)); + return _MALI_OSK_ERR_FAULT; + } + } else { +@@ -437,16 +432,11 @@ + list_for_each_entry(m_page, &os_mem->pages, list) { + if (count >= offset) { + +- ret = vm_insert_pfn(vma, vstart, page_to_pfn(m_page->page)); ++ ret = vmf_insert_pfn(vma, vstart, page_to_pfn(m_page->page)); + +- if (unlikely(0 != ret)) { +- /*will return -EBUSY If the page has already been mapped into table, but it's OK*/ +- if (-EBUSY == ret) { +- break; +- } else { +- MALI_DEBUG_PRINT(1, ("OS Mem: mali_mem_os_resize_cpu_map_locked failed, ret = %d, count is %d, offset is %d,page_count is %d\n", +- ret, count, offset, os_mem->count)); +- } ++ if (unlikely(ret & VM_FAULT_ERROR)) { ++ MALI_DEBUG_PRINT(1, ("OS Mem: mali_mem_os_resize_cpu_map_locked failed, ret = %d, count is %d, offset is %d,page_count is %d\n", ++ ret, count, offset, os_mem->count)); + return _MALI_OSK_ERR_FAULT; + } + } +diff -Nur a/driver/src/devicedrv/mali/linux/mali_memory_secure.c b/driver/src/devicedrv/mali/linux/mali_memory_secure.c +--- a/driver/src/devicedrv/mali/linux/mali_memory_secure.c 2018-12-08 12:15:38.000000000 +0100 ++++ b/driver/src/devicedrv/mali/linux/mali_memory_secure.c 2018-12-08 12:31:05.461174554 +0100 +@@ -132,9 +132,9 @@ + MALI_DEBUG_ASSERT(0 == size % _MALI_OSK_MALI_PAGE_SIZE); + + for (j = 0; j < size / _MALI_OSK_MALI_PAGE_SIZE; j++) { +- ret = vm_insert_pfn(vma, addr, PFN_DOWN(phys)); ++ ret = vmf_insert_pfn(vma, addr, PFN_DOWN(phys)); + +- if (unlikely(0 != ret)) { ++ if (unlikely(ret & VM_FAULT_ERROR)) { + return -EFAULT; + } + addr += _MALI_OSK_MALI_PAGE_SIZE; +diff -Nur a/driver/src/devicedrv/mali/linux/mali_osk_time.c b/driver/src/devicedrv/mali/linux/mali_osk_time.c +--- a/driver/src/devicedrv/mali/linux/mali_osk_time.c 2018-09-13 08:52:20.000000000 +0200 ++++ b/driver/src/devicedrv/mali/linux/mali_osk_time.c 2018-12-08 12:32:12.632086846 +0100 +@@ -53,7 +53,5 @@ + + u64 _mali_osk_boot_time_get_ns(void) + { +- struct timespec tsval; +- get_monotonic_boottime(&tsval); +- return (u64)timespec_to_ns(&tsval); ++ return (u64)ktime_to_ns(ktime_get_boottime()); + } diff --git a/packages/linux-drivers/gpu-sunxi/patches/fix-building-with-5.0.patch b/packages/linux-drivers/gpu-sunxi/patches/fix-building-with-5.0.patch new file mode 100644 index 0000000000..8bf06e7309 --- /dev/null +++ b/packages/linux-drivers/gpu-sunxi/patches/fix-building-with-5.0.patch @@ -0,0 +1,35 @@ +diff -Nur a/driver/src/devicedrv/mali/linux/mali_ukk_mem.c b/driver/src/devicedrv/mali/linux/mali_ukk_mem.c +--- a/driver/src/devicedrv/mali/linux/mali_ukk_mem.c 2018-09-13 08:52:20.000000000 +0200 ++++ b/driver/src/devicedrv/mali/linux/mali_ukk_mem.c 2019-02-09 20:10:06.867561465 +0100 +@@ -207,10 +207,17 @@ + kargs.ctx = (uintptr_t)session_data; + + /* Check if we can access the buffers */ ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,0,0) ++ if (!access_ok(kargs.dest, kargs.size) ++ || !access_ok(kargs.src, kargs.size)) { ++ return -EINVAL; ++ } ++#else + if (!access_ok(VERIFY_WRITE, kargs.dest, kargs.size) + || !access_ok(VERIFY_READ, kargs.src, kargs.size)) { + return -EINVAL; + } ++#endif + + /* Check if size wraps */ + if ((kargs.size + kargs.dest) <= kargs.dest +@@ -266,8 +273,13 @@ + goto err_exit; + + user_buffer = (void __user *)(uintptr_t)kargs.buffer; ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,0,0) ++ if (!access_ok(user_buffer, kargs.size)) ++ goto err_exit; ++#else + if (!access_ok(VERIFY_WRITE, user_buffer, kargs.size)) + goto err_exit; ++#endif + + /* allocate temporary buffer (kernel side) to store mmu page table info */ + if (kargs.size <= 0)