shinys000114/linux
1
0
Fork 0
mirror of https://github.com/hardkernel/linux.git synced 2026-06-06 02:50:49 +09:00
Code Issues Packages Projects Releases Wiki Activity

video: rockchip: rga3: adapt to kernel-6.12

Browse Source 
Change-Id: I2770caf4f4363cce36cae4f8cfbb0be9d322e82b
Signed-off-by: Yu Qiaowei <cerf.yu@rock-chips.com>
This commit is contained in:
Yu Qiaowei
2025-05-29 18:02:33 +08:00
committed by Tao Huang
parent 3515a9f56b
commit 8597ef189a
6 changed files with 47 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/video/rockchip/rga3/include/rga_common.h
View File

@@ -83,4 +83,6 @@ void rga_dump_memory_parm(struct rga_memory_parm *parm);
void rga_dump_external_buffer(struct rga_external_buffer *buffer);
void rga_dump_req(struct rga_request *request, struct rga_req *req);
unsigned long rga_get_free_pages(gfp_t gfp_mask, unsigned int *order, unsigned long size);
#endif

24
drivers/video/rockchip/rga3/rga_common.c
View File

@@ -925,3 +925,27 @@ void rga_dump_req(struct rga_request *request, struct rga_req *req)
rga_req_log(request, "core_mask = %#x, priority = %d, in_fence = %d(%#x)\n",
req->core, req->priority, req->in_fence_fd, req->in_fence_fd);
}
unsigned long rga_get_free_pages(gfp_t gfp_mask, unsigned int *order, unsigned long size)
{
int cur_order, max_order;
unsigned long pages;
#if LINUX_VERSION_CODE < KERNEL_VERSION(6, 8, 0)
max_order = MAX_ORDER;
#else
max_order = MAX_PAGE_ORDER;
#endif
cur_order = get_order(size);
if (cur_order > max_order) {
rga_err("Can not alloc pages with order[%d] for viraddr pages, max_order = %d\n",
cur_order, max_order);
return 0;
}
pages = __get_free_pages(gfp_mask, cur_order);
*order = cur_order;
return pages;
}

1
drivers/video/rockchip/rga3/rga_debugger.c
View File

@@ -14,6 +14,7 @@
#include <linux/debugfs.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/vmalloc.h>
#include "rga.h"
#include "rga_debugger.h"

6
drivers/video/rockchip/rga3/rga_drv.c
View File

@@ -1497,7 +1497,11 @@ pm_disable:
return ret;
}
#if LINUX_VERSION_CODE < KERNEL_VERSION(6, 11, 0)
static int rga_drv_remove(struct platform_device *pdev)
#else
static void rga_drv_remove(struct platform_device *pdev)
#endif
{
struct rga_scheduler_t *scheduler = NULL;
@@ -1515,7 +1519,9 @@ static int rga_drv_remove(struct platform_device *pdev)
up_write(&rga_drvdata->rwsem);
#if LINUX_VERSION_CODE < KERNEL_VERSION(6, 11, 0)
return 0;
#endif
}
static void rga_drv_shutdown(struct platform_device *pdev)

20
drivers/video/rockchip/rga3/rga_iommu.c
View File

@@ -167,28 +167,16 @@ struct rga_mmu_base *rga_mmu_base_init(size_t size)
* malloc pre scale mid buf mmu table:
* size * channel_num * address_size
*/
order = get_order(size * 3 * sizeof(*mmu_base->buf_virtual));
if (order >= MAX_ORDER) {
pr_err("Can not alloc pages with order[%d] for mmu_page_table, max_order = %d\n",
order, MAX_ORDER);
goto err_free_mmu_base;
}
mmu_base->buf_virtual = (uint32_t *) __get_free_pages(GFP_KERNEL | GFP_DMA32, order);
mmu_base->buf_virtual = (uint32_t *)rga_get_free_pages(GFP_KERNEL | GFP_DMA32,
&order, size * 3 * sizeof(*mmu_base->buf_virtual));
if (mmu_base->buf_virtual == NULL) {
pr_err("Can not alloc pages for mmu_page_table\n");
goto err_free_mmu_base;
}
mmu_base->buf_order = order;
order = get_order(size * sizeof(*mmu_base->pages));
if (order >= MAX_ORDER) {
pr_err("Can not alloc pages with order[%d] for mmu_base->pages, max_order = %d\n",
order, MAX_ORDER);
goto err_free_buf_virtual;
}
mmu_base->pages = (struct page **)__get_free_pages(GFP_KERNEL | GFP_DMA32, order);
mmu_base->pages = (struct page **)rga_get_free_pages(GFP_KERNEL | GFP_DMA32,
&order, size * sizeof(*mmu_base->pages));
if (mmu_base->pages == NULL) {
pr_err("Can not alloc pages for mmu_base->pages\n");
goto err_free_buf_virtual;

35
drivers/video/rockchip/rga3/rga_mm.c
View File

@@ -133,9 +133,12 @@ static int rga_get_user_pages(struct page **pages, unsigned long Memory,
result = get_user_pages_remote(current, current_mm,
Memory << PAGE_SHIFT,
pageCount, writeFlag ? FOLL_WRITE : 0, pages, NULL, NULL);
#else
#elif LINUX_VERSION_CODE < KERNEL_VERSION(6, 5, 0)
result = get_user_pages_remote(current_mm, Memory << PAGE_SHIFT,
pageCount, writeFlag ? FOLL_WRITE : 0, pages, NULL, NULL);
#else
result = get_user_pages_remote(current_mm, Memory << PAGE_SHIFT,
pageCount, writeFlag ? FOLL_WRITE : 0, pages, NULL);
#endif
if (result > 0 && result >= pageCount) {
@@ -252,14 +255,8 @@ static int rga_alloc_virt_addr(struct rga_virt_addr **virt_addr_p,
}
/* alloc pages and page_table */
order = get_order(count * sizeof(struct page *));
if (order >= MAX_ORDER) {
rga_err("Can not alloc pages with order[%d] for viraddr pages, max_order = %d\n",
order, MAX_ORDER);
return -ENOMEM;
}
pages = (struct page **)__get_free_pages(GFP_KERNEL, order);
pages = (struct page **)rga_get_free_pages(GFP_KERNEL,
&order, count * sizeof(struct page *));
if (pages == NULL) {
rga_err("%s can not alloc pages for viraddr pages\n", __func__);
return -ENOMEM;
@@ -1196,14 +1193,8 @@ static int rga_mm_set_mmu_base(struct rga_job *job,
}
if (job->flags & RGA_JOB_USE_HANDLE) {
order = get_order(page_count * sizeof(uint32_t *));
if (order >= MAX_ORDER) {
rga_job_err(job, "Can not alloc pages with order[%d] for page_table, max_order = %d\n",
order, MAX_ORDER);
return -ENOMEM;
}
page_table = (uint32_t *)__get_free_pages(GFP_KERNEL | GFP_DMA32, order);
page_table = (uint32_t *)rga_get_free_pages(GFP_KERNEL | GFP_DMA32,
&order, page_count * sizeof(uint32_t *));
if (page_table == NULL) {
rga_job_err(job, "%s can not alloc pages for page_table, order = %d\n",
__func__, order);
@@ -1261,14 +1252,8 @@ static int rga_mm_set_mmu_base(struct rga_job *job,
}
if (job->flags & RGA_JOB_USE_HANDLE) {
order = get_order(page_count * sizeof(uint32_t *));
if (order >= MAX_ORDER) {
rga_job_err(job, "Can not alloc pages with order[%d] for page_table, max_order = %d\n",
order, MAX_ORDER);
return -ENOMEM;
}
page_table = (uint32_t *)__get_free_pages(GFP_KERNEL | GFP_DMA32, order);
page_table = (uint32_t *)rga_get_free_pages(GFP_KERNEL | GFP_DMA32,
&order, page_count * sizeof(uint32_t *));
if (page_table == NULL) {
rga_job_err(job, "%s can not alloc pages for page_table, order = %d\n",
__func__, order);