include/uapi/drm/tegra_drm.h

   1 /* SPDX-License-Identifier: MIT */
   2 /* Copyright (c) 2012-2020 NVIDIA Corporation */
   3
   4 #ifndef _UAPI_TEGRA_DRM_H_
   5 #define _UAPI_TEGRA_DRM_H_
   6
   7 #include "drm.h"
   8
   9 #if defined(__cplusplus)
  10 extern "C" {
  11 #endif
  12
  13 /* Tegra DRM legacy UAPI. Only enabled with STAGING */
  14
  15 #define DRM_TEGRA_GEM_CREATE_TILED     (1 << 0)
  16 #define DRM_TEGRA_GEM_CREATE_BOTTOM_UP (1 << 1)
  17
  18 /**
  19  * struct drm_tegra_gem_create - parameters for the GEM object creation IOCTL
  20  */
  21 struct drm_tegra_gem_create {
  22         /**
  23          * @size:
  24          *
  25          * The size, in bytes, of the buffer object to be created.
  26          */
  27         __u64 size;
  28
  29         /**
  30          * @flags:
  31          *
  32          * A bitmask of flags that influence the creation of GEM objects:
  33          *
  34          * DRM_TEGRA_GEM_CREATE_TILED
  35          *   Use the 16x16 tiling format for this buffer.
  36          *
  37          * DRM_TEGRA_GEM_CREATE_BOTTOM_UP
  38          *   The buffer has a bottom-up layout.
  39          */
  40         __u32 flags;
  41
  42         /**
  43          * @handle:
  44          *
  45          * The handle of the created GEM object. Set by the kernel upon
  46          * successful completion of the IOCTL.
  47          */
  48         __u32 handle;
  49 };
  50
  51 /**
  52  * struct drm_tegra_gem_mmap - parameters for the GEM mmap IOCTL
  53  */
  54 struct drm_tegra_gem_mmap {
  55         /**
  56          * @handle:
  57          *
  58          * Handle of the GEM object to obtain an mmap offset for.
  59          */
  60         __u32 handle;
  61
  62         /**
  63          * @pad:
  64          *
  65          * Structure padding that may be used in the future. Must be 0.
  66          */
  67         __u32 pad;
  68
  69         /**
  70          * @offset:
  71          *
  72          * The mmap offset for the given GEM object. Set by the kernel upon
  73          * successful completion of the IOCTL.
  74          */
  75         __u64 offset;
  76 };
  77
  78 /**
  79  * struct drm_tegra_syncpt_read - parameters for the read syncpoint IOCTL
  80  */
  81 struct drm_tegra_syncpt_read {
  82         /**
  83          * @id:
  84          *
  85          * ID of the syncpoint to read the current value from.
  86          */
  87         __u32 id;
  88
  89         /**
  90          * @value:
  91          *
  92          * The current syncpoint value. Set by the kernel upon successful
  93          * completion of the IOCTL.
  94          */
  95         __u32 value;
  96 };
  97
  98 /**
  99  * struct drm_tegra_syncpt_incr - parameters for the increment syncpoint IOCTL
 100  */
 101 struct drm_tegra_syncpt_incr {
 102         /**
 103          * @id:
 104          *
 105          * ID of the syncpoint to increment.
 106          */
 107         __u32 id;
 108
 109         /**
 110          * @pad:
 111          *
 112          * Structure padding that may be used in the future. Must be 0.
 113          */
 114         __u32 pad;
 115 };
 116
 117 /**
 118  * struct drm_tegra_syncpt_wait - parameters for the wait syncpoint IOCTL
 119  */
 120 struct drm_tegra_syncpt_wait {
 121         /**
 122          * @id:
 123          *
 124          * ID of the syncpoint to wait on.
 125          */
 126         __u32 id;
 127
 128         /**
 129          * @thresh:
 130          *
 131          * Threshold value for which to wait.
 132          */
 133         __u32 thresh;
 134
 135         /**
 136          * @timeout:
 137          *
 138          * Timeout, in milliseconds, to wait.
 139          */
 140         __u32 timeout;
 141
 142         /**
 143          * @value:
 144          *
 145          * The new syncpoint value after the wait. Set by the kernel upon
 146          * successful completion of the IOCTL.
 147          */
 148         __u32 value;
 149 };
 150
 151 #define DRM_TEGRA_NO_TIMEOUT    (0xffffffff)
 152
 153 /**
 154  * struct drm_tegra_open_channel - parameters for the open channel IOCTL
 155  */
 156 struct drm_tegra_open_channel {
 157         /**
 158          * @client:
 159          *
 160          * The client ID for this channel.
 161          */
 162         __u32 client;
 163
 164         /**
 165          * @pad:
 166          *
 167          * Structure padding that may be used in the future. Must be 0.
 168          */
 169         __u32 pad;
 170
 171         /**
 172          * @context:
 173          *
 174          * The application context of this channel. Set by the kernel upon
 175          * successful completion of the IOCTL. This context needs to be passed
 176          * to the DRM_TEGRA_CHANNEL_CLOSE or the DRM_TEGRA_SUBMIT IOCTLs.
 177          */
 178         __u64 context;
 179 };
 180
 181 /**
 182  * struct drm_tegra_close_channel - parameters for the close channel IOCTL
 183  */
 184 struct drm_tegra_close_channel {
 185         /**
 186          * @context:
 187          *
 188          * The application context of this channel. This is obtained from the
 189          * DRM_TEGRA_OPEN_CHANNEL IOCTL.
 190          */
 191         __u64 context;
 192 };
 193
 194 /**
 195  * struct drm_tegra_get_syncpt - parameters for the get syncpoint IOCTL
 196  */
 197 struct drm_tegra_get_syncpt {
 198         /**
 199          * @context:
 200          *
 201          * The application context identifying the channel for which to obtain
 202          * the syncpoint ID.
 203          */
 204         __u64 context;
 205
 206         /**
 207          * @index:
 208          *
 209          * Index of the client syncpoint for which to obtain the ID.
 210          */
 211         __u32 index;
 212
 213         /**
 214          * @id:
 215          *
 216          * The ID of the given syncpoint. Set by the kernel upon successful
 217          * completion of the IOCTL.
 218          */
 219         __u32 id;
 220 };
 221
 222 /**
 223  * struct drm_tegra_get_syncpt_base - parameters for the get wait base IOCTL
 224  */
 225 struct drm_tegra_get_syncpt_base {
 226         /**
 227          * @context:
 228          *
 229          * The application context identifying for which channel to obtain the
 230          * wait base.
 231          */
 232         __u64 context;
 233
 234         /**
 235          * @syncpt:
 236          *
 237          * ID of the syncpoint for which to obtain the wait base.
 238          */
 239         __u32 syncpt;
 240
 241         /**
 242          * @id:
 243          *
 244          * The ID of the wait base corresponding to the client syncpoint. Set
 245          * by the kernel upon successful completion of the IOCTL.
 246          */
 247         __u32 id;
 248 };
 249
 250 /**
 251  * struct drm_tegra_syncpt - syncpoint increment operation
 252  */
 253 struct drm_tegra_syncpt {
 254         /**
 255          * @id:
 256          *
 257          * ID of the syncpoint to operate on.
 258          */
 259         __u32 id;
 260
 261         /**
 262          * @incrs:
 263          *
 264          * Number of increments to perform for the syncpoint.
 265          */
 266         __u32 incrs;
 267 };
 268
 269 /**
 270  * struct drm_tegra_cmdbuf - structure describing a command buffer
 271  */
 272 struct drm_tegra_cmdbuf {
 273         /**
 274          * @handle:
 275          *
 276          * Handle to a GEM object containing the command buffer.
 277          */
 278         __u32 handle;
 279
 280         /**
 281          * @offset:
 282          *
 283          * Offset, in bytes, into the GEM object identified by @handle at
 284          * which the command buffer starts.
 285          */
 286         __u32 offset;
 287
 288         /**
 289          * @words:
 290          *
 291          * Number of 32-bit words in this command buffer.
 292          */
 293         __u32 words;
 294
 295         /**
 296          * @pad:
 297          *
 298          * Structure padding that may be used in the future. Must be 0.
 299          */
 300         __u32 pad;
 301 };
 302
 303 /**
 304  * struct drm_tegra_reloc - GEM object relocation structure
 305  */
 306 struct drm_tegra_reloc {
 307         struct {
 308                 /**
 309                  * @cmdbuf.handle:
 310                  *
 311                  * Handle to the GEM object containing the command buffer for
 312                  * which to perform this GEM object relocation.
 313                  */
 314                 __u32 handle;
 315
 316                 /**
 317                  * @cmdbuf.offset:
 318                  *
 319                  * Offset, in bytes, into the command buffer at which to
 320                  * insert the relocated address.
 321                  */
 322                 __u32 offset;
 323         } cmdbuf;
 324         struct {
 325                 /**
 326                  * @target.handle:
 327                  *
 328                  * Handle to the GEM object to be relocated.
 329                  */
 330                 __u32 handle;
 331
 332                 /**
 333                  * @target.offset:
 334                  *
 335                  * Offset, in bytes, into the target GEM object at which the
 336                  * relocated data starts.
 337                  */
 338                 __u32 offset;
 339         } target;
 340
 341         /**
 342          * @shift:
 343          *
 344          * The number of bits by which to shift relocated addresses.
 345          */
 346         __u32 shift;
 347
 348         /**
 349          * @pad:
 350          *
 351          * Structure padding that may be used in the future. Must be 0.
 352          */
 353         __u32 pad;
 354 };
 355
 356 /**
 357  * struct drm_tegra_waitchk - wait check structure
 358  */
 359 struct drm_tegra_waitchk {
 360         /**
 361          * @handle:
 362          *
 363          * Handle to the GEM object containing a command stream on which to
 364          * perform the wait check.
 365          */
 366         __u32 handle;
 367
 368         /**
 369          * @offset:
 370          *
 371          * Offset, in bytes, of the location in the command stream to perform
 372          * the wait check on.
 373          */
 374         __u32 offset;
 375
 376         /**
 377          * @syncpt:
 378          *
 379          * ID of the syncpoint to wait check.
 380          */
 381         __u32 syncpt;
 382
 383         /**
 384          * @thresh:
 385          *
 386          * Threshold value for which to check.
 387          */
 388         __u32 thresh;
 389 };
 390
 391 /**
 392  * struct drm_tegra_submit - job submission structure
 393  */
 394 struct drm_tegra_submit {
 395         /**
 396          * @context:
 397          *
 398          * The application context identifying the channel to use for the
 399          * execution of this job.
 400          */
 401         __u64 context;
 402
 403         /**
 404          * @num_syncpts:
 405          *
 406          * The number of syncpoints operated on by this job. This defines the
 407          * length of the array pointed to by @syncpts.
 408          */
 409         __u32 num_syncpts;
 410
 411         /**
 412          * @num_cmdbufs:
 413          *
 414          * The number of command buffers to execute as part of this job. This
 415          * defines the length of the array pointed to by @cmdbufs.
 416          */
 417         __u32 num_cmdbufs;
 418
 419         /**
 420          * @num_relocs:
 421          *
 422          * The number of relocations to perform before executing this job.
 423          * This defines the length of the array pointed to by @relocs.
 424          */
 425         __u32 num_relocs;
 426
 427         /**
 428          * @num_waitchks:
 429          *
 430          * The number of wait checks to perform as part of this job. This
 431          * defines the length of the array pointed to by @waitchks.
 432          */
 433         __u32 num_waitchks;
 434
 435         /**
 436          * @waitchk_mask:
 437          *
 438          * Bitmask of valid wait checks.
 439          */
 440         __u32 waitchk_mask;
 441
 442         /**
 443          * @timeout:
 444          *
 445          * Timeout, in milliseconds, before this job is cancelled.
 446          */
 447         __u32 timeout;
 448
 449         /**
 450          * @syncpts:
 451          *
 452          * A pointer to an array of &struct drm_tegra_syncpt structures that
 453          * specify the syncpoint operations performed as part of this job.
 454          * The number of elements in the array must be equal to the value
 455          * given by @num_syncpts.
 456          */
 457         __u64 syncpts;
 458
 459         /**
 460          * @cmdbufs:
 461          *
 462          * A pointer to an array of &struct drm_tegra_cmdbuf structures that
 463          * define the command buffers to execute as part of this job. The
 464          * number of elements in the array must be equal to the value given
 465          * by @num_syncpts.
 466          */
 467         __u64 cmdbufs;
 468
 469         /**
 470          * @relocs:
 471          *
 472          * A pointer to an array of &struct drm_tegra_reloc structures that
 473          * specify the relocations that need to be performed before executing
 474          * this job. The number of elements in the array must be equal to the
 475          * value given by @num_relocs.
 476          */
 477         __u64 relocs;
 478
 479         /**
 480          * @waitchks:
 481          *
 482          * A pointer to an array of &struct drm_tegra_waitchk structures that
 483          * specify the wait checks to be performed while executing this job.
 484          * The number of elements in the array must be equal to the value
 485          * given by @num_waitchks.
 486          */
 487         __u64 waitchks;
 488
 489         /**
 490          * @fence:
 491          *
 492          * The threshold of the syncpoint associated with this job after it
 493          * has been completed. Set by the kernel upon successful completion of
 494          * the IOCTL. This can be used with the DRM_TEGRA_SYNCPT_WAIT IOCTL to
 495          * wait for this job to be finished.
 496          */
 497         __u32 fence;
 498
 499         /**
 500          * @reserved:
 501          *
 502          * This field is reserved for future use. Must be 0.
 503          */
 504         __u32 reserved[5];
 505 };
 506
 507 #define DRM_TEGRA_GEM_TILING_MODE_PITCH 0
 508 #define DRM_TEGRA_GEM_TILING_MODE_TILED 1
 509 #define DRM_TEGRA_GEM_TILING_MODE_BLOCK 2
 510
 511 /**
 512  * struct drm_tegra_gem_set_tiling - parameters for the set tiling IOCTL
 513  */
 514 struct drm_tegra_gem_set_tiling {
 515         /**
 516          * @handle:
 517          *
 518          * Handle to the GEM object for which to set the tiling parameters.
 519          */
 520         __u32 handle;
 521
 522         /**
 523          * @mode:
 524          *
 525          * The tiling mode to set. Must be one of:
 526          *
 527          * DRM_TEGRA_GEM_TILING_MODE_PITCH
 528          *   pitch linear format
 529          *
 530          * DRM_TEGRA_GEM_TILING_MODE_TILED
 531          *   16x16 tiling format
 532          *
 533          * DRM_TEGRA_GEM_TILING_MODE_BLOCK
 534          *   16Bx2 tiling format
 535          */
 536         __u32 mode;
 537
 538         /**
 539          * @value:
 540          *
 541          * The value to set for the tiling mode parameter.
 542          */
 543         __u32 value;
 544
 545         /**
 546          * @pad:
 547          *
 548          * Structure padding that may be used in the future. Must be 0.
 549          */
 550         __u32 pad;
 551 };
 552
 553 /**
 554  * struct drm_tegra_gem_get_tiling - parameters for the get tiling IOCTL
 555  */
 556 struct drm_tegra_gem_get_tiling {
 557         /**
 558          * @handle:
 559          *
 560          * Handle to the GEM object for which to query the tiling parameters.
 561          */
 562         __u32 handle;
 563
 564         /**
 565          * @mode:
 566          *
 567          * The tiling mode currently associated with the GEM object. Set by
 568          * the kernel upon successful completion of the IOCTL.
 569          */
 570         __u32 mode;
 571
 572         /**
 573          * @value:
 574          *
 575          * The tiling mode parameter currently associated with the GEM object.
 576          * Set by the kernel upon successful completion of the IOCTL.
 577          */
 578         __u32 value;
 579
 580         /**
 581          * @pad:
 582          *
 583          * Structure padding that may be used in the future. Must be 0.
 584          */
 585         __u32 pad;
 586 };
 587
 588 #define DRM_TEGRA_GEM_BOTTOM_UP         (1 << 0)
 589 #define DRM_TEGRA_GEM_FLAGS             (DRM_TEGRA_GEM_BOTTOM_UP)
 590
 591 /**
 592  * struct drm_tegra_gem_set_flags - parameters for the set flags IOCTL
 593  */
 594 struct drm_tegra_gem_set_flags {
 595         /**
 596          * @handle:
 597          *
 598          * Handle to the GEM object for which to set the flags.
 599          */
 600         __u32 handle;
 601
 602         /**
 603          * @flags:
 604          *
 605          * The flags to set for the GEM object.
 606          */
 607         __u32 flags;
 608 };
 609
 610 /**
 611  * struct drm_tegra_gem_get_flags - parameters for the get flags IOCTL
 612  */
 613 struct drm_tegra_gem_get_flags {
 614         /**
 615          * @handle:
 616          *
 617          * Handle to the GEM object for which to query the flags.
 618          */
 619         __u32 handle;
 620
 621         /**
 622          * @flags:
 623          *
 624          * The flags currently associated with the GEM object. Set by the
 625          * kernel upon successful completion of the IOCTL.
 626          */
 627         __u32 flags;
 628 };
 629
 630 #define DRM_TEGRA_GEM_CREATE            0x00
 631 #define DRM_TEGRA_GEM_MMAP              0x01
 632 #define DRM_TEGRA_SYNCPT_READ           0x02
 633 #define DRM_TEGRA_SYNCPT_INCR           0x03
 634 #define DRM_TEGRA_SYNCPT_WAIT           0x04
 635 #define DRM_TEGRA_OPEN_CHANNEL          0x05
 636 #define DRM_TEGRA_CLOSE_CHANNEL         0x06
 637 #define DRM_TEGRA_GET_SYNCPT            0x07
 638 #define DRM_TEGRA_SUBMIT                0x08
 639 #define DRM_TEGRA_GET_SYNCPT_BASE       0x09
 640 #define DRM_TEGRA_GEM_SET_TILING        0x0a
 641 #define DRM_TEGRA_GEM_GET_TILING        0x0b
 642 #define DRM_TEGRA_GEM_SET_FLAGS         0x0c
 643 #define DRM_TEGRA_GEM_GET_FLAGS         0x0d
 644
 645 #define DRM_IOCTL_TEGRA_GEM_CREATE DRM_IOWR(DRM_COMMAND_BASE + DRM_TEGRA_GEM_CREATE, struct drm_tegra_gem_create)
 646 #define DRM_IOCTL_TEGRA_GEM_MMAP DRM_IOWR(DRM_COMMAND_BASE + DRM_TEGRA_GEM_MMAP, struct drm_tegra_gem_mmap)
 647 #define DRM_IOCTL_TEGRA_SYNCPT_READ DRM_IOWR(DRM_COMMAND_BASE + DRM_TEGRA_SYNCPT_READ, struct drm_tegra_syncpt_read)
 648 #define DRM_IOCTL_TEGRA_SYNCPT_INCR DRM_IOWR(DRM_COMMAND_BASE + DRM_TEGRA_SYNCPT_INCR, struct drm_tegra_syncpt_incr)
 649 #define DRM_IOCTL_TEGRA_SYNCPT_WAIT DRM_IOWR(DRM_COMMAND_BASE + DRM_TEGRA_SYNCPT_WAIT, struct drm_tegra_syncpt_wait)
 650 #define DRM_IOCTL_TEGRA_OPEN_CHANNEL DRM_IOWR(DRM_COMMAND_BASE + DRM_TEGRA_OPEN_CHANNEL, struct drm_tegra_open_channel)
 651 #define DRM_IOCTL_TEGRA_CLOSE_CHANNEL DRM_IOWR(DRM_COMMAND_BASE + DRM_TEGRA_CLOSE_CHANNEL, struct drm_tegra_close_channel)
 652 #define DRM_IOCTL_TEGRA_GET_SYNCPT DRM_IOWR(DRM_COMMAND_BASE + DRM_TEGRA_GET_SYNCPT, struct drm_tegra_get_syncpt)
 653 #define DRM_IOCTL_TEGRA_SUBMIT DRM_IOWR(DRM_COMMAND_BASE + DRM_TEGRA_SUBMIT, struct drm_tegra_submit)
 654 #define DRM_IOCTL_TEGRA_GET_SYNCPT_BASE DRM_IOWR(DRM_COMMAND_BASE + DRM_TEGRA_GET_SYNCPT_BASE, struct drm_tegra_get_syncpt_base)
 655 #define DRM_IOCTL_TEGRA_GEM_SET_TILING DRM_IOWR(DRM_COMMAND_BASE + DRM_TEGRA_GEM_SET_TILING, struct drm_tegra_gem_set_tiling)
 656 #define DRM_IOCTL_TEGRA_GEM_GET_TILING DRM_IOWR(DRM_COMMAND_BASE + DRM_TEGRA_GEM_GET_TILING, struct drm_tegra_gem_get_tiling)
 657 #define DRM_IOCTL_TEGRA_GEM_SET_FLAGS DRM_IOWR(DRM_COMMAND_BASE + DRM_TEGRA_GEM_SET_FLAGS, struct drm_tegra_gem_set_flags)
 658 #define DRM_IOCTL_TEGRA_GEM_GET_FLAGS DRM_IOWR(DRM_COMMAND_BASE + DRM_TEGRA_GEM_GET_FLAGS, struct drm_tegra_gem_get_flags)
 659
 660 /* New Tegra DRM UAPI */
 661
 662 /*
 663  * Reported by the driver in the `capabilities` field.
 664  *
 665  * DRM_TEGRA_CHANNEL_CAP_CACHE_COHERENT: If set, the engine is cache coherent
 666  * with regard to the system memory.
 667  */
 668 #define DRM_TEGRA_CHANNEL_CAP_CACHE_COHERENT (1 << 0)
 669
 670 struct drm_tegra_channel_open {
 671         /**
 672          * @host1x_class: [in]
 673          *
 674          * Host1x class of the engine that will be programmed using this
 675          * channel.
 676          */
 677         __u32 host1x_class;
 678
 679         /**
 680          * @flags: [in]
 681          *
 682          * Flags.
 683          */
 684         __u32 flags;
 685
 686         /**
 687          * @context: [out]
 688          *
 689          * Opaque identifier corresponding to the opened channel.
 690          */
 691         __u32 context;
 692
 693         /**
 694          * @version: [out]
 695          *
 696          * Version of the engine hardware. This can be used by userspace
 697          * to determine how the engine needs to be programmed.
 698          */
 699         __u32 version;
 700
 701         /**
 702          * @capabilities: [out]
 703          *
 704          * Flags describing the hardware capabilities.
 705          */
 706         __u32 capabilities;
 707         __u32 padding;
 708 };
 709
 710 struct drm_tegra_channel_close {
 711         /**
 712          * @context: [in]
 713          *
 714          * Identifier of the channel to close.
 715          */
 716         __u32 context;
 717         __u32 padding;
 718 };
 719
 720 /*
 721  * Mapping flags that can be used to influence how the mapping is created.
 722  *
 723  * DRM_TEGRA_CHANNEL_MAP_READ: create mapping that allows HW read access
 724  * DRM_TEGRA_CHANNEL_MAP_WRITE: create mapping that allows HW write access
 725  */
 726 #define DRM_TEGRA_CHANNEL_MAP_READ  (1 << 0)
 727 #define DRM_TEGRA_CHANNEL_MAP_WRITE (1 << 1)
 728 #define DRM_TEGRA_CHANNEL_MAP_READ_WRITE (DRM_TEGRA_CHANNEL_MAP_READ | \
 729                                           DRM_TEGRA_CHANNEL_MAP_WRITE)
 730
 731 struct drm_tegra_channel_map {
 732         /**
 733          * @context: [in]
 734          *
 735          * Identifier of the channel to which make memory available for.
 736          */
 737         __u32 context;
 738
 739         /**
 740          * @handle: [in]
 741          *
 742          * GEM handle of the memory to map.
 743          */
 744         __u32 handle;
 745
 746         /**
 747          * @flags: [in]
 748          *
 749          * Flags.
 750          */
 751         __u32 flags;
 752
 753         /**
 754          * @mapping: [out]
 755          *
 756          * Identifier corresponding to the mapping, to be used for
 757          * relocations or unmapping later.
 758          */
 759         __u32 mapping;
 760 };
 761
 762 struct drm_tegra_channel_unmap {
 763         /**
 764          * @context: [in]
 765          *
 766          * Channel identifier of the channel to unmap memory from.
 767          */
 768         __u32 context;
 769
 770         /**
 771          * @mapping: [in]
 772          *
 773          * Mapping identifier of the memory mapping to unmap.
 774          */
 775         __u32 mapping;
 776 };
 777
 778 /* Submission */
 779
 780 /**
 781  * Specify that bit 39 of the patched-in address should be set to switch
 782  * swizzling between Tegra and non-Tegra sector layout on systems that store
 783  * surfaces in system memory in non-Tegra sector layout.
 784  */
 785 #define DRM_TEGRA_SUBMIT_RELOC_SECTOR_LAYOUT (1 << 0)
 786
 787 struct drm_tegra_submit_buf {
 788         /**
 789          * @mapping: [in]
 790          *
 791          * Identifier of the mapping to use in the submission.
 792          */
 793         __u32 mapping;
 794
 795         /**
 796          * @flags: [in]
 797          *
 798          * Flags.
 799          */
 800         __u32 flags;
 801
 802         /**
 803          * Information for relocation patching.
 804          */
 805         struct {
 806                 /**
 807                  * @target_offset: [in]
 808                  *
 809                  * Offset from the start of the mapping of the data whose
 810                  * address is to be patched into the gather.
 811                  */
 812                 __u64 target_offset;
 813
 814                 /**
 815                  * @gather_offset_words: [in]
 816                  *
 817                  * Offset in words from the start of the gather data to
 818                  * where the address should be patched into.
 819                  */
 820                 __u32 gather_offset_words;
 821
 822                 /**
 823                  * @shift: [in]
 824                  *
 825                  * Number of bits the address should be shifted right before
 826                  * patching in.
 827                  */
 828                 __u32 shift;
 829         } reloc;
 830 };
 831
 832 /**
 833  * Execute `words` words of Host1x opcodes specified in the `gather_data_ptr`
 834  * buffer. Each GATHER_UPTR command uses successive words from the buffer.
 835  */
 836 #define DRM_TEGRA_SUBMIT_CMD_GATHER_UPTR                0
 837 /**
 838  * Wait for a syncpoint to reach a value before continuing with further
 839  * commands.
 840  */
 841 #define DRM_TEGRA_SUBMIT_CMD_WAIT_SYNCPT                1
 842 /**
 843  * Wait for a syncpoint to reach a value before continuing with further
 844  * commands. The threshold is calculated relative to the start of the job.
 845  */
 846 #define DRM_TEGRA_SUBMIT_CMD_WAIT_SYNCPT_RELATIVE       2
 847
 848 struct drm_tegra_submit_cmd_gather_uptr {
 849         __u32 words;
 850         __u32 reserved[3];
 851 };
 852
 853 struct drm_tegra_submit_cmd_wait_syncpt {
 854         __u32 id;
 855         __u32 value;
 856         __u32 reserved[2];
 857 };
 858
 859 struct drm_tegra_submit_cmd {
 860         /**
 861          * @type: [in]
 862          *
 863          * Command type to execute. One of the DRM_TEGRA_SUBMIT_CMD*
 864          * defines.
 865          */
 866         __u32 type;
 867
 868         /**
 869          * @flags: [in]
 870          *
 871          * Flags.
 872          */
 873         __u32 flags;
 874
 875         union {
 876                 struct drm_tegra_submit_cmd_gather_uptr gather_uptr;
 877                 struct drm_tegra_submit_cmd_wait_syncpt wait_syncpt;
 878                 __u32 reserved[4];
 879         };
 880 };
 881
 882 struct drm_tegra_submit_syncpt {
 883         /**
 884          * @id: [in]
 885          *
 886          * ID of the syncpoint that the job will increment.
 887          */
 888         __u32 id;
 889
 890         /**
 891          * @flags: [in]
 892          *
 893          * Flags.
 894          */
 895         __u32 flags;
 896
 897         /**
 898          * @increments: [in]
 899          *
 900          * Number of times the job will increment this syncpoint.
 901          */
 902         __u32 increments;
 903
 904         /**
 905          * @value: [out]
 906          *
 907          * Value the syncpoint will have once the job has completed all
 908          * its specified syncpoint increments.
 909          *
 910          * Note that the kernel may increment the syncpoint before or after
 911          * the job. These increments are not reflected in this field.
 912          *
 913          * If the job hangs or times out, not all of the increments may
 914          * get executed.
 915          */
 916         __u32 value;
 917 };
 918
 919 struct drm_tegra_channel_submit {
 920         /**
 921          * @context: [in]
 922          *
 923          * Identifier of the channel to submit this job to.
 924          */
 925         __u32 context;
 926
 927         /**
 928          * @num_bufs: [in]
 929          *
 930          * Number of elements in the `bufs_ptr` array.
 931          */
 932         __u32 num_bufs;
 933
 934         /**
 935          * @num_cmds: [in]
 936          *
 937          * Number of elements in the `cmds_ptr` array.
 938          */
 939         __u32 num_cmds;
 940
 941         /**
 942          * @gather_data_words: [in]
 943          *
 944          * Number of 32-bit words in the `gather_data_ptr` array.
 945          */
 946         __u32 gather_data_words;
 947
 948         /**
 949          * @bufs_ptr: [in]
 950          *
 951          * Pointer to an array of drm_tegra_submit_buf structures.
 952          */
 953         __u64 bufs_ptr;
 954
 955         /**
 956          * @cmds_ptr: [in]
 957          *
 958          * Pointer to an array of drm_tegra_submit_cmd structures.
 959          */
 960         __u64 cmds_ptr;
 961
 962         /**
 963          * @gather_data_ptr: [in]
 964          *
 965          * Pointer to an array of Host1x opcodes to be used by GATHER_UPTR
 966          * commands.
 967          */
 968         __u64 gather_data_ptr;
 969
 970         /**
 971          * @syncobj_in: [in]
 972          *
 973          * Handle for DRM syncobj that will be waited before submission.
 974          * Ignored if zero.
 975          */
 976         __u32 syncobj_in;
 977
 978         /**
 979          * @syncobj_out: [in]
 980          *
 981          * Handle for DRM syncobj that will have its fence replaced with
 982          * the job's completion fence. Ignored if zero.
 983          */
 984         __u32 syncobj_out;
 985
 986         /**
 987          * @syncpt_incr: [in,out]
 988          *
 989          * Information about the syncpoint the job will increment.
 990          */
 991         struct drm_tegra_submit_syncpt syncpt;
 992 };
 993
 994 struct drm_tegra_syncpoint_allocate {
 995         /**
 996          * @id: [out]
 997          *
 998          * ID of allocated syncpoint.
 999          */
1000         __u32 id;
1001         __u32 padding;
1002 };
1003
1004 struct drm_tegra_syncpoint_free {
1005         /**
1006          * @id: [in]
1007          *
1008          * ID of syncpoint to free.
1009          */
1010         __u32 id;
1011         __u32 padding;
1012 };
1013
1014 struct drm_tegra_syncpoint_wait {
1015         /**
1016          * @timeout: [in]
1017          *
1018          * Absolute timestamp at which the wait will time out.
1019          */
1020         __s64 timeout_ns;
1021
1022         /**
1023          * @id: [in]
1024          *
1025          * ID of syncpoint to wait on.
1026          */
1027         __u32 id;
1028
1029         /**
1030          * @threshold: [in]
1031          *
1032          * Threshold to wait for.
1033          */
1034         __u32 threshold;
1035
1036         /**
1037          * @value: [out]
1038          *
1039          * Value of the syncpoint upon wait completion.
1040          */
1041         __u32 value;
1042
1043         __u32 padding;
1044 };
1045
1046 #define DRM_IOCTL_TEGRA_CHANNEL_OPEN DRM_IOWR(DRM_COMMAND_BASE + 0x10, struct drm_tegra_channel_open)
1047 #define DRM_IOCTL_TEGRA_CHANNEL_CLOSE DRM_IOWR(DRM_COMMAND_BASE + 0x11, struct drm_tegra_channel_close)
1048 #define DRM_IOCTL_TEGRA_CHANNEL_MAP DRM_IOWR(DRM_COMMAND_BASE + 0x12, struct drm_tegra_channel_map)
1049 #define DRM_IOCTL_TEGRA_CHANNEL_UNMAP DRM_IOWR(DRM_COMMAND_BASE + 0x13, struct drm_tegra_channel_unmap)
1050 #define DRM_IOCTL_TEGRA_CHANNEL_SUBMIT DRM_IOWR(DRM_COMMAND_BASE + 0x14, struct drm_tegra_channel_submit)
1051
1052 #define DRM_IOCTL_TEGRA_SYNCPOINT_ALLOCATE DRM_IOWR(DRM_COMMAND_BASE + 0x20, struct drm_tegra_syncpoint_allocate)
1053 #define DRM_IOCTL_TEGRA_SYNCPOINT_FREE DRM_IOWR(DRM_COMMAND_BASE + 0x21, struct drm_tegra_syncpoint_free)
1054 #define DRM_IOCTL_TEGRA_SYNCPOINT_WAIT DRM_IOWR(DRM_COMMAND_BASE + 0x22, struct drm_tegra_syncpoint_wait)
1055
1056 #if defined(__cplusplus)
1057 }
1058 #endif
1059
1060 #endif