drm-nvdc-docs.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016-2021 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 drmIsMaster(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 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);
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 drmModeAtomicGetCursor(drmModeAtomicReqPtr req);


int drmModeAtomicMerge(drmModeAtomicReqPtr base, drmModeAtomicReqPtr augment);


void drmModeAtomicSetCursor(drmModeAtomicReqPtr req, int cursor);


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 drmOpenWithType(const char *name, const char *busid, int type);

int drmOpenControl(int minor);

int drmOpenRender(int minor);

int drmGetInterruptFromBusID(int fd, int busnum, int devnum, int funcnum);

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

int drmGetClient(int fd, int idx, int *auth, int *pid, int *uid, unsigned long *magic, unsigned long *iocs);

int drmGetStats(int fd, drmStatsT *stats);

int drmCommandNone(int fd, unsigned long drmCommandIndex);

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

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

int drmAddContextPrivateMapping(int fd, drm_context_t ctx_id, drm_handle_t handle);

int drmAddBufs(int fd, int count, int size, drmBufDescFlags flags, int agp_offset);

int drmMarkBufs(int fd, double low, double high);

int drmGetContextFlags(int fd, drm_context_t context, drm_context_tFlagsPtr flags);

int drmSwitchToContext(int fd, drm_context_t context);

int drmCtlInstHandler(int fd, int irq);

int drmCtlUninstHandler(int fd);

int drmCrtcGetSequence(int fd, uint32_t crtcId, uint64_t *sequence, uint64_t *ns);

int drmCrtcQueueSequence(int fd, uint32_t crtcId, uint32_t flags, uint64_t sequence, uint64_t *sequence_queued, uint64_t user_data);

int drmUnmapBufs(drmBufMapPtr bufs);

int drmDMA(int fd, drmDMAReqPtr request);

int drmFreeBufs(int fd, int count, int *list);

int drmFinish(int fd, int context, drmLockFlags flags);

int drmGetContextPrivateMapping(int fd, drm_context_t ctx_id,  drm_handle_t * handle);

int drmAgpAcquire(int fd);

int drmAgpRelease(int fd);

int drmAgpEnable(int fd, unsigned long mode);

int drmAgpAlloc(int fd, unsigned long size, unsigned long type, unsigned long *address, drm_handle_t *handle);

int drmAgpFree(int fd, drm_handle_t handle);

int drmAgpBind(int fd, drm_handle_t handle, unsigned long offset);

int drmAgpUnbind(int fd, drm_handle_t handle);

int drmAgpVersionMajor(int fd);

int drmAgpVersionMinor(int fd);

int drmScatterGatherAlloc(int fd, unsigned long size, drm_handle_t *handle);

int drmScatterGatherFree(int fd, drm_handle_t handle);

int drmError(int err, const char *label);

int drmHashDestroy(void *t);

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

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

int drmHashDelete(void *t, unsigned long key);

int drmRandomDestroy(void *state);

int drmSLDestroy(void *l);

int drmSLLookup(void *l, unsigned long key, void **value);

int drmSLInsert(void *l, unsigned long key, void *value);

int drmSLDelete(void *l, unsigned long key);

int drmSLNext(void *l, unsigned long *key, void **value);

int drmSLFirst(void *l, unsigned long *key, void **value);

int drmSLLookupNeighbors(void *l, unsigned long key,  unsigned long *prev_key, void **prev_value,  unsigned long *next_key, void **next_value);

int drmOpenOnce(void *unused, const char *BusID, int *newlyopened);

int drmOpenOnceWithType(const char *BusID, int *newlyopened, int type);

int drmGetNodeTypeFromFd(int fd);

int drmGetDevice(int fd, drmDevicePtr *device);

int drmGetDevices(drmDevicePtr devices[], int max_devices);

int drmGetDevice2(int fd, uint32_t flags, drmDevicePtr *device);

int drmGetDevices2(uint32_t flags, drmDevicePtr devices[], int max_devices);

int drmDevicesEqual(drmDevicePtr a, drmDevicePtr b);

int drmSyncobjCreate(int fd, uint32_t flags, uint32_t *handle);

int drmSyncobjDestroy(int fd, uint32_t handle);

int drmSyncobjHandleToFD(int fd, uint32_t handle, int *obj_fd);

int drmSyncobjFDToHandle(int fd, int obj_fd, uint32_t *handle);

int drmSyncobjImportSyncFile(int fd, uint32_t handle, int sync_file_fd);

int drmSyncobjExportSyncFile(int fd, uint32_t handle, int *sync_file_fd);

int drmSyncobjWait(int fd, uint32_t *handles, unsigned num_handles, int64_t timeout_nsec, unsigned flags, uint32_t *first_signaled);

int drmSyncobjTimelineWait(int fd, uint32_t *handles, uint64_t *points, unsigned num_handles, int64_t timeout_nsec, unsigned flags, uint32_t *first_signaled);

int drmSyncobjReset(int fd, const uint32_t *handles, uint32_t handle_count);

int drmSyncobjSignal(int fd, const uint32_t *handles, uint32_t handle_count);

int drmSyncobjTimelineSignal(int fd, const uint32_t *handles, uint64_t *points, uint32_t handle_count);

int drmSyncobjTransfer(int fd, uint32_t dst_handle, uint64_t dst_point, uint32_t src_handle, uint64_t src_point, uint32_t flags);

int drmSyncobjQuery(int fd, uint32_t *handles, uint64_t *points, uint32_t handle_count);

int drmSyncobjQuery2(int fd, uint32_t *handles, uint64_t *points, uint32_t handle_count, uint32_t flags);

unsigned long drmRandom(void *state);

double drmRandomDouble(void *state);

unsigned long drmAgpGetMode(int fd);

unsigned long drmAgpBase(int fd);

unsigned long drmAgpSize(int fd);

unsigned long drmAgpMemoryUsed(int fd);

unsigned long drmAgpMemoryAvail(int fd);

unsigned int drmAgpVendorId(int fd);

unsigned int drmAgpDeviceId(int fd);

void drmSLDump(void *l);

void drmCloseOnce(int fd);

void drmFreeDevice(drmDevicePtr *device);

void drmFreeDevices(drmDevicePtr devices[], int count);

char *drmGetDeviceNameFromFd2(int fd);

char *drmGetPrimaryDeviceNameFromFd(int fd);

char *drmGetRenderDeviceNameFromFd(int fd);

drmVersionPtr drmGetLibVersion(int fd);

drmBufInfoPtr drmGetBufInfo(int fd);

drmBufMapPtr drmMapBufs(int fd);

void *drmMalloc(int size);

void *drmRandomCreate(unsigned long seed);

void *drmHashCreate(void);

void *drmSLCreate(void);

void drmModeFreeModeInfo(drmModeModeInfoPtr ptr);

void drmModeFreeFB(drmModeFBPtr ptr);

void drmModeFreeFB2(drmModeFB2Ptr ptr);

void drmModeAtomicSetCursor(drmModeAtomicReqPtr req, int cursor);

drmModeFBPtr drmModeGetFB(int fd, uint32_t bufferId);

drmModeFB2Ptr drmModeGetFB2(int fd, uint32_t bufferId);

drmModeConnectorPtr drmModeGetConnectorCurrent(int fd, uint32_t connector_id);

drmModeAtomicReqPtr drmModeAtomicDuplicate(drmModeAtomicReqPtr req);

drmModeLesseeListPtr drmModeListLessees(int fd);

drmModeObjectListPtr drmModeGetLease(int fd);

int drmModeDirtyFB(int fd, uint32_t bufferId, drmModeClipPtr clips, uint32_t num_clips);
{
    return -ENOTSUP;
}

int drmModeAttachMode(int fd, uint32_t connectorId, drmModeModeInfoPtr mode_info);

int drmModeDetachMode(int fd, uint32_t connectorId, drmModeModeInfoPtr mode_info);

int drmCheckModesettingSupported(const char *busid);

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

int drmModeRevokeLease(int fd, uint32_t lessee_id);

int drmModeCreateLease(int fd, const uint32_t *objects, int num_objects, int flags, uint32_t *lessee_id);

void drmMsg(const char *format, ...)