1 // SPDX-License-Identifier: GPL-2.0 OR MIT 2 /* Copyright 2017-2019 Qiang Yu <yuq825@gmail.com> */ 3 4 #include <linux/module.h> 5 #include <linux/of_platform.h> 6 #include <linux/uaccess.h> 7 #include <linux/slab.h> 8 #include <drm/drm_ioctl.h> 9 #include <drm/drm_drv.h> 10 #include <drm/drm_prime.h> 11 #include <drm/lima_drm.h> 12 13 #include "lima_drv.h" 14 #include "lima_gem.h" 15 #include "lima_vm.h" 16 17 int lima_sched_timeout_ms; 18 uint lima_heap_init_nr_pages = 8; 19 uint lima_max_error_tasks; 20 21 MODULE_PARM_DESC(sched_timeout_ms, "task run timeout in ms"); 22 module_param_named(sched_timeout_ms, lima_sched_timeout_ms, int, 0444); 23 24 MODULE_PARM_DESC(heap_init_nr_pages, "heap buffer init number of pages"); 25 module_param_named(heap_init_nr_pages, lima_heap_init_nr_pages, uint, 0444); 26 27 MODULE_PARM_DESC(max_error_tasks, "max number of error tasks to save"); 28 module_param_named(max_error_tasks, lima_max_error_tasks, uint, 0644); 29 30 static int lima_ioctl_get_param(struct drm_device *dev, void *data, struct drm_file *file) 31 { 32 struct drm_lima_get_param *args = data; 33 struct lima_device *ldev = to_lima_dev(dev); 34 35 if (args->pad) 36 return -EINVAL; 37 38 switch (args->param) { 39 case DRM_LIMA_PARAM_GPU_ID: 40 switch (ldev->id) { 41 case lima_gpu_mali400: 42 args->value = DRM_LIMA_PARAM_GPU_ID_MALI400; 43 break; 44 case lima_gpu_mali450: 45 args->value = DRM_LIMA_PARAM_GPU_ID_MALI450; 46 break; 47 default: 48 args->value = DRM_LIMA_PARAM_GPU_ID_UNKNOWN; 49 break; 50 } 51 break; 52 53 case DRM_LIMA_PARAM_NUM_PP: 54 args->value = ldev->pipe[lima_pipe_pp].num_processor; 55 break; 56 57 case DRM_LIMA_PARAM_GP_VERSION: 58 args->value = ldev->gp_version; 59 break; 60 61 case DRM_LIMA_PARAM_PP_VERSION: 62 args->value = ldev->pp_version; 63 break; 64 65 default: 66 return -EINVAL; 67 } 68 69 return 0; 70 } 71 72 static int lima_ioctl_gem_create(struct drm_device *dev, void *data, struct drm_file *file) 73 { 74 struct drm_lima_gem_create *args = data; 75 76 if (args->pad) 77 return -EINVAL; 78 79 if (args->flags & ~(LIMA_BO_FLAG_HEAP)) 80 return -EINVAL; 81 82 if (args->size == 0) 83 return -EINVAL; 84 85 return lima_gem_create_handle(dev, file, args->size, args->flags, &args->handle); 86 } 87 88 static int lima_ioctl_gem_info(struct drm_device *dev, void *data, struct drm_file *file) 89 { 90 struct drm_lima_gem_info *args = data; 91 92 return lima_gem_get_info(file, args->handle, &args->va, &args->offset); 93 } 94 95 static int lima_ioctl_gem_submit(struct drm_device *dev, void *data, struct drm_file *file) 96 { 97 struct drm_lima_gem_submit *args = data; 98 struct lima_device *ldev = to_lima_dev(dev); 99 struct lima_drm_priv *priv = file->driver_priv; 100 struct drm_lima_gem_submit_bo *bos; 101 struct lima_sched_pipe *pipe; 102 struct lima_sched_task *task; 103 struct lima_ctx *ctx; 104 struct lima_submit submit = {0}; 105 size_t size; 106 int err = 0; 107 108 if (args->pipe >= lima_pipe_num || args->nr_bos == 0) 109 return -EINVAL; 110 111 if (args->flags & ~(LIMA_SUBMIT_FLAG_EXPLICIT_FENCE)) 112 return -EINVAL; 113 114 pipe = ldev->pipe + args->pipe; 115 if (args->frame_size != pipe->frame_size) 116 return -EINVAL; 117 118 bos = kvcalloc(args->nr_bos, sizeof(*submit.bos) + sizeof(*submit.lbos), GFP_KERNEL); 119 if (!bos) 120 return -ENOMEM; 121 122 size = args->nr_bos * sizeof(*submit.bos); 123 if (copy_from_user(bos, u64_to_user_ptr(args->bos), size)) { 124 err = -EFAULT; 125 goto out0; 126 } 127 128 task = kmem_cache_zalloc(pipe->task_slab, GFP_KERNEL); 129 if (!task) { 130 err = -ENOMEM; 131 goto out0; 132 } 133 134 task->frame = task + 1; 135 if (copy_from_user(task->frame, u64_to_user_ptr(args->frame), args->frame_size)) { 136 err = -EFAULT; 137 goto out1; 138 } 139 140 err = pipe->task_validate(pipe, task); 141 if (err) 142 goto out1; 143 144 ctx = lima_ctx_get(&priv->ctx_mgr, args->ctx); 145 if (!ctx) { 146 err = -ENOENT; 147 goto out1; 148 } 149 150 submit.pipe = args->pipe; 151 submit.bos = bos; 152 submit.lbos = (void *)bos + size; 153 submit.nr_bos = args->nr_bos; 154 submit.task = task; 155 submit.ctx = ctx; 156 submit.flags = args->flags; 157 submit.in_sync[0] = args->in_sync[0]; 158 submit.in_sync[1] = args->in_sync[1]; 159 submit.out_sync = args->out_sync; 160 161 err = lima_gem_submit(file, &submit); 162 163 lima_ctx_put(ctx); 164 out1: 165 if (err) 166 kmem_cache_free(pipe->task_slab, task); 167 out0: 168 kvfree(bos); 169 return err; 170 } 171 172 static int lima_ioctl_gem_wait(struct drm_device *dev, void *data, struct drm_file *file) 173 { 174 struct drm_lima_gem_wait *args = data; 175 176 if (args->op & ~(LIMA_GEM_WAIT_READ|LIMA_GEM_WAIT_WRITE)) 177 return -EINVAL; 178 179 return lima_gem_wait(file, args->handle, args->op, args->timeout_ns); 180 } 181 182 static int lima_ioctl_ctx_create(struct drm_device *dev, void *data, struct drm_file *file) 183 { 184 struct drm_lima_ctx_create *args = data; 185 struct lima_drm_priv *priv = file->driver_priv; 186 struct lima_device *ldev = to_lima_dev(dev); 187 188 if (args->_pad) 189 return -EINVAL; 190 191 return lima_ctx_create(ldev, &priv->ctx_mgr, &args->id); 192 } 193 194 static int lima_ioctl_ctx_free(struct drm_device *dev, void *data, struct drm_file *file) 195 { 196 struct drm_lima_ctx_create *args = data; 197 struct lima_drm_priv *priv = file->driver_priv; 198 199 if (args->_pad) 200 return -EINVAL; 201 202 return lima_ctx_free(&priv->ctx_mgr, args->id); 203 } 204 205 static int lima_drm_driver_open(struct drm_device *dev, struct drm_file *file) 206 { 207 int err; 208 struct lima_drm_priv *priv; 209 struct lima_device *ldev = to_lima_dev(dev); 210 211 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 212 if (!priv) 213 return -ENOMEM; 214 215 priv->vm = lima_vm_create(ldev); 216 if (!priv->vm) { 217 err = -ENOMEM; 218 goto err_out0; 219 } 220 221 lima_ctx_mgr_init(&priv->ctx_mgr); 222 223 file->driver_priv = priv; 224 return 0; 225 226 err_out0: 227 kfree(priv); 228 return err; 229 } 230 231 static void lima_drm_driver_postclose(struct drm_device *dev, struct drm_file *file) 232 { 233 struct lima_drm_priv *priv = file->driver_priv; 234 235 lima_ctx_mgr_fini(&priv->ctx_mgr); 236 lima_vm_put(priv->vm); 237 kfree(priv); 238 } 239 240 static const struct drm_ioctl_desc lima_drm_driver_ioctls[] = { 241 DRM_IOCTL_DEF_DRV(LIMA_GET_PARAM, lima_ioctl_get_param, DRM_RENDER_ALLOW), 242 DRM_IOCTL_DEF_DRV(LIMA_GEM_CREATE, lima_ioctl_gem_create, DRM_RENDER_ALLOW), 243 DRM_IOCTL_DEF_DRV(LIMA_GEM_INFO, lima_ioctl_gem_info, DRM_RENDER_ALLOW), 244 DRM_IOCTL_DEF_DRV(LIMA_GEM_SUBMIT, lima_ioctl_gem_submit, DRM_RENDER_ALLOW), 245 DRM_IOCTL_DEF_DRV(LIMA_GEM_WAIT, lima_ioctl_gem_wait, DRM_RENDER_ALLOW), 246 DRM_IOCTL_DEF_DRV(LIMA_CTX_CREATE, lima_ioctl_ctx_create, DRM_RENDER_ALLOW), 247 DRM_IOCTL_DEF_DRV(LIMA_CTX_FREE, lima_ioctl_ctx_free, DRM_RENDER_ALLOW), 248 }; 249 250 DEFINE_DRM_GEM_FOPS(lima_drm_driver_fops); 251 252 /** 253 * Changelog: 254 * 255 * - 1.1.0 - add heap buffer support 256 */ 257 258 static struct drm_driver lima_drm_driver = { 259 .driver_features = DRIVER_RENDER | DRIVER_GEM | DRIVER_SYNCOBJ, 260 .open = lima_drm_driver_open, 261 .postclose = lima_drm_driver_postclose, 262 .ioctls = lima_drm_driver_ioctls, 263 .num_ioctls = ARRAY_SIZE(lima_drm_driver_ioctls), 264 .fops = &lima_drm_driver_fops, 265 .name = "lima", 266 .desc = "lima DRM", 267 .date = "20191231", 268 .major = 1, 269 .minor = 1, 270 .patchlevel = 0, 271 272 .gem_create_object = lima_gem_create_object, 273 .prime_fd_to_handle = drm_gem_prime_fd_to_handle, 274 .gem_prime_import_sg_table = drm_gem_shmem_prime_import_sg_table, 275 .prime_handle_to_fd = drm_gem_prime_handle_to_fd, 276 .gem_prime_mmap = drm_gem_prime_mmap, 277 }; 278 279 static int lima_pdev_probe(struct platform_device *pdev) 280 { 281 struct lima_device *ldev; 282 struct drm_device *ddev; 283 int err; 284 285 err = lima_sched_slab_init(); 286 if (err) 287 return err; 288 289 ldev = devm_kzalloc(&pdev->dev, sizeof(*ldev), GFP_KERNEL); 290 if (!ldev) { 291 err = -ENOMEM; 292 goto err_out0; 293 } 294 295 ldev->pdev = pdev; 296 ldev->dev = &pdev->dev; 297 ldev->id = (enum lima_gpu_id)of_device_get_match_data(&pdev->dev); 298 299 platform_set_drvdata(pdev, ldev); 300 301 /* Allocate and initialize the DRM device. */ 302 ddev = drm_dev_alloc(&lima_drm_driver, &pdev->dev); 303 if (IS_ERR(ddev)) 304 return PTR_ERR(ddev); 305 306 ddev->dev_private = ldev; 307 ldev->ddev = ddev; 308 309 err = lima_device_init(ldev); 310 if (err) 311 goto err_out1; 312 313 /* 314 * Register the DRM device with the core and the connectors with 315 * sysfs. 316 */ 317 err = drm_dev_register(ddev, 0); 318 if (err < 0) 319 goto err_out2; 320 321 return 0; 322 323 err_out2: 324 lima_device_fini(ldev); 325 err_out1: 326 drm_dev_put(ddev); 327 err_out0: 328 lima_sched_slab_fini(); 329 return err; 330 } 331 332 static int lima_pdev_remove(struct platform_device *pdev) 333 { 334 struct lima_device *ldev = platform_get_drvdata(pdev); 335 struct drm_device *ddev = ldev->ddev; 336 337 drm_dev_unregister(ddev); 338 lima_device_fini(ldev); 339 drm_dev_put(ddev); 340 lima_sched_slab_fini(); 341 return 0; 342 } 343 344 static const struct of_device_id dt_match[] = { 345 { .compatible = "arm,mali-400", .data = (void *)lima_gpu_mali400 }, 346 { .compatible = "arm,mali-450", .data = (void *)lima_gpu_mali450 }, 347 {} 348 }; 349 MODULE_DEVICE_TABLE(of, dt_match); 350 351 static struct platform_driver lima_platform_driver = { 352 .probe = lima_pdev_probe, 353 .remove = lima_pdev_remove, 354 .driver = { 355 .name = "lima", 356 .of_match_table = dt_match, 357 }, 358 }; 359 360 static int __init lima_init(void) 361 { 362 return platform_driver_register(&lima_platform_driver); 363 } 364 module_init(lima_init); 365 366 static void __exit lima_exit(void) 367 { 368 platform_driver_unregister(&lima_platform_driver); 369 } 370 module_exit(lima_exit); 371 372 MODULE_AUTHOR("Lima Project Developers"); 373 MODULE_DESCRIPTION("Lima DRM Driver"); 374 MODULE_LICENSE("GPL v2"); 375