drm/lima/lima_drv.c

0001 // SPDX-License-Identifier: GPL-2.0 OR MIT
0002 /* Copyright 2017-2019 Qiang Yu <yuq825@gmail.com> */
0003
0004 #include <linux/module.h>
0005 #include <linux/of_platform.h>
0006 #include <linux/uaccess.h>
0007 #include <linux/slab.h>
0008 #include <linux/pm_runtime.h>
0009 #include <drm/drm_ioctl.h>
0010 #include <drm/drm_drv.h>
0011 #include <drm/drm_prime.h>
0012 #include <drm/lima_drm.h>
0013
0014 #include "lima_device.h"
0015 #include "lima_drv.h"
0016 #include "lima_gem.h"
0017 #include "lima_vm.h"
0018
0019 int lima_sched_timeout_ms;
0020 uint lima_heap_init_nr_pages = 8;
0021 uint lima_max_error_tasks;
0022 uint lima_job_hang_limit;
0023
0024 MODULE_PARM_DESC(sched_timeout_ms, "task run timeout in ms");
0025 module_param_named(sched_timeout_ms, lima_sched_timeout_ms, int, 0444);
0026
0027 MODULE_PARM_DESC(heap_init_nr_pages, "heap buffer init number of pages");
0028 module_param_named(heap_init_nr_pages, lima_heap_init_nr_pages, uint, 0444);
0029
0030 MODULE_PARM_DESC(max_error_tasks, "max number of error tasks to save");
0031 module_param_named(max_error_tasks, lima_max_error_tasks, uint, 0644);
0032
0033 MODULE_PARM_DESC(job_hang_limit, "number of times to allow a job to hang before dropping it (default 0)");
0034 module_param_named(job_hang_limit, lima_job_hang_limit, uint, 0444);
0035
0036 static int lima_ioctl_get_param(struct drm_device *dev, void *data, struct drm_file *file)
0037 {
0038     struct drm_lima_get_param *args = data;
0039     struct lima_device *ldev = to_lima_dev(dev);
0040
0041     if (args->pad)
0042         return -EINVAL;
0043
0044     switch (args->param) {
0045     case DRM_LIMA_PARAM_GPU_ID:
0046         switch (ldev->id) {
0047         case lima_gpu_mali400:
0048             args->value = DRM_LIMA_PARAM_GPU_ID_MALI400;
0049             break;
0050         case lima_gpu_mali450:
0051             args->value = DRM_LIMA_PARAM_GPU_ID_MALI450;
0052             break;
0053         default:
0054             args->value = DRM_LIMA_PARAM_GPU_ID_UNKNOWN;
0055             break;
0056         }
0057         break;
0058
0059     case DRM_LIMA_PARAM_NUM_PP:
0060         args->value = ldev->pipe[lima_pipe_pp].num_processor;
0061         break;
0062
0063     case DRM_LIMA_PARAM_GP_VERSION:
0064         args->value = ldev->gp_version;
0065         break;
0066
0067     case DRM_LIMA_PARAM_PP_VERSION:
0068         args->value = ldev->pp_version;
0069         break;
0070
0071     default:
0072         return -EINVAL;
0073     }
0074
0075     return 0;
0076 }
0077
0078 static int lima_ioctl_gem_create(struct drm_device *dev, void *data, struct drm_file *file)
0079 {
0080     struct drm_lima_gem_create *args = data;
0081
0082     if (args->pad)
0083         return -EINVAL;
0084
0085     if (args->flags & ~(LIMA_BO_FLAG_HEAP))
0086         return -EINVAL;
0087
0088     if (args->size == 0)
0089         return -EINVAL;
0090
0091     return lima_gem_create_handle(dev, file, args->size, args->flags, &args->handle);
0092 }
0093
0094 static int lima_ioctl_gem_info(struct drm_device *dev, void *data, struct drm_file *file)
0095 {
0096     struct drm_lima_gem_info *args = data;
0097
0098     return lima_gem_get_info(file, args->handle, &args->va, &args->offset);
0099 }
0100
0101 static int lima_ioctl_gem_submit(struct drm_device *dev, void *data, struct drm_file *file)
0102 {
0103     struct drm_lima_gem_submit *args = data;
0104     struct lima_device *ldev = to_lima_dev(dev);
0105     struct lima_drm_priv *priv = file->driver_priv;
0106     struct drm_lima_gem_submit_bo *bos;
0107     struct lima_sched_pipe *pipe;
0108     struct lima_sched_task *task;
0109     struct lima_ctx *ctx;
0110     struct lima_submit submit = {0};
0111     size_t size;
0112     int err = 0;
0113
0114     if (args->pipe >= lima_pipe_num || args->nr_bos == 0)
0115         return -EINVAL;
0116
0117     if (args->flags & ~(LIMA_SUBMIT_FLAG_EXPLICIT_FENCE))
0118         return -EINVAL;
0119
0120     pipe = ldev->pipe + args->pipe;
0121     if (args->frame_size != pipe->frame_size)
0122         return -EINVAL;
0123
0124     bos = kvcalloc(args->nr_bos, sizeof(*submit.bos) + sizeof(*submit.lbos), GFP_KERNEL);
0125     if (!bos)
0126         return -ENOMEM;
0127
0128     size = args->nr_bos * sizeof(*submit.bos);
0129     if (copy_from_user(bos, u64_to_user_ptr(args->bos), size)) {
0130         err = -EFAULT;
0131         goto out0;
0132     }
0133
0134     task = kmem_cache_zalloc(pipe->task_slab, GFP_KERNEL);
0135     if (!task) {
0136         err = -ENOMEM;
0137         goto out0;
0138     }
0139
0140     task->frame = task + 1;
0141     if (copy_from_user(task->frame, u64_to_user_ptr(args->frame), args->frame_size)) {
0142         err = -EFAULT;
0143         goto out1;
0144     }
0145
0146     err = pipe->task_validate(pipe, task);
0147     if (err)
0148         goto out1;
0149
0150     ctx = lima_ctx_get(&priv->ctx_mgr, args->ctx);
0151     if (!ctx) {
0152         err = -ENOENT;
0153         goto out1;
0154     }
0155
0156     submit.pipe = args->pipe;
0157     submit.bos = bos;
0158     submit.lbos = (void *)bos + size;
0159     submit.nr_bos = args->nr_bos;
0160     submit.task = task;
0161     submit.ctx = ctx;
0162     submit.flags = args->flags;
0163     submit.in_sync[0] = args->in_sync[0];
0164     submit.in_sync[1] = args->in_sync[1];
0165     submit.out_sync = args->out_sync;
0166
0167     err = lima_gem_submit(file, &submit);
0168
0169     lima_ctx_put(ctx);
0170 out1:
0171     if (err)
0172         kmem_cache_free(pipe->task_slab, task);
0173 out0:
0174     kvfree(bos);
0175     return err;
0176 }
0177
0178 static int lima_ioctl_gem_wait(struct drm_device *dev, void *data, struct drm_file *file)
0179 {
0180     struct drm_lima_gem_wait *args = data;
0181
0182     if (args->op & ~(LIMA_GEM_WAIT_READ|LIMA_GEM_WAIT_WRITE))
0183         return -EINVAL;
0184
0185     return lima_gem_wait(file, args->handle, args->op, args->timeout_ns);
0186 }
0187
0188 static int lima_ioctl_ctx_create(struct drm_device *dev, void *data, struct drm_file *file)
0189 {
0190     struct drm_lima_ctx_create *args = data;
0191     struct lima_drm_priv *priv = file->driver_priv;
0192     struct lima_device *ldev = to_lima_dev(dev);
0193
0194     if (args->_pad)
0195         return -EINVAL;
0196
0197     return lima_ctx_create(ldev, &priv->ctx_mgr, &args->id);
0198 }
0199
0200 static int lima_ioctl_ctx_free(struct drm_device *dev, void *data, struct drm_file *file)
0201 {
0202     struct drm_lima_ctx_create *args = data;
0203     struct lima_drm_priv *priv = file->driver_priv;
0204
0205     if (args->_pad)
0206         return -EINVAL;
0207
0208     return lima_ctx_free(&priv->ctx_mgr, args->id);
0209 }
0210
0211 static int lima_drm_driver_open(struct drm_device *dev, struct drm_file *file)
0212 {
0213     int err;
0214     struct lima_drm_priv *priv;
0215     struct lima_device *ldev = to_lima_dev(dev);
0216
0217     priv = kzalloc(sizeof(*priv), GFP_KERNEL);
0218     if (!priv)
0219         return -ENOMEM;
0220
0221     priv->vm = lima_vm_create(ldev);
0222     if (!priv->vm) {
0223         err = -ENOMEM;
0224         goto err_out0;
0225     }
0226
0227     lima_ctx_mgr_init(&priv->ctx_mgr);
0228
0229     file->driver_priv = priv;
0230     return 0;
0231
0232 err_out0:
0233     kfree(priv);
0234     return err;
0235 }
0236
0237 static void lima_drm_driver_postclose(struct drm_device *dev, struct drm_file *file)
0238 {
0239     struct lima_drm_priv *priv = file->driver_priv;
0240
0241     lima_ctx_mgr_fini(&priv->ctx_mgr);
0242     lima_vm_put(priv->vm);
0243     kfree(priv);
0244 }
0245
0246 static const struct drm_ioctl_desc lima_drm_driver_ioctls[] = {
0247     DRM_IOCTL_DEF_DRV(LIMA_GET_PARAM, lima_ioctl_get_param, DRM_RENDER_ALLOW),
0248     DRM_IOCTL_DEF_DRV(LIMA_GEM_CREATE, lima_ioctl_gem_create, DRM_RENDER_ALLOW),
0249     DRM_IOCTL_DEF_DRV(LIMA_GEM_INFO, lima_ioctl_gem_info, DRM_RENDER_ALLOW),
0250     DRM_IOCTL_DEF_DRV(LIMA_GEM_SUBMIT, lima_ioctl_gem_submit, DRM_RENDER_ALLOW),
0251     DRM_IOCTL_DEF_DRV(LIMA_GEM_WAIT, lima_ioctl_gem_wait, DRM_RENDER_ALLOW),
0252     DRM_IOCTL_DEF_DRV(LIMA_CTX_CREATE, lima_ioctl_ctx_create, DRM_RENDER_ALLOW),
0253     DRM_IOCTL_DEF_DRV(LIMA_CTX_FREE, lima_ioctl_ctx_free, DRM_RENDER_ALLOW),
0254 };
0255
0256 DEFINE_DRM_GEM_FOPS(lima_drm_driver_fops);
0257
0258 /*
0259  * Changelog:
0260  *
0261  * - 1.1.0 - add heap buffer support
0262  */
0263
0264 static const struct drm_driver lima_drm_driver = {
0265     .driver_features    = DRIVER_RENDER | DRIVER_GEM | DRIVER_SYNCOBJ,
0266     .open               = lima_drm_driver_open,
0267     .postclose          = lima_drm_driver_postclose,
0268     .ioctls             = lima_drm_driver_ioctls,
0269     .num_ioctls         = ARRAY_SIZE(lima_drm_driver_ioctls),
0270     .fops               = &lima_drm_driver_fops,
0271     .name               = "lima",
0272     .desc               = "lima DRM",
0273     .date               = "20191231",
0274     .major              = 1,
0275     .minor              = 1,
0276     .patchlevel         = 0,
0277
0278     .gem_create_object  = lima_gem_create_object,
0279     .prime_fd_to_handle = drm_gem_prime_fd_to_handle,
0280     .gem_prime_import_sg_table = drm_gem_shmem_prime_import_sg_table,
0281     .prime_handle_to_fd = drm_gem_prime_handle_to_fd,
0282     .gem_prime_mmap = drm_gem_prime_mmap,
0283 };
0284
0285 struct lima_block_reader {
0286     void *dst;
0287     size_t base;
0288     size_t count;
0289     size_t off;
0290     ssize_t read;
0291 };
0292
0293 static bool lima_read_block(struct lima_block_reader *reader,
0294                 void *src, size_t src_size)
0295 {
0296     size_t max_off = reader->base + src_size;
0297
0298     if (reader->off < max_off) {
0299         size_t size = min_t(size_t, max_off - reader->off,
0300                     reader->count);
0301
0302         memcpy(reader->dst, src + (reader->off - reader->base), size);
0303
0304         reader->dst += size;
0305         reader->off += size;
0306         reader->read += size;
0307         reader->count -= size;
0308     }
0309
0310     reader->base = max_off;
0311
0312     return !!reader->count;
0313 }
0314
0315 static ssize_t lima_error_state_read(struct file *filp, struct kobject *kobj,
0316                      struct bin_attribute *attr, char *buf,
0317                      loff_t off, size_t count)
0318 {
0319     struct device *dev = kobj_to_dev(kobj);
0320     struct lima_device *ldev = dev_get_drvdata(dev);
0321     struct lima_sched_error_task *et;
0322     struct lima_block_reader reader = {
0323         .dst = buf,
0324         .count = count,
0325         .off = off,
0326     };
0327
0328     mutex_lock(&ldev->error_task_list_lock);
0329
0330     if (lima_read_block(&reader, &ldev->dump, sizeof(ldev->dump))) {
0331         list_for_each_entry(et, &ldev->error_task_list, list) {
0332             if (!lima_read_block(&reader, et->data, et->size))
0333                 break;
0334         }
0335     }
0336
0337     mutex_unlock(&ldev->error_task_list_lock);
0338     return reader.read;
0339 }
0340
0341 static ssize_t lima_error_state_write(struct file *file, struct kobject *kobj,
0342                       struct bin_attribute *attr, char *buf,
0343                       loff_t off, size_t count)
0344 {
0345     struct device *dev = kobj_to_dev(kobj);
0346     struct lima_device *ldev = dev_get_drvdata(dev);
0347     struct lima_sched_error_task *et, *tmp;
0348
0349     mutex_lock(&ldev->error_task_list_lock);
0350
0351     list_for_each_entry_safe(et, tmp, &ldev->error_task_list, list) {
0352         list_del(&et->list);
0353         kvfree(et);
0354     }
0355
0356     ldev->dump.size = 0;
0357     ldev->dump.num_tasks = 0;
0358
0359     mutex_unlock(&ldev->error_task_list_lock);
0360
0361     return count;
0362 }
0363
0364 static const struct bin_attribute lima_error_state_attr = {
0365     .attr.name = "error",
0366     .attr.mode = 0600,
0367     .size = 0,
0368     .read = lima_error_state_read,
0369     .write = lima_error_state_write,
0370 };
0371
0372 static int lima_pdev_probe(struct platform_device *pdev)
0373 {
0374     struct lima_device *ldev;
0375     struct drm_device *ddev;
0376     int err;
0377
0378     err = lima_sched_slab_init();
0379     if (err)
0380         return err;
0381
0382     ldev = devm_kzalloc(&pdev->dev, sizeof(*ldev), GFP_KERNEL);
0383     if (!ldev) {
0384         err = -ENOMEM;
0385         goto err_out0;
0386     }
0387
0388     ldev->dev = &pdev->dev;
0389     ldev->id = (enum lima_gpu_id)of_device_get_match_data(&pdev->dev);
0390
0391     platform_set_drvdata(pdev, ldev);
0392
0393     /* Allocate and initialize the DRM device. */
0394     ddev = drm_dev_alloc(&lima_drm_driver, &pdev->dev);
0395     if (IS_ERR(ddev))
0396         return PTR_ERR(ddev);
0397
0398     ddev->dev_private = ldev;
0399     ldev->ddev = ddev;
0400
0401     err = lima_device_init(ldev);
0402     if (err)
0403         goto err_out1;
0404
0405     err = lima_devfreq_init(ldev);
0406     if (err) {
0407         dev_err(&pdev->dev, "Fatal error during devfreq init\n");
0408         goto err_out2;
0409     }
0410
0411     pm_runtime_set_active(ldev->dev);
0412     pm_runtime_mark_last_busy(ldev->dev);
0413     pm_runtime_set_autosuspend_delay(ldev->dev, 200);
0414     pm_runtime_use_autosuspend(ldev->dev);
0415     pm_runtime_enable(ldev->dev);
0416
0417     /*
0418      * Register the DRM device with the core and the connectors with
0419      * sysfs.
0420      */
0421     err = drm_dev_register(ddev, 0);
0422     if (err < 0)
0423         goto err_out3;
0424
0425     if (sysfs_create_bin_file(&ldev->dev->kobj, &lima_error_state_attr))
0426         dev_warn(ldev->dev, "fail to create error state sysfs\n");
0427
0428     return 0;
0429
0430 err_out3:
0431     pm_runtime_disable(ldev->dev);
0432     lima_devfreq_fini(ldev);
0433 err_out2:
0434     lima_device_fini(ldev);
0435 err_out1:
0436     drm_dev_put(ddev);
0437 err_out0:
0438     lima_sched_slab_fini();
0439     return err;
0440 }
0441
0442 static int lima_pdev_remove(struct platform_device *pdev)
0443 {
0444     struct lima_device *ldev = platform_get_drvdata(pdev);
0445     struct drm_device *ddev = ldev->ddev;
0446
0447     sysfs_remove_bin_file(&ldev->dev->kobj, &lima_error_state_attr);
0448
0449     drm_dev_unregister(ddev);
0450
0451     /* stop autosuspend to make sure device is in active state */
0452     pm_runtime_set_autosuspend_delay(ldev->dev, -1);
0453     pm_runtime_disable(ldev->dev);
0454
0455     lima_devfreq_fini(ldev);
0456     lima_device_fini(ldev);
0457
0458     drm_dev_put(ddev);
0459     lima_sched_slab_fini();
0460     return 0;
0461 }
0462
0463 static const struct of_device_id dt_match[] = {
0464     { .compatible = "arm,mali-400", .data = (void *)lima_gpu_mali400 },
0465     { .compatible = "arm,mali-450", .data = (void *)lima_gpu_mali450 },
0466     {}
0467 };
0468 MODULE_DEVICE_TABLE(of, dt_match);
0469
0470 static const struct dev_pm_ops lima_pm_ops = {
0471     SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, pm_runtime_force_resume)
0472     SET_RUNTIME_PM_OPS(lima_device_suspend, lima_device_resume, NULL)
0473 };
0474
0475 static struct platform_driver lima_platform_driver = {
0476     .probe      = lima_pdev_probe,
0477     .remove     = lima_pdev_remove,
0478     .driver     = {
0479         .name   = "lima",
0480         .pm = &lima_pm_ops,
0481         .of_match_table = dt_match,
0482     },
0483 };
0484
0485 module_platform_driver(lima_platform_driver);
0486
0487 MODULE_AUTHOR("Lima Project Developers");
0488 MODULE_DESCRIPTION("Lima DRM Driver");
0489 MODULE_LICENSE("GPL v2");