![Qiang Yu](/assets/img/avatar_default.png)
- Mali 4xx GPUs have two kinds of processors GP and PP. GP is for OpenGL vertex shader processing and PP is for fragment shader processing. Each processor has its own MMU so prcessors work in virtual address space. - There's only one GP but multiple PP (max 4 for mali 400 and 8 for mali 450) in the same mali 4xx GPU. All PPs are grouped togather to handle a single fragment shader task divided by FB output tiled pixels. Mali 400 user space driver is responsible for assign target tiled pixels to each PP, but mali 450 has a HW module called DLBU to dynamically balance each PP's load. - User space driver allocate buffer object and map into GPU virtual address space, upload command stream and draw data with CPU mmap of the buffer object, then submit task to GP/PP with a register frame indicating where is the command stream and misc settings. - There's no command stream validation/relocation due to each user process has its own GPU virtual address space. GP/PP's MMU switch virtual address space before running two tasks from different user process. Error or evil user space code just get MMU fault or GP/PP error IRQ, then the HW/SW will be recovered. - Use GEM+shmem for MM. Currently just alloc and pin memory when gem object creation. GPU vm map of the buffer is also done in the alloc stage in kernel space. We may delay the memory allocation and real GPU vm map to command submission stage in the furture as improvement. - Use drm_sched for GPU task schedule. Each OpenGL context should have a lima context object in the kernel to distinguish tasks from different user. drm_sched gets task from each lima context in a fair way. mesa driver can be found here before upstreamed: https://gitlab.freedesktop.org/lima/mesa v8: - add comments for in_sync - fix ctx free miss mutex unlock v7: - remove lima_fence_ops with default value - move fence slab create to device probe - check pad ioctl args to be zero - add comments for user/kernel interface v6: - fix comments by checkpatch.pl v5: - export gp/pp version to userspace - rebase on drm-misc-next v4: - use get param interface to get info - separate context create/free ioctl - remove unused max sched task param - update copyright time - use xarray instead of idr - stop using drmP.h v3: - fix comments from kbuild robot - restrict supported arch to tested ones v2: - fix syscall argument check - fix job finish fence leak since kernel 5.0 - use drm syncobj to replace native fence - move buffer object GPU va map into kernel - reserve syscall argument space for future info - remove kernel gem modifier - switch TTM back to GEM+shmem MM - use time based io poll - use whole register name - adopt gem reservation obj integration - use drm_timeout_abs_to_jiffies Cc: Eric Anholt <eric@anholt.net> Cc: Rob Herring <robh@kernel.org> Cc: Christian König <ckoenig.leichtzumerken@gmail.com> Cc: Daniel Vetter <daniel@ffwll.ch> Cc: Alex Deucher <alexdeucher@gmail.com> Cc: Sam Ravnborg <sam@ravnborg.org> Cc: Rob Clark <robdclark@gmail.com> Cc: Dave Airlie <airlied@gmail.com> Signed-off-by: Andreas Baierl <ichgeh@imkreisrum.de> Signed-off-by: Erico Nunes <nunes.erico@gmail.com> Signed-off-by: Heiko Stuebner <heiko@sntech.de> Signed-off-by: Marek Vasut <marex@denx.de> Signed-off-by: Neil Armstrong <narmstrong@baylibre.com> Signed-off-by: Simon Shields <simon@lineageos.org> Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com> Signed-off-by: Qiang Yu <yuq825@gmail.com> Reviewed-by: Eric Anholt <eric@anholt.net> Reviewed-by: Rob Herring <robh@kerrnel.org> Signed-off-by: Eric Anholt <eric@anholt.net> Link: https://patchwork.freedesktop.org/patch/291200/
377 lines
9.1 KiB
C
377 lines
9.1 KiB
C
// SPDX-License-Identifier: GPL-2.0 OR MIT
|
|
/* Copyright 2017-2019 Qiang Yu <yuq825@gmail.com> */
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/of_platform.h>
|
|
#include <linux/uaccess.h>
|
|
#include <linux/slab.h>
|
|
#include <drm/drm_ioctl.h>
|
|
#include <drm/drm_drv.h>
|
|
#include <drm/drm_prime.h>
|
|
#include <drm/lima_drm.h>
|
|
|
|
#include "lima_drv.h"
|
|
#include "lima_gem.h"
|
|
#include "lima_gem_prime.h"
|
|
#include "lima_vm.h"
|
|
|
|
int lima_sched_timeout_ms;
|
|
|
|
MODULE_PARM_DESC(sched_timeout_ms, "task run timeout in ms (0 = no timeout (default))");
|
|
module_param_named(sched_timeout_ms, lima_sched_timeout_ms, int, 0444);
|
|
|
|
static int lima_ioctl_get_param(struct drm_device *dev, void *data, struct drm_file *file)
|
|
{
|
|
struct drm_lima_get_param *args = data;
|
|
struct lima_device *ldev = to_lima_dev(dev);
|
|
|
|
if (args->pad)
|
|
return -EINVAL;
|
|
|
|
switch (args->param) {
|
|
case DRM_LIMA_PARAM_GPU_ID:
|
|
switch (ldev->id) {
|
|
case lima_gpu_mali400:
|
|
args->value = DRM_LIMA_PARAM_GPU_ID_MALI400;
|
|
break;
|
|
case lima_gpu_mali450:
|
|
args->value = DRM_LIMA_PARAM_GPU_ID_MALI450;
|
|
break;
|
|
default:
|
|
args->value = DRM_LIMA_PARAM_GPU_ID_UNKNOWN;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case DRM_LIMA_PARAM_NUM_PP:
|
|
args->value = ldev->pipe[lima_pipe_pp].num_processor;
|
|
break;
|
|
|
|
case DRM_LIMA_PARAM_GP_VERSION:
|
|
args->value = ldev->gp_version;
|
|
break;
|
|
|
|
case DRM_LIMA_PARAM_PP_VERSION:
|
|
args->value = ldev->pp_version;
|
|
break;
|
|
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int lima_ioctl_gem_create(struct drm_device *dev, void *data, struct drm_file *file)
|
|
{
|
|
struct drm_lima_gem_create *args = data;
|
|
|
|
if (args->pad)
|
|
return -EINVAL;
|
|
|
|
if (args->flags)
|
|
return -EINVAL;
|
|
|
|
if (args->size == 0)
|
|
return -EINVAL;
|
|
|
|
return lima_gem_create_handle(dev, file, args->size, args->flags, &args->handle);
|
|
}
|
|
|
|
static int lima_ioctl_gem_info(struct drm_device *dev, void *data, struct drm_file *file)
|
|
{
|
|
struct drm_lima_gem_info *args = data;
|
|
|
|
return lima_gem_get_info(file, args->handle, &args->va, &args->offset);
|
|
}
|
|
|
|
static int lima_ioctl_gem_submit(struct drm_device *dev, void *data, struct drm_file *file)
|
|
{
|
|
struct drm_lima_gem_submit *args = data;
|
|
struct lima_device *ldev = to_lima_dev(dev);
|
|
struct lima_drm_priv *priv = file->driver_priv;
|
|
struct drm_lima_gem_submit_bo *bos;
|
|
struct lima_sched_pipe *pipe;
|
|
struct lima_sched_task *task;
|
|
struct lima_ctx *ctx;
|
|
struct lima_submit submit = {0};
|
|
size_t size;
|
|
int err = 0;
|
|
|
|
if (args->pipe >= lima_pipe_num || args->nr_bos == 0)
|
|
return -EINVAL;
|
|
|
|
if (args->flags & ~(LIMA_SUBMIT_FLAG_EXPLICIT_FENCE))
|
|
return -EINVAL;
|
|
|
|
pipe = ldev->pipe + args->pipe;
|
|
if (args->frame_size != pipe->frame_size)
|
|
return -EINVAL;
|
|
|
|
bos = kvcalloc(args->nr_bos, sizeof(*submit.bos) + sizeof(*submit.lbos), GFP_KERNEL);
|
|
if (!bos)
|
|
return -ENOMEM;
|
|
|
|
size = args->nr_bos * sizeof(*submit.bos);
|
|
if (copy_from_user(bos, u64_to_user_ptr(args->bos), size)) {
|
|
err = -EFAULT;
|
|
goto out0;
|
|
}
|
|
|
|
task = kmem_cache_zalloc(pipe->task_slab, GFP_KERNEL);
|
|
if (!task) {
|
|
err = -ENOMEM;
|
|
goto out0;
|
|
}
|
|
|
|
task->frame = task + 1;
|
|
if (copy_from_user(task->frame, u64_to_user_ptr(args->frame), args->frame_size)) {
|
|
err = -EFAULT;
|
|
goto out1;
|
|
}
|
|
|
|
err = pipe->task_validate(pipe, task);
|
|
if (err)
|
|
goto out1;
|
|
|
|
ctx = lima_ctx_get(&priv->ctx_mgr, args->ctx);
|
|
if (!ctx) {
|
|
err = -ENOENT;
|
|
goto out1;
|
|
}
|
|
|
|
submit.pipe = args->pipe;
|
|
submit.bos = bos;
|
|
submit.lbos = (void *)bos + size;
|
|
submit.nr_bos = args->nr_bos;
|
|
submit.task = task;
|
|
submit.ctx = ctx;
|
|
submit.flags = args->flags;
|
|
submit.in_sync[0] = args->in_sync[0];
|
|
submit.in_sync[1] = args->in_sync[1];
|
|
submit.out_sync = args->out_sync;
|
|
|
|
err = lima_gem_submit(file, &submit);
|
|
|
|
lima_ctx_put(ctx);
|
|
out1:
|
|
if (err)
|
|
kmem_cache_free(pipe->task_slab, task);
|
|
out0:
|
|
kvfree(bos);
|
|
return err;
|
|
}
|
|
|
|
static int lima_ioctl_gem_wait(struct drm_device *dev, void *data, struct drm_file *file)
|
|
{
|
|
struct drm_lima_gem_wait *args = data;
|
|
|
|
if (args->op & ~(LIMA_GEM_WAIT_READ|LIMA_GEM_WAIT_WRITE))
|
|
return -EINVAL;
|
|
|
|
return lima_gem_wait(file, args->handle, args->op, args->timeout_ns);
|
|
}
|
|
|
|
static int lima_ioctl_ctx_create(struct drm_device *dev, void *data, struct drm_file *file)
|
|
{
|
|
struct drm_lima_ctx_create *args = data;
|
|
struct lima_drm_priv *priv = file->driver_priv;
|
|
struct lima_device *ldev = to_lima_dev(dev);
|
|
|
|
if (args->_pad)
|
|
return -EINVAL;
|
|
|
|
return lima_ctx_create(ldev, &priv->ctx_mgr, &args->id);
|
|
}
|
|
|
|
static int lima_ioctl_ctx_free(struct drm_device *dev, void *data, struct drm_file *file)
|
|
{
|
|
struct drm_lima_ctx_create *args = data;
|
|
struct lima_drm_priv *priv = file->driver_priv;
|
|
|
|
if (args->_pad)
|
|
return -EINVAL;
|
|
|
|
return lima_ctx_free(&priv->ctx_mgr, args->id);
|
|
}
|
|
|
|
static int lima_drm_driver_open(struct drm_device *dev, struct drm_file *file)
|
|
{
|
|
int err;
|
|
struct lima_drm_priv *priv;
|
|
struct lima_device *ldev = to_lima_dev(dev);
|
|
|
|
priv = kzalloc(sizeof(*priv), GFP_KERNEL);
|
|
if (!priv)
|
|
return -ENOMEM;
|
|
|
|
priv->vm = lima_vm_create(ldev);
|
|
if (!priv->vm) {
|
|
err = -ENOMEM;
|
|
goto err_out0;
|
|
}
|
|
|
|
lima_ctx_mgr_init(&priv->ctx_mgr);
|
|
|
|
file->driver_priv = priv;
|
|
return 0;
|
|
|
|
err_out0:
|
|
kfree(priv);
|
|
return err;
|
|
}
|
|
|
|
static void lima_drm_driver_postclose(struct drm_device *dev, struct drm_file *file)
|
|
{
|
|
struct lima_drm_priv *priv = file->driver_priv;
|
|
|
|
lima_ctx_mgr_fini(&priv->ctx_mgr);
|
|
lima_vm_put(priv->vm);
|
|
kfree(priv);
|
|
}
|
|
|
|
static const struct drm_ioctl_desc lima_drm_driver_ioctls[] = {
|
|
DRM_IOCTL_DEF_DRV(LIMA_GET_PARAM, lima_ioctl_get_param, DRM_AUTH|DRM_RENDER_ALLOW),
|
|
DRM_IOCTL_DEF_DRV(LIMA_GEM_CREATE, lima_ioctl_gem_create, DRM_AUTH|DRM_RENDER_ALLOW),
|
|
DRM_IOCTL_DEF_DRV(LIMA_GEM_INFO, lima_ioctl_gem_info, DRM_AUTH|DRM_RENDER_ALLOW),
|
|
DRM_IOCTL_DEF_DRV(LIMA_GEM_SUBMIT, lima_ioctl_gem_submit, DRM_AUTH|DRM_RENDER_ALLOW),
|
|
DRM_IOCTL_DEF_DRV(LIMA_GEM_WAIT, lima_ioctl_gem_wait, DRM_AUTH|DRM_RENDER_ALLOW),
|
|
DRM_IOCTL_DEF_DRV(LIMA_CTX_CREATE, lima_ioctl_ctx_create, DRM_AUTH|DRM_RENDER_ALLOW),
|
|
DRM_IOCTL_DEF_DRV(LIMA_CTX_FREE, lima_ioctl_ctx_free, DRM_AUTH|DRM_RENDER_ALLOW),
|
|
};
|
|
|
|
static const struct file_operations lima_drm_driver_fops = {
|
|
.owner = THIS_MODULE,
|
|
.open = drm_open,
|
|
.release = drm_release,
|
|
.unlocked_ioctl = drm_ioctl,
|
|
#ifdef CONFIG_COMPAT
|
|
.compat_ioctl = drm_compat_ioctl,
|
|
#endif
|
|
.mmap = lima_gem_mmap,
|
|
};
|
|
|
|
static struct drm_driver lima_drm_driver = {
|
|
.driver_features = DRIVER_RENDER | DRIVER_GEM | DRIVER_PRIME | DRIVER_SYNCOBJ,
|
|
.open = lima_drm_driver_open,
|
|
.postclose = lima_drm_driver_postclose,
|
|
.ioctls = lima_drm_driver_ioctls,
|
|
.num_ioctls = ARRAY_SIZE(lima_drm_driver_ioctls),
|
|
.fops = &lima_drm_driver_fops,
|
|
.gem_free_object_unlocked = lima_gem_free_object,
|
|
.gem_open_object = lima_gem_object_open,
|
|
.gem_close_object = lima_gem_object_close,
|
|
.gem_vm_ops = &lima_gem_vm_ops,
|
|
.name = "lima",
|
|
.desc = "lima DRM",
|
|
.date = "20190217",
|
|
.major = 1,
|
|
.minor = 0,
|
|
.patchlevel = 0,
|
|
|
|
.prime_fd_to_handle = drm_gem_prime_fd_to_handle,
|
|
.gem_prime_import_sg_table = lima_gem_prime_import_sg_table,
|
|
.prime_handle_to_fd = drm_gem_prime_handle_to_fd,
|
|
.gem_prime_get_sg_table = lima_gem_prime_get_sg_table,
|
|
.gem_prime_mmap = lima_gem_prime_mmap,
|
|
};
|
|
|
|
static int lima_pdev_probe(struct platform_device *pdev)
|
|
{
|
|
struct lima_device *ldev;
|
|
struct drm_device *ddev;
|
|
int err;
|
|
|
|
err = lima_sched_slab_init();
|
|
if (err)
|
|
return err;
|
|
|
|
ldev = devm_kzalloc(&pdev->dev, sizeof(*ldev), GFP_KERNEL);
|
|
if (!ldev) {
|
|
err = -ENOMEM;
|
|
goto err_out0;
|
|
}
|
|
|
|
ldev->pdev = pdev;
|
|
ldev->dev = &pdev->dev;
|
|
ldev->id = (enum lima_gpu_id)of_device_get_match_data(&pdev->dev);
|
|
|
|
platform_set_drvdata(pdev, ldev);
|
|
|
|
/* Allocate and initialize the DRM device. */
|
|
ddev = drm_dev_alloc(&lima_drm_driver, &pdev->dev);
|
|
if (IS_ERR(ddev))
|
|
return PTR_ERR(ddev);
|
|
|
|
ddev->dev_private = ldev;
|
|
ldev->ddev = ddev;
|
|
|
|
err = lima_device_init(ldev);
|
|
if (err) {
|
|
dev_err(&pdev->dev, "Fatal error during GPU init\n");
|
|
goto err_out1;
|
|
}
|
|
|
|
/*
|
|
* Register the DRM device with the core and the connectors with
|
|
* sysfs.
|
|
*/
|
|
err = drm_dev_register(ddev, 0);
|
|
if (err < 0)
|
|
goto err_out2;
|
|
|
|
return 0;
|
|
|
|
err_out2:
|
|
lima_device_fini(ldev);
|
|
err_out1:
|
|
drm_dev_put(ddev);
|
|
err_out0:
|
|
lima_sched_slab_fini();
|
|
return err;
|
|
}
|
|
|
|
static int lima_pdev_remove(struct platform_device *pdev)
|
|
{
|
|
struct lima_device *ldev = platform_get_drvdata(pdev);
|
|
struct drm_device *ddev = ldev->ddev;
|
|
|
|
drm_dev_unregister(ddev);
|
|
lima_device_fini(ldev);
|
|
drm_dev_put(ddev);
|
|
lima_sched_slab_fini();
|
|
return 0;
|
|
}
|
|
|
|
static const struct of_device_id dt_match[] = {
|
|
{ .compatible = "arm,mali-400", .data = (void *)lima_gpu_mali400 },
|
|
{ .compatible = "arm,mali-450", .data = (void *)lima_gpu_mali450 },
|
|
{}
|
|
};
|
|
MODULE_DEVICE_TABLE(of, dt_match);
|
|
|
|
static struct platform_driver lima_platform_driver = {
|
|
.probe = lima_pdev_probe,
|
|
.remove = lima_pdev_remove,
|
|
.driver = {
|
|
.name = "lima",
|
|
.of_match_table = dt_match,
|
|
},
|
|
};
|
|
|
|
static int __init lima_init(void)
|
|
{
|
|
return platform_driver_register(&lima_platform_driver);
|
|
}
|
|
module_init(lima_init);
|
|
|
|
static void __exit lima_exit(void)
|
|
{
|
|
platform_driver_unregister(&lima_platform_driver);
|
|
}
|
|
module_exit(lima_exit);
|
|
|
|
MODULE_AUTHOR("Lima Project Developers");
|
|
MODULE_DESCRIPTION("Lima DRM Driver");
|
|
MODULE_LICENSE("GPL v2");
|