Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0-only OR MIT
2/* Copyright (c) 2023 Imagination Technologies Ltd. */
3
4#include "pvr_context.h"
5#include "pvr_debugfs.h"
6#include "pvr_device.h"
7#include "pvr_drv.h"
8#include "pvr_free_list.h"
9#include "pvr_gem.h"
10#include "pvr_hwrt.h"
11#include "pvr_job.h"
12#include "pvr_mmu.h"
13#include "pvr_power.h"
14#include "pvr_rogue_defs.h"
15#include "pvr_rogue_fwif_client.h"
16#include "pvr_rogue_fwif_shared.h"
17#include "pvr_vm.h"
18
19#include <uapi/drm/pvr_drm.h>
20
21#include <drm/drm_device.h>
22#include <drm/drm_drv.h>
23#include <drm/drm_file.h>
24#include <drm/drm_gem.h>
25#include <drm/drm_ioctl.h>
26
27#include <linux/err.h>
28#include <linux/export.h>
29#include <linux/fs.h>
30#include <linux/kernel.h>
31#include <linux/mod_devicetable.h>
32#include <linux/module.h>
33#include <linux/moduleparam.h>
34#include <linux/of_device.h>
35#include <linux/of_platform.h>
36#include <linux/platform_device.h>
37#include <linux/pm_runtime.h>
38#include <linux/xarray.h>
39
40/**
41 * DOC: PowerVR (Series 6 and later) and IMG Graphics Driver
42 *
43 * This driver supports the following PowerVR/IMG graphics cores from Imagination Technologies:
44 *
45 * * AXE-1-16M (found in Texas Instruments AM62)
46 */
47
48/**
49 * pvr_ioctl_create_bo() - IOCTL to create a GEM buffer object.
50 * @drm_dev: [IN] Target DRM device.
51 * @raw_args: [IN/OUT] Arguments passed to this IOCTL. This must be of type
52 * &struct drm_pvr_ioctl_create_bo_args.
53 * @file: [IN] DRM file-private data.
54 *
55 * Called from userspace with %DRM_IOCTL_PVR_CREATE_BO.
56 *
57 * Return:
58 * * 0 on success,
59 * * -%EINVAL if the value of &drm_pvr_ioctl_create_bo_args.size is zero
60 * or wider than &typedef size_t,
61 * * -%EINVAL if any bits in &drm_pvr_ioctl_create_bo_args.flags that are
62 * reserved or undefined are set,
63 * * -%EINVAL if any padding fields in &drm_pvr_ioctl_create_bo_args are not
64 * zero,
65 * * Any error encountered while creating the object (see
66 * pvr_gem_object_create()), or
67 * * Any error encountered while transferring ownership of the object into a
68 * userspace-accessible handle (see pvr_gem_object_into_handle()).
69 */
70static int
71pvr_ioctl_create_bo(struct drm_device *drm_dev, void *raw_args,
72 struct drm_file *file)
73{
74 struct drm_pvr_ioctl_create_bo_args *args = raw_args;
75 struct pvr_device *pvr_dev = to_pvr_device(drm_dev);
76 struct pvr_file *pvr_file = to_pvr_file(file);
77
78 struct pvr_gem_object *pvr_obj;
79 size_t sanitized_size;
80
81 int idx;
82 int err;
83
84 if (!drm_dev_enter(drm_dev, &idx))
85 return -EIO;
86
87 /* All padding fields must be zeroed. */
88 if (args->_padding_c != 0) {
89 err = -EINVAL;
90 goto err_drm_dev_exit;
91 }
92
93 /*
94 * On 64-bit platforms (our primary target), size_t is a u64. However,
95 * on other architectures we have to check for overflow when casting
96 * down to size_t from u64.
97 *
98 * We also disallow zero-sized allocations, and reserved (kernel-only)
99 * flags.
100 */
101 if (args->size > SIZE_MAX || args->size == 0 || args->flags &
102 ~DRM_PVR_BO_FLAGS_MASK || args->size & (PVR_DEVICE_PAGE_SIZE - 1)) {
103 err = -EINVAL;
104 goto err_drm_dev_exit;
105 }
106
107 sanitized_size = (size_t)args->size;
108
109 /*
110 * Create a buffer object and transfer ownership to a userspace-
111 * accessible handle.
112 */
113 pvr_obj = pvr_gem_object_create(pvr_dev, sanitized_size, args->flags);
114 if (IS_ERR(pvr_obj)) {
115 err = PTR_ERR(pvr_obj);
116 goto err_drm_dev_exit;
117 }
118
119 /* This function will not modify &args->handle unless it succeeds. */
120 err = pvr_gem_object_into_handle(pvr_obj, pvr_file, &args->handle);
121 if (err)
122 goto err_destroy_obj;
123
124 drm_dev_exit(idx);
125
126 return 0;
127
128err_destroy_obj:
129 /*
130 * GEM objects are refcounted, so there is no explicit destructor
131 * function. Instead, we release the singular reference we currently
132 * hold on the object and let GEM take care of the rest.
133 */
134 pvr_gem_object_put(pvr_obj);
135
136err_drm_dev_exit:
137 drm_dev_exit(idx);
138
139 return err;
140}
141
142/**
143 * pvr_ioctl_get_bo_mmap_offset() - IOCTL to generate a "fake" offset to be
144 * used when calling mmap() from userspace to map the given GEM buffer object
145 * @drm_dev: [IN] DRM device (unused).
146 * @raw_args: [IN/OUT] Arguments passed to this IOCTL. This must be of type
147 * &struct drm_pvr_ioctl_get_bo_mmap_offset_args.
148 * @file: [IN] DRM file private data.
149 *
150 * Called from userspace with %DRM_IOCTL_PVR_GET_BO_MMAP_OFFSET.
151 *
152 * This IOCTL does *not* perform an mmap. See the docs on
153 * &struct drm_pvr_ioctl_get_bo_mmap_offset_args for details.
154 *
155 * Return:
156 * * 0 on success,
157 * * -%ENOENT if the handle does not reference a valid GEM buffer object,
158 * * -%EINVAL if any padding fields in &struct
159 * drm_pvr_ioctl_get_bo_mmap_offset_args are not zero, or
160 * * Any error returned by drm_gem_create_mmap_offset().
161 */
162static int
163pvr_ioctl_get_bo_mmap_offset(struct drm_device *drm_dev, void *raw_args,
164 struct drm_file *file)
165{
166 struct drm_pvr_ioctl_get_bo_mmap_offset_args *args = raw_args;
167 struct pvr_file *pvr_file = to_pvr_file(file);
168 struct pvr_gem_object *pvr_obj;
169 struct drm_gem_object *gem_obj;
170 int idx;
171 int ret;
172
173 if (!drm_dev_enter(drm_dev, &idx))
174 return -EIO;
175
176 /* All padding fields must be zeroed. */
177 if (args->_padding_4 != 0) {
178 ret = -EINVAL;
179 goto err_drm_dev_exit;
180 }
181
182 /*
183 * Obtain a kernel reference to the buffer object. This reference is
184 * counted and must be manually dropped before returning. If a buffer
185 * object cannot be found for the specified handle, return -%ENOENT (No
186 * such file or directory).
187 */
188 pvr_obj = pvr_gem_object_from_handle(pvr_file, args->handle);
189 if (!pvr_obj) {
190 ret = -ENOENT;
191 goto err_drm_dev_exit;
192 }
193
194 gem_obj = gem_from_pvr_gem(pvr_obj);
195
196 /*
197 * Allocate a fake offset which can be used in userspace calls to mmap
198 * on the DRM device file. If this fails, return the error code. This
199 * operation is idempotent.
200 */
201 ret = drm_gem_create_mmap_offset(gem_obj);
202 if (ret != 0) {
203 /* Drop our reference to the buffer object. */
204 drm_gem_object_put(gem_obj);
205 goto err_drm_dev_exit;
206 }
207
208 /*
209 * Read out the fake offset allocated by the earlier call to
210 * drm_gem_create_mmap_offset.
211 */
212 args->offset = drm_vma_node_offset_addr(&gem_obj->vma_node);
213
214 /* Drop our reference to the buffer object. */
215 pvr_gem_object_put(pvr_obj);
216
217err_drm_dev_exit:
218 drm_dev_exit(idx);
219
220 return ret;
221}
222
223static __always_inline u64
224pvr_fw_version_packed(u32 major, u32 minor)
225{
226 return ((u64)major << 32) | minor;
227}
228
229static u32
230rogue_get_common_store_partition_space_size(struct pvr_device *pvr_dev)
231{
232 u32 max_partitions = 0;
233 u32 tile_size_x = 0;
234 u32 tile_size_y = 0;
235
236 PVR_FEATURE_VALUE(pvr_dev, tile_size_x, &tile_size_x);
237 PVR_FEATURE_VALUE(pvr_dev, tile_size_y, &tile_size_y);
238 PVR_FEATURE_VALUE(pvr_dev, max_partitions, &max_partitions);
239
240 if (tile_size_x == 16 && tile_size_y == 16) {
241 u32 usc_min_output_registers_per_pix = 0;
242
243 PVR_FEATURE_VALUE(pvr_dev, usc_min_output_registers_per_pix,
244 &usc_min_output_registers_per_pix);
245
246 return tile_size_x * tile_size_y * max_partitions *
247 usc_min_output_registers_per_pix;
248 }
249
250 return max_partitions * 1024;
251}
252
253static u32
254rogue_get_common_store_alloc_region_size(struct pvr_device *pvr_dev)
255{
256 u32 common_store_size_in_dwords = 512 * 4 * 4;
257 u32 alloc_region_size;
258
259 PVR_FEATURE_VALUE(pvr_dev, common_store_size_in_dwords, &common_store_size_in_dwords);
260
261 alloc_region_size = common_store_size_in_dwords - (256U * 4U) -
262 rogue_get_common_store_partition_space_size(pvr_dev);
263
264 if (PVR_HAS_QUIRK(pvr_dev, 44079)) {
265 u32 common_store_split_point = (768U * 4U * 4U);
266
267 return min(common_store_split_point - (256U * 4U), alloc_region_size);
268 }
269
270 return alloc_region_size;
271}
272
273static inline u32
274rogue_get_num_phantoms(struct pvr_device *pvr_dev)
275{
276 u32 num_clusters = 1;
277
278 PVR_FEATURE_VALUE(pvr_dev, num_clusters, &num_clusters);
279
280 return ROGUE_REQ_NUM_PHANTOMS(num_clusters);
281}
282
283static inline u32
284rogue_get_max_coeffs(struct pvr_device *pvr_dev)
285{
286 u32 max_coeff_additional_portion = ROGUE_MAX_VERTEX_SHARED_REGISTERS;
287 u32 pending_allocation_shared_regs = 2U * 1024U;
288 u32 pending_allocation_coeff_regs = 0U;
289 u32 num_phantoms = rogue_get_num_phantoms(pvr_dev);
290 u32 tiles_in_flight = 0;
291 u32 max_coeff_pixel_portion;
292
293 PVR_FEATURE_VALUE(pvr_dev, isp_max_tiles_in_flight, &tiles_in_flight);
294 max_coeff_pixel_portion = DIV_ROUND_UP(tiles_in_flight, num_phantoms);
295 max_coeff_pixel_portion *= ROGUE_MAX_PIXEL_SHARED_REGISTERS;
296
297 /*
298 * Compute tasks on cores with BRN48492 and without compute overlap may lock
299 * up without two additional lines of coeffs.
300 */
301 if (PVR_HAS_QUIRK(pvr_dev, 48492) && !PVR_HAS_FEATURE(pvr_dev, compute_overlap))
302 pending_allocation_coeff_regs = 2U * 1024U;
303
304 if (PVR_HAS_ENHANCEMENT(pvr_dev, 38748))
305 pending_allocation_shared_regs = 0;
306
307 if (PVR_HAS_ENHANCEMENT(pvr_dev, 38020))
308 max_coeff_additional_portion += ROGUE_MAX_COMPUTE_SHARED_REGISTERS;
309
310 return rogue_get_common_store_alloc_region_size(pvr_dev) + pending_allocation_coeff_regs -
311 (max_coeff_pixel_portion + max_coeff_additional_portion +
312 pending_allocation_shared_regs);
313}
314
315static inline u32
316rogue_get_cdm_max_local_mem_size_regs(struct pvr_device *pvr_dev)
317{
318 u32 available_coeffs_in_dwords = rogue_get_max_coeffs(pvr_dev);
319
320 if (PVR_HAS_QUIRK(pvr_dev, 48492) && PVR_HAS_FEATURE(pvr_dev, roguexe) &&
321 !PVR_HAS_FEATURE(pvr_dev, compute_overlap)) {
322 /* Driver must not use the 2 reserved lines. */
323 available_coeffs_in_dwords -= ROGUE_CSRM_LINE_SIZE_IN_DWORDS * 2;
324 }
325
326 /*
327 * The maximum amount of local memory available to a kernel is the minimum
328 * of the total number of coefficient registers available and the max common
329 * store allocation size which can be made by the CDM.
330 *
331 * If any coeff lines are reserved for tessellation or pixel then we need to
332 * subtract those too.
333 */
334 return min(available_coeffs_in_dwords, (u32)ROGUE_MAX_PER_KERNEL_LOCAL_MEM_SIZE_REGS);
335}
336
337/**
338 * pvr_dev_query_gpu_info_get()
339 * @pvr_dev: Device pointer.
340 * @args: [IN] Device query arguments containing a pointer to a userspace
341 * struct drm_pvr_dev_query_gpu_info.
342 *
343 * If the query object pointer is NULL, the size field is updated with the
344 * expected size of the query object.
345 *
346 * Returns:
347 * * 0 on success, or if size is requested using a NULL pointer, or
348 * * -%E2BIG if the indicated length of the allocation is less than is
349 * required to contain the copied data, or
350 * * -%EFAULT if local memory could not be copied to userspace.
351 */
352static int
353pvr_dev_query_gpu_info_get(struct pvr_device *pvr_dev,
354 struct drm_pvr_ioctl_dev_query_args *args)
355{
356 struct drm_pvr_dev_query_gpu_info gpu_info = {0};
357 int err;
358
359 if (!args->pointer) {
360 args->size = sizeof(struct drm_pvr_dev_query_gpu_info);
361 return 0;
362 }
363
364 gpu_info.gpu_id =
365 pvr_gpu_id_to_packed_bvnc(&pvr_dev->gpu_id);
366 gpu_info.num_phantoms = rogue_get_num_phantoms(pvr_dev);
367
368 err = PVR_UOBJ_SET(args->pointer, args->size, gpu_info);
369 if (err < 0)
370 return err;
371
372 if (args->size > sizeof(gpu_info))
373 args->size = sizeof(gpu_info);
374 return 0;
375}
376
377/**
378 * pvr_dev_query_runtime_info_get()
379 * @pvr_dev: Device pointer.
380 * @args: [IN] Device query arguments containing a pointer to a userspace
381 * struct drm_pvr_dev_query_runtime_info.
382 *
383 * If the query object pointer is NULL, the size field is updated with the
384 * expected size of the query object.
385 *
386 * Returns:
387 * * 0 on success, or if size is requested using a NULL pointer, or
388 * * -%E2BIG if the indicated length of the allocation is less than is
389 * required to contain the copied data, or
390 * * -%EFAULT if local memory could not be copied to userspace.
391 */
392static int
393pvr_dev_query_runtime_info_get(struct pvr_device *pvr_dev,
394 struct drm_pvr_ioctl_dev_query_args *args)
395{
396 struct drm_pvr_dev_query_runtime_info runtime_info = {0};
397 int err;
398
399 if (!args->pointer) {
400 args->size = sizeof(struct drm_pvr_dev_query_runtime_info);
401 return 0;
402 }
403
404 runtime_info.free_list_min_pages =
405 pvr_get_free_list_min_pages(pvr_dev);
406 runtime_info.free_list_max_pages =
407 ROGUE_PM_MAX_FREELIST_SIZE / ROGUE_PM_PAGE_SIZE;
408 runtime_info.common_store_alloc_region_size =
409 rogue_get_common_store_alloc_region_size(pvr_dev);
410 runtime_info.common_store_partition_space_size =
411 rogue_get_common_store_partition_space_size(pvr_dev);
412 runtime_info.max_coeffs = rogue_get_max_coeffs(pvr_dev);
413 runtime_info.cdm_max_local_mem_size_regs =
414 rogue_get_cdm_max_local_mem_size_regs(pvr_dev);
415
416 err = PVR_UOBJ_SET(args->pointer, args->size, runtime_info);
417 if (err < 0)
418 return err;
419
420 if (args->size > sizeof(runtime_info))
421 args->size = sizeof(runtime_info);
422 return 0;
423}
424
425/**
426 * pvr_dev_query_quirks_get() - Unpack array of quirks at the address given
427 * in a struct drm_pvr_dev_query_quirks, or gets the amount of space required
428 * for it.
429 * @pvr_dev: Device pointer.
430 * @args: [IN] Device query arguments containing a pointer to a userspace
431 * struct drm_pvr_dev_query_query_quirks.
432 *
433 * If the query object pointer is NULL, the size field is updated with the
434 * expected size of the query object.
435 * If the userspace pointer in the query object is NULL, or the count is
436 * short, no data is copied.
437 * The count field will be updated to that copied, or if either pointer is
438 * NULL, that which would have been copied.
439 * The size field in the query object will be updated to the size copied.
440 *
441 * Returns:
442 * * 0 on success, or if size/count is requested using a NULL pointer, or
443 * * -%EINVAL if args contained non-zero reserved fields, or
444 * * -%E2BIG if the indicated length of the allocation is less than is
445 * required to contain the copied data, or
446 * * -%EFAULT if local memory could not be copied to userspace.
447 */
448static int
449pvr_dev_query_quirks_get(struct pvr_device *pvr_dev,
450 struct drm_pvr_ioctl_dev_query_args *args)
451{
452 /*
453 * @FIXME - hardcoding of numbers here is intended as an
454 * intermediate step so the UAPI can be fixed, but requires a
455 * a refactor in the future to store them in a more appropriate
456 * location
457 */
458 static const u32 umd_quirks_musthave[] = {
459 47217,
460 49927,
461 62269,
462 };
463 static const u32 umd_quirks[] = {
464 48545,
465 51764,
466 };
467 struct drm_pvr_dev_query_quirks query;
468 u32 out[ARRAY_SIZE(umd_quirks_musthave) + ARRAY_SIZE(umd_quirks)];
469 size_t out_musthave_count = 0;
470 size_t out_count = 0;
471 int err;
472
473 if (!args->pointer) {
474 args->size = sizeof(struct drm_pvr_dev_query_quirks);
475 return 0;
476 }
477
478 err = PVR_UOBJ_GET(query, args->size, args->pointer);
479
480 if (err < 0)
481 return err;
482 if (query._padding_c)
483 return -EINVAL;
484
485 for (int i = 0; i < ARRAY_SIZE(umd_quirks_musthave); i++) {
486 if (pvr_device_has_uapi_quirk(pvr_dev, umd_quirks_musthave[i])) {
487 out[out_count++] = umd_quirks_musthave[i];
488 out_musthave_count++;
489 }
490 }
491
492 for (int i = 0; i < ARRAY_SIZE(umd_quirks); i++) {
493 if (pvr_device_has_uapi_quirk(pvr_dev, umd_quirks[i]))
494 out[out_count++] = umd_quirks[i];
495 }
496
497 if (!query.quirks)
498 goto copy_out;
499 if (query.count < out_count)
500 return -E2BIG;
501
502 if (copy_to_user(u64_to_user_ptr(query.quirks), out,
503 out_count * sizeof(u32))) {
504 return -EFAULT;
505 }
506
507 query.musthave_count = out_musthave_count;
508
509copy_out:
510 query.count = out_count;
511 err = PVR_UOBJ_SET(args->pointer, args->size, query);
512 if (err < 0)
513 return err;
514
515 args->size = sizeof(query);
516 return 0;
517}
518
519/**
520 * pvr_dev_query_enhancements_get() - Unpack array of enhancements at the
521 * address given in a struct drm_pvr_dev_query_enhancements, or gets the amount
522 * of space required for it.
523 * @pvr_dev: Device pointer.
524 * @args: [IN] Device query arguments containing a pointer to a userspace
525 * struct drm_pvr_dev_query_enhancements.
526 *
527 * If the query object pointer is NULL, the size field is updated with the
528 * expected size of the query object.
529 * If the userspace pointer in the query object is NULL, or the count is
530 * short, no data is copied.
531 * The count field will be updated to that copied, or if either pointer is
532 * NULL, that which would have been copied.
533 * The size field in the query object will be updated to the size copied.
534 *
535 * Returns:
536 * * 0 on success, or if size/count is requested using a NULL pointer, or
537 * * -%EINVAL if args contained non-zero reserved fields, or
538 * * -%E2BIG if the indicated length of the allocation is less than is
539 * required to contain the copied data, or
540 * * -%EFAULT if local memory could not be copied to userspace.
541 */
542static int
543pvr_dev_query_enhancements_get(struct pvr_device *pvr_dev,
544 struct drm_pvr_ioctl_dev_query_args *args)
545{
546 /*
547 * @FIXME - hardcoding of numbers here is intended as an
548 * intermediate step so the UAPI can be fixed, but requires a
549 * a refactor in the future to store them in a more appropriate
550 * location
551 */
552 const u32 umd_enhancements[] = {
553 35421,
554 42064,
555 };
556 struct drm_pvr_dev_query_enhancements query;
557 u32 out[ARRAY_SIZE(umd_enhancements)];
558 size_t out_idx = 0;
559 int err;
560
561 if (!args->pointer) {
562 args->size = sizeof(struct drm_pvr_dev_query_enhancements);
563 return 0;
564 }
565
566 err = PVR_UOBJ_GET(query, args->size, args->pointer);
567
568 if (err < 0)
569 return err;
570 if (query._padding_a)
571 return -EINVAL;
572 if (query._padding_c)
573 return -EINVAL;
574
575 for (int i = 0; i < ARRAY_SIZE(umd_enhancements); i++) {
576 if (pvr_device_has_uapi_enhancement(pvr_dev, umd_enhancements[i]))
577 out[out_idx++] = umd_enhancements[i];
578 }
579
580 if (!query.enhancements)
581 goto copy_out;
582 if (query.count < out_idx)
583 return -E2BIG;
584
585 if (copy_to_user(u64_to_user_ptr(query.enhancements), out,
586 out_idx * sizeof(u32))) {
587 return -EFAULT;
588 }
589
590copy_out:
591 query.count = out_idx;
592 err = PVR_UOBJ_SET(args->pointer, args->size, query);
593 if (err < 0)
594 return err;
595
596 args->size = sizeof(query);
597 return 0;
598}
599
600/**
601 * pvr_ioctl_dev_query() - IOCTL to copy information about a device
602 * @drm_dev: [IN] DRM device.
603 * @raw_args: [IN/OUT] Arguments passed to this IOCTL. This must be of type
604 * &struct drm_pvr_ioctl_dev_query_args.
605 * @file: [IN] DRM file private data.
606 *
607 * Called from userspace with %DRM_IOCTL_PVR_DEV_QUERY.
608 * If the given receiving struct pointer is NULL, or the indicated size is too
609 * small, the expected size of the struct type will be returned in the size
610 * argument field.
611 *
612 * Return:
613 * * 0 on success or when fetching the size with args->pointer == NULL, or
614 * * -%E2BIG if the indicated size of the receiving struct is less than is
615 * required to contain the copied data, or
616 * * -%EINVAL if the indicated struct type is unknown, or
617 * * -%ENOMEM if local memory could not be allocated, or
618 * * -%EFAULT if local memory could not be copied to userspace.
619 */
620static int
621pvr_ioctl_dev_query(struct drm_device *drm_dev, void *raw_args,
622 struct drm_file *file)
623{
624 struct pvr_device *pvr_dev = to_pvr_device(drm_dev);
625 struct drm_pvr_ioctl_dev_query_args *args = raw_args;
626 int idx;
627 int ret = -EINVAL;
628
629 if (!drm_dev_enter(drm_dev, &idx))
630 return -EIO;
631
632 switch ((enum drm_pvr_dev_query)args->type) {
633 case DRM_PVR_DEV_QUERY_GPU_INFO_GET:
634 ret = pvr_dev_query_gpu_info_get(pvr_dev, args);
635 break;
636
637 case DRM_PVR_DEV_QUERY_RUNTIME_INFO_GET:
638 ret = pvr_dev_query_runtime_info_get(pvr_dev, args);
639 break;
640
641 case DRM_PVR_DEV_QUERY_QUIRKS_GET:
642 ret = pvr_dev_query_quirks_get(pvr_dev, args);
643 break;
644
645 case DRM_PVR_DEV_QUERY_ENHANCEMENTS_GET:
646 ret = pvr_dev_query_enhancements_get(pvr_dev, args);
647 break;
648
649 case DRM_PVR_DEV_QUERY_HEAP_INFO_GET:
650 ret = pvr_heap_info_get(pvr_dev, args);
651 break;
652
653 case DRM_PVR_DEV_QUERY_STATIC_DATA_AREAS_GET:
654 ret = pvr_static_data_areas_get(pvr_dev, args);
655 break;
656 }
657
658 drm_dev_exit(idx);
659
660 return ret;
661}
662
663/**
664 * pvr_ioctl_create_context() - IOCTL to create a context
665 * @drm_dev: [IN] DRM device.
666 * @raw_args: [IN/OUT] Arguments passed to this IOCTL. This must be of type
667 * &struct drm_pvr_ioctl_create_context_args.
668 * @file: [IN] DRM file private data.
669 *
670 * Called from userspace with %DRM_IOCTL_PVR_CREATE_CONTEXT.
671 *
672 * Return:
673 * * 0 on success, or
674 * * -%EINVAL if provided arguments are invalid, or
675 * * -%EFAULT if arguments can't be copied from userspace, or
676 * * Any error returned by pvr_create_render_context().
677 */
678static int
679pvr_ioctl_create_context(struct drm_device *drm_dev, void *raw_args,
680 struct drm_file *file)
681{
682 struct drm_pvr_ioctl_create_context_args *args = raw_args;
683 struct pvr_file *pvr_file = file->driver_priv;
684 int idx;
685 int ret;
686
687 if (!drm_dev_enter(drm_dev, &idx))
688 return -EIO;
689
690 ret = pvr_context_create(pvr_file, args);
691
692 drm_dev_exit(idx);
693
694 return ret;
695}
696
697/**
698 * pvr_ioctl_destroy_context() - IOCTL to destroy a context
699 * @drm_dev: [IN] DRM device.
700 * @raw_args: [IN/OUT] Arguments passed to this IOCTL. This must be of type
701 * &struct drm_pvr_ioctl_destroy_context_args.
702 * @file: [IN] DRM file private data.
703 *
704 * Called from userspace with %DRM_IOCTL_PVR_DESTROY_CONTEXT.
705 *
706 * Return:
707 * * 0 on success, or
708 * * -%EINVAL if context not in context list.
709 */
710static int
711pvr_ioctl_destroy_context(struct drm_device *drm_dev, void *raw_args,
712 struct drm_file *file)
713{
714 struct drm_pvr_ioctl_destroy_context_args *args = raw_args;
715 struct pvr_file *pvr_file = file->driver_priv;
716
717 if (args->_padding_4)
718 return -EINVAL;
719
720 return pvr_context_destroy(pvr_file, args->handle);
721}
722
723/**
724 * pvr_ioctl_create_free_list() - IOCTL to create a free list
725 * @drm_dev: [IN] DRM device.
726 * @raw_args: [IN/OUT] Arguments passed to this IOCTL. This must be of type
727 * &struct drm_pvr_ioctl_create_free_list_args.
728 * @file: [IN] DRM file private data.
729 *
730 * Called from userspace with %DRM_IOCTL_PVR_CREATE_FREE_LIST.
731 *
732 * Return:
733 * * 0 on success, or
734 * * Any error returned by pvr_free_list_create().
735 */
736static int
737pvr_ioctl_create_free_list(struct drm_device *drm_dev, void *raw_args,
738 struct drm_file *file)
739{
740 struct drm_pvr_ioctl_create_free_list_args *args = raw_args;
741 struct pvr_file *pvr_file = to_pvr_file(file);
742 struct pvr_free_list *free_list;
743 int idx;
744 int err;
745
746 if (!drm_dev_enter(drm_dev, &idx))
747 return -EIO;
748
749 free_list = pvr_free_list_create(pvr_file, args);
750 if (IS_ERR(free_list)) {
751 err = PTR_ERR(free_list);
752 goto err_drm_dev_exit;
753 }
754
755 /* Allocate object handle for userspace. */
756 err = xa_alloc(&pvr_file->free_list_handles,
757 &args->handle,
758 free_list,
759 xa_limit_32b,
760 GFP_KERNEL);
761 if (err < 0)
762 goto err_cleanup;
763
764 drm_dev_exit(idx);
765
766 return 0;
767
768err_cleanup:
769 pvr_free_list_put(free_list);
770
771err_drm_dev_exit:
772 drm_dev_exit(idx);
773
774 return err;
775}
776
777/**
778 * pvr_ioctl_destroy_free_list() - IOCTL to destroy a free list
779 * @drm_dev: [IN] DRM device.
780 * @raw_args: [IN] Arguments passed to this IOCTL. This must be of type
781 * &struct drm_pvr_ioctl_destroy_free_list_args.
782 * @file: [IN] DRM file private data.
783 *
784 * Called from userspace with %DRM_IOCTL_PVR_DESTROY_FREE_LIST.
785 *
786 * Return:
787 * * 0 on success, or
788 * * -%EINVAL if free list not in object list.
789 */
790static int
791pvr_ioctl_destroy_free_list(struct drm_device *drm_dev, void *raw_args,
792 struct drm_file *file)
793{
794 struct drm_pvr_ioctl_destroy_free_list_args *args = raw_args;
795 struct pvr_file *pvr_file = to_pvr_file(file);
796 struct pvr_free_list *free_list;
797
798 if (args->_padding_4)
799 return -EINVAL;
800
801 free_list = xa_erase(&pvr_file->free_list_handles, args->handle);
802 if (!free_list)
803 return -EINVAL;
804
805 pvr_free_list_put(free_list);
806 return 0;
807}
808
809/**
810 * pvr_ioctl_create_hwrt_dataset() - IOCTL to create a HWRT dataset
811 * @drm_dev: [IN] DRM device.
812 * @raw_args: [IN/OUT] Arguments passed to this IOCTL. This must be of type
813 * &struct drm_pvr_ioctl_create_hwrt_dataset_args.
814 * @file: [IN] DRM file private data.
815 *
816 * Called from userspace with %DRM_IOCTL_PVR_CREATE_HWRT_DATASET.
817 *
818 * Return:
819 * * 0 on success, or
820 * * Any error returned by pvr_hwrt_dataset_create().
821 */
822static int
823pvr_ioctl_create_hwrt_dataset(struct drm_device *drm_dev, void *raw_args,
824 struct drm_file *file)
825{
826 struct drm_pvr_ioctl_create_hwrt_dataset_args *args = raw_args;
827 struct pvr_file *pvr_file = to_pvr_file(file);
828 struct pvr_hwrt_dataset *hwrt;
829 int idx;
830 int err;
831
832 if (!drm_dev_enter(drm_dev, &idx))
833 return -EIO;
834
835 hwrt = pvr_hwrt_dataset_create(pvr_file, args);
836 if (IS_ERR(hwrt)) {
837 err = PTR_ERR(hwrt);
838 goto err_drm_dev_exit;
839 }
840
841 /* Allocate object handle for userspace. */
842 err = xa_alloc(&pvr_file->hwrt_handles,
843 &args->handle,
844 hwrt,
845 xa_limit_32b,
846 GFP_KERNEL);
847 if (err < 0)
848 goto err_cleanup;
849
850 drm_dev_exit(idx);
851
852 return 0;
853
854err_cleanup:
855 pvr_hwrt_dataset_put(hwrt);
856
857err_drm_dev_exit:
858 drm_dev_exit(idx);
859
860 return err;
861}
862
863/**
864 * pvr_ioctl_destroy_hwrt_dataset() - IOCTL to destroy a HWRT dataset
865 * @drm_dev: [IN] DRM device.
866 * @raw_args: [IN] Arguments passed to this IOCTL. This must be of type
867 * &struct drm_pvr_ioctl_destroy_hwrt_dataset_args.
868 * @file: [IN] DRM file private data.
869 *
870 * Called from userspace with %DRM_IOCTL_PVR_DESTROY_HWRT_DATASET.
871 *
872 * Return:
873 * * 0 on success, or
874 * * -%EINVAL if HWRT dataset not in object list.
875 */
876static int
877pvr_ioctl_destroy_hwrt_dataset(struct drm_device *drm_dev, void *raw_args,
878 struct drm_file *file)
879{
880 struct drm_pvr_ioctl_destroy_hwrt_dataset_args *args = raw_args;
881 struct pvr_file *pvr_file = to_pvr_file(file);
882 struct pvr_hwrt_dataset *hwrt;
883
884 if (args->_padding_4)
885 return -EINVAL;
886
887 hwrt = xa_erase(&pvr_file->hwrt_handles, args->handle);
888 if (!hwrt)
889 return -EINVAL;
890
891 pvr_hwrt_dataset_put(hwrt);
892 return 0;
893}
894
895/**
896 * pvr_ioctl_create_vm_context() - IOCTL to create a VM context
897 * @drm_dev: [IN] DRM device.
898 * @raw_args: [IN/OUT] Arguments passed to this IOCTL. This must be of type
899 * &struct drm_pvr_ioctl_create_vm_context_args.
900 * @file: [IN] DRM file private data.
901 *
902 * Called from userspace with %DRM_IOCTL_PVR_CREATE_VM_CONTEXT.
903 *
904 * Return:
905 * * 0 on success, or
906 * * Any error returned by pvr_vm_create_context().
907 */
908static int
909pvr_ioctl_create_vm_context(struct drm_device *drm_dev, void *raw_args,
910 struct drm_file *file)
911{
912 struct drm_pvr_ioctl_create_vm_context_args *args = raw_args;
913 struct pvr_file *pvr_file = to_pvr_file(file);
914 struct pvr_vm_context *vm_ctx;
915 int idx;
916 int err;
917
918 if (!drm_dev_enter(drm_dev, &idx))
919 return -EIO;
920
921 if (args->_padding_4) {
922 err = -EINVAL;
923 goto err_drm_dev_exit;
924 }
925
926 vm_ctx = pvr_vm_create_context(pvr_file->pvr_dev, true);
927 if (IS_ERR(vm_ctx)) {
928 err = PTR_ERR(vm_ctx);
929 goto err_drm_dev_exit;
930 }
931
932 /* Allocate object handle for userspace. */
933 err = xa_alloc(&pvr_file->vm_ctx_handles,
934 &args->handle,
935 vm_ctx,
936 xa_limit_32b,
937 GFP_KERNEL);
938 if (err < 0)
939 goto err_cleanup;
940
941 drm_dev_exit(idx);
942
943 return 0;
944
945err_cleanup:
946 pvr_vm_context_put(vm_ctx);
947
948err_drm_dev_exit:
949 drm_dev_exit(idx);
950
951 return err;
952}
953
954/**
955 * pvr_ioctl_destroy_vm_context() - IOCTL to destroy a VM context
956* @drm_dev: [IN] DRM device.
957* @raw_args: [IN] Arguments passed to this IOCTL. This must be of type
958* &struct drm_pvr_ioctl_destroy_vm_context_args.
959* @file: [IN] DRM file private data.
960*
961* Called from userspace with %DRM_IOCTL_PVR_DESTROY_VM_CONTEXT.
962*
963* Return:
964* * 0 on success, or
965* * -%EINVAL if object not in object list.
966 */
967static int
968pvr_ioctl_destroy_vm_context(struct drm_device *drm_dev, void *raw_args,
969 struct drm_file *file)
970{
971 struct drm_pvr_ioctl_destroy_vm_context_args *args = raw_args;
972 struct pvr_file *pvr_file = to_pvr_file(file);
973 struct pvr_vm_context *vm_ctx;
974
975 if (args->_padding_4)
976 return -EINVAL;
977
978 vm_ctx = xa_erase(&pvr_file->vm_ctx_handles, args->handle);
979 if (!vm_ctx)
980 return -EINVAL;
981
982 pvr_vm_context_put(vm_ctx);
983 return 0;
984}
985
986/**
987 * pvr_ioctl_vm_map() - IOCTL to map buffer to GPU address space.
988 * @drm_dev: [IN] DRM device.
989 * @raw_args: [IN] Arguments passed to this IOCTL. This must be of type
990 * &struct drm_pvr_ioctl_vm_map_args.
991 * @file: [IN] DRM file private data.
992 *
993 * Called from userspace with %DRM_IOCTL_PVR_VM_MAP.
994 *
995 * Return:
996 * * 0 on success,
997 * * -%EINVAL if &drm_pvr_ioctl_vm_op_map_args.flags is not zero,
998 * * -%EINVAL if the bounds specified by &drm_pvr_ioctl_vm_op_map_args.offset
999 * and &drm_pvr_ioctl_vm_op_map_args.size are not valid or do not fall
1000 * within the buffer object specified by
1001 * &drm_pvr_ioctl_vm_op_map_args.handle,
1002 * * -%EINVAL if the bounds specified by
1003 * &drm_pvr_ioctl_vm_op_map_args.device_addr and
1004 * &drm_pvr_ioctl_vm_op_map_args.size do not form a valid device-virtual
1005 * address range which falls entirely within a single heap, or
1006 * * -%ENOENT if &drm_pvr_ioctl_vm_op_map_args.handle does not refer to a
1007 * valid PowerVR buffer object.
1008 */
1009static int
1010pvr_ioctl_vm_map(struct drm_device *drm_dev, void *raw_args,
1011 struct drm_file *file)
1012{
1013 struct pvr_device *pvr_dev = to_pvr_device(drm_dev);
1014 struct drm_pvr_ioctl_vm_map_args *args = raw_args;
1015 struct pvr_file *pvr_file = to_pvr_file(file);
1016 struct pvr_vm_context *vm_ctx;
1017
1018 struct pvr_gem_object *pvr_obj;
1019 size_t pvr_obj_size;
1020
1021 u64 offset_plus_size;
1022 int idx;
1023 int err;
1024
1025 if (!drm_dev_enter(drm_dev, &idx))
1026 return -EIO;
1027
1028 /* Initial validation of args. */
1029 if (args->_padding_14) {
1030 err = -EINVAL;
1031 goto err_drm_dev_exit;
1032 }
1033
1034 if (args->flags != 0 ||
1035 check_add_overflow(args->offset, args->size, &offset_plus_size) ||
1036 !pvr_find_heap_containing(pvr_dev, args->device_addr, args->size)) {
1037 err = -EINVAL;
1038 goto err_drm_dev_exit;
1039 }
1040
1041 vm_ctx = pvr_vm_context_lookup(pvr_file, args->vm_context_handle);
1042 if (!vm_ctx) {
1043 err = -EINVAL;
1044 goto err_drm_dev_exit;
1045 }
1046
1047 pvr_obj = pvr_gem_object_from_handle(pvr_file, args->handle);
1048 if (!pvr_obj) {
1049 err = -ENOENT;
1050 goto err_put_vm_context;
1051 }
1052
1053 pvr_obj_size = pvr_gem_object_size(pvr_obj);
1054
1055 /*
1056 * Validate offset and size args. The alignment of these will be
1057 * checked when mapping; for now just check that they're within valid
1058 * bounds
1059 */
1060 if (args->offset >= pvr_obj_size || offset_plus_size > pvr_obj_size) {
1061 err = -EINVAL;
1062 goto err_put_pvr_object;
1063 }
1064
1065 err = pvr_vm_map(vm_ctx, pvr_obj, args->offset,
1066 args->device_addr, args->size);
1067 if (err)
1068 goto err_put_pvr_object;
1069
1070 /*
1071 * In order to set up the mapping, we needed a reference to &pvr_obj.
1072 * However, pvr_vm_map() obtains and stores its own reference, so we
1073 * must release ours before returning.
1074 */
1075
1076err_put_pvr_object:
1077 pvr_gem_object_put(pvr_obj);
1078
1079err_put_vm_context:
1080 pvr_vm_context_put(vm_ctx);
1081
1082err_drm_dev_exit:
1083 drm_dev_exit(idx);
1084
1085 return err;
1086}
1087
1088/**
1089 * pvr_ioctl_vm_unmap() - IOCTL to unmap buffer from GPU address space.
1090 * @drm_dev: [IN] DRM device.
1091 * @raw_args: [IN] Arguments passed to this IOCTL. This must be of type
1092 * &struct drm_pvr_ioctl_vm_unmap_args.
1093 * @file: [IN] DRM file private data.
1094 *
1095 * Called from userspace with %DRM_IOCTL_PVR_VM_UNMAP.
1096 *
1097 * Return:
1098 * * 0 on success,
1099 * * -%EINVAL if &drm_pvr_ioctl_vm_op_unmap_args.device_addr is not a valid
1100 * device page-aligned device-virtual address, or
1101 * * -%ENOENT if there is currently no PowerVR buffer object mapped at
1102 * &drm_pvr_ioctl_vm_op_unmap_args.device_addr.
1103 */
1104static int
1105pvr_ioctl_vm_unmap(struct drm_device *drm_dev, void *raw_args,
1106 struct drm_file *file)
1107{
1108 struct drm_pvr_ioctl_vm_unmap_args *args = raw_args;
1109 struct pvr_file *pvr_file = to_pvr_file(file);
1110 struct pvr_vm_context *vm_ctx;
1111 int err;
1112
1113 /* Initial validation of args. */
1114 if (args->_padding_4)
1115 return -EINVAL;
1116
1117 vm_ctx = pvr_vm_context_lookup(pvr_file, args->vm_context_handle);
1118 if (!vm_ctx)
1119 return -EINVAL;
1120
1121 err = pvr_vm_unmap(vm_ctx, args->device_addr, args->size);
1122
1123 pvr_vm_context_put(vm_ctx);
1124
1125 return err;
1126}
1127
1128/*
1129 * pvr_ioctl_submit_job() - IOCTL to submit a job to the GPU
1130 * @drm_dev: [IN] DRM device.
1131 * @raw_args: [IN] Arguments passed to this IOCTL. This must be of type
1132 * &struct drm_pvr_ioctl_submit_job_args.
1133 * @file: [IN] DRM file private data.
1134 *
1135 * Called from userspace with %DRM_IOCTL_PVR_SUBMIT_JOB.
1136 *
1137 * Return:
1138 * * 0 on success, or
1139 * * -%EINVAL if arguments are invalid.
1140 */
1141static int
1142pvr_ioctl_submit_jobs(struct drm_device *drm_dev, void *raw_args,
1143 struct drm_file *file)
1144{
1145 struct drm_pvr_ioctl_submit_jobs_args *args = raw_args;
1146 struct pvr_device *pvr_dev = to_pvr_device(drm_dev);
1147 struct pvr_file *pvr_file = to_pvr_file(file);
1148 int idx;
1149 int err;
1150
1151 if (!drm_dev_enter(drm_dev, &idx))
1152 return -EIO;
1153
1154 err = pvr_submit_jobs(pvr_dev, pvr_file, args);
1155
1156 drm_dev_exit(idx);
1157
1158 return err;
1159}
1160
1161int
1162pvr_get_uobj(u64 usr_ptr, u32 usr_stride, u32 min_stride, u32 obj_size, void *out)
1163{
1164 if (usr_stride < min_stride)
1165 return -EINVAL;
1166
1167 return copy_struct_from_user(out, obj_size, u64_to_user_ptr(usr_ptr), usr_stride);
1168}
1169
1170int
1171pvr_set_uobj(u64 usr_ptr, u32 usr_stride, u32 min_stride, u32 obj_size, const void *in)
1172{
1173 if (usr_stride < min_stride)
1174 return -EINVAL;
1175
1176 if (copy_to_user(u64_to_user_ptr(usr_ptr), in, min_t(u32, usr_stride, obj_size)))
1177 return -EFAULT;
1178
1179 if (usr_stride > obj_size &&
1180 clear_user(u64_to_user_ptr(usr_ptr + obj_size), usr_stride - obj_size)) {
1181 return -EFAULT;
1182 }
1183
1184 return 0;
1185}
1186
1187int
1188pvr_get_uobj_array(const struct drm_pvr_obj_array *in, u32 min_stride, u32 obj_size, void **out)
1189{
1190 int ret = 0;
1191 void *out_alloc;
1192
1193 if (in->stride < min_stride)
1194 return -EINVAL;
1195
1196 if (!in->count)
1197 return 0;
1198
1199 out_alloc = kvmalloc_array(in->count, obj_size, GFP_KERNEL);
1200 if (!out_alloc)
1201 return -ENOMEM;
1202
1203 if (obj_size == in->stride) {
1204 if (copy_from_user(out_alloc, u64_to_user_ptr(in->array),
1205 (unsigned long)obj_size * in->count))
1206 ret = -EFAULT;
1207 } else {
1208 void __user *in_ptr = u64_to_user_ptr(in->array);
1209 void *out_ptr = out_alloc;
1210
1211 for (u32 i = 0; i < in->count; i++) {
1212 ret = copy_struct_from_user(out_ptr, obj_size, in_ptr, in->stride);
1213 if (ret)
1214 break;
1215
1216 out_ptr += obj_size;
1217 in_ptr += in->stride;
1218 }
1219 }
1220
1221 if (ret) {
1222 kvfree(out_alloc);
1223 return ret;
1224 }
1225
1226 *out = out_alloc;
1227 return 0;
1228}
1229
1230int
1231pvr_set_uobj_array(const struct drm_pvr_obj_array *out, u32 min_stride, u32 obj_size,
1232 const void *in)
1233{
1234 if (out->stride < min_stride)
1235 return -EINVAL;
1236
1237 if (!out->count)
1238 return 0;
1239
1240 if (obj_size == out->stride) {
1241 if (copy_to_user(u64_to_user_ptr(out->array), in,
1242 (unsigned long)obj_size * out->count))
1243 return -EFAULT;
1244 } else {
1245 u32 cpy_elem_size = min_t(u32, out->stride, obj_size);
1246 void __user *out_ptr = u64_to_user_ptr(out->array);
1247 const void *in_ptr = in;
1248
1249 for (u32 i = 0; i < out->count; i++) {
1250 if (copy_to_user(out_ptr, in_ptr, cpy_elem_size))
1251 return -EFAULT;
1252
1253 out_ptr += obj_size;
1254 in_ptr += out->stride;
1255 }
1256
1257 if (out->stride > obj_size &&
1258 clear_user(u64_to_user_ptr(out->array + obj_size),
1259 out->stride - obj_size)) {
1260 return -EFAULT;
1261 }
1262 }
1263
1264 return 0;
1265}
1266
1267#define DRM_PVR_IOCTL(_name, _func, _flags) \
1268 DRM_IOCTL_DEF_DRV(PVR_##_name, pvr_ioctl_##_func, _flags)
1269
1270/* clang-format off */
1271
1272static const struct drm_ioctl_desc pvr_drm_driver_ioctls[] = {
1273 DRM_PVR_IOCTL(DEV_QUERY, dev_query, DRM_RENDER_ALLOW),
1274 DRM_PVR_IOCTL(CREATE_BO, create_bo, DRM_RENDER_ALLOW),
1275 DRM_PVR_IOCTL(GET_BO_MMAP_OFFSET, get_bo_mmap_offset, DRM_RENDER_ALLOW),
1276 DRM_PVR_IOCTL(CREATE_VM_CONTEXT, create_vm_context, DRM_RENDER_ALLOW),
1277 DRM_PVR_IOCTL(DESTROY_VM_CONTEXT, destroy_vm_context, DRM_RENDER_ALLOW),
1278 DRM_PVR_IOCTL(VM_MAP, vm_map, DRM_RENDER_ALLOW),
1279 DRM_PVR_IOCTL(VM_UNMAP, vm_unmap, DRM_RENDER_ALLOW),
1280 DRM_PVR_IOCTL(CREATE_CONTEXT, create_context, DRM_RENDER_ALLOW),
1281 DRM_PVR_IOCTL(DESTROY_CONTEXT, destroy_context, DRM_RENDER_ALLOW),
1282 DRM_PVR_IOCTL(CREATE_FREE_LIST, create_free_list, DRM_RENDER_ALLOW),
1283 DRM_PVR_IOCTL(DESTROY_FREE_LIST, destroy_free_list, DRM_RENDER_ALLOW),
1284 DRM_PVR_IOCTL(CREATE_HWRT_DATASET, create_hwrt_dataset, DRM_RENDER_ALLOW),
1285 DRM_PVR_IOCTL(DESTROY_HWRT_DATASET, destroy_hwrt_dataset, DRM_RENDER_ALLOW),
1286 DRM_PVR_IOCTL(SUBMIT_JOBS, submit_jobs, DRM_RENDER_ALLOW),
1287};
1288
1289/* clang-format on */
1290
1291#undef DRM_PVR_IOCTL
1292
1293/**
1294 * pvr_drm_driver_open() - Driver callback when a new &struct drm_file is opened
1295 * @drm_dev: [IN] DRM device.
1296 * @file: [IN] DRM file private data.
1297 *
1298 * Allocates powervr-specific file private data (&struct pvr_file).
1299 *
1300 * Registered in &pvr_drm_driver.
1301 *
1302 * Return:
1303 * * 0 on success,
1304 * * -%ENOMEM if the allocation of a &struct ipvr_file fails, or
1305 * * Any error returned by pvr_memory_context_init().
1306 */
1307static int
1308pvr_drm_driver_open(struct drm_device *drm_dev, struct drm_file *file)
1309{
1310 struct pvr_device *pvr_dev = to_pvr_device(drm_dev);
1311 struct pvr_file *pvr_file;
1312
1313 pvr_file = kzalloc(sizeof(*pvr_file), GFP_KERNEL);
1314 if (!pvr_file)
1315 return -ENOMEM;
1316
1317 /*
1318 * Store reference to base DRM file private data for use by
1319 * from_pvr_file.
1320 */
1321 pvr_file->file = file;
1322
1323 /*
1324 * Store reference to powervr-specific outer device struct in file
1325 * private data for convenient access.
1326 */
1327 pvr_file->pvr_dev = pvr_dev;
1328
1329 xa_init_flags(&pvr_file->ctx_handles, XA_FLAGS_ALLOC1);
1330 xa_init_flags(&pvr_file->free_list_handles, XA_FLAGS_ALLOC1);
1331 xa_init_flags(&pvr_file->hwrt_handles, XA_FLAGS_ALLOC1);
1332 xa_init_flags(&pvr_file->vm_ctx_handles, XA_FLAGS_ALLOC1);
1333
1334 /*
1335 * Store reference to powervr-specific file private data in DRM file
1336 * private data.
1337 */
1338 file->driver_priv = pvr_file;
1339
1340 return 0;
1341}
1342
1343/**
1344 * pvr_drm_driver_postclose() - One of the driver callbacks when a &struct
1345 * drm_file is closed.
1346 * @drm_dev: [IN] DRM device (unused).
1347 * @file: [IN] DRM file private data.
1348 *
1349 * Frees powervr-specific file private data (&struct pvr_file).
1350 *
1351 * Registered in &pvr_drm_driver.
1352 */
1353static void
1354pvr_drm_driver_postclose(__always_unused struct drm_device *drm_dev,
1355 struct drm_file *file)
1356{
1357 struct pvr_file *pvr_file = to_pvr_file(file);
1358
1359 /* Kill remaining contexts. */
1360 pvr_destroy_contexts_for_file(pvr_file);
1361
1362 /* Drop references on any remaining objects. */
1363 pvr_destroy_free_lists_for_file(pvr_file);
1364 pvr_destroy_hwrt_datasets_for_file(pvr_file);
1365 pvr_destroy_vm_contexts_for_file(pvr_file);
1366
1367 kfree(pvr_file);
1368 file->driver_priv = NULL;
1369}
1370
1371DEFINE_DRM_GEM_FOPS(pvr_drm_driver_fops);
1372
1373static struct drm_driver pvr_drm_driver = {
1374 .driver_features = DRIVER_GEM | DRIVER_GEM_GPUVA | DRIVER_RENDER |
1375 DRIVER_SYNCOBJ | DRIVER_SYNCOBJ_TIMELINE,
1376 .open = pvr_drm_driver_open,
1377 .postclose = pvr_drm_driver_postclose,
1378 .ioctls = pvr_drm_driver_ioctls,
1379 .num_ioctls = ARRAY_SIZE(pvr_drm_driver_ioctls),
1380 .fops = &pvr_drm_driver_fops,
1381#if defined(CONFIG_DEBUG_FS)
1382 .debugfs_init = pvr_debugfs_init,
1383#endif
1384
1385 .name = PVR_DRIVER_NAME,
1386 .desc = PVR_DRIVER_DESC,
1387 .date = PVR_DRIVER_DATE,
1388 .major = PVR_DRIVER_MAJOR,
1389 .minor = PVR_DRIVER_MINOR,
1390 .patchlevel = PVR_DRIVER_PATCHLEVEL,
1391
1392 .gem_prime_import_sg_table = drm_gem_shmem_prime_import_sg_table,
1393 .gem_create_object = pvr_gem_create_object,
1394};
1395
1396static int
1397pvr_probe(struct platform_device *plat_dev)
1398{
1399 struct pvr_device *pvr_dev;
1400 struct drm_device *drm_dev;
1401 int err;
1402
1403 pvr_dev = devm_drm_dev_alloc(&plat_dev->dev, &pvr_drm_driver,
1404 struct pvr_device, base);
1405 if (IS_ERR(pvr_dev))
1406 return PTR_ERR(pvr_dev);
1407
1408 drm_dev = &pvr_dev->base;
1409
1410 platform_set_drvdata(plat_dev, drm_dev);
1411
1412 init_rwsem(&pvr_dev->reset_sem);
1413
1414 pvr_context_device_init(pvr_dev);
1415
1416 err = pvr_queue_device_init(pvr_dev);
1417 if (err)
1418 goto err_context_fini;
1419
1420 devm_pm_runtime_enable(&plat_dev->dev);
1421 pm_runtime_mark_last_busy(&plat_dev->dev);
1422
1423 pm_runtime_set_autosuspend_delay(&plat_dev->dev, 50);
1424 pm_runtime_use_autosuspend(&plat_dev->dev);
1425 pvr_watchdog_init(pvr_dev);
1426
1427 err = pvr_device_init(pvr_dev);
1428 if (err)
1429 goto err_watchdog_fini;
1430
1431 err = drm_dev_register(drm_dev, 0);
1432 if (err)
1433 goto err_device_fini;
1434
1435 xa_init_flags(&pvr_dev->free_list_ids, XA_FLAGS_ALLOC1);
1436 xa_init_flags(&pvr_dev->job_ids, XA_FLAGS_ALLOC1);
1437
1438 return 0;
1439
1440err_device_fini:
1441 pvr_device_fini(pvr_dev);
1442
1443err_watchdog_fini:
1444 pvr_watchdog_fini(pvr_dev);
1445
1446 pvr_queue_device_fini(pvr_dev);
1447
1448err_context_fini:
1449 pvr_context_device_fini(pvr_dev);
1450
1451 return err;
1452}
1453
1454static int
1455pvr_remove(struct platform_device *plat_dev)
1456{
1457 struct drm_device *drm_dev = platform_get_drvdata(plat_dev);
1458 struct pvr_device *pvr_dev = to_pvr_device(drm_dev);
1459
1460 WARN_ON(!xa_empty(&pvr_dev->job_ids));
1461 WARN_ON(!xa_empty(&pvr_dev->free_list_ids));
1462
1463 xa_destroy(&pvr_dev->job_ids);
1464 xa_destroy(&pvr_dev->free_list_ids);
1465
1466 pm_runtime_suspend(drm_dev->dev);
1467 pvr_device_fini(pvr_dev);
1468 drm_dev_unplug(drm_dev);
1469 pvr_watchdog_fini(pvr_dev);
1470 pvr_queue_device_fini(pvr_dev);
1471 pvr_context_device_fini(pvr_dev);
1472
1473 return 0;
1474}
1475
1476static const struct of_device_id dt_match[] = {
1477 { .compatible = "img,img-axe", .data = NULL },
1478 {}
1479};
1480MODULE_DEVICE_TABLE(of, dt_match);
1481
1482static const struct dev_pm_ops pvr_pm_ops = {
1483 RUNTIME_PM_OPS(pvr_power_device_suspend, pvr_power_device_resume, pvr_power_device_idle)
1484};
1485
1486static struct platform_driver pvr_driver = {
1487 .probe = pvr_probe,
1488 .remove = pvr_remove,
1489 .driver = {
1490 .name = PVR_DRIVER_NAME,
1491 .pm = &pvr_pm_ops,
1492 .of_match_table = dt_match,
1493 },
1494};
1495module_platform_driver(pvr_driver);
1496
1497MODULE_AUTHOR("Imagination Technologies Ltd.");
1498MODULE_DESCRIPTION(PVR_DRIVER_DESC);
1499MODULE_LICENSE("Dual MIT/GPL");
1500MODULE_IMPORT_NS(DMA_BUF);
1501MODULE_FIRMWARE("powervr/rogue_33.15.11.3_v1.fw");