Loading...
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 <linux/pm_runtime.h>
9#include <drm/drm_ioctl.h>
10#include <drm/drm_drv.h>
11#include <drm/drm_prime.h>
12#include <drm/lima_drm.h>
13
14#include "lima_device.h"
15#include "lima_drv.h"
16#include "lima_gem.h"
17#include "lima_vm.h"
18
19int lima_sched_timeout_ms;
20uint lima_heap_init_nr_pages = 8;
21uint lima_max_error_tasks;
22uint lima_job_hang_limit;
23
24MODULE_PARM_DESC(sched_timeout_ms, "task run timeout in ms");
25module_param_named(sched_timeout_ms, lima_sched_timeout_ms, int, 0444);
26
27MODULE_PARM_DESC(heap_init_nr_pages, "heap buffer init number of pages");
28module_param_named(heap_init_nr_pages, lima_heap_init_nr_pages, uint, 0444);
29
30MODULE_PARM_DESC(max_error_tasks, "max number of error tasks to save");
31module_param_named(max_error_tasks, lima_max_error_tasks, uint, 0644);
32
33MODULE_PARM_DESC(job_hang_limit, "number of times to allow a job to hang before dropping it (default 0)");
34module_param_named(job_hang_limit, lima_job_hang_limit, uint, 0444);
35
36static int lima_ioctl_get_param(struct drm_device *dev, void *data, struct drm_file *file)
37{
38 struct drm_lima_get_param *args = data;
39 struct lima_device *ldev = to_lima_dev(dev);
40
41 if (args->pad)
42 return -EINVAL;
43
44 switch (args->param) {
45 case DRM_LIMA_PARAM_GPU_ID:
46 switch (ldev->id) {
47 case lima_gpu_mali400:
48 args->value = DRM_LIMA_PARAM_GPU_ID_MALI400;
49 break;
50 case lima_gpu_mali450:
51 args->value = DRM_LIMA_PARAM_GPU_ID_MALI450;
52 break;
53 default:
54 args->value = DRM_LIMA_PARAM_GPU_ID_UNKNOWN;
55 break;
56 }
57 break;
58
59 case DRM_LIMA_PARAM_NUM_PP:
60 args->value = ldev->pipe[lima_pipe_pp].num_processor;
61 break;
62
63 case DRM_LIMA_PARAM_GP_VERSION:
64 args->value = ldev->gp_version;
65 break;
66
67 case DRM_LIMA_PARAM_PP_VERSION:
68 args->value = ldev->pp_version;
69 break;
70
71 default:
72 return -EINVAL;
73 }
74
75 return 0;
76}
77
78static int lima_ioctl_gem_create(struct drm_device *dev, void *data, struct drm_file *file)
79{
80 struct drm_lima_gem_create *args = data;
81
82 if (args->pad)
83 return -EINVAL;
84
85 if (args->flags & ~(LIMA_BO_FLAG_HEAP))
86 return -EINVAL;
87
88 if (args->size == 0)
89 return -EINVAL;
90
91 return lima_gem_create_handle(dev, file, args->size, args->flags, &args->handle);
92}
93
94static int lima_ioctl_gem_info(struct drm_device *dev, void *data, struct drm_file *file)
95{
96 struct drm_lima_gem_info *args = data;
97
98 return lima_gem_get_info(file, args->handle, &args->va, &args->offset);
99}
100
101static int lima_ioctl_gem_submit(struct drm_device *dev, void *data, struct drm_file *file)
102{
103 struct drm_lima_gem_submit *args = data;
104 struct lima_device *ldev = to_lima_dev(dev);
105 struct lima_drm_priv *priv = file->driver_priv;
106 struct drm_lima_gem_submit_bo *bos;
107 struct lima_sched_pipe *pipe;
108 struct lima_sched_task *task;
109 struct lima_ctx *ctx;
110 struct lima_submit submit = {0};
111 size_t size;
112 int err = 0;
113
114 if (args->pipe >= lima_pipe_num || args->nr_bos == 0)
115 return -EINVAL;
116
117 if (args->flags & ~(LIMA_SUBMIT_FLAG_EXPLICIT_FENCE))
118 return -EINVAL;
119
120 pipe = ldev->pipe + args->pipe;
121 if (args->frame_size != pipe->frame_size)
122 return -EINVAL;
123
124 bos = kvcalloc(args->nr_bos, sizeof(*submit.bos) + sizeof(*submit.lbos), GFP_KERNEL);
125 if (!bos)
126 return -ENOMEM;
127
128 size = args->nr_bos * sizeof(*submit.bos);
129 if (copy_from_user(bos, u64_to_user_ptr(args->bos), size)) {
130 err = -EFAULT;
131 goto out0;
132 }
133
134 task = kmem_cache_zalloc(pipe->task_slab, GFP_KERNEL);
135 if (!task) {
136 err = -ENOMEM;
137 goto out0;
138 }
139
140 task->frame = task + 1;
141 if (copy_from_user(task->frame, u64_to_user_ptr(args->frame), args->frame_size)) {
142 err = -EFAULT;
143 goto out1;
144 }
145
146 err = pipe->task_validate(pipe, task);
147 if (err)
148 goto out1;
149
150 ctx = lima_ctx_get(&priv->ctx_mgr, args->ctx);
151 if (!ctx) {
152 err = -ENOENT;
153 goto out1;
154 }
155
156 submit.pipe = args->pipe;
157 submit.bos = bos;
158 submit.lbos = (void *)bos + size;
159 submit.nr_bos = args->nr_bos;
160 submit.task = task;
161 submit.ctx = ctx;
162 submit.flags = args->flags;
163 submit.in_sync[0] = args->in_sync[0];
164 submit.in_sync[1] = args->in_sync[1];
165 submit.out_sync = args->out_sync;
166
167 err = lima_gem_submit(file, &submit);
168
169 lima_ctx_put(ctx);
170out1:
171 if (err)
172 kmem_cache_free(pipe->task_slab, task);
173out0:
174 kvfree(bos);
175 return err;
176}
177
178static int lima_ioctl_gem_wait(struct drm_device *dev, void *data, struct drm_file *file)
179{
180 struct drm_lima_gem_wait *args = data;
181
182 if (args->op & ~(LIMA_GEM_WAIT_READ|LIMA_GEM_WAIT_WRITE))
183 return -EINVAL;
184
185 return lima_gem_wait(file, args->handle, args->op, args->timeout_ns);
186}
187
188static int lima_ioctl_ctx_create(struct drm_device *dev, void *data, struct drm_file *file)
189{
190 struct drm_lima_ctx_create *args = data;
191 struct lima_drm_priv *priv = file->driver_priv;
192 struct lima_device *ldev = to_lima_dev(dev);
193
194 if (args->_pad)
195 return -EINVAL;
196
197 return lima_ctx_create(ldev, &priv->ctx_mgr, &args->id);
198}
199
200static int lima_ioctl_ctx_free(struct drm_device *dev, void *data, struct drm_file *file)
201{
202 struct drm_lima_ctx_create *args = data;
203 struct lima_drm_priv *priv = file->driver_priv;
204
205 if (args->_pad)
206 return -EINVAL;
207
208 return lima_ctx_free(&priv->ctx_mgr, args->id);
209}
210
211static int lima_drm_driver_open(struct drm_device *dev, struct drm_file *file)
212{
213 int err;
214 struct lima_drm_priv *priv;
215 struct lima_device *ldev = to_lima_dev(dev);
216
217 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
218 if (!priv)
219 return -ENOMEM;
220
221 priv->vm = lima_vm_create(ldev);
222 if (!priv->vm) {
223 err = -ENOMEM;
224 goto err_out0;
225 }
226
227 lima_ctx_mgr_init(&priv->ctx_mgr);
228
229 file->driver_priv = priv;
230 return 0;
231
232err_out0:
233 kfree(priv);
234 return err;
235}
236
237static void lima_drm_driver_postclose(struct drm_device *dev, struct drm_file *file)
238{
239 struct lima_drm_priv *priv = file->driver_priv;
240
241 lima_ctx_mgr_fini(&priv->ctx_mgr);
242 lima_vm_put(priv->vm);
243 kfree(priv);
244}
245
246static const struct drm_ioctl_desc lima_drm_driver_ioctls[] = {
247 DRM_IOCTL_DEF_DRV(LIMA_GET_PARAM, lima_ioctl_get_param, DRM_RENDER_ALLOW),
248 DRM_IOCTL_DEF_DRV(LIMA_GEM_CREATE, lima_ioctl_gem_create, DRM_RENDER_ALLOW),
249 DRM_IOCTL_DEF_DRV(LIMA_GEM_INFO, lima_ioctl_gem_info, DRM_RENDER_ALLOW),
250 DRM_IOCTL_DEF_DRV(LIMA_GEM_SUBMIT, lima_ioctl_gem_submit, DRM_RENDER_ALLOW),
251 DRM_IOCTL_DEF_DRV(LIMA_GEM_WAIT, lima_ioctl_gem_wait, DRM_RENDER_ALLOW),
252 DRM_IOCTL_DEF_DRV(LIMA_CTX_CREATE, lima_ioctl_ctx_create, DRM_RENDER_ALLOW),
253 DRM_IOCTL_DEF_DRV(LIMA_CTX_FREE, lima_ioctl_ctx_free, DRM_RENDER_ALLOW),
254};
255
256DEFINE_DRM_GEM_FOPS(lima_drm_driver_fops);
257
258/**
259 * Changelog:
260 *
261 * - 1.1.0 - add heap buffer support
262 */
263
264static struct drm_driver lima_drm_driver = {
265 .driver_features = DRIVER_RENDER | DRIVER_GEM | DRIVER_SYNCOBJ,
266 .open = lima_drm_driver_open,
267 .postclose = lima_drm_driver_postclose,
268 .ioctls = lima_drm_driver_ioctls,
269 .num_ioctls = ARRAY_SIZE(lima_drm_driver_ioctls),
270 .fops = &lima_drm_driver_fops,
271 .name = "lima",
272 .desc = "lima DRM",
273 .date = "20191231",
274 .major = 1,
275 .minor = 1,
276 .patchlevel = 0,
277
278 .gem_create_object = lima_gem_create_object,
279 .prime_fd_to_handle = drm_gem_prime_fd_to_handle,
280 .gem_prime_import_sg_table = drm_gem_shmem_prime_import_sg_table,
281 .prime_handle_to_fd = drm_gem_prime_handle_to_fd,
282 .gem_prime_mmap = drm_gem_prime_mmap,
283};
284
285struct lima_block_reader {
286 void *dst;
287 size_t base;
288 size_t count;
289 size_t off;
290 ssize_t read;
291};
292
293static bool lima_read_block(struct lima_block_reader *reader,
294 void *src, size_t src_size)
295{
296 size_t max_off = reader->base + src_size;
297
298 if (reader->off < max_off) {
299 size_t size = min_t(size_t, max_off - reader->off,
300 reader->count);
301
302 memcpy(reader->dst, src + (reader->off - reader->base), size);
303
304 reader->dst += size;
305 reader->off += size;
306 reader->read += size;
307 reader->count -= size;
308 }
309
310 reader->base = max_off;
311
312 return !!reader->count;
313}
314
315static ssize_t lima_error_state_read(struct file *filp, struct kobject *kobj,
316 struct bin_attribute *attr, char *buf,
317 loff_t off, size_t count)
318{
319 struct device *dev = kobj_to_dev(kobj);
320 struct lima_device *ldev = dev_get_drvdata(dev);
321 struct lima_sched_error_task *et;
322 struct lima_block_reader reader = {
323 .dst = buf,
324 .count = count,
325 .off = off,
326 };
327
328 mutex_lock(&ldev->error_task_list_lock);
329
330 if (lima_read_block(&reader, &ldev->dump, sizeof(ldev->dump))) {
331 list_for_each_entry(et, &ldev->error_task_list, list) {
332 if (!lima_read_block(&reader, et->data, et->size))
333 break;
334 }
335 }
336
337 mutex_unlock(&ldev->error_task_list_lock);
338 return reader.read;
339}
340
341static ssize_t lima_error_state_write(struct file *file, struct kobject *kobj,
342 struct bin_attribute *attr, char *buf,
343 loff_t off, size_t count)
344{
345 struct device *dev = kobj_to_dev(kobj);
346 struct lima_device *ldev = dev_get_drvdata(dev);
347 struct lima_sched_error_task *et, *tmp;
348
349 mutex_lock(&ldev->error_task_list_lock);
350
351 list_for_each_entry_safe(et, tmp, &ldev->error_task_list, list) {
352 list_del(&et->list);
353 kvfree(et);
354 }
355
356 ldev->dump.size = 0;
357 ldev->dump.num_tasks = 0;
358
359 mutex_unlock(&ldev->error_task_list_lock);
360
361 return count;
362}
363
364static const struct bin_attribute lima_error_state_attr = {
365 .attr.name = "error",
366 .attr.mode = 0600,
367 .size = 0,
368 .read = lima_error_state_read,
369 .write = lima_error_state_write,
370};
371
372static int lima_pdev_probe(struct platform_device *pdev)
373{
374 struct lima_device *ldev;
375 struct drm_device *ddev;
376 int err;
377
378 err = lima_sched_slab_init();
379 if (err)
380 return err;
381
382 ldev = devm_kzalloc(&pdev->dev, sizeof(*ldev), GFP_KERNEL);
383 if (!ldev) {
384 err = -ENOMEM;
385 goto err_out0;
386 }
387
388 ldev->dev = &pdev->dev;
389 ldev->id = (enum lima_gpu_id)of_device_get_match_data(&pdev->dev);
390
391 platform_set_drvdata(pdev, ldev);
392
393 /* Allocate and initialize the DRM device. */
394 ddev = drm_dev_alloc(&lima_drm_driver, &pdev->dev);
395 if (IS_ERR(ddev))
396 return PTR_ERR(ddev);
397
398 ddev->dev_private = ldev;
399 ldev->ddev = ddev;
400
401 err = lima_device_init(ldev);
402 if (err)
403 goto err_out1;
404
405 err = lima_devfreq_init(ldev);
406 if (err) {
407 dev_err(&pdev->dev, "Fatal error during devfreq init\n");
408 goto err_out2;
409 }
410
411 pm_runtime_set_active(ldev->dev);
412 pm_runtime_mark_last_busy(ldev->dev);
413 pm_runtime_set_autosuspend_delay(ldev->dev, 200);
414 pm_runtime_use_autosuspend(ldev->dev);
415 pm_runtime_enable(ldev->dev);
416
417 /*
418 * Register the DRM device with the core and the connectors with
419 * sysfs.
420 */
421 err = drm_dev_register(ddev, 0);
422 if (err < 0)
423 goto err_out3;
424
425 if (sysfs_create_bin_file(&ldev->dev->kobj, &lima_error_state_attr))
426 dev_warn(ldev->dev, "fail to create error state sysfs\n");
427
428 return 0;
429
430err_out3:
431 pm_runtime_disable(ldev->dev);
432 lima_devfreq_fini(ldev);
433err_out2:
434 lima_device_fini(ldev);
435err_out1:
436 drm_dev_put(ddev);
437err_out0:
438 lima_sched_slab_fini();
439 return err;
440}
441
442static int lima_pdev_remove(struct platform_device *pdev)
443{
444 struct lima_device *ldev = platform_get_drvdata(pdev);
445 struct drm_device *ddev = ldev->ddev;
446
447 sysfs_remove_bin_file(&ldev->dev->kobj, &lima_error_state_attr);
448
449 drm_dev_unregister(ddev);
450
451 /* stop autosuspend to make sure device is in active state */
452 pm_runtime_set_autosuspend_delay(ldev->dev, -1);
453 pm_runtime_disable(ldev->dev);
454
455 lima_devfreq_fini(ldev);
456 lima_device_fini(ldev);
457
458 drm_dev_put(ddev);
459 lima_sched_slab_fini();
460 return 0;
461}
462
463static const struct of_device_id dt_match[] = {
464 { .compatible = "arm,mali-400", .data = (void *)lima_gpu_mali400 },
465 { .compatible = "arm,mali-450", .data = (void *)lima_gpu_mali450 },
466 {}
467};
468MODULE_DEVICE_TABLE(of, dt_match);
469
470static const struct dev_pm_ops lima_pm_ops = {
471 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, pm_runtime_force_resume)
472 SET_RUNTIME_PM_OPS(lima_device_suspend, lima_device_resume, NULL)
473};
474
475static struct platform_driver lima_platform_driver = {
476 .probe = lima_pdev_probe,
477 .remove = lima_pdev_remove,
478 .driver = {
479 .name = "lima",
480 .pm = &lima_pm_ops,
481 .of_match_table = dt_match,
482 },
483};
484
485module_platform_driver(lima_platform_driver);
486
487MODULE_AUTHOR("Lima Project Developers");
488MODULE_DESCRIPTION("Lima DRM Driver");
489MODULE_LICENSE("GPL v2");
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_gem_prime.h"
16#include "lima_vm.h"
17
18int lima_sched_timeout_ms;
19
20MODULE_PARM_DESC(sched_timeout_ms, "task run timeout in ms");
21module_param_named(sched_timeout_ms, lima_sched_timeout_ms, int, 0444);
22
23static int lima_ioctl_get_param(struct drm_device *dev, void *data, struct drm_file *file)
24{
25 struct drm_lima_get_param *args = data;
26 struct lima_device *ldev = to_lima_dev(dev);
27
28 if (args->pad)
29 return -EINVAL;
30
31 switch (args->param) {
32 case DRM_LIMA_PARAM_GPU_ID:
33 switch (ldev->id) {
34 case lima_gpu_mali400:
35 args->value = DRM_LIMA_PARAM_GPU_ID_MALI400;
36 break;
37 case lima_gpu_mali450:
38 args->value = DRM_LIMA_PARAM_GPU_ID_MALI450;
39 break;
40 default:
41 args->value = DRM_LIMA_PARAM_GPU_ID_UNKNOWN;
42 break;
43 }
44 break;
45
46 case DRM_LIMA_PARAM_NUM_PP:
47 args->value = ldev->pipe[lima_pipe_pp].num_processor;
48 break;
49
50 case DRM_LIMA_PARAM_GP_VERSION:
51 args->value = ldev->gp_version;
52 break;
53
54 case DRM_LIMA_PARAM_PP_VERSION:
55 args->value = ldev->pp_version;
56 break;
57
58 default:
59 return -EINVAL;
60 }
61
62 return 0;
63}
64
65static int lima_ioctl_gem_create(struct drm_device *dev, void *data, struct drm_file *file)
66{
67 struct drm_lima_gem_create *args = data;
68
69 if (args->pad)
70 return -EINVAL;
71
72 if (args->flags)
73 return -EINVAL;
74
75 if (args->size == 0)
76 return -EINVAL;
77
78 return lima_gem_create_handle(dev, file, args->size, args->flags, &args->handle);
79}
80
81static int lima_ioctl_gem_info(struct drm_device *dev, void *data, struct drm_file *file)
82{
83 struct drm_lima_gem_info *args = data;
84
85 return lima_gem_get_info(file, args->handle, &args->va, &args->offset);
86}
87
88static int lima_ioctl_gem_submit(struct drm_device *dev, void *data, struct drm_file *file)
89{
90 struct drm_lima_gem_submit *args = data;
91 struct lima_device *ldev = to_lima_dev(dev);
92 struct lima_drm_priv *priv = file->driver_priv;
93 struct drm_lima_gem_submit_bo *bos;
94 struct lima_sched_pipe *pipe;
95 struct lima_sched_task *task;
96 struct lima_ctx *ctx;
97 struct lima_submit submit = {0};
98 size_t size;
99 int err = 0;
100
101 if (args->pipe >= lima_pipe_num || args->nr_bos == 0)
102 return -EINVAL;
103
104 if (args->flags & ~(LIMA_SUBMIT_FLAG_EXPLICIT_FENCE))
105 return -EINVAL;
106
107 pipe = ldev->pipe + args->pipe;
108 if (args->frame_size != pipe->frame_size)
109 return -EINVAL;
110
111 bos = kvcalloc(args->nr_bos, sizeof(*submit.bos) + sizeof(*submit.lbos), GFP_KERNEL);
112 if (!bos)
113 return -ENOMEM;
114
115 size = args->nr_bos * sizeof(*submit.bos);
116 if (copy_from_user(bos, u64_to_user_ptr(args->bos), size)) {
117 err = -EFAULT;
118 goto out0;
119 }
120
121 task = kmem_cache_zalloc(pipe->task_slab, GFP_KERNEL);
122 if (!task) {
123 err = -ENOMEM;
124 goto out0;
125 }
126
127 task->frame = task + 1;
128 if (copy_from_user(task->frame, u64_to_user_ptr(args->frame), args->frame_size)) {
129 err = -EFAULT;
130 goto out1;
131 }
132
133 err = pipe->task_validate(pipe, task);
134 if (err)
135 goto out1;
136
137 ctx = lima_ctx_get(&priv->ctx_mgr, args->ctx);
138 if (!ctx) {
139 err = -ENOENT;
140 goto out1;
141 }
142
143 submit.pipe = args->pipe;
144 submit.bos = bos;
145 submit.lbos = (void *)bos + size;
146 submit.nr_bos = args->nr_bos;
147 submit.task = task;
148 submit.ctx = ctx;
149 submit.flags = args->flags;
150 submit.in_sync[0] = args->in_sync[0];
151 submit.in_sync[1] = args->in_sync[1];
152 submit.out_sync = args->out_sync;
153
154 err = lima_gem_submit(file, &submit);
155
156 lima_ctx_put(ctx);
157out1:
158 if (err)
159 kmem_cache_free(pipe->task_slab, task);
160out0:
161 kvfree(bos);
162 return err;
163}
164
165static int lima_ioctl_gem_wait(struct drm_device *dev, void *data, struct drm_file *file)
166{
167 struct drm_lima_gem_wait *args = data;
168
169 if (args->op & ~(LIMA_GEM_WAIT_READ|LIMA_GEM_WAIT_WRITE))
170 return -EINVAL;
171
172 return lima_gem_wait(file, args->handle, args->op, args->timeout_ns);
173}
174
175static int lima_ioctl_ctx_create(struct drm_device *dev, void *data, struct drm_file *file)
176{
177 struct drm_lima_ctx_create *args = data;
178 struct lima_drm_priv *priv = file->driver_priv;
179 struct lima_device *ldev = to_lima_dev(dev);
180
181 if (args->_pad)
182 return -EINVAL;
183
184 return lima_ctx_create(ldev, &priv->ctx_mgr, &args->id);
185}
186
187static int lima_ioctl_ctx_free(struct drm_device *dev, void *data, struct drm_file *file)
188{
189 struct drm_lima_ctx_create *args = data;
190 struct lima_drm_priv *priv = file->driver_priv;
191
192 if (args->_pad)
193 return -EINVAL;
194
195 return lima_ctx_free(&priv->ctx_mgr, args->id);
196}
197
198static int lima_drm_driver_open(struct drm_device *dev, struct drm_file *file)
199{
200 int err;
201 struct lima_drm_priv *priv;
202 struct lima_device *ldev = to_lima_dev(dev);
203
204 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
205 if (!priv)
206 return -ENOMEM;
207
208 priv->vm = lima_vm_create(ldev);
209 if (!priv->vm) {
210 err = -ENOMEM;
211 goto err_out0;
212 }
213
214 lima_ctx_mgr_init(&priv->ctx_mgr);
215
216 file->driver_priv = priv;
217 return 0;
218
219err_out0:
220 kfree(priv);
221 return err;
222}
223
224static void lima_drm_driver_postclose(struct drm_device *dev, struct drm_file *file)
225{
226 struct lima_drm_priv *priv = file->driver_priv;
227
228 lima_ctx_mgr_fini(&priv->ctx_mgr);
229 lima_vm_put(priv->vm);
230 kfree(priv);
231}
232
233static const struct drm_ioctl_desc lima_drm_driver_ioctls[] = {
234 DRM_IOCTL_DEF_DRV(LIMA_GET_PARAM, lima_ioctl_get_param, DRM_RENDER_ALLOW),
235 DRM_IOCTL_DEF_DRV(LIMA_GEM_CREATE, lima_ioctl_gem_create, DRM_RENDER_ALLOW),
236 DRM_IOCTL_DEF_DRV(LIMA_GEM_INFO, lima_ioctl_gem_info, DRM_RENDER_ALLOW),
237 DRM_IOCTL_DEF_DRV(LIMA_GEM_SUBMIT, lima_ioctl_gem_submit, DRM_RENDER_ALLOW),
238 DRM_IOCTL_DEF_DRV(LIMA_GEM_WAIT, lima_ioctl_gem_wait, DRM_RENDER_ALLOW),
239 DRM_IOCTL_DEF_DRV(LIMA_CTX_CREATE, lima_ioctl_ctx_create, DRM_RENDER_ALLOW),
240 DRM_IOCTL_DEF_DRV(LIMA_CTX_FREE, lima_ioctl_ctx_free, DRM_RENDER_ALLOW),
241};
242
243static const struct file_operations lima_drm_driver_fops = {
244 .owner = THIS_MODULE,
245 .open = drm_open,
246 .release = drm_release,
247 .unlocked_ioctl = drm_ioctl,
248#ifdef CONFIG_COMPAT
249 .compat_ioctl = drm_compat_ioctl,
250#endif
251 .mmap = lima_gem_mmap,
252};
253
254static struct drm_driver lima_drm_driver = {
255 .driver_features = DRIVER_RENDER | DRIVER_GEM | DRIVER_SYNCOBJ,
256 .open = lima_drm_driver_open,
257 .postclose = lima_drm_driver_postclose,
258 .ioctls = lima_drm_driver_ioctls,
259 .num_ioctls = ARRAY_SIZE(lima_drm_driver_ioctls),
260 .fops = &lima_drm_driver_fops,
261 .gem_free_object_unlocked = lima_gem_free_object,
262 .gem_open_object = lima_gem_object_open,
263 .gem_close_object = lima_gem_object_close,
264 .gem_vm_ops = &lima_gem_vm_ops,
265 .name = "lima",
266 .desc = "lima DRM",
267 .date = "20190217",
268 .major = 1,
269 .minor = 0,
270 .patchlevel = 0,
271
272 .prime_fd_to_handle = drm_gem_prime_fd_to_handle,
273 .gem_prime_import_sg_table = lima_gem_prime_import_sg_table,
274 .prime_handle_to_fd = drm_gem_prime_handle_to_fd,
275 .gem_prime_get_sg_table = lima_gem_prime_get_sg_table,
276 .gem_prime_mmap = lima_gem_prime_mmap,
277};
278
279static 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
323err_out2:
324 lima_device_fini(ldev);
325err_out1:
326 drm_dev_put(ddev);
327err_out0:
328 lima_sched_slab_fini();
329 return err;
330}
331
332static 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
344static 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};
349MODULE_DEVICE_TABLE(of, dt_match);
350
351static 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
360static int __init lima_init(void)
361{
362 return platform_driver_register(&lima_platform_driver);
363}
364module_init(lima_init);
365
366static void __exit lima_exit(void)
367{
368 platform_driver_unregister(&lima_platform_driver);
369}
370module_exit(lima_exit);
371
372MODULE_AUTHOR("Lima Project Developers");
373MODULE_DESCRIPTION("Lima DRM Driver");
374MODULE_LICENSE("GPL v2");