Back to index

libdrm  2.4.37
Defines | Functions | Variables
xf86drm.c File Reference

User-level interface to DRM device. More...

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <strings.h>
#include <ctype.h>
#include <fcntl.h>
#include <errno.h>
#include <signal.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/time.h>
#include <stdarg.h>
#include "xf86drm.h"
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines

#define stat_t   struct stat
#define MAP_FAILED   ((void *)-1)
#define DRM_MAJOR   226 /* Linux */
#define makedev(x, y)   ((dev_t)(((x) << 8) | (y)))
#define DRM_MSG_VERBOSITY   3
#define DRM_NODE_CONTROL   0
#define DRM_NODE_RENDER   1
#define DRM_DMA_RETRY   16
#define SET_VALUE
#define SET_COUNT
#define SET_BYTE
#define DRM_MAX_FDS   16

Functions

void drmSetServerInfo (drmServerInfoPtr info)
static int drmDebugPrint (const char *format, va_list ap)
 Output a message to stderr.
void drmMsg (const char *format,...)
void drmSetDebugMsgFunction (int(*debug_msg_ptr)(const char *format, va_list ap))
void * drmGetHashTable (void)
void * drmMalloc (int size)
void drmFree (void *pt)
int drmIoctl (int fd, unsigned long request, void *arg)
 Call ioctl, restarting if it is interupted.
static unsigned long drmGetKeyFromFd (int fd)
drmHashEntrydrmGetEntry (int fd)
static int drmMatchBusID (const char *id1, const char *id2, int pci_domain_ok)
 Compare two busid strings.
static int chown_check_return (const char *path, uid_t owner, gid_t group)
 Handles error checking for chown call.
static int drmOpenDevice (long dev, int minor, int type)
 Open the DRM device, creating it if necessary.
static int drmOpenMinor (int minor, int create, int type)
 Open the DRM device.
int drmAvailable (void)
 Determine whether the DRM kernel driver has been loaded.
static int drmOpenByBusid (const char *busid)
 Open the device by bus ID.
static int drmOpenByName (const char *name)
 Open the device by name.
int drmOpen (const char *name, const char *busid)
 Open the DRM device.
int drmOpenControl (int minor)
void drmFreeVersion (drmVersionPtr v)
 Free the version information returned by drmGetVersion().
static void drmFreeKernelVersion (drm_version_t *v)
 Free the non-public version information returned by the kernel.
static void drmCopyVersion (drmVersionPtr d, const drm_version_t *s)
 Copy version information.
drmVersionPtr drmGetVersion (int fd)
 Query the driver version information.
drmVersionPtr drmGetLibVersion (int fd)
 Get version information for the DRM user space library.
int drmGetCap (int fd, uint64_t capability, uint64_t *value)
void drmFreeBusid (const char *busid)
 Free the bus ID information.
char * drmGetBusid (int fd)
 Get the bus ID of the device.
int drmSetBusid (int fd, const char *busid)
 Set the bus ID of the device.
int drmGetMagic (int fd, drm_magic_t *magic)
int drmAuthMagic (int fd, drm_magic_t magic)
int drmAddMap (int fd, drm_handle_t offset, drmSize size, drmMapType type, drmMapFlags flags, drm_handle_t *handle)
 Specifies a range of memory that is available for mapping by a non-root process.
int drmRmMap (int fd, drm_handle_t handle)
int drmAddBufs (int fd, int count, int size, drmBufDescFlags flags, int agp_offset)
 Make buffers available for DMA transfers.
int drmMarkBufs (int fd, double low, double high)
int drmFreeBufs (int fd, int count, int *list)
 Free buffers.
int drmClose (int fd)
 Close the device.
int drmMap (int fd, drm_handle_t handle, drmSize size, drmAddressPtr address)
 Map a region of memory.
int drmUnmap (drmAddress address, drmSize size)
 Unmap mappings obtained with drmMap().
drmBufInfoPtr drmGetBufInfo (int fd)
drmBufMapPtr drmMapBufs (int fd)
 Map all DMA buffers into client-virtual space.
int drmUnmapBufs (drmBufMapPtr bufs)
 Unmap buffers allocated with drmMapBufs().
int drmDMA (int fd, drmDMAReqPtr request)
 Reserve DMA buffers.
int drmGetLock (int fd, drm_context_t context, drmLockFlags flags)
 Obtain heavyweight hardware lock.
int drmUnlock (int fd, drm_context_t context)
 Release the hardware lock.
drm_context_tdrmGetReservedContextList (int fd, int *count)
void drmFreeReservedContextList (drm_context_t *pt)
int drmCreateContext (int fd, drm_context_t *handle)
 Create context.
int drmSwitchToContext (int fd, drm_context_t context)
int drmSetContextFlags (int fd, drm_context_t context, drm_context_tFlags flags)
int drmGetContextFlags (int fd, drm_context_t context, drm_context_tFlagsPtr flags)
int drmDestroyContext (int fd, drm_context_t handle)
 Destroy context.
int drmCreateDrawable (int fd, drm_drawable_t *handle)
int drmDestroyDrawable (int fd, drm_drawable_t handle)
int drmUpdateDrawableInfo (int fd, drm_drawable_t handle, drm_drawable_info_type_t type, unsigned int num, void *data)
int drmAgpAcquire (int fd)
 Acquire the AGP device.
int drmAgpRelease (int fd)
 Release the AGP device.
int drmAgpEnable (int fd, unsigned long mode)
 Set the AGP mode.
int drmAgpAlloc (int fd, unsigned long size, unsigned long type, unsigned long *address, drm_handle_t *handle)
 Allocate a chunk of AGP memory.
int drmAgpFree (int fd, drm_handle_t handle)
 Free a chunk of AGP memory.
int drmAgpBind (int fd, drm_handle_t handle, unsigned long offset)
 Bind a chunk of AGP memory.
int drmAgpUnbind (int fd, drm_handle_t handle)
 Unbind a chunk of AGP memory.
int drmAgpVersionMajor (int fd)
 Get AGP driver major version number.
int drmAgpVersionMinor (int fd)
 Get AGP driver minor version number.
unsigned long drmAgpGetMode (int fd)
 Get AGP mode.
unsigned long drmAgpBase (int fd)
 Get AGP aperture base.
unsigned long drmAgpSize (int fd)
 Get AGP aperture size.
unsigned long drmAgpMemoryUsed (int fd)
 Get used AGP memory.
unsigned long drmAgpMemoryAvail (int fd)
 Get available AGP memory.
unsigned int drmAgpVendorId (int fd)
 Get hardware vendor ID.
unsigned int drmAgpDeviceId (int fd)
 Get hardware device ID.
int drmScatterGatherAlloc (int fd, unsigned long size, drm_handle_t *handle)
int drmScatterGatherFree (int fd, drm_handle_t handle)
int drmWaitVBlank (int fd, drmVBlankPtr vbl)
 Wait for VBLANK.
int drmError (int err, const char *label)
int drmCtlInstHandler (int fd, int irq)
 Install IRQ handler.
int drmCtlUninstHandler (int fd)
 Uninstall IRQ handler.
int drmFinish (int fd, int context, drmLockFlags flags)
int drmGetInterruptFromBusID (int fd, int busnum, int devnum, int funcnum)
 Get IRQ from bus ID.
int drmAddContextTag (int fd, drm_context_t context, void *tag)
int drmDelContextTag (int fd, drm_context_t context)
void * drmGetContextTag (int fd, drm_context_t context)
int drmAddContextPrivateMapping (int fd, drm_context_t ctx_id, drm_handle_t handle)
int drmGetContextPrivateMapping (int fd, drm_context_t ctx_id, drm_handle_t *handle)
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 drmSetInterfaceVersion (int fd, drmSetVersion *version)
 Issue a set-version ioctl.
int drmCommandNone (int fd, unsigned long drmCommandIndex)
 Send a device-specific command.
int drmCommandRead (int fd, unsigned long drmCommandIndex, void *data, unsigned long size)
 Send a device-specific read command.
int drmCommandWrite (int fd, unsigned long drmCommandIndex, void *data, unsigned long size)
 Send a device-specific write command.
int drmCommandWriteRead (int fd, unsigned long drmCommandIndex, void *data, unsigned long size)
 Send a device-specific read-write command.
int drmOpenOnce (void *unused, const char *BusID, int *newlyopened)
void drmCloseOnce (int fd)
int drmSetMaster (int fd)
int drmDropMaster (int fd)
char * drmGetDeviceNameFromFd (int fd)

Variables

static drmServerInfoPtr drm_server_info
static int(* drm_debug_print )(const char *format, va_list ap) = drmDebugPrint
static void * drmHashTable = NULL
struct {
char * BusID
int fd
int refcount
connection [DRM_MAX_FDS]
static int nr_fds = 0

Detailed Description

User-level interface to DRM device.

Author:
Rickard E. (Rik) Faith faith.nosp@m.@val.nosp@m.inux..nosp@m.com
Kevin E. Martin marti.nosp@m.n@va.nosp@m.linux.nosp@m..com

Definition in file xf86drm.c.


Define Documentation

#define DRM_DMA_RETRY   16

Definition at line 1279 of file xf86drm.c.

#define DRM_MAJOR   226 /* Linux */

Definition at line 75 of file xf86drm.c.

#define DRM_MAX_FDS   16

Definition at line 2449 of file xf86drm.c.

#define DRM_MSG_VERBOSITY   3

Definition at line 86 of file xf86drm.c.

#define DRM_NODE_CONTROL   0

Definition at line 88 of file xf86drm.c.

#define DRM_NODE_RENDER   1

Definition at line 89 of file xf86drm.c.

#define makedev (   x,
 
)    ((dev_t)(((x) << 8) | (y)))

Definition at line 83 of file xf86drm.c.

#define MAP_FAILED   ((void *)-1)

Definition at line 57 of file xf86drm.c.

#define SET_BYTE
Value:
stats->data[i].long_format = "%-20.20s";   \
    stats->data[i].rate_format = "%5.5s";      \
    stats->data[i].isvalue     = 0;            \
    stats->data[i].mult_names  = "KGM";        \
    stats->data[i].mult        = 1024;         \
    stats->data[i].verbose     = 0
#define SET_COUNT
Value:
stats->data[i].long_format = "%-20.20s";   \
    stats->data[i].rate_format = "%5.5s";      \
    stats->data[i].isvalue     = 0;            \
    stats->data[i].mult_names  = "kgm";        \
    stats->data[i].mult        = 1000;         \
    stats->data[i].verbose     = 0
#define SET_VALUE
Value:
stats->data[i].long_format = "%-20.20s";   \
    stats->data[i].rate_format = "%8.8s";      \
    stats->data[i].isvalue     = 1;            \
    stats->data[i].verbose     = 0
#define stat_t   struct stat

Definition at line 49 of file xf86drm.c.


Function Documentation

static int chown_check_return ( const char *  path,
uid_t  owner,
gid_t  group 
) [static]

Handles error checking for chown call.

Parameters:
pathto file.
idof the new owner.
idof the new group.
Returns:
zero if success or -1 if failure.

Checks for failure. If failure was caused by signal call chown again. If any other failure happened then it will output error mesage using drmMsg() call.

Definition at line 272 of file xf86drm.c.

{
       int rv;

       do {
              rv = chown(path, owner, group);
       } while (rv != 0 && errno == EINTR);

       if (rv == 0)
              return 0;

       drmMsg("Failed to change owner or group for file %s! %d: %s\n",
                     path, errno, strerror(errno));
       return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Make buffers available for DMA transfers.

Parameters:
fdfile descriptor.
countnumber of buffers.
sizesize of each buffer.
flagsbuffer allocation flags.
agp_offsetoffset in the AGP aperture
Returns:
number of buffers allocated, negative on error.

This function is a wrapper around DRM_IOCTL_ADD_BUFS ioctl.

See also:
drm_buf_desc.

Definition at line 1010 of file xf86drm.c.

{
    drm_buf_desc_t request;

    request.count     = count;
    request.size      = size;
    request.low_mark  = 0;
    request.high_mark = 0;
    request.flags     = flags;
    request.agp_start = agp_offset;

    if (drmIoctl(fd, DRM_IOCTL_ADD_BUFS, &request))
       return -errno;
    return request.count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 2117 of file xf86drm.c.

{
    drm_ctx_priv_map_t map;

    map.ctx_id = ctx_id;
    map.handle = (void *)(uintptr_t)handle;

    if (drmIoctl(fd, DRM_IOCTL_SET_SAREA_CTX, &map))
       return -errno;
    return 0;
}

Here is the call graph for this function:

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

Definition at line 2088 of file xf86drm.c.

{
    drmHashEntry  *entry = drmGetEntry(fd);

    if (drmHashInsert(entry->tagTable, context, tag)) {
       drmHashDelete(entry->tagTable, context);
       drmHashInsert(entry->tagTable, context, tag);
    }
    return 0;
}

Here is the call graph for this function:

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

Specifies a range of memory that is available for mapping by a non-root process.

Parameters:
fdfile descriptor.
offsetusually the physical address. The actual meaning depends of the type parameter. See below.
sizeof the memory in bytes.
typetype of the memory to be mapped.
flagscombination of several flags to modify the function actions.
handlewill be set to a value that may be used as the offset parameter for mmap().
Returns:
zero on success or a negative value on error.
Mapping the frame buffer
For the frame buffer
  • offset will be the physical address of the start of the frame buffer,
  • size will be the size of the frame buffer in bytes, and
  • type will be DRM_FRAME_BUFFER.
The area mapped will be uncached. If MTRR support is available in the kernel, the frame buffer area will be set to write combining.
Mapping the MMIO register area
For the MMIO register area,
  • offset will be the physical address of the start of the register area,
  • size will be the size of the register area bytes, and
  • type will be DRM_REGISTERS.
The area mapped will be uncached.
Mapping the SAREA
For the SAREA,
  • offset will be ignored and should be set to zero,
  • size will be the desired size of the SAREA in bytes,
  • type will be DRM_SHM.
A shared memory area of the requested size will be created and locked in kernel memory. This area may be mapped into client-space by using the handle returned.
Note:
May only be called by root.

This function is a wrapper around the DRM_IOCTL_ADD_MAP ioctl, passing the arguments in a drm_map structure.

Definition at line 966 of file xf86drm.c.

{
    drm_map_t map;

    map.offset  = offset;
    map.size    = size;
    map.handle  = 0;
    map.type    = type;
    map.flags   = flags;
    if (drmIoctl(fd, DRM_IOCTL_ADD_MAP, &map))
       return -errno;
    if (handle)
       *handle = (drm_handle_t)(uintptr_t)map.handle;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int drmAgpAcquire ( int  fd)

Acquire the AGP device.

Must be called before any of the other AGP related calls.

Parameters:
fdfile descriptor.
Returns:
zero on success, or a negative value on failure.

This function is a wrapper around the DRM_IOCTL_AGP_ACQUIRE ioctl.

Definition at line 1563 of file xf86drm.c.

{
    if (drmIoctl(fd, DRM_IOCTL_AGP_ACQUIRE, NULL))
       return -errno;
    return 0;
}

Here is the call graph for this function:

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

Allocate a chunk of AGP memory.

Parameters:
fdfile descriptor.
sizerequested memory size in bytes. Will be rounded to page boundary.
typetype of memory to allocate.
addressif not zero, will be set to the physical address of the allocated memory.
handleon success will be set to a handle of the allocated memory.
Returns:
zero on success, or a negative value on failure.

This function is a wrapper around the DRM_IOCTL_AGP_ALLOC ioctl, passing the arguments in a drm_agp_buffer structure.

Definition at line 1628 of file xf86drm.c.

{
    drm_agp_buffer_t b;

    *handle = DRM_AGP_NO_HANDLE;
    b.size   = size;
    b.handle = 0;
    b.type   = type;
    if (drmIoctl(fd, DRM_IOCTL_AGP_ALLOC, &b))
       return -errno;
    if (address != 0UL)
       *address = b.physical;
    *handle = b.handle;
    return 0;
}

Here is the call graph for this function:

unsigned long drmAgpBase ( int  fd)

Get AGP aperture base.

Parameters:
fdfile descriptor.
Returns:
aperture base on success, zero on failure.

This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the necessary information in a drm_agp_info structure.

Definition at line 1793 of file xf86drm.c.

{
    drm_agp_info_t i;

    if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
       return 0;
    return i.aperture_base;
}

Here is the call graph for this function:

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

Bind a chunk of AGP memory.

Parameters:
fdfile descriptor.
handlehandle to the allocated memory, as given by drmAgpAllocate().
offsetoffset in bytes. It will round to page boundary.
Returns:
zero on success, or a negative value on failure.

This function is a wrapper around the DRM_IOCTL_AGP_BIND ioctl, passing the argument in a drm_agp_binding structure.

Definition at line 1683 of file xf86drm.c.

{
    drm_agp_binding_t b;

    b.handle = handle;
    b.offset = offset;
    if (drmIoctl(fd, DRM_IOCTL_AGP_BIND, &b))
       return -errno;
    return 0;
}

Here is the call graph for this function:

unsigned int drmAgpDeviceId ( int  fd)

Get hardware device ID.

Parameters:
fdfile descriptor.
Returns:
zero on success, or zero on failure.

This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the necessary information in a drm_agp_info structure.

Definition at line 1898 of file xf86drm.c.

{
    drm_agp_info_t i;

    if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
       return 0;
    return i.id_device;
}

Here is the call graph for this function:

int drmAgpEnable ( int  fd,
unsigned long  mode 
)

Set the AGP mode.

Parameters:
fdfile descriptor.
modeAGP mode.
Returns:
zero on success, or a negative value on failure.

This function is a wrapper around the DRM_IOCTL_AGP_ENABLE ioctl, passing the argument in a drm_agp_mode structure.

Definition at line 1601 of file xf86drm.c.

{
    drm_agp_mode_t m;

    m.mode = mode;
    if (drmIoctl(fd, DRM_IOCTL_AGP_ENABLE, &m))
       return -errno;
    return 0;
}

Here is the call graph for this function:

int drmAgpFree ( int  fd,
drm_handle_t  handle 
)

Free a chunk of AGP memory.

Parameters:
fdfile descriptor.
handlehandle to the allocated memory, as given by drmAgpAllocate().
Returns:
zero on success, or a negative value on failure.

This function is a wrapper around the DRM_IOCTL_AGP_FREE ioctl, passing the argument in a drm_agp_buffer structure.

Definition at line 1658 of file xf86drm.c.

{
    drm_agp_buffer_t b;

    b.size   = 0;
    b.handle = handle;
    if (drmIoctl(fd, DRM_IOCTL_AGP_FREE, &b))
       return -errno;
    return 0;
}

Here is the call graph for this function:

unsigned long drmAgpGetMode ( int  fd)

Get AGP mode.

Parameters:
fdfile descriptor.
Returns:
mode on success, or zero on failure.

This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the necessary information in a drm_agp_info structure.

Definition at line 1772 of file xf86drm.c.

{
    drm_agp_info_t i;

    if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
       return 0;
    return i.mode;
}

Here is the call graph for this function:

unsigned long drmAgpMemoryAvail ( int  fd)

Get available AGP memory.

Parameters:
fdfile descriptor.
Returns:
memory available on success, or zero on failure.

This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the necessary information in a drm_agp_info structure.

Definition at line 1856 of file xf86drm.c.

{
    drm_agp_info_t i;

    if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
       return 0;
    return i.memory_allowed;
}

Here is the call graph for this function:

unsigned long drmAgpMemoryUsed ( int  fd)

Get used AGP memory.

Parameters:
fdfile descriptor.
Returns:
memory used on success, or zero on failure.

This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the necessary information in a drm_agp_info structure.

Definition at line 1835 of file xf86drm.c.

{
    drm_agp_info_t i;

    if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
       return 0;
    return i.memory_used;
}

Here is the call graph for this function:

int drmAgpRelease ( int  fd)

Release the AGP device.

Parameters:
fdfile descriptor.
Returns:
zero on success, or a negative value on failure.

This function is a wrapper around the DRM_IOCTL_AGP_RELEASE ioctl.

Definition at line 1581 of file xf86drm.c.

{
    if (drmIoctl(fd, DRM_IOCTL_AGP_RELEASE, NULL))
       return -errno;
    return 0;
}

Here is the call graph for this function:

unsigned long drmAgpSize ( int  fd)

Get AGP aperture size.

Parameters:
fdfile descriptor.
Returns:
aperture size on success, zero on failure.

This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the necessary information in a drm_agp_info structure.

Definition at line 1814 of file xf86drm.c.

{
    drm_agp_info_t i;

    if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
       return 0;
    return i.aperture_size;
}

Here is the call graph for this function:

int drmAgpUnbind ( int  fd,
drm_handle_t  handle 
)

Unbind a chunk of AGP memory.

Parameters:
fdfile descriptor.
handlehandle to the allocated memory, as given by drmAgpAllocate().
Returns:
zero on success, or a negative value on failure.

This function is a wrapper around the DRM_IOCTL_AGP_UNBIND ioctl, passing the argument in a drm_agp_binding structure.

Definition at line 1707 of file xf86drm.c.

{
    drm_agp_binding_t b;

    b.handle = handle;
    b.offset = 0;
    if (drmIoctl(fd, DRM_IOCTL_AGP_UNBIND, &b))
       return -errno;
    return 0;
}

Here is the call graph for this function:

unsigned int drmAgpVendorId ( int  fd)

Get hardware vendor ID.

Parameters:
fdfile descriptor.
Returns:
vendor ID on success, or zero on failure.

This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the necessary information in a drm_agp_info structure.

Definition at line 1877 of file xf86drm.c.

{
    drm_agp_info_t i;

    if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
       return 0;
    return i.id_vendor;
}

Here is the call graph for this function:

int drmAgpVersionMajor ( int  fd)

Get AGP driver major version number.

Parameters:
fdfile descriptor.
Returns:
major version number on success, or a negative value on failure..

This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the necessary information in a drm_agp_info structure.

Definition at line 1730 of file xf86drm.c.

{
    drm_agp_info_t i;

    if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
       return -errno;
    return i.agp_version_major;
}

Here is the call graph for this function:

int drmAgpVersionMinor ( int  fd)

Get AGP driver minor version number.

Parameters:
fdfile descriptor.
Returns:
minor version number on success, or a negative value on failure.

This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the necessary information in a drm_agp_info structure.

Definition at line 1751 of file xf86drm.c.

{
    drm_agp_info_t i;

    if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
       return -errno;
    return i.agp_version_minor;
}

Here is the call graph for this function:

int drmAuthMagic ( int  fd,
drm_magic_t  magic 
)

Definition at line 906 of file xf86drm.c.

{
    drm_auth_t auth;

    auth.magic = magic;
    if (drmIoctl(fd, DRM_IOCTL_AUTH_MAGIC, &auth))
       return -errno;
    return 0;
}

Here is the call graph for this function:

int drmAvailable ( void  )

Determine whether the DRM kernel driver has been loaded.

Returns:
1 if the DRM driver is loaded, 0 otherwise.

Determine the presence of the kernel driver by attempting to open the 0 minor and get version information. For backward compatibility with older Linux implementations, /proc/dri is also checked.

Definition at line 437 of file xf86drm.c.

{
    drmVersionPtr version;
    int           retval = 0;
    int           fd;

    if ((fd = drmOpenMinor(0, 1, DRM_NODE_RENDER)) < 0) {
#ifdef __linux__
       /* Try proc for backward Linux compatibility */
       if (!access("/proc/dri/0", R_OK))
           return 1;
#endif
       return 0;
    }
    
    if ((version = drmGetVersion(fd))) {
       retval = 1;
       drmFreeVersion(version);
    }
    close(fd);

    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int drmClose ( int  fd)

Close the device.

Parameters:
fdfile descriptor.

This function closes the file descriptor.

Definition at line 1099 of file xf86drm.c.

{
    unsigned long key    = drmGetKeyFromFd(fd);
    drmHashEntry  *entry = drmGetEntry(fd);

    drmHashDestroy(entry->tagTable);
    entry->fd       = 0;
    entry->f        = NULL;
    entry->tagTable = NULL;

    drmHashDelete(drmHashTable, key);
    drmFree(entry);

    return close(fd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void drmCloseOnce ( int  fd)

Definition at line 2491 of file xf86drm.c.

{
    int i;

    for (i = 0; i < nr_fds; i++) {
       if (fd == connection[i].fd) {
           if (--connection[i].refcount == 0) {
              drmClose(connection[i].fd);
              free(connection[i].BusID);
           
              if (i < --nr_fds) 
                  connection[i] = connection[nr_fds];

              return;
           }
       }
    }
}

Here is the call graph for this function:

int drmCommandNone ( int  fd,
unsigned long  drmCommandIndex 
)

Send a device-specific command.

Parameters:
fdfile descriptor.
drmCommandIndexcommand index
Returns:
zero on success, or a negative value on failure.

It issues a ioctl given by

 DRM_COMMAND_BASE + drmCommandIndex 

.

Definition at line 2350 of file xf86drm.c.

{
    void *data = NULL; /* dummy */
    unsigned long request;

    request = DRM_IO( DRM_COMMAND_BASE + drmCommandIndex);

    if (drmIoctl(fd, request, data)) {
       return -errno;
    }
    return 0;
}

Here is the call graph for this function:

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

Send a device-specific read command.

Parameters:
fdfile descriptor.
drmCommandIndexcommand index
datadestination pointer of the data to be read.
sizesize of the data to be read.
Returns:
zero on success, or a negative value on failure.

It issues a read ioctl given by

 DRM_COMMAND_BASE + drmCommandIndex 

.

Definition at line 2378 of file xf86drm.c.

{
    unsigned long request;

    request = DRM_IOC( DRM_IOC_READ, DRM_IOCTL_BASE, 
       DRM_COMMAND_BASE + drmCommandIndex, size);

    if (drmIoctl(fd, request, data)) {
       return -errno;
    }
    return 0;
}

Here is the call graph for this function:

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

Send a device-specific write command.

Parameters:
fdfile descriptor.
drmCommandIndexcommand index
datasource pointer of the data to be written.
sizesize of the data to be written.
Returns:
zero on success, or a negative value on failure.

It issues a write ioctl given by

 DRM_COMMAND_BASE + drmCommandIndex 

.

Definition at line 2407 of file xf86drm.c.

{
    unsigned long request;

    request = DRM_IOC( DRM_IOC_WRITE, DRM_IOCTL_BASE, 
       DRM_COMMAND_BASE + drmCommandIndex, size);

    if (drmIoctl(fd, request, data)) {
       return -errno;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Send a device-specific read-write command.

Parameters:
fdfile descriptor.
drmCommandIndexcommand index
datasource pointer of the data to be read and written.
sizesize of the data to be read and written.
Returns:
zero on success, or a negative value on failure.

It issues a read-write ioctl given by

 DRM_COMMAND_BASE + drmCommandIndex 

.

Definition at line 2436 of file xf86drm.c.

{
    unsigned long request;

    request = DRM_IOC( DRM_IOC_READ|DRM_IOC_WRITE, DRM_IOCTL_BASE, 
       DRM_COMMAND_BASE + drmCommandIndex, size);

    if (drmIoctl(fd, request, data))
       return -errno;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void drmCopyVersion ( drmVersionPtr  d,
const drm_version_t *  s 
) [static]

Copy version information.

Parameters:
ddestination pointer.
ssource pointer.

Used by drmGetVersion() to translate the information returned by the ioctl interface in a private structure into the public structure counterpart.

Definition at line 708 of file xf86drm.c.

{
    d->version_major      = s->version_major;
    d->version_minor      = s->version_minor;
    d->version_patchlevel = s->version_patchlevel;
    d->name_len           = s->name_len;
    d->name               = strdup(s->name);
    d->date_len           = s->date_len;
    d->date               = strdup(s->date);
    d->desc_len           = s->desc_len;
    d->desc               = strdup(s->desc);
}

Here is the caller graph for this function:

int drmCreateContext ( int  fd,
drm_context_t handle 
)

Create context.

Used by the X server during GLXContext initialization. This causes per-context kernel-level resources to be allocated.

Parameters:
fdfile descriptor.
handleis set on success. To be used by the client when requesting DMA dispatch with drmDMA().
Returns:
zero on success, or a negative value on failure.
Note:
May only be called by root.

This function is a wrapper around the DRM_IOCTL_ADD_CTX ioctl, passing the argument in a drm_ctx structure.

Definition at line 1432 of file xf86drm.c.

{
    drm_ctx_t ctx;

    ctx.flags = 0;   /* Modified with functions below */
    if (drmIoctl(fd, DRM_IOCTL_ADD_CTX, &ctx))
       return -errno;
    *handle = ctx.handle;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int drmCreateDrawable ( int  fd,
drm_drawable_t handle 
)

Definition at line 1516 of file xf86drm.c.

{
    drm_draw_t draw;
    if (drmIoctl(fd, DRM_IOCTL_ADD_DRAW, &draw))
       return -errno;
    *handle = draw.handle;
    return 0;
}

Here is the call graph for this function:

int drmCtlInstHandler ( int  fd,
int  irq 
)

Install IRQ handler.

Parameters:
fdfile descriptor.
irqIRQ number.
Returns:
zero on success, or a negative value on failure.

This function is a wrapper around the DRM_IOCTL_CONTROL ioctl, passing the argument in a drm_control structure.

Definition at line 2011 of file xf86drm.c.

{
    drm_control_t ctl;

    ctl.func  = DRM_INST_HANDLER;
    ctl.irq   = irq;
    if (drmIoctl(fd, DRM_IOCTL_CONTROL, &ctl))
       return -errno;
    return 0;
}

Here is the call graph for this function:

int drmCtlUninstHandler ( int  fd)

Uninstall IRQ handler.

Parameters:
fdfile descriptor.
Returns:
zero on success, or a negative value on failure.

This function is a wrapper around the DRM_IOCTL_CONTROL ioctl, passing the argument in a drm_control structure.

Definition at line 2034 of file xf86drm.c.

{
    drm_control_t ctl;

    ctl.func  = DRM_UNINST_HANDLER;
    ctl.irq   = 0;
    if (drmIoctl(fd, DRM_IOCTL_CONTROL, &ctl))
       return -errno;
    return 0;
}

Here is the call graph for this function:

static int drmDebugPrint ( const char *  format,
va_list  ap 
) [static]

Output a message to stderr.

Parameters:
formatprintf() like format string.

This function is a wrapper around vfprintf().

Definition at line 107 of file xf86drm.c.

{
    return vfprintf(stderr, format, ap);
}
int drmDelContextTag ( int  fd,
drm_context_t  context 
)

Definition at line 2099 of file xf86drm.c.

{
    drmHashEntry  *entry = drmGetEntry(fd);

    return drmHashDelete(entry->tagTable, context);
}

Here is the call graph for this function:

int drmDestroyContext ( int  fd,
drm_context_t  handle 
)

Destroy context.

Free any kernel-level resources allocated with drmCreateContext() associated with the context.

Parameters:
fdfile descriptor.
handlehandle given by drmCreateContext().
Returns:
zero on success, or a negative value on failure.
Note:
May only be called by root.

This function is a wrapper around the DRM_IOCTL_RM_CTX ioctl, passing the argument in a drm_ctx structure.

Definition at line 1507 of file xf86drm.c.

{
    drm_ctx_t ctx;
    ctx.handle = handle;
    if (drmIoctl(fd, DRM_IOCTL_RM_CTX, &ctx))
       return -errno;
    return 0;
}

Here is the call graph for this function:

int drmDestroyDrawable ( int  fd,
drm_drawable_t  handle 
)

Definition at line 1525 of file xf86drm.c.

{
    drm_draw_t draw;
    draw.handle = handle;
    if (drmIoctl(fd, DRM_IOCTL_RM_DRAW, &draw))
       return -errno;
    return 0;
}

Here is the call graph for this function:

int drmDMA ( int  fd,
drmDMAReqPtr  request 
)

Reserve DMA buffers.

Parameters:
fdfile descriptor.
request
Returns:
zero on success, or a negative value on failure.

Assemble the arguments into a drm_dma structure and keeps issuing the DRM_IOCTL_DMA ioctl until success or until maximum number of retries.

Definition at line 1293 of file xf86drm.c.

{
    drm_dma_t dma;
    int ret, i = 0;

    dma.context         = request->context;
    dma.send_count      = request->send_count;
    dma.send_indices    = request->send_list;
    dma.send_sizes      = request->send_sizes;
    dma.flags           = request->flags;
    dma.request_count   = request->request_count;
    dma.request_size    = request->request_size;
    dma.request_indices = request->request_list;
    dma.request_sizes   = request->request_sizes;
    dma.granted_count   = 0;

    do {
       ret = ioctl( fd, DRM_IOCTL_DMA, &dma );
    } while ( ret && errno == EAGAIN && i++ < DRM_DMA_RETRY );

    if ( ret == 0 ) {
       request->granted_count = dma.granted_count;
       return 0;
    } else {
       return -errno;
    }
}

Here is the caller graph for this function:

int drmDropMaster ( int  fd)

Definition at line 2515 of file xf86drm.c.

{
       return ioctl(fd, DRM_IOCTL_DROP_MASTER, 0);
}
int drmError ( int  err,
const char *  label 
)

Definition at line 1974 of file xf86drm.c.

{
    switch (err) {
    case DRM_ERR_NO_DEVICE:
       fprintf(stderr, "%s: no device\n", label);
       break;
    case DRM_ERR_NO_ACCESS:
       fprintf(stderr, "%s: no access\n", label);
       break;
    case DRM_ERR_NOT_ROOT:
       fprintf(stderr, "%s: not root\n", label);
       break;
    case DRM_ERR_INVALID:
       fprintf(stderr, "%s: invalid args\n", label);
       break;
    default:
       if (err < 0)
           err = -err;
       fprintf( stderr, "%s: error %d (%s)\n", label, err, strerror(err) );
       break;
    }

    return 1;
}

Here is the caller graph for this function:

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

Definition at line 2045 of file xf86drm.c.

{
    drm_lock_t lock;

    lock.context = context;
    lock.flags   = 0;
    if (flags & DRM_LOCK_READY)      lock.flags |= _DRM_LOCK_READY;
    if (flags & DRM_LOCK_QUIESCENT)  lock.flags |= _DRM_LOCK_QUIESCENT;
    if (flags & DRM_LOCK_FLUSH)      lock.flags |= _DRM_LOCK_FLUSH;
    if (flags & DRM_LOCK_FLUSH_ALL)  lock.flags |= _DRM_LOCK_FLUSH_ALL;
    if (flags & DRM_HALT_ALL_QUEUES) lock.flags |= _DRM_HALT_ALL_QUEUES;
    if (flags & DRM_HALT_CUR_QUEUES) lock.flags |= _DRM_HALT_CUR_QUEUES;
    if (drmIoctl(fd, DRM_IOCTL_FINISH, &lock))
       return -errno;
    return 0;
}

Here is the call graph for this function:

void drmFree ( void *  pt)

Definition at line 152 of file xf86drm.c.

{
    if (pt)
       free(pt);
}

Here is the caller graph for this function:

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

Free buffers.

Parameters:
fdfile descriptor.
countnumber of buffers to free.
listlist of buffers to be freed.
Returns:
zero on success, or a negative value on failure.
Note:
This function is primarily used for debugging.

This function is a wrapper around the DRM_IOCTL_FREE_BUFS ioctl, passing the arguments in a drm_buf_free structure.

Definition at line 1079 of file xf86drm.c.

{
    drm_buf_free_t request;

    request.count = count;
    request.list  = list;
    if (drmIoctl(fd, DRM_IOCTL_FREE_BUFS, &request))
       return -errno;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void drmFreeBusid ( const char *  busid)

Free the bus ID information.

Parameters:
busidbus ID information string as given by drmGetBusid().

This function is just frees the memory pointed by busid.

Definition at line 834 of file xf86drm.c.

{
    drmFree((void *)busid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void drmFreeKernelVersion ( drm_version_t *  v) [static]

Free the non-public version information returned by the kernel.

Parameters:
vpointer to the version information.

Used by drmGetVersion() to free the memory pointed by v as well as all the non-null strings pointers in it.

Definition at line 687 of file xf86drm.c.

{
    if (!v)
       return;
    drmFree(v->name);
    drmFree(v->date);
    drmFree(v->desc);
    drmFree(v);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1409 of file xf86drm.c.

{
    drmFree(pt);
}

Here is the call graph for this function:

Free the version information returned by drmGetVersion().

Parameters:
vpointer to the version information.

It frees the memory pointed by v as well as all the non-null strings pointers in it.

Definition at line 667 of file xf86drm.c.

{
    if (!v)
       return;
    drmFree(v->name);
    drmFree(v->date);
    drmFree(v->desc);
    drmFree(v);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1165 of file xf86drm.c.

{
    drm_buf_info_t info;
    drmBufInfoPtr  retval;
    int            i;

    info.count = 0;
    info.list  = NULL;

    if (drmIoctl(fd, DRM_IOCTL_INFO_BUFS, &info))
       return NULL;

    if (info.count) {
       if (!(info.list = drmMalloc(info.count * sizeof(*info.list))))
           return NULL;

       if (drmIoctl(fd, DRM_IOCTL_INFO_BUFS, &info)) {
           drmFree(info.list);
           return NULL;
       }

       retval = drmMalloc(sizeof(*retval));
       retval->count = info.count;
       retval->list  = drmMalloc(info.count * sizeof(*retval->list));
       for (i = 0; i < info.count; i++) {
           retval->list[i].count     = info.list[i].count;
           retval->list[i].size      = info.list[i].size;
           retval->list[i].low_mark  = info.list[i].low_mark;
           retval->list[i].high_mark = info.list[i].high_mark;
       }
       drmFree(info.list);
       return retval;
    }
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* drmGetBusid ( int  fd)

Get the bus ID of the device.

Parameters:
fdfile descriptor.
Returns:
bus ID string.

This function gets the bus ID via successive DRM_IOCTL_GET_UNIQUE ioctls to get the string length and data, passing the arguments in a drm_unique structure.

Definition at line 852 of file xf86drm.c.

{
    drm_unique_t u;

    u.unique_len = 0;
    u.unique     = NULL;

    if (drmIoctl(fd, DRM_IOCTL_GET_UNIQUE, &u))
       return NULL;
    u.unique = drmMalloc(u.unique_len + 1);
    if (drmIoctl(fd, DRM_IOCTL_GET_UNIQUE, &u))
       return NULL;
    u.unique[u.unique_len] = '\0';

    return u.unique;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 813 of file xf86drm.c.

{
       struct drm_get_cap cap = { capability, 0 };
       int ret;

       ret = drmIoctl(fd, DRM_IOCTL_GET_CAP, &cap);
       if (ret)
              return ret;

       *value = cap.value;
       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 2163 of file xf86drm.c.

{
    drm_client_t client;

    client.idx = idx;
    if (drmIoctl(fd, DRM_IOCTL_GET_CLIENT, &client))
       return -errno;
    *auth      = client.auth;
    *pid       = client.pid;
    *uid       = client.uid;
    *magic     = client.magic;
    *iocs      = client.iocs;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1474 of file xf86drm.c.

{
    drm_ctx_t ctx;

    ctx.handle = context;
    if (drmIoctl(fd, DRM_IOCTL_GET_CTX, &ctx))
       return -errno;
    *flags = 0;
    if (ctx.flags & _DRM_CONTEXT_PRESERVED)
       *flags |= DRM_CONTEXT_PRESERVED;
    if (ctx.flags & _DRM_CONTEXT_2DONLY)
       *flags |= DRM_CONTEXT_2DONLY;
    return 0;
}

Here is the call graph for this function:

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

Definition at line 2130 of file xf86drm.c.

{
    drm_ctx_priv_map_t map;

    map.ctx_id = ctx_id;

    if (drmIoctl(fd, DRM_IOCTL_GET_SAREA_CTX, &map))
       return -errno;
    if (handle)
       *handle = (drm_handle_t)(uintptr_t)map.handle;

    return 0;
}

Here is the call graph for this function:

void* drmGetContextTag ( int  fd,
drm_context_t  context 
)

Definition at line 2106 of file xf86drm.c.

{
    drmHashEntry  *entry = drmGetEntry(fd);
    void          *value;

    if (drmHashLookup(entry->tagTable, context, &value))
       return NULL;

    return value;
}

Here is the call graph for this function:

char* drmGetDeviceNameFromFd ( int  fd)

Definition at line 2520 of file xf86drm.c.

{
       char name[128];
       struct stat sbuf;
       dev_t d;
       int i;

       /* The whole drmOpen thing is a fiasco and we need to find a way
        * back to just using open(2).  For now, however, lets just make
        * things worse with even more ad hoc directory walking code to
        * discover the device file name. */

       fstat(fd, &sbuf);
       d = sbuf.st_rdev;

       for (i = 0; i < DRM_MAX_MINOR; i++) {
              snprintf(name, sizeof name, DRM_DEV_NAME, DRM_DIR_NAME, i);
              if (stat(name, &sbuf) == 0 && sbuf.st_rdev == d)
                     break;
       }
       if (i == DRM_MAX_MINOR)
              return NULL;

       return strdup(name);
}

Here is the caller graph for this function:

drmHashEntry* drmGetEntry ( int  fd)

Definition at line 181 of file xf86drm.c.

{
    unsigned long key = drmGetKeyFromFd(fd);
    void          *value;
    drmHashEntry  *entry;

    if (!drmHashTable)
       drmHashTable = drmHashCreate();

    if (drmHashLookup(drmHashTable, key, &value)) {
       entry           = drmMalloc(sizeof(*entry));
       entry->fd       = fd;
       entry->f        = NULL;
       entry->tagTable = drmHashCreate();
       drmHashInsert(drmHashTable, key, entry);
    } else {
       entry = value;
    }
    return entry;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void* drmGetHashTable ( void  )

Definition at line 139 of file xf86drm.c.

{
    return drmHashTable;
}
int drmGetInterruptFromBusID ( int  fd,
int  busnum,
int  devnum,
int  funcnum 
)

Get IRQ from bus ID.

Parameters:
fdfile descriptor.
busnumbus number.
devnumdevice number.
funcnumfunction number.
Returns:
IRQ number on success, or a negative value on failure.

This function is a wrapper around the DRM_IOCTL_IRQ_BUSID ioctl, passing the arguments in a drm_irq_busid structure.

Definition at line 2076 of file xf86drm.c.

{
    drm_irq_busid_t p;

    p.busnum  = busnum;
    p.devnum  = devnum;
    p.funcnum = funcnum;
    if (drmIoctl(fd, DRM_IOCTL_IRQ_BUSID, &p))
       return -errno;
    return p.irq;
}

Here is the call graph for this function:

static unsigned long drmGetKeyFromFd ( int  fd) [static]

Definition at line 172 of file xf86drm.c.

{
    stat_t     st;

    st.st_rdev = 0;
    fstat(fd, &st);
    return st.st_rdev;
}

Here is the caller graph for this function:

Get version information for the DRM user space library.

This version number is driver independent.

Parameters:
fdfile descriptor.
Returns:
version information.

This function allocates and fills a drm_version structure with a hard coded version number.

Definition at line 792 of file xf86drm.c.

{
    drm_version_t *version = drmMalloc(sizeof(*version));

    /* Version history:
     *   NOTE THIS MUST NOT GO ABOVE VERSION 1.X due to drivers needing it
     *   revision 1.0.x = original DRM interface with no drmGetLibVersion
     *                    entry point and many drm<Device> extensions
     *   revision 1.1.x = added drmCommand entry points for device extensions
     *                    added drmGetLibVersion to identify libdrm.a version
     *   revision 1.2.x = added drmSetInterfaceVersion
     *                    modified drmOpen to handle both busid and name
     *   revision 1.3.x = added server + memory manager
     */
    version->version_major      = 1;
    version->version_minor      = 3;
    version->version_patchlevel = 0;

    return (drmVersionPtr)version;
}

Here is the call graph for this function:

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

Obtain heavyweight hardware lock.

Parameters:
fdfile descriptor.
contextcontext.
flagsflags that determine the sate of the hardware when the function returns.
Returns:
always zero.

This function translates the arguments into a drm_lock structure and issue the DRM_IOCTL_LOCK ioctl until the lock is successfully acquired.

Definition at line 1336 of file xf86drm.c.

{
    drm_lock_t lock;

    lock.context = context;
    lock.flags   = 0;
    if (flags & DRM_LOCK_READY)      lock.flags |= _DRM_LOCK_READY;
    if (flags & DRM_LOCK_QUIESCENT)  lock.flags |= _DRM_LOCK_QUIESCENT;
    if (flags & DRM_LOCK_FLUSH)      lock.flags |= _DRM_LOCK_FLUSH;
    if (flags & DRM_LOCK_FLUSH_ALL)  lock.flags |= _DRM_LOCK_FLUSH_ALL;
    if (flags & DRM_HALT_ALL_QUEUES) lock.flags |= _DRM_HALT_ALL_QUEUES;
    if (flags & DRM_HALT_CUR_QUEUES) lock.flags |= _DRM_HALT_CUR_QUEUES;

    while (drmIoctl(fd, DRM_IOCTL_LOCK, &lock))
       ;
    return 0;
}

Here is the call graph for this function:

int drmGetMagic ( int  fd,
drm_magic_t magic 
)

Definition at line 895 of file xf86drm.c.

{
    drm_auth_t auth;

    *magic = 0;
    if (drmIoctl(fd, DRM_IOCTL_GET_MAGIC, &auth))
       return -errno;
    *magic = auth.magic;
    return 0;
}

Here is the call graph for this function:

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

Definition at line 2145 of file xf86drm.c.

{
    drm_map_t map;

    map.offset = idx;
    if (drmIoctl(fd, DRM_IOCTL_GET_MAP, &map))
       return -errno;
    *offset = map.offset;
    *size   = map.size;
    *type   = map.type;
    *flags  = map.flags;
    *handle = (unsigned long)map.handle;
    *mtrr   = map.mtrr;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

drm_context_t* drmGetReservedContextList ( int  fd,
int *  count 
)

Definition at line 1375 of file xf86drm.c.

{
    drm_ctx_res_t res;
    drm_ctx_t     *list;
    drm_context_t * retval;
    int           i;

    res.count    = 0;
    res.contexts = NULL;
    if (drmIoctl(fd, DRM_IOCTL_RES_CTX, &res))
       return NULL;

    if (!res.count)
       return NULL;

    if (!(list   = drmMalloc(res.count * sizeof(*list))))
       return NULL;
    if (!(retval = drmMalloc(res.count * sizeof(*retval)))) {
       drmFree(list);
       return NULL;
    }

    res.contexts = list;
    if (drmIoctl(fd, DRM_IOCTL_RES_CTX, &res))
       return NULL;

    for (i = 0; i < res.count; i++)
       retval[i] = list[i].handle;
    drmFree(list);

    *count = res.count;
    return retval;
}

Here is the call graph for this function:

int drmGetStats ( int  fd,
drmStatsT stats 
)

Definition at line 2179 of file xf86drm.c.

{
    drm_stats_t s;
    int         i;

    if (drmIoctl(fd, DRM_IOCTL_GET_STATS, &s))
       return -errno;

    stats->count = 0;
    memset(stats, 0, sizeof(*stats));
    if (s.count > sizeof(stats->data)/sizeof(stats->data[0]))
       return -1;

#define SET_VALUE                              \
    stats->data[i].long_format = "%-20.20s";   \
    stats->data[i].rate_format = "%8.8s";      \
    stats->data[i].isvalue     = 1;            \
    stats->data[i].verbose     = 0

#define SET_COUNT                              \
    stats->data[i].long_format = "%-20.20s";   \
    stats->data[i].rate_format = "%5.5s";      \
    stats->data[i].isvalue     = 0;            \
    stats->data[i].mult_names  = "kgm";        \
    stats->data[i].mult        = 1000;         \
    stats->data[i].verbose     = 0

#define SET_BYTE                               \
    stats->data[i].long_format = "%-20.20s";   \
    stats->data[i].rate_format = "%5.5s";      \
    stats->data[i].isvalue     = 0;            \
    stats->data[i].mult_names  = "KGM";        \
    stats->data[i].mult        = 1024;         \
    stats->data[i].verbose     = 0


    stats->count = s.count;
    for (i = 0; i < s.count; i++) {
       stats->data[i].value = s.data[i].value;
       switch (s.data[i].type) {
       case _DRM_STAT_LOCK:
           stats->data[i].long_name = "Lock";
           stats->data[i].rate_name = "Lock";
           SET_VALUE;
           break;
       case _DRM_STAT_OPENS:
           stats->data[i].long_name = "Opens";
           stats->data[i].rate_name = "O";
           SET_COUNT;
           stats->data[i].verbose   = 1;
           break;
       case _DRM_STAT_CLOSES:
           stats->data[i].long_name = "Closes";
           stats->data[i].rate_name = "Lock";
           SET_COUNT;
           stats->data[i].verbose   = 1;
           break;
       case _DRM_STAT_IOCTLS:
           stats->data[i].long_name = "Ioctls";
           stats->data[i].rate_name = "Ioc/s";
           SET_COUNT;
           break;
       case _DRM_STAT_LOCKS:
           stats->data[i].long_name = "Locks";
           stats->data[i].rate_name = "Lck/s";
           SET_COUNT;
           break;
       case _DRM_STAT_UNLOCKS:
           stats->data[i].long_name = "Unlocks";
           stats->data[i].rate_name = "Unl/s";
           SET_COUNT;
           break;
       case _DRM_STAT_IRQ:
           stats->data[i].long_name = "IRQs";
           stats->data[i].rate_name = "IRQ/s";
           SET_COUNT;
           break;
       case _DRM_STAT_PRIMARY:
           stats->data[i].long_name = "Primary Bytes";
           stats->data[i].rate_name = "PB/s";
           SET_BYTE;
           break;
       case _DRM_STAT_SECONDARY:
           stats->data[i].long_name = "Secondary Bytes";
           stats->data[i].rate_name = "SB/s";
           SET_BYTE;
           break;
       case _DRM_STAT_DMA:
           stats->data[i].long_name = "DMA";
           stats->data[i].rate_name = "DMA/s";
           SET_COUNT;
           break;
       case _DRM_STAT_SPECIAL:
           stats->data[i].long_name = "Special DMA";
           stats->data[i].rate_name = "dma/s";
           SET_COUNT;
           break;
       case _DRM_STAT_MISSED:
           stats->data[i].long_name = "Miss";
           stats->data[i].rate_name = "Ms/s";
           SET_COUNT;
           break;
       case _DRM_STAT_VALUE:
           stats->data[i].long_name = "Value";
           stats->data[i].rate_name = "Value";
           SET_VALUE;
           break;
       case _DRM_STAT_BYTE:
           stats->data[i].long_name = "Bytes";
           stats->data[i].rate_name = "B/s";
           SET_BYTE;
           break;
       case _DRM_STAT_COUNT:
       default:
           stats->data[i].long_name = "Count";
           stats->data[i].rate_name = "Cnt/s";
           SET_COUNT;
           break;
       }
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Query the driver version information.

Parameters:
fdfile descriptor.
Returns:
pointer to a drmVersion structure which should be freed with drmFreeVersion().
Note:
Similar information is available via /proc/dri.

It gets the version information via successive DRM_IOCTL_VERSION ioctls, first with zeros to get the string lengths, and then the actually strings. It also null-terminates them since they might not be already.

Definition at line 737 of file xf86drm.c.

{
    drmVersionPtr retval;
    drm_version_t *version = drmMalloc(sizeof(*version));

    version->name_len    = 0;
    version->name        = NULL;
    version->date_len    = 0;
    version->date        = NULL;
    version->desc_len    = 0;
    version->desc        = NULL;

    if (drmIoctl(fd, DRM_IOCTL_VERSION, version)) {
       drmFreeKernelVersion(version);
       return NULL;
    }

    if (version->name_len)
       version->name    = drmMalloc(version->name_len + 1);
    if (version->date_len)
       version->date    = drmMalloc(version->date_len + 1);
    if (version->desc_len)
       version->desc    = drmMalloc(version->desc_len + 1);

    if (drmIoctl(fd, DRM_IOCTL_VERSION, version)) {
       drmMsg("DRM_IOCTL_VERSION: %s\n", strerror(errno));
       drmFreeKernelVersion(version);
       return NULL;
    }

    /* The results might not be null-terminated strings, so terminate them. */
    if (version->name_len) version->name[version->name_len] = '\0';
    if (version->date_len) version->date[version->date_len] = '\0';
    if (version->desc_len) version->desc[version->desc_len] = '\0';

    retval = drmMalloc(sizeof(*retval));
    drmCopyVersion(retval, version);
    drmFreeKernelVersion(version);
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Call ioctl, restarting if it is interupted.

Definition at line 162 of file xf86drm.c.

{
    int       ret;

    do {
       ret = ioctl(fd, request, arg);
    } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
    return ret;
}
void* drmMalloc ( int  size)

Definition at line 144 of file xf86drm.c.

{
    void *pt;
    if ((pt = malloc(size)))
       memset(pt, 0, size);
    return pt;
}

Here is the caller graph for this function:

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

Map a region of memory.

Parameters:
fdfile descriptor.
handlehandle returned by drmAddMap().
sizesize in bytes. Must match the size used by drmAddMap().
addresswill contain the user-space virtual address where the mapping begins.
Returns:
zero on success, or a negative value on failure.

This function is a wrapper for mmap().

Definition at line 1130 of file xf86drm.c.

{
    static unsigned long pagesize_mask = 0;

    if (fd < 0)
       return -EINVAL;

    if (!pagesize_mask)
       pagesize_mask = getpagesize() - 1;

    size = (size + pagesize_mask) & ~pagesize_mask;

    *address = mmap(0, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, handle);
    if (*address == MAP_FAILED)
       return -errno;
    return 0;
}

Here is the caller graph for this function:

drmBufMapPtr drmMapBufs ( int  fd)

Map all DMA buffers into client-virtual space.

Parameters:
fdfile descriptor.
Returns:
a pointer to a drmBufMap structure.
Note:
The client may not use these buffers until obtaining buffer indices with drmDMA().

This function calls the DRM_IOCTL_MAP_BUFS ioctl and copies the returned information about the buffers in a drm_buf_map structure into the client-visible data structures.

Definition at line 1216 of file xf86drm.c.

{
    drm_buf_map_t bufs;
    drmBufMapPtr  retval;
    int           i;

    bufs.count = 0;
    bufs.list  = NULL;
    bufs.virtual = NULL;
    if (drmIoctl(fd, DRM_IOCTL_MAP_BUFS, &bufs))
       return NULL;

    if (!bufs.count)
       return NULL;

       if (!(bufs.list = drmMalloc(bufs.count * sizeof(*bufs.list))))
           return NULL;

       if (drmIoctl(fd, DRM_IOCTL_MAP_BUFS, &bufs)) {
           drmFree(bufs.list);
           return NULL;
       }

       retval = drmMalloc(sizeof(*retval));
       retval->count = bufs.count;
       retval->list  = drmMalloc(bufs.count * sizeof(*retval->list));
       for (i = 0; i < bufs.count; i++) {
           retval->list[i].idx     = bufs.list[i].idx;
           retval->list[i].total   = bufs.list[i].total;
           retval->list[i].used    = 0;
           retval->list[i].address = bufs.list[i].address;
       }

       drmFree(bufs.list);
       
       return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1027 of file xf86drm.c.

{
    drm_buf_info_t info;
    int            i;

    info.count = 0;
    info.list  = NULL;

    if (drmIoctl(fd, DRM_IOCTL_INFO_BUFS, &info))
       return -EINVAL;

    if (!info.count)
       return -EINVAL;

    if (!(info.list = drmMalloc(info.count * sizeof(*info.list))))
       return -ENOMEM;

    if (drmIoctl(fd, DRM_IOCTL_INFO_BUFS, &info)) {
       int retval = -errno;
       drmFree(info.list);
       return retval;
    }

    for (i = 0; i < info.count; i++) {
       info.list[i].low_mark  = low  * info.list[i].count;
       info.list[i].high_mark = high * info.list[i].count;
       if (drmIoctl(fd, DRM_IOCTL_MARK_BUFS, &info.list[i])) {
           int retval = -errno;
           drmFree(info.list);
           return retval;
       }
    }
    drmFree(info.list);

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int drmMatchBusID ( const char *  id1,
const char *  id2,
int  pci_domain_ok 
) [static]

Compare two busid strings.

Parameters:
first
second
Returns:
1 if matched.

This function compares two bus ID strings. It understands the older PCI:b:d:f format and the newer pci:oooo:bb:dd.f format. In the format, o is domain, b is bus, d is device, f is function.

Definition at line 215 of file xf86drm.c.

{
    /* First, check if the IDs are exactly the same */
    if (strcasecmp(id1, id2) == 0)
       return 1;

    /* Try to match old/new-style PCI bus IDs. */
    if (strncasecmp(id1, "pci", 3) == 0) {
       unsigned int o1, b1, d1, f1;
       unsigned int o2, b2, d2, f2;
       int ret;

       ret = sscanf(id1, "pci:%04x:%02x:%02x.%u", &o1, &b1, &d1, &f1);
       if (ret != 4) {
           o1 = 0;
           ret = sscanf(id1, "PCI:%u:%u:%u", &b1, &d1, &f1);
           if (ret != 3)
              return 0;
       }

       ret = sscanf(id2, "pci:%04x:%02x:%02x.%u", &o2, &b2, &d2, &f2);
       if (ret != 4) {
           o2 = 0;
           ret = sscanf(id2, "PCI:%u:%u:%u", &b2, &d2, &f2);
           if (ret != 3)
              return 0;
       }

       /* If domains aren't properly supported by the kernel interface,
        * just ignore them, which sucks less than picking a totally random
        * card with "open by name"
        */
       if (!pci_domain_ok)
              o1 = o2 = 0;

       if ((o1 != o2) || (b1 != b2) || (d1 != d2) || (f1 != f2))
           return 0;
       else
           return 1;
    }
    return 0;
}

Here is the caller graph for this function:

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

Definition at line 115 of file xf86drm.c.

{
    va_list   ap;
    const char *env;
    if (((env = getenv("LIBGL_DEBUG")) && strstr(env, "verbose")) || drm_server_info)
    {
       va_start(ap, format);
       if (drm_server_info) {
         drm_server_info->debug_print(format,ap);
       } else {
         drm_debug_print(format, ap);
       }
       va_end(ap);
    }
}

Here is the caller graph for this function:

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

Open the DRM device.

Looks up the specified name and bus ID, and opens the device found. The entry in /dev/dri is created if necessary and if called by root.

Parameters:
namedriver name. Not referenced if bus ID is supplied.
busidbus ID. Zero if not known.
Returns:
a file descriptor on success, or a negative value on error.

It calls drmOpenByBusid() if busid is specified or drmOpenByName() otherwise.

Definition at line 631 of file xf86drm.c.

{
    if (!drmAvailable() && name != NULL && drm_server_info) {
       /* try to load the kernel */
       if (!drm_server_info->load_module(name)) {
           drmMsg("[drm] failed to load kernel module \"%s\"\n", name);
           return -1;
       }
    }

    if (busid) {
       int fd = drmOpenByBusid(busid);
       if (fd >= 0)
           return fd;
    }
    
    if (name)
       return drmOpenByName(name);

    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int drmOpenByBusid ( const char *  busid) [static]

Open the device by bus ID.

Parameters:
busidbus ID.
Returns:
a file descriptor on success, or a negative value on error.

This function attempts to open every possible minor (up to DRM_MAX_MINOR), comparing the device bus ID with the one supplied.

See also:
drmOpenMinor() and drmGetBusid().

Definition at line 475 of file xf86drm.c.

{
    int        i, pci_domain_ok = 1;
    int        fd;
    const char *buf;
    drmSetVersion sv;

    drmMsg("drmOpenByBusid: Searching for BusID %s\n", busid);
    for (i = 0; i < DRM_MAX_MINOR; i++) {
       fd = drmOpenMinor(i, 1, DRM_NODE_RENDER);
       drmMsg("drmOpenByBusid: drmOpenMinor returns %d\n", fd);
       if (fd >= 0) {
           /* We need to try for 1.4 first for proper PCI domain support
            * and if that fails, we know the kernel is busted
            */
           sv.drm_di_major = 1;
           sv.drm_di_minor = 4;
           sv.drm_dd_major = -1;   /* Don't care */
           sv.drm_dd_minor = -1;   /* Don't care */
           if (drmSetInterfaceVersion(fd, &sv)) {
#ifndef __alpha__
              pci_domain_ok = 0;
#endif
              sv.drm_di_major = 1;
              sv.drm_di_minor = 1;
              sv.drm_dd_major = -1;       /* Don't care */
              sv.drm_dd_minor = -1;       /* Don't care */
              drmMsg("drmOpenByBusid: Interface 1.4 failed, trying 1.1\n",fd);
              drmSetInterfaceVersion(fd, &sv);
           }
           buf = drmGetBusid(fd);
           drmMsg("drmOpenByBusid: drmGetBusid reports %s\n", buf);
           if (buf && drmMatchBusID(buf, busid, pci_domain_ok)) {
              drmFreeBusid(buf);
              return fd;
           }
           if (buf)
              drmFreeBusid(buf);
           close(fd);
       }
    }
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int drmOpenByName ( const char *  name) [static]

Open the device by name.

Parameters:
namedriver name.
Returns:
a file descriptor on success, or a negative value on error.

This function opens the first minor number that matches the driver name and isn't already in use. If it's in use it then it will already have a bus ID assigned.

See also:
drmOpenMinor(), drmGetVersion() and drmGetBusid().

Definition at line 534 of file xf86drm.c.

{
    int           i;
    int           fd;
    drmVersionPtr version;
    char *        id;
    
    if (!drmAvailable()) {
       if (!drm_server_info) {
           return -1;
       }
       else {
           /* try to load the kernel module now */
           if (!drm_server_info->load_module(name)) {
              drmMsg("[drm] failed to load kernel module \"%s\"\n", name);
              return -1;
           }
       }
    }

    /*
     * Open the first minor number that matches the driver name and isn't
     * already in use.  If it's in use it will have a busid assigned already.
     */
    for (i = 0; i < DRM_MAX_MINOR; i++) {
       if ((fd = drmOpenMinor(i, 1, DRM_NODE_RENDER)) >= 0) {
           if ((version = drmGetVersion(fd))) {
              if (!strcmp(version->name, name)) {
                  drmFreeVersion(version);
                  id = drmGetBusid(fd);
                  drmMsg("drmGetBusid returned '%s'\n", id ? id : "NULL");
                  if (!id || !*id) {
                     if (id)
                         drmFreeBusid(id);
                     return fd;
                  } else {
                     drmFreeBusid(id);
                  }
              } else {
                  drmFreeVersion(version);
              }
           }
           close(fd);
       }
    }

#ifdef __linux__
    /* Backward-compatibility /proc support */
    for (i = 0; i < 8; i++) {
       char proc_name[64], buf[512];
       char *driver, *pt, *devstring;
       int  retcode;
       
       sprintf(proc_name, "/proc/dri/%d/name", i);
       if ((fd = open(proc_name, 0, 0)) >= 0) {
           retcode = read(fd, buf, sizeof(buf)-1);
           close(fd);
           if (retcode) {
              buf[retcode-1] = '\0';
              for (driver = pt = buf; *pt && *pt != ' '; ++pt)
                  ;
              if (*pt) { /* Device is next */
                  *pt = '\0';
                  if (!strcmp(driver, name)) { /* Match */
                     for (devstring = ++pt; *pt && *pt != ' '; ++pt)
                         ;
                     if (*pt) { /* Found busid */
                         return drmOpenByBusid(++pt);
                     } else { /* No busid */
                         return drmOpenDevice(strtol(devstring, NULL, 0),i, DRM_NODE_RENDER);
                     }
                  }
              }
           }
       }
    }
#endif

    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int drmOpenControl ( int  minor)

Definition at line 653 of file xf86drm.c.

{
    return drmOpenMinor(minor, 0, DRM_NODE_CONTROL);
}

Here is the call graph for this function:

static int drmOpenDevice ( long  dev,
int  minor,
int  type 
) [static]

Open the DRM device, creating it if necessary.

Parameters:
devmajor and minor numbers of the device.
minorminor number of the device.
Returns:
a file descriptor on success, or a negative value on error.

Assembles the device name from minor and opens it, creating the device special file node with the major and minor numbers specified by dev and parent directory if necessary and was called by root.

Definition at line 301 of file xf86drm.c.

{
    stat_t          st;
    char            buf[64];
    int             fd;
    mode_t          devmode = DRM_DEV_MODE, serv_mode;
    int             isroot  = !geteuid();
    uid_t           user    = DRM_DEV_UID;
    gid_t           group   = DRM_DEV_GID, serv_group;
    
    sprintf(buf, type ? DRM_DEV_NAME : DRM_CONTROL_DEV_NAME, DRM_DIR_NAME, minor);
    drmMsg("drmOpenDevice: node name is %s\n", buf);

    if (drm_server_info) {
       drm_server_info->get_perms(&serv_group, &serv_mode);
       devmode  = serv_mode ? serv_mode : DRM_DEV_MODE;
       devmode &= ~(S_IXUSR|S_IXGRP|S_IXOTH);
       group = (serv_group >= 0) ? serv_group : DRM_DEV_GID;
    }

#if !defined(UDEV)
    if (stat(DRM_DIR_NAME, &st)) {
       if (!isroot)
           return DRM_ERR_NOT_ROOT;
       mkdir(DRM_DIR_NAME, DRM_DEV_DIRMODE);
       chown_check_return(DRM_DIR_NAME, 0, 0); /* root:root */
       chmod(DRM_DIR_NAME, DRM_DEV_DIRMODE);
    }

    /* Check if the device node exists and create it if necessary. */
    if (stat(buf, &st)) {
       if (!isroot)
           return DRM_ERR_NOT_ROOT;
       remove(buf);
       mknod(buf, S_IFCHR | devmode, dev);
    }

    if (drm_server_info) {
       chown_check_return(buf, user, group);
       chmod(buf, devmode);
    }
#else
    /* if we modprobed then wait for udev */
    {
       int udev_count = 0;
wait_for_udev:
        if (stat(DRM_DIR_NAME, &st)) {
              usleep(20);
              udev_count++;

              if (udev_count == 50)
                     return -1;
              goto wait_for_udev;
       }

       if (stat(buf, &st)) {
              usleep(20);
              udev_count++;

              if (udev_count == 50)
                     return -1;
              goto wait_for_udev;
       }
    }
#endif

    fd = open(buf, O_RDWR, 0);
    drmMsg("drmOpenDevice: open result is %d, (%s)\n",
              fd, fd < 0 ? strerror(errno) : "OK");
    if (fd >= 0)
       return fd;

#if !defined(UDEV)
    /* Check if the device node is not what we expect it to be, and recreate it
     * and try again if so.
     */
    if (st.st_rdev != dev) {
       if (!isroot)
           return DRM_ERR_NOT_ROOT;
       remove(buf);
       mknod(buf, S_IFCHR | devmode, dev);
       if (drm_server_info) {
           chown_check_return(buf, user, group);
           chmod(buf, devmode);
       }
    }
    fd = open(buf, O_RDWR, 0);
    drmMsg("drmOpenDevice: open result is %d, (%s)\n",
              fd, fd < 0 ? strerror(errno) : "OK");
    if (fd >= 0)
       return fd;

    drmMsg("drmOpenDevice: Open failed\n");
    remove(buf);
#endif
    return -errno;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int drmOpenMinor ( int  minor,
int  create,
int  type 
) [static]

Open the DRM device.

Parameters:
minordevice minor number.
createallow to create the device if set.
Returns:
a file descriptor on success, or a negative value on error.

Calls drmOpenDevice() if create is set, otherwise assembles the device name from minor and opens it.

Definition at line 412 of file xf86drm.c.

{
    int  fd;
    char buf[64];
    
    if (create)
       return drmOpenDevice(makedev(DRM_MAJOR, minor), minor, type);
    
    sprintf(buf, type ? DRM_DEV_NAME : DRM_CONTROL_DEV_NAME, DRM_DIR_NAME, minor);
    if ((fd = open(buf, O_RDWR, 0)) >= 0)
       return fd;
    return -errno;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 2458 of file xf86drm.c.

{
    int i;
    int fd;
   
    for (i = 0; i < nr_fds; i++)
       if (strcmp(BusID, connection[i].BusID) == 0) {
           connection[i].refcount++;
           *newlyopened = 0;
           return connection[i].fd;
       }

    fd = drmOpen(unused, BusID);
    if (fd <= 0 || nr_fds == DRM_MAX_FDS)
       return fd;
   
    connection[nr_fds].BusID = strdup(BusID);
    connection[nr_fds].fd = fd;
    connection[nr_fds].refcount = 1;
    *newlyopened = 1;

    if (0)
       fprintf(stderr, "saved connection %d for %s %d\n", 
              nr_fds, connection[nr_fds].BusID, 
              strcmp(BusID, connection[nr_fds].BusID));

    nr_fds++;

    return fd;
}

Here is the call graph for this function:

int drmRmMap ( int  fd,
drm_handle_t  handle 
)

Definition at line 983 of file xf86drm.c.

{
    drm_map_t map;

    map.handle = (void *)(uintptr_t)handle;

    if(drmIoctl(fd, DRM_IOCTL_RM_MAP, &map))
       return -errno;
    return 0;
}

Here is the call graph for this function:

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

Definition at line 1907 of file xf86drm.c.

{
    drm_scatter_gather_t sg;

    *handle = 0;
    sg.size   = size;
    sg.handle = 0;
    if (drmIoctl(fd, DRM_IOCTL_SG_ALLOC, &sg))
       return -errno;
    *handle = sg.handle;
    return 0;
}

Here is the call graph for this function:

int drmScatterGatherFree ( int  fd,
drm_handle_t  handle 
)

Definition at line 1920 of file xf86drm.c.

{
    drm_scatter_gather_t sg;

    sg.size   = 0;
    sg.handle = handle;
    if (drmIoctl(fd, DRM_IOCTL_SG_FREE, &sg))
       return -errno;
    return 0;
}

Here is the call graph for this function:

int drmSetBusid ( int  fd,
const char *  busid 
)

Set the bus ID of the device.

Parameters:
fdfile descriptor.
busidbus ID string.
Returns:
zero on success, negative on failure.

This function is a wrapper around the DRM_IOCTL_SET_UNIQUE ioctl, passing the arguments in a drm_unique structure.

Definition at line 882 of file xf86drm.c.

{
    drm_unique_t u;

    u.unique     = (char *)busid;
    u.unique_len = strlen(busid);

    if (drmIoctl(fd, DRM_IOCTL_SET_UNIQUE, &u)) {
       return -errno;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1453 of file xf86drm.c.

{
    drm_ctx_t ctx;

    /*
     * Context preserving means that no context switches are done between DMA
     * buffers from one context and the next.  This is suitable for use in the
     * X server (which promises to maintain hardware context), or in the
     * client-side library when buffers are swapped on behalf of two threads.
     */
    ctx.handle = context;
    ctx.flags  = 0;
    if (flags & DRM_CONTEXT_PRESERVED)
       ctx.flags |= _DRM_CONTEXT_PRESERVED;
    if (flags & DRM_CONTEXT_2DONLY)
       ctx.flags |= _DRM_CONTEXT_2DONLY;
    if (drmIoctl(fd, DRM_IOCTL_MOD_CTX, &ctx))
       return -errno;
    return 0;
}

Here is the call graph for this function:

void drmSetDebugMsgFunction ( int(*)(const char *format, va_list ap)  debug_msg_ptr)

Definition at line 132 of file xf86drm.c.

{
    drm_debug_print = debug_msg_ptr;
}
int drmSetInterfaceVersion ( int  fd,
drmSetVersion version 
)

Issue a set-version ioctl.

Parameters:
fdfile descriptor.
drmCommandIndexcommand index
datasource pointer of the data to be read and written.
sizesize of the data to be read and written.
Returns:
zero on success, or a negative value on failure.

It issues a read-write ioctl given by

 DRM_COMMAND_BASE + drmCommandIndex 

.

Definition at line 2316 of file xf86drm.c.

{
    int retcode = 0;
    drm_set_version_t sv;

    sv.drm_di_major = version->drm_di_major;
    sv.drm_di_minor = version->drm_di_minor;
    sv.drm_dd_major = version->drm_dd_major;
    sv.drm_dd_minor = version->drm_dd_minor;

    if (drmIoctl(fd, DRM_IOCTL_SET_VERSION, &sv)) {
       retcode = -errno;
    }

    version->drm_di_major = sv.drm_di_major;
    version->drm_di_minor = sv.drm_di_minor;
    version->drm_dd_major = sv.drm_dd_major;
    version->drm_dd_minor = sv.drm_dd_minor;

    return retcode;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int drmSetMaster ( int  fd)

Definition at line 2510 of file xf86drm.c.

{
       return ioctl(fd, DRM_IOCTL_SET_MASTER, 0);
}

Definition at line 93 of file xf86drm.c.

{
    drm_server_info = info;
}
int drmSwitchToContext ( int  fd,
drm_context_t  context 
)

Definition at line 1443 of file xf86drm.c.

{
    drm_ctx_t ctx;

    ctx.handle = context;
    if (drmIoctl(fd, DRM_IOCTL_SWITCH_CTX, &ctx))
       return -errno;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int drmUnlock ( int  fd,
drm_context_t  context 
)

Release the hardware lock.

Parameters:
fdfile descriptor.
contextcontext.
Returns:
zero on success, or a negative value on failure.

This function is a wrapper around the DRM_IOCTL_UNLOCK ioctl, passing the argument in a drm_lock structure.

Definition at line 1366 of file xf86drm.c.

{
    drm_lock_t lock;

    lock.context = context;
    lock.flags   = 0;
    return drmIoctl(fd, DRM_IOCTL_UNLOCK, &lock);
}

Here is the call graph for this function:

int drmUnmap ( drmAddress  address,
drmSize  size 
)

Unmap mappings obtained with drmMap().

Parameters:
addressaddress as given by drmMap().
sizesize in bytes. Must match the size used by drmMap().
Returns:
zero on success, or a negative value on failure.

This function is a wrapper for munmap().

Definition at line 1160 of file xf86drm.c.

{
    return munmap(address, size);
}
int drmUnmapBufs ( drmBufMapPtr  bufs)

Unmap buffers allocated with drmMapBufs().

Returns:
zero on success, or negative value on failure.

Calls munmap() for every buffer stored in bufs and frees the memory allocated by drmMapBufs().

Definition at line 1264 of file xf86drm.c.

{
    int i;

    for (i = 0; i < bufs->count; i++) {
       munmap(bufs->list[i].address, bufs->list[i].total);
    }

    drmFree(bufs->list);
    drmFree(bufs);
       
    return 0;
}

Here is the call graph for this function:

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

Definition at line 1534 of file xf86drm.c.

{
    drm_update_draw_t update;

    update.handle = handle;
    update.type = type;
    update.num = num;
    update.data = (unsigned long long)(unsigned long)data;

    if (drmIoctl(fd, DRM_IOCTL_UPDATE_DRAW, &update))
       return -errno;

    return 0;
}

Here is the call graph for this function:

int drmWaitVBlank ( int  fd,
drmVBlankPtr  vbl 
)

Wait for VBLANK.

Parameters:
fdfile descriptor.
vblpointer to a drmVBlank structure.
Returns:
zero on success, or a negative value on failure.

This function is a wrapper around the DRM_IOCTL_WAIT_VBLANK ioctl.

Definition at line 1942 of file xf86drm.c.

{
    struct timespec timeout, cur;
    int ret;

    ret = clock_gettime(CLOCK_MONOTONIC, &timeout);
    if (ret < 0) {
       fprintf(stderr, "clock_gettime failed: %s\n", strerror(ret));
       goto out;
    }
    timeout.tv_sec++;

    do {
       ret = ioctl(fd, DRM_IOCTL_WAIT_VBLANK, vbl);
       vbl->request.type &= ~DRM_VBLANK_RELATIVE;
       if (ret && errno == EINTR) {
              clock_gettime(CLOCK_MONOTONIC, &cur);
              /* Timeout after 1s */
              if (cur.tv_sec > timeout.tv_sec + 1 ||
                 (cur.tv_sec == timeout.tv_sec && cur.tv_nsec >=
                  timeout.tv_nsec)) {
                     errno = EBUSY;
                     ret = -1;
                     break;
              }
       }
    } while (ret && errno == EINTR);

out:
    return ret;
}

Here is the caller graph for this function:


Variable Documentation

struct { ... } connection[DRM_MAX_FDS] [static]
int(* drm_debug_print)(const char *format, va_list ap) = drmDebugPrint [static]

Definition at line 112 of file xf86drm.c.

Definition at line 91 of file xf86drm.c.

void* drmHashTable = NULL [static]

Definition at line 137 of file xf86drm.c.

int nr_fds = 0 [static]

Definition at line 2456 of file xf86drm.c.