| @@ -0,0 +1,1194 @@ |
| 1 | +/* SPDX-License-Identifier: MIT */ |
| 2 | +/* |
| 3 | + * Copyright (C) The Asahi Linux Contributors |
| 4 | + * Copyright (C) 2018-2023 Collabora Ltd. |
| 5 | + * Copyright (C) 2014-2018 Broadcom |
| 6 | + */ |
| 7 | +#ifndef _ASAHI_DRM_H_ |
| 8 | +#define _ASAHI_DRM_H_ |
| 9 | + |
| 10 | +#include "drm.h" |
| 11 | + |
| 12 | +#if defined(__cplusplus) |
| 13 | +extern "C" { |
| 14 | +#endif |
| 15 | + |
| 16 | +/** |
| 17 | + * DOC: Introduction to the Asahi UAPI |
| 18 | + * |
| 19 | + * This documentation describes the Asahi IOCTLs. |
| 20 | + * |
| 21 | + * Just a few generic rules about the data passed to the Asahi IOCTLs (cribbed |
| 22 | + * from Panthor): |
| 23 | + * |
| 24 | + * - Structures must be aligned on 64-bit/8-byte. If the object is not |
| 25 | + * naturally aligned, a padding field must be added. |
| 26 | + * - Fields must be explicitly aligned to their natural type alignment with |
| 27 | + * pad[0..N] fields. |
| 28 | + * - All padding fields will be checked by the driver to make sure they are |
| 29 | + * zeroed. |
| 30 | + * - Flags can be added, but not removed/replaced. |
| 31 | + * - New fields can be added to the main structures (the structures |
| 32 | + * directly passed to the ioctl). Those fields can be added at the end of |
| 33 | + * the structure, or replace existing padding fields. Any new field being |
| 34 | + * added must preserve the behavior that existed before those fields were |
| 35 | + * added when a value of zero is passed. |
| 36 | + * - New fields can be added to indirect objects (objects pointed by the |
| 37 | + * main structure), iff those objects are passed a size to reflect the |
| 38 | + * size known by the userspace driver (see |
| 39 | + * drm_asahi_cmd_header::size). |
| 40 | + * - If the kernel driver is too old to know some fields, those will be |
| 41 | + * ignored if zero, and otherwise rejected (and so will be zero on output). |
| 42 | + * - If userspace is too old to know some fields, those will be zeroed |
| 43 | + * (input) before the structure is parsed by the kernel driver. |
| 44 | + * - Each new flag/field addition must come with a driver version update so |
| 45 | + * the userspace driver doesn't have to guess which flags are supported. |
| 46 | + * - Structures should not contain unions, as this would defeat the |
| 47 | + * extensibility of such structures. |
| 48 | + * - IOCTLs can't be removed or replaced. New IOCTL IDs should be placed |
| 49 | + * at the end of the drm_asahi_ioctl_id enum. |
| 50 | + */ |
| 51 | + |
| 52 | +/** |
| 53 | + * enum drm_asahi_ioctl_id - IOCTL IDs |
| 54 | + * |
| 55 | + * Place new ioctls at the end, don't re-order, don't replace or remove entries. |
| 56 | + * |
| 57 | + * These IDs are not meant to be used directly. Use the DRM_IOCTL_ASAHI_xxx |
| 58 | + * definitions instead. |
| 59 | + */ |
| 60 | +enum drm_asahi_ioctl_id { |
| 61 | + /** @DRM_ASAHI_GET_PARAMS: Query device properties. */ |
| 62 | + DRM_ASAHI_GET_PARAMS = 0, |
| 63 | + |
| 64 | + /** @DRM_ASAHI_GET_TIME: Query device time. */ |
| 65 | + DRM_ASAHI_GET_TIME, |
| 66 | + |
| 67 | + /** @DRM_ASAHI_VM_CREATE: Create a GPU VM address space. */ |
| 68 | + DRM_ASAHI_VM_CREATE, |
| 69 | + |
| 70 | + /** @DRM_ASAHI_VM_DESTROY: Destroy a VM. */ |
| 71 | + DRM_ASAHI_VM_DESTROY, |
| 72 | + |
| 73 | + /** @DRM_ASAHI_VM_BIND: Bind/unbind memory to a VM. */ |
| 74 | + DRM_ASAHI_VM_BIND, |
| 75 | + |
| 76 | + /** @DRM_ASAHI_GEM_CREATE: Create a buffer object. */ |
| 77 | + DRM_ASAHI_GEM_CREATE, |
| 78 | + |
| 79 | + /** |
| 80 | + * @DRM_ASAHI_GEM_MMAP_OFFSET: Get offset to pass to mmap() to map a |
| 81 | + * given GEM handle. |
| 82 | + */ |
| 83 | + DRM_ASAHI_GEM_MMAP_OFFSET, |
| 84 | + |
| 85 | + /** @DRM_ASAHI_GEM_BIND_OBJECT: Bind memory as a special object */ |
| 86 | + DRM_ASAHI_GEM_BIND_OBJECT, |
| 87 | + |
| 88 | + /** @DRM_ASAHI_QUEUE_CREATE: Create a scheduling queue. */ |
| 89 | + DRM_ASAHI_QUEUE_CREATE, |
| 90 | + |
| 91 | + /** @DRM_ASAHI_QUEUE_DESTROY: Destroy a scheduling queue. */ |
| 92 | + DRM_ASAHI_QUEUE_DESTROY, |
| 93 | + |
| 94 | + /** @DRM_ASAHI_SUBMIT: Submit commands to a queue. */ |
| 95 | + DRM_ASAHI_SUBMIT, |
| 96 | +}; |
| 97 | + |
| 98 | +#define DRM_ASAHI_MAX_CLUSTERS 64 |
| 99 | + |
| 100 | +/** |
| 101 | + * struct drm_asahi_params_global - Global parameters. |
| 102 | + * |
| 103 | + * This struct may be queried by drm_asahi_get_params. |
| 104 | + */ |
| 105 | +struct drm_asahi_params_global { |
| 106 | + /** @features: Feature bits from drm_asahi_feature */ |
| 107 | + __u64 features; |
| 108 | + |
| 109 | + /** @gpu_generation: GPU generation, e.g. 13 for G13G */ |
| 110 | + __u32 gpu_generation; |
| 111 | + |
| 112 | + /** @gpu_variant: GPU variant as a character, e.g. 'C' for G13C */ |
| 113 | + __u32 gpu_variant; |
| 114 | + |
| 115 | + /** |
| 116 | + * @gpu_revision: GPU revision in BCD, e.g. 0x00 for 'A0' or |
| 117 | + * 0x21 for 'C1' |
| 118 | + */ |
| 119 | + __u32 gpu_revision; |
| 120 | + |
| 121 | + /** @chip_id: Chip ID in BCD, e.g. 0x8103 for T8103 */ |
| 122 | + __u32 chip_id; |
| 123 | + |
| 124 | + /** @num_dies: Number of dies in the SoC */ |
| 125 | + __u32 num_dies; |
| 126 | + |
| 127 | + /** @num_clusters_total: Number of GPU clusters (across all dies) */ |
| 128 | + __u32 num_clusters_total; |
| 129 | + |
| 130 | + /** |
| 131 | + * @num_cores_per_cluster: Number of logical cores per cluster |
| 132 | + * (including inactive/nonexistent) |
| 133 | + */ |
| 134 | + __u32 num_cores_per_cluster; |
| 135 | + |
| 136 | + /** @max_frequency_khz: Maximum GPU core clock frequency */ |
| 137 | + __u32 max_frequency_khz; |
| 138 | + |
| 139 | + /** @core_masks: Bitmask of present/enabled cores per cluster */ |
| 140 | + __u64 core_masks[DRM_ASAHI_MAX_CLUSTERS]; |
| 141 | + |
| 142 | + /** |
| 143 | + * @vm_start: VM range start VMA. Together with @vm_end, this defines |
| 144 | + * the window of valid GPU VAs. Userspace is expected to subdivide VAs |
| 145 | + * out of this window. |
| 146 | + * |
| 147 | + * This window contains all virtual addresses that userspace needs to |
| 148 | + * know about. There may be kernel-internal GPU VAs outside this range, |
| 149 | + * but that detail is not relevant here. |
| 150 | + */ |
| 151 | + __u64 vm_start; |
| 152 | + |
| 153 | + /** @vm_end: VM range end VMA */ |
| 154 | + __u64 vm_end; |
| 155 | + |
| 156 | + /** |
| 157 | + * @vm_kernel_min_size: Minimum kernel VMA window size. |
| 158 | + * |
| 159 | + * When creating a VM, userspace is required to carve out a section of |
| 160 | + * virtual addresses (within the range given by @vm_start and |
| 161 | + * @vm_end). The kernel will allocate various internal structures |
| 162 | + * within the specified VA range. |
| 163 | + * |
| 164 | + * Allowing userspace to choose the VA range for the kernel, rather than |
| 165 | + * the kernel reserving VAs and requiring userspace to cope, can assist |
| 166 | + * in implementing SVM. |
| 167 | + */ |
| 168 | + __u64 vm_kernel_min_size; |
| 169 | + |
| 170 | + /** |
| 171 | + * @max_commands_per_submission: Maximum number of supported commands |
| 172 | + * per submission. This mirrors firmware limits. Userspace must split up |
| 173 | + * larger command buffers, which may require inserting additional |
| 174 | + * synchronization. |
| 175 | + */ |
| 176 | + __u32 max_commands_per_submission; |
| 177 | + |
| 178 | + /** |
| 179 | + * @max_attachments: Maximum number of drm_asahi_attachment's per |
| 180 | + * command |
| 181 | + */ |
| 182 | + __u32 max_attachments; |
| 183 | + |
| 184 | + /** |
| 185 | + * @command_timestamp_frequency_hz: Timebase frequency for timestamps |
| 186 | + * written during command execution, specified via drm_asahi_timestamp |
| 187 | + * structures. As this rate is controlled by the firmware, it is a |
| 188 | + * queryable parameter. |
| 189 | + * |
| 190 | + * Userspace must divide by this frequency to convert timestamps to |
| 191 | + * seconds, rather than hardcoding a particular firmware's rate. |
| 192 | + */ |
| 193 | + __u64 command_timestamp_frequency_hz; |
| 194 | +}; |
| 195 | + |
| 196 | +/** |
| 197 | + * enum drm_asahi_feature - Feature bits |
| 198 | + * |
| 199 | + * This covers only features that userspace cannot infer from the architecture |
| 200 | + * version. Most features don't need to be here. |
| 201 | + */ |
| 202 | +enum drm_asahi_feature { |
| 203 | + /** |
| 204 | + * @DRM_ASAHI_FEATURE_SOFT_FAULTS: GPU has "soft fault" enabled. Shader |
| 205 | + * loads of unmapped memory will return zero. Shader stores to unmapped |
| 206 | + * memory will be silently discarded. Note that only shader load/store |
| 207 | + * is affected. Other hardware units are not affected, notably including |
| 208 | + * texture sampling. |
| 209 | + * |
| 210 | + * Soft fault is set when initializing the GPU and cannot be runtime |
| 211 | + * toggled. Therefore, it is exposed as a feature bit and not a |
| 212 | + * userspace-settable flag on the VM. When soft fault is enabled, |
| 213 | + * userspace can speculate memory accesses more aggressively. |
| 214 | + */ |
| 215 | + DRM_ASAHI_FEATURE_SOFT_FAULTS = (1UL) << 0, |
| 216 | +}; |
| 217 | + |
| 218 | +/** |
| 219 | + * struct drm_asahi_get_params - Arguments passed to DRM_IOCTL_ASAHI_GET_PARAMS |
| 220 | + */ |
| 221 | +struct drm_asahi_get_params { |
| 222 | + /** @param_group: Parameter group to fetch (MBZ) */ |
| 223 | + __u32 param_group; |
| 224 | + |
| 225 | + /** @pad: MBZ */ |
| 226 | + __u32 pad; |
| 227 | + |
| 228 | + /** @pointer: User pointer to write parameter struct */ |
| 229 | + __u64 pointer; |
| 230 | + |
| 231 | + /** |
| 232 | + * @size: Size of the user buffer. In case of older userspace, this may |
| 233 | + * be less than sizeof(struct drm_asahi_params_global). The kernel will |
| 234 | + * not write past the length specified here, allowing extensibility. |
| 235 | + */ |
| 236 | + __u64 size; |
| 237 | +}; |
| 238 | + |
| 239 | +/** |
| 240 | + * struct drm_asahi_vm_create - Arguments passed to DRM_IOCTL_ASAHI_VM_CREATE |
| 241 | + */ |
| 242 | +struct drm_asahi_vm_create { |
| 243 | + /** |
| 244 | + * @kernel_start: Start of the kernel-reserved address range. See |
| 245 | + * drm_asahi_params_global::vm_kernel_min_size. |
| 246 | + * |
| 247 | + * Both @kernel_start and @kernel_end must be within the range of |
| 248 | + * valid VAs given by drm_asahi_params_global::vm_start and |
| 249 | + * drm_asahi_params_global::vm_end. The size of the kernel range |
| 250 | + * (@kernel_end - @kernel_start) must be at least |
| 251 | + * drm_asahi_params_global::vm_kernel_min_size. |
| 252 | + * |
| 253 | + * Userspace must not bind any memory on this VM into this reserved |
| 254 | + * range, it is for kernel use only. |
| 255 | + */ |
| 256 | + __u64 kernel_start; |
| 257 | + |
| 258 | + /** |
| 259 | + * @kernel_end: End of the kernel-reserved address range. See |
| 260 | + * @kernel_start. |
| 261 | + */ |
| 262 | + __u64 kernel_end; |
| 263 | + |
| 264 | + /** @vm_id: Returned VM ID */ |
| 265 | + __u32 vm_id; |
| 266 | + |
| 267 | + /** @pad: MBZ */ |
| 268 | + __u32 pad; |
| 269 | +}; |
| 270 | + |
| 271 | +/** |
| 272 | + * struct drm_asahi_vm_destroy - Arguments passed to DRM_IOCTL_ASAHI_VM_DESTROY |
| 273 | + */ |
| 274 | +struct drm_asahi_vm_destroy { |
| 275 | + /** @vm_id: VM ID to be destroyed */ |
| 276 | + __u32 vm_id; |
| 277 | + |
| 278 | + /** @pad: MBZ */ |
| 279 | + __u32 pad; |
| 280 | +}; |
| 281 | + |
| 282 | +/** |
| 283 | + * enum drm_asahi_gem_flags - Flags for GEM creation |
| 284 | + */ |
| 285 | +enum drm_asahi_gem_flags { |
| 286 | + /** |
| 287 | + * @DRM_ASAHI_GEM_WRITEBACK: BO should be CPU-mapped as writeback. |
| 288 | + * |
| 289 | + * Map as writeback instead of write-combine. This optimizes for CPU |
| 290 | + * reads. |
| 291 | + */ |
| 292 | + DRM_ASAHI_GEM_WRITEBACK = (1L << 0), |
| 293 | + |
| 294 | + /** |
| 295 | + * @DRM_ASAHI_GEM_VM_PRIVATE: BO is private to this GPU VM (no exports). |
| 296 | + */ |
| 297 | + DRM_ASAHI_GEM_VM_PRIVATE = (1L << 1), |
| 298 | +}; |
| 299 | + |
| 300 | +/** |
| 301 | + * struct drm_asahi_gem_create - Arguments passed to DRM_IOCTL_ASAHI_GEM_CREATE |
| 302 | + */ |
| 303 | +struct drm_asahi_gem_create { |
| 304 | + /** @size: Size of the BO */ |
| 305 | + __u64 size; |
| 306 | + |
| 307 | + /** @flags: Combination of drm_asahi_gem_flags flags. */ |
| 308 | + __u32 flags; |
| 309 | + |
| 310 | + /** |
| 311 | + * @vm_id: VM ID to assign to the BO, if DRM_ASAHI_GEM_VM_PRIVATE is set |
| 312 | + */ |
| 313 | + __u32 vm_id; |
| 314 | + |
| 315 | + /** @handle: Returned GEM handle for the BO */ |
| 316 | + __u32 handle; |
| 317 | + |
| 318 | + /** @pad: MBZ */ |
| 319 | + __u32 pad; |
| 320 | +}; |
| 321 | + |
| 322 | +/** |
| 323 | + * struct drm_asahi_gem_mmap_offset - Arguments passed to |
| 324 | + * DRM_IOCTL_ASAHI_GEM_MMAP_OFFSET |
| 325 | + */ |
| 326 | +struct drm_asahi_gem_mmap_offset { |
| 327 | + /** @handle: Handle for the object being mapped. */ |
| 328 | + __u32 handle; |
| 329 | + |
| 330 | + /** @flags: Must be zero */ |
| 331 | + __u32 flags; |
| 332 | + |
| 333 | + /** @offset: The fake offset to use for subsequent mmap call */ |
| 334 | + __u64 offset; |
| 335 | +}; |
| 336 | + |
| 337 | +/** |
| 338 | + * enum drm_asahi_bind_flags - Flags for GEM binding |
| 339 | + */ |
| 340 | +enum drm_asahi_bind_flags { |
| 341 | + /** |
| 342 | + * @DRM_ASAHI_BIND_UNBIND: Instead of binding a GEM object to the range, |
| 343 | + * simply unbind the GPU VMA range. |
| 344 | + */ |
| 345 | + DRM_ASAHI_BIND_UNBIND = (1L << 0), |
| 346 | + |
| 347 | + /** @DRM_ASAHI_BIND_READ: Map BO with GPU read permission */ |
| 348 | + DRM_ASAHI_BIND_READ = (1L << 1), |
| 349 | + |
| 350 | + /** @DRM_ASAHI_BIND_WRITE: Map BO with GPU write permission */ |
| 351 | + DRM_ASAHI_BIND_WRITE = (1L << 2), |
| 352 | + |
| 353 | + /** |
| 354 | + * @DRM_ASAHI_BIND_SINGLE_PAGE: Map a single page of the BO repeatedly |
| 355 | + * across the VA range. |
| 356 | + * |
| 357 | + * This is useful to fill a VA range with scratch pages or zero pages. |
| 358 | + * It is intended as a mechanism to accelerate sparse. |
| 359 | + */ |
| 360 | + DRM_ASAHI_BIND_SINGLE_PAGE = (1L << 3), |
| 361 | +}; |
| 362 | + |
| 363 | +/** |
| 364 | + * struct drm_asahi_gem_bind_op - Description of a single GEM bind operation. |
| 365 | + */ |
| 366 | +struct drm_asahi_gem_bind_op { |
| 367 | + /** @flags: Combination of drm_asahi_bind_flags flags. */ |
| 368 | + __u32 flags; |
| 369 | + |
| 370 | + /** @handle: GEM object to bind (except for UNBIND) */ |
| 371 | + __u32 handle; |
| 372 | + |
| 373 | + /** |
| 374 | + * @offset: Offset into the object (except for UNBIND). |
| 375 | + * |
| 376 | + * For a regular bind, this is the beginning of the region of the GEM |
| 377 | + * object to bind. |
| 378 | + * |
| 379 | + * For a single-page bind, this is the offset to the single page that |
| 380 | + * will be repeatedly bound. |
| 381 | + * |
| 382 | + * Must be page-size aligned. |
| 383 | + */ |
| 384 | + __u64 offset; |
| 385 | + |
| 386 | + /** |
| 387 | + * @range: Number of bytes to bind/unbind to @addr. |
| 388 | + * |
| 389 | + * Must be page-size aligned. |
| 390 | + */ |
| 391 | + __u64 range; |
| 392 | + |
| 393 | + /** |
| 394 | + * @addr: Address to bind to. |
| 395 | + * |
| 396 | + * Must be page-size aligned. |
| 397 | + */ |
| 398 | + __u64 addr; |
| 399 | +}; |
| 400 | + |
| 401 | +/** |
| 402 | + * struct drm_asahi_vm_bind - Arguments passed to |
| 403 | + * DRM_IOCTL_ASAHI_VM_BIND |
| 404 | + */ |
| 405 | +struct drm_asahi_vm_bind { |
| 406 | + /** @vm_id: The ID of the VM to bind to */ |
| 407 | + __u32 vm_id; |
| 408 | + |
| 409 | + /** @num_binds: number of binds in this IOCTL. */ |
| 410 | + __u32 num_binds; |
| 411 | + |
| 412 | + /** |
| 413 | + * @stride: Stride in bytes between consecutive binds. This allows |
| 414 | + * extensibility of drm_asahi_gem_bind_op. |
| 415 | + */ |
| 416 | + __u32 stride; |
| 417 | + |
| 418 | + /** @pad: MBZ */ |
| 419 | + __u32 pad; |
| 420 | + |
| 421 | + /** |
| 422 | + * @userptr: User pointer to an array of @num_binds structures of type |
| 423 | + * @drm_asahi_gem_bind_op and size @stride bytes. |
| 424 | + */ |
| 425 | + __u64 userptr; |
| 426 | +}; |
| 427 | + |
| 428 | +/** |
| 429 | + * enum drm_asahi_bind_object_op - Special object bind operation |
| 430 | + */ |
| 431 | +enum drm_asahi_bind_object_op { |
| 432 | + /** @DRM_ASAHI_BIND_OBJECT_OP_BIND: Bind a BO as a special GPU object */ |
| 433 | + DRM_ASAHI_BIND_OBJECT_OP_BIND = 0, |
| 434 | + |
| 435 | + /** @DRM_ASAHI_BIND_OBJECT_OP_UNBIND: Unbind a special GPU object */ |
| 436 | + DRM_ASAHI_BIND_OBJECT_OP_UNBIND = 1, |
| 437 | +}; |
| 438 | + |
| 439 | +/** |
| 440 | + * enum drm_asahi_bind_object_flags - Special object bind flags |
| 441 | + */ |
| 442 | +enum drm_asahi_bind_object_flags { |
| 443 | + /** |
| 444 | + * @DRM_ASAHI_BIND_OBJECT_USAGE_TIMESTAMPS: Map a BO as a timestamp |
| 445 | + * buffer. |
| 446 | + */ |
| 447 | + DRM_ASAHI_BIND_OBJECT_USAGE_TIMESTAMPS = (1L << 0), |
| 448 | +}; |
| 449 | + |
| 450 | +/** |
| 451 | + * struct drm_asahi_gem_bind_object - Arguments passed to |
| 452 | + * DRM_IOCTL_ASAHI_GEM_BIND_OBJECT |
| 453 | + */ |
| 454 | +struct drm_asahi_gem_bind_object { |
| 455 | + /** @op: Bind operation (enum drm_asahi_bind_object_op) */ |
| 456 | + __u32 op; |
| 457 | + |
| 458 | + /** @flags: Combination of drm_asahi_bind_object_flags flags. */ |
| 459 | + __u32 flags; |
| 460 | + |
| 461 | + /** @handle: GEM object to bind/unbind (BIND) */ |
| 462 | + __u32 handle; |
| 463 | + |
| 464 | + /** @vm_id: The ID of the VM to operate on (MBZ currently) */ |
| 465 | + __u32 vm_id; |
| 466 | + |
| 467 | + /** @offset: Offset into the object (BIND only) */ |
| 468 | + __u64 offset; |
| 469 | + |
| 470 | + /** @range: Number of bytes to bind/unbind (BIND only) */ |
| 471 | + __u64 range; |
| 472 | + |
| 473 | + /** @object_handle: Object handle (out for BIND, in for UNBIND) */ |
| 474 | + __u32 object_handle; |
| 475 | + |
| 476 | + /** @pad: MBZ */ |
| 477 | + __u32 pad; |
| 478 | +}; |
| 479 | + |
| 480 | +/** |
| 481 | + * enum drm_asahi_cmd_type - Command type |
| 482 | + */ |
| 483 | +enum drm_asahi_cmd_type { |
| 484 | + /** |
| 485 | + * @DRM_ASAHI_CMD_RENDER: Render command, executing on the render |
| 486 | + * subqueue. Combined vertex and fragment operation. |
| 487 | + * |
| 488 | + * Followed by a @drm_asahi_cmd_render payload. |
| 489 | + */ |
| 490 | + DRM_ASAHI_CMD_RENDER = 0, |
| 491 | + |
| 492 | + /** |
| 493 | + * @DRM_ASAHI_CMD_COMPUTE: Compute command on the compute subqueue. |
| 494 | + * |
| 495 | + * Followed by a @drm_asahi_cmd_compute payload. |
| 496 | + */ |
| 497 | + DRM_ASAHI_CMD_COMPUTE = 1, |
| 498 | + |
| 499 | + /** |
| 500 | + * @DRM_ASAHI_SET_VERTEX_ATTACHMENTS: Software command to set |
| 501 | + * attachments for subsequent vertex shaders in the same submit. |
| 502 | + * |
| 503 | + * Followed by (possibly multiple) @drm_asahi_attachment payloads. |
| 504 | + */ |
| 505 | + DRM_ASAHI_SET_VERTEX_ATTACHMENTS = 2, |
| 506 | + |
| 507 | + /** |
| 508 | + * @DRM_ASAHI_SET_FRAGMENT_ATTACHMENTS: Software command to set |
| 509 | + * attachments for subsequent fragment shaders in the same submit. |
| 510 | + * |
| 511 | + * Followed by (possibly multiple) @drm_asahi_attachment payloads. |
| 512 | + */ |
| 513 | + DRM_ASAHI_SET_FRAGMENT_ATTACHMENTS = 3, |
| 514 | + |
| 515 | + /** |
| 516 | + * @DRM_ASAHI_SET_COMPUTE_ATTACHMENTS: Software command to set |
| 517 | + * attachments for subsequent compute shaders in the same submit. |
| 518 | + * |
| 519 | + * Followed by (possibly multiple) @drm_asahi_attachment payloads. |
| 520 | + */ |
| 521 | + DRM_ASAHI_SET_COMPUTE_ATTACHMENTS = 4, |
| 522 | +}; |
| 523 | + |
| 524 | +/** |
| 525 | + * enum drm_asahi_priority - Scheduling queue priority. |
| 526 | + * |
| 527 | + * These priorities are forwarded to the firmware to influence firmware |
| 528 | + * scheduling. The exact policy is ultimately decided by firmware, but |
| 529 | + * these enums allow userspace to communicate the intentions. |
| 530 | + */ |
| 531 | +enum drm_asahi_priority { |
| 532 | + /** @DRM_ASAHI_PRIORITY_LOW: Low priority queue. */ |
| 533 | + DRM_ASAHI_PRIORITY_LOW = 0, |
| 534 | + |
| 535 | + /** @DRM_ASAHI_PRIORITY_MEDIUM: Medium priority queue. */ |
| 536 | + DRM_ASAHI_PRIORITY_MEDIUM = 1, |
| 537 | + |
| 538 | + /** |
| 539 | + * @DRM_ASAHI_PRIORITY_HIGH: High priority queue. |
| 540 | + * |
| 541 | + * Reserved for future extension. |
| 542 | + */ |
| 543 | + DRM_ASAHI_PRIORITY_HIGH = 2, |
| 544 | + |
| 545 | + /** |
| 546 | + * @DRM_ASAHI_PRIORITY_REALTIME: Real-time priority queue. |
| 547 | + * |
| 548 | + * Reserved for future extension. |
| 549 | + */ |
| 550 | + DRM_ASAHI_PRIORITY_REALTIME = 3, |
| 551 | +}; |
| 552 | + |
| 553 | +/** |
| 554 | + * struct drm_asahi_queue_create - Arguments passed to |
| 555 | + * DRM_IOCTL_ASAHI_QUEUE_CREATE |
| 556 | + */ |
| 557 | +struct drm_asahi_queue_create { |
| 558 | + /** @flags: MBZ */ |
| 559 | + __u32 flags; |
| 560 | + |
| 561 | + /** @vm_id: The ID of the VM this queue is bound to */ |
| 562 | + __u32 vm_id; |
| 563 | + |
| 564 | + /** @priority: One of drm_asahi_priority */ |
| 565 | + __u32 priority; |
| 566 | + |
| 567 | + /** @queue_id: The returned queue ID */ |
| 568 | + __u32 queue_id; |
| 569 | + |
| 570 | + /** |
| 571 | + * @usc_exec_base: GPU base address for all USC binaries (shaders) on |
| 572 | + * this queue. USC addresses are 32-bit relative to this 64-bit base. |
| 573 | + * |
| 574 | + * This sets the following registers on all queue commands: |
| 575 | + * |
| 576 | + * USC_EXEC_BASE_TA (vertex) |
| 577 | + * USC_EXEC_BASE_ISP (fragment) |
| 578 | + * USC_EXEC_BASE_CP (compute) |
| 579 | + * |
| 580 | + * While the hardware lets us configure these independently per command, |
| 581 | + * we do not have a use case for this. Instead, we expect userspace to |
| 582 | + * fix a 4GiB VA carveout for USC memory and pass its base address here. |
| 583 | + */ |
| 584 | + __u64 usc_exec_base; |
| 585 | +}; |
| 586 | + |
| 587 | +/** |
| 588 | + * struct drm_asahi_queue_destroy - Arguments passed to |
| 589 | + * DRM_IOCTL_ASAHI_QUEUE_DESTROY |
| 590 | + */ |
| 591 | +struct drm_asahi_queue_destroy { |
| 592 | + /** @queue_id: The queue ID to be destroyed */ |
| 593 | + __u32 queue_id; |
| 594 | + |
| 595 | + /** @pad: MBZ */ |
| 596 | + __u32 pad; |
| 597 | +}; |
| 598 | + |
| 599 | +/** |
| 600 | + * enum drm_asahi_sync_type - Sync item type |
| 601 | + */ |
| 602 | +enum drm_asahi_sync_type { |
| 603 | + /** @DRM_ASAHI_SYNC_SYNCOBJ: Binary sync object */ |
| 604 | + DRM_ASAHI_SYNC_SYNCOBJ = 0, |
| 605 | + |
| 606 | + /** @DRM_ASAHI_SYNC_TIMELINE_SYNCOBJ: Timeline sync object */ |
| 607 | + DRM_ASAHI_SYNC_TIMELINE_SYNCOBJ = 1, |
| 608 | +}; |
| 609 | + |
| 610 | +/** |
| 611 | + * struct drm_asahi_sync - Sync item |
| 612 | + */ |
| 613 | +struct drm_asahi_sync { |
| 614 | + /** @sync_type: One of drm_asahi_sync_type */ |
| 615 | + __u32 sync_type; |
| 616 | + |
| 617 | + /** @handle: The sync object handle */ |
| 618 | + __u32 handle; |
| 619 | + |
| 620 | + /** @timeline_value: Timeline value for timeline sync objects */ |
| 621 | + __u64 timeline_value; |
| 622 | +}; |
| 623 | + |
| 624 | +/** |
| 625 | + * define DRM_ASAHI_BARRIER_NONE - Command index for no barrier |
| 626 | + * |
| 627 | + * This special value may be passed in to drm_asahi_command::vdm_barrier or |
| 628 | + * drm_asahi_command::cdm_barrier to indicate that the respective subqueue |
| 629 | + * should not wait on any previous work. |
| 630 | + */ |
| 631 | +#define DRM_ASAHI_BARRIER_NONE (0xFFFFu) |
| 632 | + |
| 633 | +/** |
| 634 | + * struct drm_asahi_cmd_header - Top level command structure |
| 635 | + * |
| 636 | + * This struct is core to the command buffer definition and therefore is not |
| 637 | + * extensible. |
| 638 | + */ |
| 639 | +struct drm_asahi_cmd_header { |
| 640 | + /** @cmd_type: One of drm_asahi_cmd_type */ |
| 641 | + __u16 cmd_type; |
| 642 | + |
| 643 | + /** |
| 644 | + * @size: Size of this command, not including this header. |
| 645 | + * |
| 646 | + * For hardware commands, this enables extensibility of commands without |
| 647 | + * requiring extra command types. Passing a command that is shorter |
| 648 | + * than expected is explicitly allowed for backwards-compatibility. |
| 649 | + * Truncated fields will be zeroed. |
| 650 | + * |
| 651 | + * For the synthetic attachment setting commands, this implicitly |
| 652 | + * encodes the number of attachments. These commands take multiple |
| 653 | + * fixed-size @drm_asahi_attachment structures as their payload, so size |
| 654 | + * equals number of attachments * sizeof(struct drm_asahi_attachment). |
| 655 | + */ |
| 656 | + __u16 size; |
| 657 | + |
| 658 | + /** |
| 659 | + * @vdm_barrier: VDM (render) command index to wait on. |
| 660 | + * |
| 661 | + * Barriers are indices relative to the beginning of a given submit. A |
| 662 | + * barrier of 0 waits on commands submitted to the respective subqueue |
| 663 | + * in previous submit ioctls. A barrier of N waits on N previous |
| 664 | + * commands on the subqueue within the current submit ioctl. As a |
| 665 | + * special case, passing @DRM_ASAHI_BARRIER_NONE avoids waiting on any |
| 666 | + * commands in the subqueue. |
| 667 | + * |
| 668 | + * Examples: |
| 669 | + * |
| 670 | + * 0: This waits on all previous work. |
| 671 | + * |
| 672 | + * NONE: This does not wait for anything on this subqueue. |
| 673 | + * |
| 674 | + * 1: This waits on the first render command in the submit. |
| 675 | + * This is valid only if there are multiple render commands in the |
| 676 | + * same submit. |
| 677 | + * |
| 678 | + * Barriers are valid only for hardware commands. Synthetic software |
| 679 | + * commands to set attachments must pass NONE here. |
| 680 | + */ |
| 681 | + __u16 vdm_barrier; |
| 682 | + |
| 683 | + /** |
| 684 | + * @cdm_barrier: CDM (compute) command index to wait on. |
| 685 | + * |
| 686 | + * See @vdm_barrier, and replace VDM/render with CDM/compute. |
| 687 | + */ |
| 688 | + __u16 cdm_barrier; |
| 689 | +}; |
| 690 | + |
| 691 | +/** |
| 692 | + * struct drm_asahi_submit - Arguments passed to DRM_IOCTL_ASAHI_SUBMIT |
| 693 | + */ |
| 694 | +struct drm_asahi_submit { |
| 695 | + /** |
| 696 | + * @syncs: An optional pointer to an array of drm_asahi_sync. The first |
| 697 | + * @in_sync_count elements are in-syncs, then the remaining |
| 698 | + * @out_sync_count elements are out-syncs. Using a single array with |
| 699 | + * explicit partitioning simplifies handling. |
| 700 | + */ |
| 701 | + __u64 syncs; |
| 702 | + |
| 703 | + /** |
| 704 | + * @cmdbuf: Pointer to the command buffer to submit. |
| 705 | + * |
| 706 | + * This is a flat command buffer. By design, it contains no CPU |
| 707 | + * pointers, which makes it suitable for a virtgpu wire protocol without |
| 708 | + * requiring any serializing/deserializing step. |
| 709 | + * |
| 710 | + * It consists of a series of commands. Each command begins with a |
| 711 | + * fixed-size @drm_asahi_cmd_header header and is followed by a |
| 712 | + * variable-length payload according to the type and size in the header. |
| 713 | + * |
| 714 | + * The combined count of "real" hardware commands must be nonzero and at |
| 715 | + * most drm_asahi_params_global::max_commands_per_submission. |
| 716 | + */ |
| 717 | + __u64 cmdbuf; |
| 718 | + |
| 719 | + /** @flags: Flags for command submission (MBZ) */ |
| 720 | + __u32 flags; |
| 721 | + |
| 722 | + /** @queue_id: The queue ID to be submitted to */ |
| 723 | + __u32 queue_id; |
| 724 | + |
| 725 | + /** |
| 726 | + * @in_sync_count: Number of sync objects to wait on before starting |
| 727 | + * this job. |
| 728 | + */ |
| 729 | + __u32 in_sync_count; |
| 730 | + |
| 731 | + /** |
| 732 | + * @out_sync_count: Number of sync objects to signal upon completion of |
| 733 | + * this job. |
| 734 | + */ |
| 735 | + __u32 out_sync_count; |
| 736 | + |
| 737 | + /** @cmdbuf_size: Command buffer size in bytes */ |
| 738 | + __u32 cmdbuf_size; |
| 739 | + |
| 740 | + /** @pad: MBZ */ |
| 741 | + __u32 pad; |
| 742 | +}; |
| 743 | + |
| 744 | +/** |
| 745 | + * struct drm_asahi_attachment - Describe an "attachment". |
| 746 | + * |
| 747 | + * Attachments are any memory written by shaders, notably including render |
| 748 | + * target attachments written by the end-of-tile program. This is purely a hint |
| 749 | + * about the accessed memory regions. It is optional to specify, which is |
| 750 | + * fortunate as it cannot be specified precisely with bindless access anyway. |
| 751 | + * But where possible, it's probably a good idea for userspace to include these |
| 752 | + * hints, forwarded to the firmware. |
| 753 | + * |
| 754 | + * This struct is implicitly sized and therefore is not extensible. |
| 755 | + */ |
| 756 | +struct drm_asahi_attachment { |
| 757 | + /** @pointer: Base address of the attachment */ |
| 758 | + __u64 pointer; |
| 759 | + |
| 760 | + /** @size: Size of the attachment in bytes */ |
| 761 | + __u64 size; |
| 762 | + |
| 763 | + /** @pad: MBZ */ |
| 764 | + __u32 pad; |
| 765 | + |
| 766 | + /** @flags: MBZ */ |
| 767 | + __u32 flags; |
| 768 | +}; |
| 769 | + |
| 770 | +enum drm_asahi_render_flags { |
| 771 | + /** |
| 772 | + * @DRM_ASAHI_RENDER_VERTEX_SCRATCH: A vertex stage shader uses scratch |
| 773 | + * memory. |
| 774 | + */ |
| 775 | + DRM_ASAHI_RENDER_VERTEX_SCRATCH = (1U << 0), |
| 776 | + |
| 777 | + /** |
| 778 | + * @DRM_ASAHI_RENDER_PROCESS_EMPTY_TILES: Process even empty tiles. |
| 779 | + * This must be set when clearing render targets. |
| 780 | + */ |
| 781 | + DRM_ASAHI_RENDER_PROCESS_EMPTY_TILES = (1U << 1), |
| 782 | + |
| 783 | + /** |
| 784 | + * @DRM_ASAHI_RENDER_NO_VERTEX_CLUSTERING: Run vertex stage on a single |
| 785 | + * cluster (on multi-cluster GPUs) |
| 786 | + * |
| 787 | + * This harms performance but can workaround certain sync/coherency |
| 788 | + * bugs, and therefore is useful for debugging. |
| 789 | + */ |
| 790 | + DRM_ASAHI_RENDER_NO_VERTEX_CLUSTERING = (1U << 2), |
| 791 | + |
| 792 | + /** |
| 793 | + * @DRM_ASAHI_RENDER_DBIAS_IS_INT: Use integer depth bias formula. |
| 794 | + * |
| 795 | + * Graphics specifications contain two alternate formulas for depth |
| 796 | + * bias, a float formula used with floating-point depth buffers and an |
| 797 | + * integer formula using with unorm depth buffers. This flag specifies |
| 798 | + * that the integer formula should be used. If omitted, the float |
| 799 | + * formula is used instead. |
| 800 | + * |
| 801 | + * This corresponds to bit 18 of the relevant hardware control register, |
| 802 | + * so we match that here for efficiency. |
| 803 | + */ |
| 804 | + DRM_ASAHI_RENDER_DBIAS_IS_INT = (1U << 18), |
| 805 | +}; |
| 806 | + |
| 807 | +/** |
| 808 | + * struct drm_asahi_zls_buffer - Describe a depth or stencil buffer. |
| 809 | + * |
| 810 | + * These fields correspond to hardware registers in the ZLS (Z Load/Store) unit. |
| 811 | + * There are three hardware registers for each field respectively for loads, |
| 812 | + * stores, and partial renders. In practice, it makes sense to set all to the |
| 813 | + * same values, except in exceptional cases not yet implemented in userspace, so |
| 814 | + * we do not duplicate here for simplicity/efficiency. |
| 815 | + * |
| 816 | + * This struct is embedded in other structs and therefore is not extensible. |
| 817 | + */ |
| 818 | +struct drm_asahi_zls_buffer { |
| 819 | + /** @base: Base address of the buffer */ |
| 820 | + __u64 base; |
| 821 | + |
| 822 | + /** |
| 823 | + * @comp_base: If the load buffer is compressed, address of the |
| 824 | + * compression metadata section. |
| 825 | + */ |
| 826 | + __u64 comp_base; |
| 827 | + |
| 828 | + /** |
| 829 | + * @stride: If layered rendering is enabled, the number of bytes |
| 830 | + * between each layer of the buffer. |
| 831 | + */ |
| 832 | + __u32 stride; |
| 833 | + |
| 834 | + /** |
| 835 | + * @comp_stride: If layered rendering is enabled, the number of bytes |
| 836 | + * between each layer of the compression metadata. |
| 837 | + */ |
| 838 | + __u32 comp_stride; |
| 839 | +}; |
| 840 | + |
| 841 | +/** |
| 842 | + * struct drm_asahi_timestamp - Describe a timestamp write. |
| 843 | + * |
| 844 | + * The firmware can optionally write the GPU timestamp at render pass |
| 845 | + * granularities, but it needs to be mapped specially via |
| 846 | + * DRM_IOCTL_ASAHI_GEM_BIND_OBJECT. This structure therefore describes where to |
| 847 | + * write as a handle-offset pair, rather than a GPU address like normal. |
| 848 | + * |
| 849 | + * This struct is embedded in other structs and therefore is not extensible. |
| 850 | + */ |
| 851 | +struct drm_asahi_timestamp { |
| 852 | + /** |
| 853 | + * @handle: Handle of the timestamp buffer, or 0 to skip this |
| 854 | + * timestamp. If nonzero, this must equal the value returned in |
| 855 | + * drm_asahi_gem_bind_object::object_handle. |
| 856 | + */ |
| 857 | + __u32 handle; |
| 858 | + |
| 859 | + /** @offset: Offset to write into the timestamp buffer */ |
| 860 | + __u32 offset; |
| 861 | +}; |
| 862 | + |
| 863 | +/** |
| 864 | + * struct drm_asahi_timestamps - Describe timestamp writes. |
| 865 | + * |
| 866 | + * Each operation that can be timestamped, can be timestamped at the start and |
| 867 | + * end. Therefore, drm_asahi_timestamp structs always come in pairs, bundled |
| 868 | + * together into drm_asahi_timestamps. |
| 869 | + * |
| 870 | + * This struct is embedded in other structs and therefore is not extensible. |
| 871 | + */ |
| 872 | +struct drm_asahi_timestamps { |
| 873 | + /** @start: Timestamp recorded at the start of the operation */ |
| 874 | + struct drm_asahi_timestamp start; |
| 875 | + |
| 876 | + /** @end: Timestamp recorded at the end of the operation */ |
| 877 | + struct drm_asahi_timestamp end; |
| 878 | +}; |
| 879 | + |
| 880 | +/** |
| 881 | + * struct drm_asahi_helper_program - Describe helper program configuration. |
| 882 | + * |
| 883 | + * The helper program is a compute-like kernel required for various hardware |
| 884 | + * functionality. Its most important role is dynamically allocating |
| 885 | + * scratch/stack memory for individual subgroups, by partitioning a static |
| 886 | + * allocation shared for the whole device. It is supplied by userspace via |
| 887 | + * drm_asahi_helper_program and internally dispatched by the hardware as needed. |
| 888 | + * |
| 889 | + * This struct is embedded in other structs and therefore is not extensible. |
| 890 | + */ |
| 891 | +struct drm_asahi_helper_program { |
| 892 | + /** |
| 893 | + * @binary: USC address to the helper program binary. This is a tagged |
| 894 | + * pointer with configuration in the bottom bits. |
| 895 | + */ |
| 896 | + __u32 binary; |
| 897 | + |
| 898 | + /** @cfg: Additional configuration bits for the helper program. */ |
| 899 | + __u32 cfg; |
| 900 | + |
| 901 | + /** |
| 902 | + * @data: Data passed to the helper program. This value is not |
| 903 | + * interpreted by the kernel, firmware, or hardware in any way. It is |
| 904 | + * simply a sideband for userspace, set with the submit ioctl and read |
| 905 | + * via special registers inside the helper program. |
| 906 | + * |
| 907 | + * In practice, userspace will pass a 64-bit GPU VA here pointing to the |
| 908 | + * actual arguments, which presumably don't fit in 64-bits. |
| 909 | + */ |
| 910 | + __u64 data; |
| 911 | +}; |
| 912 | + |
| 913 | +/** |
| 914 | + * struct drm_asahi_bg_eot - Describe a background or end-of-tile program. |
| 915 | + * |
| 916 | + * The background and end-of-tile programs are dispatched by the hardware at the |
| 917 | + * beginning and end of rendering. As the hardware "tilebuffer" is simply local |
| 918 | + * memory, these programs are necessary to implement API-level render targets. |
| 919 | + * The fragment-like background program is responsible for loading either the |
| 920 | + * clear colour or the existing render target contents, while the compute-like |
| 921 | + * end-of-tile program stores the tilebuffer contents to memory. |
| 922 | + * |
| 923 | + * This struct is embedded in other structs and therefore is not extensible. |
| 924 | + */ |
| 925 | +struct drm_asahi_bg_eot { |
| 926 | + /** |
| 927 | + * @usc: USC address of the hardware USC words binding resources |
| 928 | + * (including images and uniforms) and the program itself. Note this is |
| 929 | + * an additional layer of indirection compared to the helper program, |
| 930 | + * avoiding the need for a sideband for data. This is a tagged pointer |
| 931 | + * with additional configuration in the bottom bits. |
| 932 | + */ |
| 933 | + __u32 usc; |
| 934 | + |
| 935 | + /** |
| 936 | + * @rsrc_spec: Resource specifier for the program. This is a packed |
| 937 | + * hardware data structure describing the required number of registers, |
| 938 | + * uniforms, bound textures, and bound samplers. |
| 939 | + */ |
| 940 | + __u32 rsrc_spec; |
| 941 | +}; |
| 942 | + |
| 943 | +/** |
| 944 | + * struct drm_asahi_cmd_render - Command to submit 3D |
| 945 | + * |
| 946 | + * This command submits a single render pass. The hardware control stream may |
| 947 | + * include many draws and subpasses, but within the command, the framebuffer |
| 948 | + * dimensions and attachments are fixed. |
| 949 | + * |
| 950 | + * The hardware requires the firmware to set a large number of Control Registers |
| 951 | + * setting up state at render pass granularity before each command rendering 3D. |
| 952 | + * The firmware bundles this state into data structures. Unfortunately, we |
| 953 | + * cannot expose either any of that directly to userspace, because the |
| 954 | + * kernel-firmware ABI is not stable. Although we can guarantee the firmware |
| 955 | + * updates in tandem with the kernel, we cannot break old userspace when |
| 956 | + * upgrading the firmware and kernel. Therefore, we need to abstract well the |
| 957 | + * data structures to avoid tying our hands with future firmwares. |
| 958 | + * |
| 959 | + * The bulk of drm_asahi_cmd_render therefore consists of values of hardware |
| 960 | + * control registers, marshalled via the firmware interface. |
| 961 | + * |
| 962 | + * The framebuffer/tilebuffer dimensions are also specified here. In addition to |
| 963 | + * being passed to the firmware/hardware, the kernel requires these dimensions |
| 964 | + * to calculate various essential tiling-related data structures. It is |
| 965 | + * unfortunate that our submits are heavier than on vendors with saner |
| 966 | + * hardware-software interfaces. The upshot is all of this information is |
| 967 | + * readily available to userspace with all current APIs. |
| 968 | + * |
| 969 | + * It looks odd - but it's not overly burdensome and it ensures we can remain |
| 970 | + * compatible with old userspace. |
| 971 | + */ |
| 972 | +struct drm_asahi_cmd_render { |
| 973 | + /** @flags: Combination of drm_asahi_render_flags flags. */ |
| 974 | + __u32 flags; |
| 975 | + |
| 976 | + /** |
| 977 | + * @isp_zls_pixels: ISP_ZLS_PIXELS register value. This contains the |
| 978 | + * depth/stencil width/height, which may differ from the framebuffer |
| 979 | + * width/height. |
| 980 | + */ |
| 981 | + __u32 isp_zls_pixels; |
| 982 | + |
| 983 | + /** |
| 984 | + * @vdm_ctrl_stream_base: VDM_CTRL_STREAM_BASE register value. GPU |
| 985 | + * address to the beginning of the VDM control stream. |
| 986 | + */ |
| 987 | + __u64 vdm_ctrl_stream_base; |
| 988 | + |
| 989 | + /** @vertex_helper: Helper program used for the vertex shader */ |
| 990 | + struct drm_asahi_helper_program vertex_helper; |
| 991 | + |
| 992 | + /** @fragment_helper: Helper program used for the fragment shader */ |
| 993 | + struct drm_asahi_helper_program fragment_helper; |
| 994 | + |
| 995 | + /** |
| 996 | + * @isp_scissor_base: ISP_SCISSOR_BASE register value. GPU address of an |
| 997 | + * array of scissor descriptors indexed in the render pass. |
| 998 | + */ |
| 999 | + __u64 isp_scissor_base; |
| 1000 | + |
| 1001 | + /** |
| 1002 | + * @isp_dbias_base: ISP_DBIAS_BASE register value. GPU address of an |
| 1003 | + * array of depth bias values indexed in the render pass. |
| 1004 | + */ |
| 1005 | + __u64 isp_dbias_base; |
| 1006 | + |
| 1007 | + /** |
| 1008 | + * @isp_oclqry_base: ISP_OCLQRY_BASE register value. GPU address of an |
| 1009 | + * array of occlusion query results written by the render pass. |
| 1010 | + */ |
| 1011 | + __u64 isp_oclqry_base; |
| 1012 | + |
| 1013 | + /** @depth: Depth buffer */ |
| 1014 | + struct drm_asahi_zls_buffer depth; |
| 1015 | + |
| 1016 | + /** @stencil: Stencil buffer */ |
| 1017 | + struct drm_asahi_zls_buffer stencil; |
| 1018 | + |
| 1019 | + /** @zls_ctrl: ZLS_CTRL register value */ |
| 1020 | + __u64 zls_ctrl; |
| 1021 | + |
| 1022 | + /** @ppp_multisamplectl: PPP_MULTISAMPLECTL register value */ |
| 1023 | + __u64 ppp_multisamplectl; |
| 1024 | + |
| 1025 | + /** |
| 1026 | + * @sampler_heap: Base address of the sampler heap. This heap is used |
| 1027 | + * for both vertex shaders and fragment shaders. The registers are |
| 1028 | + * per-stage, but there is no known use case for separate heaps. |
| 1029 | + */ |
| 1030 | + __u64 sampler_heap; |
| 1031 | + |
| 1032 | + /** @ppp_ctrl: PPP_CTRL register value */ |
| 1033 | + __u32 ppp_ctrl; |
| 1034 | + |
| 1035 | + /** @width_px: Framebuffer width in pixels */ |
| 1036 | + __u16 width_px; |
| 1037 | + |
| 1038 | + /** @height_px: Framebuffer height in pixels */ |
| 1039 | + __u16 height_px; |
| 1040 | + |
| 1041 | + /** @layers: Number of layers in the framebuffer */ |
| 1042 | + __u16 layers; |
| 1043 | + |
| 1044 | + /** @sampler_count: Number of samplers in the sampler heap. */ |
| 1045 | + __u16 sampler_count; |
| 1046 | + |
| 1047 | + /** @utile_width_px: Width of a logical tilebuffer tile in pixels */ |
| 1048 | + __u8 utile_width_px; |
| 1049 | + |
| 1050 | + /** @utile_height_px: Height of a logical tilebuffer tile in pixels */ |
| 1051 | + __u8 utile_height_px; |
| 1052 | + |
| 1053 | + /** @samples: # of samples in the framebuffer. Must be 1, 2, or 4. */ |
| 1054 | + __u8 samples; |
| 1055 | + |
| 1056 | + /** @sample_size_B: # of bytes in the tilebuffer required per sample. */ |
| 1057 | + __u8 sample_size_B; |
| 1058 | + |
| 1059 | + /** |
| 1060 | + * @isp_merge_upper_x: 32-bit float used in the hardware triangle |
| 1061 | + * merging. Calculate as: tan(60 deg) * width. |
| 1062 | + * |
| 1063 | + * Making these values UAPI avoids requiring floating-point calculations |
| 1064 | + * in the kernel in the hot path. |
| 1065 | + */ |
| 1066 | + __u32 isp_merge_upper_x; |
| 1067 | + |
| 1068 | + /** |
| 1069 | + * @isp_merge_upper_y: 32-bit float. Calculate as: tan(60 deg) * height. |
| 1070 | + * See @isp_merge_upper_x. |
| 1071 | + */ |
| 1072 | + __u32 isp_merge_upper_y; |
| 1073 | + |
| 1074 | + /** @bg: Background program run for each tile at the start */ |
| 1075 | + struct drm_asahi_bg_eot bg; |
| 1076 | + |
| 1077 | + /** @eot: End-of-tile program ran for each tile at the end */ |
| 1078 | + struct drm_asahi_bg_eot eot; |
| 1079 | + |
| 1080 | + /** |
| 1081 | + * @partial_bg: Background program ran at the start of each tile when |
| 1082 | + * resuming the render pass during a partial render. |
| 1083 | + */ |
| 1084 | + struct drm_asahi_bg_eot partial_bg; |
| 1085 | + |
| 1086 | + /** |
| 1087 | + * @partial_eot: End-of-tile program ran at the end of each tile when |
| 1088 | + * pausing the render pass during a partial render. |
| 1089 | + */ |
| 1090 | + struct drm_asahi_bg_eot partial_eot; |
| 1091 | + |
| 1092 | + /** |
| 1093 | + * @isp_bgobjdepth: ISP_BGOBJDEPTH register value. This is the depth |
| 1094 | + * buffer clear value, encoded in the depth buffer's format: either a |
| 1095 | + * 32-bit float or a 16-bit unorm (with upper bits zeroed). |
| 1096 | + */ |
| 1097 | + __u32 isp_bgobjdepth; |
| 1098 | + |
| 1099 | + /** |
| 1100 | + * @isp_bgobjvals: ISP_BGOBJVALS register value. The bottom 8-bits |
| 1101 | + * contain the stencil buffer clear value. |
| 1102 | + */ |
| 1103 | + __u32 isp_bgobjvals; |
| 1104 | + |
| 1105 | + /** @ts_vtx: Timestamps for the vertex portion of the render */ |
| 1106 | + struct drm_asahi_timestamps ts_vtx; |
| 1107 | + |
| 1108 | + /** @ts_frag: Timestamps for the fragment portion of the render */ |
| 1109 | + struct drm_asahi_timestamps ts_frag; |
| 1110 | +}; |
| 1111 | + |
| 1112 | +/** |
| 1113 | + * struct drm_asahi_cmd_compute - Command to submit compute |
| 1114 | + * |
| 1115 | + * This command submits a control stream consisting of compute dispatches. There |
| 1116 | + * is essentially no limit on how many compute dispatches may be included in a |
| 1117 | + * single compute command, although timestamps are at command granularity. |
| 1118 | + */ |
| 1119 | +struct drm_asahi_cmd_compute { |
| 1120 | + /** @flags: MBZ */ |
| 1121 | + __u32 flags; |
| 1122 | + |
| 1123 | + /** @sampler_count: Number of samplers in the sampler heap. */ |
| 1124 | + __u32 sampler_count; |
| 1125 | + |
| 1126 | + /** |
| 1127 | + * @cdm_ctrl_stream_base: CDM_CTRL_STREAM_BASE register value. GPU |
| 1128 | + * address to the beginning of the CDM control stream. |
| 1129 | + */ |
| 1130 | + __u64 cdm_ctrl_stream_base; |
| 1131 | + |
| 1132 | + /** |
| 1133 | + * @cdm_ctrl_stream_end: GPU base address to the end of the hardware |
| 1134 | + * control stream. Note this only considers the first contiguous segment |
| 1135 | + * of the control stream, as the stream might jump elsewhere. |
| 1136 | + */ |
| 1137 | + __u64 cdm_ctrl_stream_end; |
| 1138 | + |
| 1139 | + /** @sampler_heap: Base address of the sampler heap. */ |
| 1140 | + __u64 sampler_heap; |
| 1141 | + |
| 1142 | + /** @helper: Helper program used for this compute command */ |
| 1143 | + struct drm_asahi_helper_program helper; |
| 1144 | + |
| 1145 | + /** @ts: Timestamps for the compute command */ |
| 1146 | + struct drm_asahi_timestamps ts; |
| 1147 | +}; |
| 1148 | + |
| 1149 | +/** |
| 1150 | + * struct drm_asahi_get_time - Arguments passed to DRM_IOCTL_ASAHI_GET_TIME |
| 1151 | + */ |
| 1152 | +struct drm_asahi_get_time { |
| 1153 | + /** @flags: MBZ. */ |
| 1154 | + __u64 flags; |
| 1155 | + |
| 1156 | + /** @gpu_timestamp: On return, the GPU timestamp in nanoseconds. */ |
| 1157 | + __u64 gpu_timestamp; |
| 1158 | +}; |
| 1159 | + |
| 1160 | +/** |
| 1161 | + * DRM_IOCTL_ASAHI() - Build an Asahi IOCTL number |
| 1162 | + * @__access: Access type. Must be R, W or RW. |
| 1163 | + * @__id: One of the DRM_ASAHI_xxx id. |
| 1164 | + * @__type: Suffix of the type being passed to the IOCTL. |
| 1165 | + * |
| 1166 | + * Don't use this macro directly, use the DRM_IOCTL_ASAHI_xxx |
| 1167 | + * values instead. |
| 1168 | + * |
| 1169 | + * Return: An IOCTL number to be passed to ioctl() from userspace. |
| 1170 | + */ |
| 1171 | +#define DRM_IOCTL_ASAHI(__access, __id, __type) \ |
| 1172 | + DRM_IO ## __access(DRM_COMMAND_BASE + DRM_ASAHI_ ## __id, \ |
| 1173 | + struct drm_asahi_ ## __type) |
| 1174 | + |
| 1175 | +/* Note: this is an enum so that it can be resolved by Rust bindgen. */ |
| 1176 | +enum { |
| 1177 | + DRM_IOCTL_ASAHI_GET_PARAMS = DRM_IOCTL_ASAHI(W, GET_PARAMS, get_params), |
| 1178 | + DRM_IOCTL_ASAHI_GET_TIME = DRM_IOCTL_ASAHI(WR, GET_TIME, get_time), |
| 1179 | + DRM_IOCTL_ASAHI_VM_CREATE = DRM_IOCTL_ASAHI(WR, VM_CREATE, vm_create), |
| 1180 | + DRM_IOCTL_ASAHI_VM_DESTROY = DRM_IOCTL_ASAHI(W, VM_DESTROY, vm_destroy), |
| 1181 | + DRM_IOCTL_ASAHI_VM_BIND = DRM_IOCTL_ASAHI(W, VM_BIND, vm_bind), |
| 1182 | + DRM_IOCTL_ASAHI_GEM_CREATE = DRM_IOCTL_ASAHI(WR, GEM_CREATE, gem_create), |
| 1183 | + DRM_IOCTL_ASAHI_GEM_MMAP_OFFSET = DRM_IOCTL_ASAHI(WR, GEM_MMAP_OFFSET, gem_mmap_offset), |
| 1184 | + DRM_IOCTL_ASAHI_GEM_BIND_OBJECT = DRM_IOCTL_ASAHI(WR, GEM_BIND_OBJECT, gem_bind_object), |
| 1185 | + DRM_IOCTL_ASAHI_QUEUE_CREATE = DRM_IOCTL_ASAHI(WR, QUEUE_CREATE, queue_create), |
| 1186 | + DRM_IOCTL_ASAHI_QUEUE_DESTROY = DRM_IOCTL_ASAHI(W, QUEUE_DESTROY, queue_destroy), |
| 1187 | + DRM_IOCTL_ASAHI_SUBMIT = DRM_IOCTL_ASAHI(W, SUBMIT, submit), |
| 1188 | +}; |
| 1189 | + |
| 1190 | +#if defined(__cplusplus) |
| 1191 | +} |
| 1192 | +#endif |
| 1193 | + |
| 1194 | +#endif /* _ASAHI_DRM_H_ */ |