drm-nvdc-docs.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016-2018 NVIDIA CORPORATION.  All rights reserved.
 *
 * NVIDIA CORPORATION and its licensors retain all intellectual property
 * and proprietary rights in and to this software, related documentation
 * and any modifications thereto.  Any use, reproduction, disclosure or
 * distribution of this software and related documentation without an express
 * license agreement from NVIDIA CORPORATION is strictly prohibited.
 */


int drmOpen(const char* name, const char* busid);


int drmClose(int fd);


int drmGetCap(int fd, uint64_t capability, uint64_t *value);


int drmSetClientCap(int fd, uint64_t capability, uint64_t value);


int drmSetMaster(int fd);


int drmDropMaster(int fd);


int drmGetMagic( int fd, drm_magic_t * magic);


int drmAuthMagic(int fd, drm_magic_t magic);


drmVersionPtr drmGetVersion(int fd);


void drmFreeVersion(drmVersionPtr version);


int drmHandleEvent(int fd, drmEventContextPtr evctx);


int drmIoctl(int fd, unsigned long request, void *arg);


int drmWaitVBlank(int fd, drmVBlankPtr vbl);


int drmModeAddFB(int fd,
                 uint32_t width,
                 uint32_t height,
                 uint8_t depth,
                 uint8_t bpp,
                 uint32_t pitch,
                 uint32_t bo_handle,
                 uint32_t *buf_id);


int drmModeAddFB2(int fd,
                  uint32_t width,
                  uint32_t height,
                  uint32_t pixel_format,
                  const uint32_t bo_handles[4],
                  const uint32_t pitches[4],
                  const uint32_t offsets[4],
                  uint32_t *buf_id,
                  uint32_t flags);


int drmModeRmFB(int fd, uint32_t fb_id);


drmModeConnectorPtr drmModeGetConnector(int fd, uint32_t connector_id);


void drmModeFreeConnector(drmModeConnectorPtr ptr);


int drmModeConnectorSetProperty(int fd,
                                uint32_t connector_id,
                                uint32_t property_id,
                                uint64_t value);


drmModeCrtcPtr drmModeGetCrtc(int fd, uint32_t crtc_id);


void drmModeFreeCrtc(drmModeCrtcPtr ptr);


int drmModeSetCrtc(int fd,
                   uint32_t crtc_id,
                   uint32_t fb_id,
                   uint32_t x,
                   uint32_t y,
                   uint32_t *connectors,
                   int count,
                   drmModeModeInfoPtr drm_mode);


int drmModeCrtcSetGamma(int fd, uint32_t crtc_id, uint32_t size,
                        uint16_t *red, uint16_t *green, uint16_t *blue);


int drmModeCrtcGetGamma(int fd, uint32_t crtc_id, uint32_t size,
                              uint16_t *red, uint16_t *green, uint16_t *blue);


int drmModePageFlip(int fd,
                    uint32_t crtc_id,
                    uint32_t fb_id,
                    uint32_t flags,
                    void *user_data);


int drmModeSetCursor(int fd,
                     uint32_t crtc_id,
                     uint32_t bo_handle,
                     uint32_t width,
                     uint32_t height);


int drmModeMoveCursor(int fd, uint32_t crtc_id, int x, int y);


drmModeEncoderPtr drmModeGetEncoder(int fd, uint32_t encoder_id);


void drmModeFreeEncoder(drmModeEncoderPtr ptr);


drmModePlanePtr drmModeGetPlane(int fd, uint32_t plane_id);


void drmModeFreePlane(drmModePlanePtr ptr);


int drmModeSetPlane(int fd,
                    uint32_t plane_id,
                    uint32_t crtc_id,
                    uint32_t fb_id,
                    uint32_t flags,
                    int32_t crtc_x,
                    int32_t crtc_y,
                    uint32_t crtc_w,
                    uint32_t crtc_h,
                    uint32_t src_x,
                    uint32_t src_y,
                    uint32_t src_w,
                    uint32_t src_h);


 drmModeObjectPropertiesPtr drmModeObjectGetProperties(int fd,
                                                      uint32_t object_id,
                                                      uint32_t object_type);


void drmModeFreeObjectProperties(drmModeObjectPropertiesPtr ptr);


 *     /* Print the property name, which will be "Primary", "Overlay", or "Cursor". */
 *     printf("\tcon_value    : %s\n", name);
 * } else {
 *     /* The specified plane property value does not appear in the DRM properties. */
 *     /* Print the property value for which we were looking. */
 *     printf("\tcon_value    : %" PRIu64 "\n", value);
 * }
 * @endcode
 *
 * @note The zpos value for a plane is initialized with an offset of 10 relative to
 * the next plane. This is to allow for flexible configuration of heads. For example:
 * - "Primary" type Plane zpos = 10
 * - First "Overlay" Plane zpos = 20
 * - Next "Overlay" Plane zpos = 30
 * - Etc.
 *
 * @note The allowed range for zpos is [0, 255]. Planes with numerically greater values for
 * zpos occlude planes with numerically lesser values.
 *
 * @note The alpha value for a plane causes a plane-wide transparency to be
 * applied as well as the per-pixel alpha contained in the buffer object.  The
 * allowed range for alpha is [0, 255], where 0 is fully transparent and 255 indicates
 * that only per-pixel alpha has an effect.  For non-alpha pixel formats,
 * there is no per-pixel alpha, so 255 indicates fully opaque.
 *
 * @post If the call is successful, the application must free the property
 * information structure by calling ::drmModeFreeProperty.
 *
 * @param fd          The file descriptor of an open DRM device.
 * @param propertyId  Property ID of the property object to be fetched.
 * @return  A @c drmModePropertyPtr if successful, or NULL otherwise.
 */
drmModePropertyPtr drmModeGetProperty(int fd, uint32_t propertyId);

int drmModeObjectSetProperty(int fd, uint32_t object_id, uint32_t object_type,
                             uint32_t property_id, uint64_t value);

void drmModeFreeProperty(drmModePropertyPtr ptr);


drmModeResPtr drmModeGetResources(int fd);


void drmModeFreeResources(drmModeResPtr ptr);


drmModePlaneResPtr drmModeGetPlaneResources(int fd);


void drmModeFreePlaneResources(drmModePlaneResPtr ptr);


int drmPrimeFDToHandle(int fd, int prime_fd, uint32_t *handle);

int drmPrimeHandleToFD(int fd, uint32_t handle, uint32_t flags, int *prime_fd)


drmModeAtomicReqPtr drmModeAtomicAlloc(void);


int drmModeAtomicAddProperty(drmModeAtomicReqPtr req,
                             uint32_t object_id,
                             uint32_t property_id,
                             uint64_t value);


int drmModeAtomicCommit(int fd,
                        drmModeAtomicReqPtr req,
                        uint32_t flags,
                        void *user_data);


void drmModeAtomicFree(drmModeAtomicReqPtr req);


int drmSetInterfaceVersion(int fd, drmSetVersion *version);


char *drmGetBusid(int fd);


void drmFreeBusid(const char *busid);


int drmModeCreatePropertyBlob(int fd,
                              const void *data, size_t size,
                              uint32_t *id);


int drmModeDestroyPropertyBlob(int fd, uint32_t id);


drmModePropertyBlobPtr drmModeGetPropertyBlob(int fd, uint32_t blob_id);


void drmModeFreePropertyBlob(drmModePropertyBlobPtr ptr);


char *drmGetDeviceNameFromFd(int fd);


void drmFree(void *p);

int drmCommandWriteRead(int fd,
                        unsigned long drmCommandIndex,
                        void *data,
                        unsigned long size);

drmHashEntry *drmGetEntry(int fd);


int drmRmMap(int fd, drm_handle_t handle);

int drmAvailable(void);

int drmDestroyDrawable(int fd, drm_drawable_t handle);

int drmDestroyContext(int fd, drm_context_t handle);

int drmSetContextFlags(int fd, drm_context_t context, drm_context_tFlags flags);

int drmMap(int fd, drm_handle_t handle, drmSize size, drmAddressPtr address);

int drmUnlock(int fd, drm_context_t context);

void drmFreeReservedContextList(drm_context_t *pt);

void drmSetServerInfo(drmServerInfoPtr info);

int drmAddContextTag(int fd, drm_context_t context, void *tag);

int drmAddMap(int fd, drm_handle_t offset, drmSize size,
              drmMapType type, drmMapFlags flags,
              drm_handle_t *handle);

int drmCreateContext(int fd, drm_context_t *handle);

int drmUpdateDrawableInfo(int fd, drm_drawable_t handle,
                          drm_drawable_info_type_t type,
                          unsigned int num,
                          void *data);

int drmCreateDrawable(int fd, drm_drawable_t *handle);

void *drmGetHashTable(void);

int drmDelContextTag(int fd, drm_context_t context);

int drmUnmap(drmAddress address, drmSize size);

int drmSetBusid(int fd, const char *busid);

int drmGetLock(int fd, drm_context_t context, drmLockFlags flags);

void *drmGetContextTag(int fd, drm_context_t context);

drm_context_t *drmGetReservedContextList(int fd, int *count);

int drmHashNext(void *t, unsigned long *key, void **value);

int drmHashFirst(void *t, unsigned long *key, void **value);

int drmModeSetCursor2(int fd, uint32_t crtcId, uint32_t bo_handle,
                      uint32_t width, uint32_t height, int32_t hot_x,
                      int32_t hot_y)


int drmModeAddFB2WithModifiers(int fd, uint32_t width,
                               uint32_t height, uint32_t pixel_format,
                               const uint32_t bo_handles[4],
                               const uint32_t pitches[4],
                               const uint32_t offsets[4],
                               const uint64_t modifier[4],
                               uint32_t *buf_id, uint32_t flags);