1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright 2018 Marty E. Plummer <hanetzer@startmail.com> */
3 /* Copyright 2019 Linaro, Ltd., Rob Herring <robh@kernel.org> */
4 /* Copyright 2019 Collabora ltd. */
6 #include <linux/module.h>
7 #include <linux/of_platform.h>
8 #include <linux/pagemap.h>
9 #include <linux/pm_runtime.h>
10 #include <drm/panfrost_drm.h>
11 #include <drm/drm_drv.h>
12 #include <drm/drm_ioctl.h>
13 #include <drm/drm_syncobj.h>
14 #include <drm/drm_utils.h>
16 #include "panfrost_device.h"
17 #include "panfrost_devfreq.h"
18 #include "panfrost_gem.h"
19 #include "panfrost_mmu.h"
20 #include "panfrost_job.h"
21 #include "panfrost_gpu.h"
22 #include "panfrost_perfcnt.h"
24 static bool unstable_ioctls;
25 module_param_unsafe(unstable_ioctls, bool, 0600);
27 static int panfrost_ioctl_get_param(struct drm_device *ddev, void *data, struct drm_file *file)
29 struct drm_panfrost_get_param *param = data;
30 struct panfrost_device *pfdev = ddev->dev_private;
35 switch (param->param) {
36 case DRM_PANFROST_PARAM_GPU_PROD_ID:
37 param->value = pfdev->features.id;
46 static int panfrost_ioctl_create_bo(struct drm_device *dev, void *data,
47 struct drm_file *file)
50 struct drm_gem_shmem_object *shmem;
51 struct drm_panfrost_create_bo *args = data;
53 if (!args->size || args->flags || args->pad)
56 shmem = drm_gem_shmem_create_with_handle(file, dev, args->size,
59 return PTR_ERR(shmem);
61 ret = panfrost_mmu_map(to_panfrost_bo(&shmem->base));
65 args->offset = to_panfrost_bo(&shmem->base)->node.start << PAGE_SHIFT;
70 drm_gem_handle_delete(file, args->handle);
75 * panfrost_lookup_bos() - Sets up job->bo[] with the GEM objects
76 * referenced by the job.
78 * @file_priv: DRM file for this fd
80 * @job: job being set up
82 * Resolve handles from userspace to BOs and attach them to job.
84 * Note that this function doesn't need to unreference the BOs on
85 * failure, because that will happen at panfrost_job_cleanup() time.
88 panfrost_lookup_bos(struct drm_device *dev,
89 struct drm_file *file_priv,
90 struct drm_panfrost_submit *args,
91 struct panfrost_job *job)
93 job->bo_count = args->bo_handle_count;
98 job->implicit_fences = kvmalloc_array(job->bo_count,
99 sizeof(struct dma_fence *),
100 GFP_KERNEL | __GFP_ZERO);
101 if (!job->implicit_fences)
104 return drm_gem_objects_lookup(file_priv,
105 (void __user *)(uintptr_t)args->bo_handles,
106 job->bo_count, &job->bos);
110 * panfrost_copy_in_sync() - Sets up job->in_fences[] with the sync objects
111 * referenced by the job.
113 * @file_priv: DRM file for this fd
115 * @job: job being set up
117 * Resolve syncobjs from userspace to fences and attach them to job.
119 * Note that this function doesn't need to unreference the fences on
120 * failure, because that will happen at panfrost_job_cleanup() time.
123 panfrost_copy_in_sync(struct drm_device *dev,
124 struct drm_file *file_priv,
125 struct drm_panfrost_submit *args,
126 struct panfrost_job *job)
132 job->in_fence_count = args->in_sync_count;
134 if (!job->in_fence_count)
137 job->in_fences = kvmalloc_array(job->in_fence_count,
138 sizeof(struct dma_fence *),
139 GFP_KERNEL | __GFP_ZERO);
140 if (!job->in_fences) {
141 DRM_DEBUG("Failed to allocate job in fences\n");
145 handles = kvmalloc_array(job->in_fence_count, sizeof(u32), GFP_KERNEL);
148 DRM_DEBUG("Failed to allocate incoming syncobj handles\n");
152 if (copy_from_user(handles,
153 (void __user *)(uintptr_t)args->in_syncs,
154 job->in_fence_count * sizeof(u32))) {
156 DRM_DEBUG("Failed to copy in syncobj handles\n");
160 for (i = 0; i < job->in_fence_count; i++) {
161 ret = drm_syncobj_find_fence(file_priv, handles[i], 0, 0,
172 static int panfrost_ioctl_submit(struct drm_device *dev, void *data,
173 struct drm_file *file)
175 struct panfrost_device *pfdev = dev->dev_private;
176 struct drm_panfrost_submit *args = data;
177 struct drm_syncobj *sync_out = NULL;
178 struct panfrost_job *job;
184 if (args->requirements && args->requirements != PANFROST_JD_REQ_FS)
187 if (args->out_sync > 0) {
188 sync_out = drm_syncobj_find(file, args->out_sync);
193 job = kzalloc(sizeof(*job), GFP_KERNEL);
199 kref_init(&job->refcount);
203 job->requirements = args->requirements;
204 job->flush_id = panfrost_gpu_get_latest_flush_id(pfdev);
205 job->file_priv = file->driver_priv;
207 ret = panfrost_copy_in_sync(dev, file, args, job);
211 ret = panfrost_lookup_bos(dev, file, args, job);
215 ret = panfrost_job_push(job);
219 /* Update the return sync object for the job */
221 drm_syncobj_replace_fence(sync_out, job->render_done_fence);
224 panfrost_job_put(job);
227 drm_syncobj_put(sync_out);
233 panfrost_ioctl_wait_bo(struct drm_device *dev, void *data,
234 struct drm_file *file_priv)
237 struct drm_panfrost_wait_bo *args = data;
238 struct drm_gem_object *gem_obj;
239 unsigned long timeout = drm_timeout_abs_to_jiffies(args->timeout_ns);
244 gem_obj = drm_gem_object_lookup(file_priv, args->handle);
248 ret = reservation_object_wait_timeout_rcu(gem_obj->resv, true,
251 ret = timeout ? -ETIMEDOUT : -EBUSY;
253 drm_gem_object_put_unlocked(gem_obj);
258 static int panfrost_ioctl_mmap_bo(struct drm_device *dev, void *data,
259 struct drm_file *file_priv)
261 struct drm_panfrost_mmap_bo *args = data;
262 struct drm_gem_object *gem_obj;
265 if (args->flags != 0) {
266 DRM_INFO("unknown mmap_bo flags: %d\n", args->flags);
270 gem_obj = drm_gem_object_lookup(file_priv, args->handle);
272 DRM_DEBUG("Failed to look up GEM BO %d\n", args->handle);
276 ret = drm_gem_create_mmap_offset(gem_obj);
278 args->offset = drm_vma_node_offset_addr(&gem_obj->vma_node);
279 drm_gem_object_put_unlocked(gem_obj);
284 static int panfrost_ioctl_get_bo_offset(struct drm_device *dev, void *data,
285 struct drm_file *file_priv)
287 struct drm_panfrost_get_bo_offset *args = data;
288 struct drm_gem_object *gem_obj;
289 struct panfrost_gem_object *bo;
291 gem_obj = drm_gem_object_lookup(file_priv, args->handle);
293 DRM_DEBUG("Failed to look up GEM BO %d\n", args->handle);
296 bo = to_panfrost_bo(gem_obj);
298 args->offset = bo->node.start << PAGE_SHIFT;
300 drm_gem_object_put_unlocked(gem_obj);
304 int panfrost_unstable_ioctl_check(void)
306 if (!unstable_ioctls)
313 panfrost_open(struct drm_device *dev, struct drm_file *file)
315 struct panfrost_device *pfdev = dev->dev_private;
316 struct panfrost_file_priv *panfrost_priv;
318 panfrost_priv = kzalloc(sizeof(*panfrost_priv), GFP_KERNEL);
322 panfrost_priv->pfdev = pfdev;
323 file->driver_priv = panfrost_priv;
325 return panfrost_job_open(panfrost_priv);
329 panfrost_postclose(struct drm_device *dev, struct drm_file *file)
331 struct panfrost_file_priv *panfrost_priv = file->driver_priv;
333 panfrost_perfcnt_close(panfrost_priv);
334 panfrost_job_close(panfrost_priv);
336 kfree(panfrost_priv);
339 /* DRM_AUTH is required on SUBMIT for now, while all clients share a single
340 * address space. Note that render nodes would be able to submit jobs that
341 * could access BOs from clients authenticated with the master node.
343 static const struct drm_ioctl_desc panfrost_drm_driver_ioctls[] = {
344 #define PANFROST_IOCTL(n, func, flags) \
345 DRM_IOCTL_DEF_DRV(PANFROST_##n, panfrost_ioctl_##func, flags)
347 PANFROST_IOCTL(SUBMIT, submit, DRM_RENDER_ALLOW | DRM_AUTH),
348 PANFROST_IOCTL(WAIT_BO, wait_bo, DRM_RENDER_ALLOW),
349 PANFROST_IOCTL(CREATE_BO, create_bo, DRM_RENDER_ALLOW),
350 PANFROST_IOCTL(MMAP_BO, mmap_bo, DRM_RENDER_ALLOW),
351 PANFROST_IOCTL(GET_PARAM, get_param, DRM_RENDER_ALLOW),
352 PANFROST_IOCTL(GET_BO_OFFSET, get_bo_offset, DRM_RENDER_ALLOW),
353 PANFROST_IOCTL(PERFCNT_ENABLE, perfcnt_enable, DRM_RENDER_ALLOW),
354 PANFROST_IOCTL(PERFCNT_DUMP, perfcnt_dump, DRM_RENDER_ALLOW),
357 DEFINE_DRM_GEM_SHMEM_FOPS(panfrost_drm_driver_fops);
359 static struct drm_driver panfrost_drm_driver = {
360 .driver_features = DRIVER_RENDER | DRIVER_GEM | DRIVER_PRIME |
362 .open = panfrost_open,
363 .postclose = panfrost_postclose,
364 .ioctls = panfrost_drm_driver_ioctls,
365 .num_ioctls = ARRAY_SIZE(panfrost_drm_driver_ioctls),
366 .fops = &panfrost_drm_driver_fops,
368 .desc = "panfrost DRM",
373 .gem_create_object = panfrost_gem_create_object,
374 .prime_handle_to_fd = drm_gem_prime_handle_to_fd,
375 .prime_fd_to_handle = drm_gem_prime_fd_to_handle,
376 .gem_prime_import_sg_table = panfrost_gem_prime_import_sg_table,
377 .gem_prime_mmap = drm_gem_prime_mmap,
380 static int panfrost_probe(struct platform_device *pdev)
382 struct panfrost_device *pfdev;
383 struct drm_device *ddev;
386 pfdev = devm_kzalloc(&pdev->dev, sizeof(*pfdev), GFP_KERNEL);
391 pfdev->dev = &pdev->dev;
393 platform_set_drvdata(pdev, pfdev);
395 /* Allocate and initialze the DRM device. */
396 ddev = drm_dev_alloc(&panfrost_drm_driver, &pdev->dev);
398 return PTR_ERR(ddev);
400 ddev->dev_private = pfdev;
403 spin_lock_init(&pfdev->mm_lock);
405 /* 4G enough for now. can be 48-bit */
406 drm_mm_init(&pfdev->mm, SZ_32M >> PAGE_SHIFT, (SZ_4G - SZ_32M) >> PAGE_SHIFT);
408 pm_runtime_use_autosuspend(pfdev->dev);
409 pm_runtime_set_autosuspend_delay(pfdev->dev, 50); /* ~3 frames */
410 pm_runtime_enable(pfdev->dev);
412 err = panfrost_device_init(pfdev);
414 if (err != -EPROBE_DEFER)
415 dev_err(&pdev->dev, "Fatal error during GPU init\n");
419 err = panfrost_devfreq_init(pfdev);
421 if (err != -EPROBE_DEFER)
422 dev_err(&pdev->dev, "Fatal error during devfreq init\n");
427 * Register the DRM device with the core and the connectors with
430 err = drm_dev_register(ddev, 0);
437 panfrost_device_fini(pfdev);
439 pm_runtime_disable(pfdev->dev);
444 static int panfrost_remove(struct platform_device *pdev)
446 struct panfrost_device *pfdev = platform_get_drvdata(pdev);
447 struct drm_device *ddev = pfdev->ddev;
449 drm_dev_unregister(ddev);
450 pm_runtime_get_sync(pfdev->dev);
451 pm_runtime_put_sync_autosuspend(pfdev->dev);
452 pm_runtime_disable(pfdev->dev);
453 panfrost_device_fini(pfdev);
458 static const struct of_device_id dt_match[] = {
459 { .compatible = "arm,mali-t604" },
460 { .compatible = "arm,mali-t624" },
461 { .compatible = "arm,mali-t628" },
462 { .compatible = "arm,mali-t720" },
463 { .compatible = "arm,mali-t760" },
464 { .compatible = "arm,mali-t820" },
465 { .compatible = "arm,mali-t830" },
466 { .compatible = "arm,mali-t860" },
467 { .compatible = "arm,mali-t880" },
470 MODULE_DEVICE_TABLE(of, dt_match);
472 static const struct dev_pm_ops panfrost_pm_ops = {
473 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, pm_runtime_force_resume)
474 SET_RUNTIME_PM_OPS(panfrost_device_suspend, panfrost_device_resume, NULL)
477 static struct platform_driver panfrost_driver = {
478 .probe = panfrost_probe,
479 .remove = panfrost_remove,
482 .pm = &panfrost_pm_ops,
483 .of_match_table = dt_match,
486 module_platform_driver(panfrost_driver);
488 MODULE_AUTHOR("Panfrost Project Developers");
489 MODULE_DESCRIPTION("Panfrost DRM Driver");
490 MODULE_LICENSE("GPL v2");