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, ...)