Merged DRM documentation.

1 files changed, 717 insertions, 19 deletions

diff --git a/libdrm/xf86drm.c b/libdrm/xf86drm.c
index a5bb8050..75a90825 100644
--- a/libdrm/xf86drm.c
+++ b/libdrm/xf86drm.c
@@ -1,6 +1,12 @@
-/* xf86drm.c -- User-level interface to DRM device
- * Created: Tue Jan  5 08:16:21 1999 by faith@precisioninsight.com
+/**
+ * \file xf86drm.c 
+ * User-level interface to DRM device
  *
+ * \author Rickard E. (Rik) Faith <faith@valinux.com>
+ * \author Kevin E. Martin <martin@valinux.com>
+ */
+
+/*
  * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
  * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
  * All Rights Reserved.
@@ -23,14 +29,10 @@
  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  * DEALINGS IN THE SOFTWARE.
- *
- * Authors: Rickard E. (Rik) Faith <faith@valinux.com>
- *	    Kevin E. Martin <martin@valinux.com>
- *
- * $XFree86: xc/programs/Xserver/hw/xfree86/os-support/linux/drm/xf86drm.c,v 1.31 2003/02/04 03:01:59 dawes Exp $
- *
  */
 
+/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/linux/drm/xf86drm.c,v 1.31 2003/02/04 03:01:59 dawes Exp $ */
+
 #ifdef XFree86Server
 # include "xf86.h"
 # include "xf86_OSproc.h"
@@ -114,6 +116,14 @@ extern unsigned long _bus_base(void);
 
 #define DRM_MSG_VERBOSITY 3
 
+/**
+ * Output a message to stderr.
+ *
+ * \param format printf() like format string.
+ *
+ * \internal
+ * This function is a wrapper around vfprintf().
+ */
 static void
 drmMsg(const char *format, ...)
 {
@@ -196,6 +206,19 @@ static drmHashEntry *drmGetEntry(int fd)
     return entry;
 }
 
+/**
+ * Open the DRM device, creating it if necessary.
+ *
+ * \param dev major and minor numbers of the device.
+ * \param minor minor number of the device.
+ * 
+ * \return a file descriptor on success, or a negative value on error.
+ *
+ * \internal
+ * Assembles the device name from \p minor and opens it, creating the device
+ * special file node with the major and minor numbers specified by \p dev and
+ * parent directory if necessary and was called by root.
+ */
 static int drmOpenDevice(long dev, int minor)
 {
     stat_t          st;
@@ -255,6 +278,19 @@ static int drmOpenDevice(long dev, int minor)
     return -errno;
 }
 
+
+/**
+ * Open the DRM device
+ *
+ * \param minor device minor number.
+ * \param create allow to create the device if set.
+ *
+ * \return a file descriptor on success, or a negative value on error.
+ * 
+ * \internal
+ * Calls drmOpenDevice() if \p create is set, otherwise assembles the device
+ * name from \p minor and opens it.
+ */
 static int drmOpenMinor(int minor, int create)
 {
     int  fd;
@@ -267,10 +303,17 @@ static int drmOpenMinor(int minor, int create)
     return -errno;
 }
 
-/* drmAvailable looks for (DRM_MAJOR, 0) and returns 1 if it returns
-   information for DRM_IOCTL_VERSION.  For backward compatibility with
-   older Linux implementations, /proc/dri is also checked. */
 
+/**
+ * Determine whether the DRM kernel driver has been loaded.
+ * 
+ * \return 1 if the DRM driver is loaded, 0 otherwise.
+ *
+ * \internal 
+ * 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.
+ */
 int drmAvailable(void)
 {
     drmVersionPtr version;
@@ -292,6 +335,20 @@ int drmAvailable(void)
     return retval;
 }
 
+
+/**
+ * Open the device by bus ID.
+ *
+ * \param busid bus ID.
+ *
+ * \return a file descriptor on success, or a negative value on error.
+ *
+ * \internal
+ * This function attempts to open every possible minor (up to DRM_MAX_MINOR),
+ * comparing the device bus ID with the one supplied.
+ *
+ * \sa drmOpenMinor() and drmGetBusid().
+ */
 static int drmOpenByBusid(const char *busid)
 {
     int        i;
@@ -316,6 +373,21 @@ static int drmOpenByBusid(const char *busid)
     return -1;
 }
 
+
+/**
+ * Open the device by name.
+ *
+ * \param name driver name.
+ * 
+ * \return a file descriptor on success, or a negative value on error.
+ * 
+ * \internal
+ * 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.
+ * 
+ * \sa drmOpenMinor(), drmGetVersion() and drmGetBusid().
+ */
 static int drmOpenByName(const char *name)
 {
     int           i;
@@ -398,11 +470,22 @@ static int drmOpenByName(const char *name)
     return -1;
 }
 
-/* drmOpen looks up the specified name and busid, and opens the device
-   found.  The entry in /dev/dri is created if necessary (and if root).
-   A file descriptor is returned.  On error, the return value is
-   negative. */
 
+/**
+ * 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.
+ *
+ * \param name driver name. Not referenced if bus ID is supplied.
+ * \param busid bus ID. Zero if not known.
+ * 
+ * \return a file descriptor on success, or a negative value on error.
+ * 
+ * \internal
+ * It calls drmOpenByBusid() if \p busid is specified or drmOpenByName()
+ * otherwise.
+ */
 int drmOpen(const char *name, const char *busid)
 {
 
@@ -410,6 +493,16 @@ int drmOpen(const char *name, const char *busid)
     return drmOpenByName(name);
 }
 
+
+/**
+ * Free the version information returned by drmGetVersion().
+ *
+ * \param v pointer to the version information.
+ *
+ * \internal
+ * It frees the memory pointed by \p %v as well as all the non-null strings
+ * pointers in it.
+ */
 void drmFreeVersion(drmVersionPtr v)
 {
     if (!v) return;
@@ -419,6 +512,16 @@ void drmFreeVersion(drmVersionPtr v)
     drmFree(v);
 }
 
+
+/**
+ * Free the non-public version information returned by the kernel.
+ *
+ * \param v pointer to the version information.
+ *
+ * \internal
+ * Used by drmGetVersion() to free the memory pointed by \p %v as well as all
+ * the non-null strings pointers in it.
+ */
 static void drmFreeKernelVersion(drm_version_t *v)
 {
     if (!v) return;
@@ -428,6 +531,17 @@ static void drmFreeKernelVersion(drm_version_t *v)
     drmFree(v);
 }
 
+
+/**
+ * Copy version information.
+ * 
+ * \param d destination pointer.
+ * \param s source pointer.
+ * 
+ * \internal
+ * Used by drmGetVersion() to translate the information returned by the ioctl
+ * interface in a private structure into the public structure counterpart.
+ */
 static void drmCopyVersion(drmVersionPtr d, const drm_version_t *s)
 {
     d->version_major      = s->version_major;
@@ -441,9 +555,22 @@ static void drmCopyVersion(drmVersionPtr d, const drm_version_t *s)
     d->desc               = drmStrdup(s->desc);
 }
 
-/* drmGet Version obtains the driver version information via an ioctl.  Similar
- * information is available via /proc/dri. */
 
+/**
+ * Query the driver version information.
+ *
+ * \param fd file descriptor.
+ * 
+ * \return pointer to a drmVersion structure which should be freed with
+ * drmFreeVersion().
+ * 
+ * \note Similar information is available via /proc/dri.
+ * 
+ * \internal
+ * 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.
+ */
 drmVersionPtr drmGetVersion(int fd)
 {
     drmVersionPtr retval;
@@ -490,9 +617,20 @@ drmVersionPtr drmGetVersion(int fd)
     return retval;
 }
 
-/* drmGetLibVersion set version information for the drm user space library.
- * this version number is driver indepedent */
 
+/**
+ * Get version information for the DRM user space library.
+ * 
+ * This version number is driver independent.
+ * 
+ * \param fd file descriptor.
+ *
+ * \return version information.
+ * 
+ * \internal
+ * This function allocates and fills a drm_version structure with a hard coded
+ * version number.
+ */
 drmVersionPtr drmGetLibVersion(int fd)
 {
     drm_version_t *version = drmMalloc(sizeof(*version));
@@ -510,11 +648,33 @@ drmVersionPtr drmGetLibVersion(int fd)
     return (drmVersionPtr)version;
 }
 
+
+/**
+ * Free the bus ID information.
+ *
+ * \param busid bus ID information string as given by drmGetBusid().
+ *
+ * \internal
+ * This function is just frees the memory pointed by \p busid.
+ */
 void drmFreeBusid(const char *busid)
 {
     drmFree((void *)busid);
 }
 
+
+/**
+ * Get the bus ID of the device.
+ *
+ * \param fd file descriptor.
+ *
+ * \return bus ID string.
+ *
+ * \internal
+ * 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.
+ */
 char *drmGetBusid(int fd)
 {
     drm_unique_t u;
@@ -529,6 +689,19 @@ char *drmGetBusid(int fd)
     return u.unique;
 }
 
+
+/**
+ * Set the bus ID of the device.
+ *
+ * \param fd file descriptor.
+ * \param busid bus ID string.
+ *
+ * \return zero on success, negative on failure.
+ *
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_SET_UNIQUE ioctl, passing
+ * the arguments in a drm_unique structure.
+ */
 int drmSetBusid(int fd, const char *busid)
 {
     drm_unique_t u;
@@ -561,6 +734,56 @@ int drmAuthMagic(int fd, drmMagic magic)
     return 0;
 }
 
+/**
+ * Specifies a range of memory that is available for mapping by a
+ * non-root process.
+ *
+ * \param fd file descriptor.
+ * \param offset usually the physical address. The actual meaning depends of
+ * the \p type parameter. See below.
+ * \param size of the memory in bytes.
+ * \param type type of the memory to be mapped.
+ * \param flags combination of several flags to modify the function actions.
+ * \param handle will be set to a value that may be used as the offset
+ * parameter for mmap().
+ * 
+ * \return zero on success or a negative value on error.
+ *
+ * \par Mapping the frame buffer
+ * For the frame buffer
+ * - \p offset will be the physical address of the start of the frame buffer,
+ * - \p size will be the size of the frame buffer in bytes, and
+ * - \p type will be DRM_FRAME_BUFFER.
+ *
+ * \par
+ * The area mapped will be uncached. If MTRR support is available in the
+ * kernel, the frame buffer area will be set to write combining. 
+ *
+ * \par Mapping the MMIO register area
+ * For the MMIO register area,
+ * - \p offset will be the physical address of the start of the register area,
+ * - \p size will be the size of the register area bytes, and
+ * - \p type will be DRM_REGISTERS.
+ * \par
+ * The area mapped will be uncached. 
+ * 
+ * \par Mapping the SAREA
+ * For the SAREA,
+ * - \p offset will be ignored and should be set to zero,
+ * - \p size will be the desired size of the SAREA in bytes,
+ * - \p type will be DRM_SHM.
+ * 
+ * \par
+ * 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.
+ *
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_ADD_MAP ioctl, passing
+ * the arguments in a drm_map structure.
+ */
 int drmAddMap(int fd,
 	      drmHandle offset,
 	      drmSize size,
@@ -596,6 +819,22 @@ int drmRmMap(int fd, drmHandle handle)
     return 0;
 }
 
+/**
+ * Make buffers available for DMA transfers.
+ * 
+ * \param fd file descriptor.
+ * \param count number of buffers.
+ * \param size size of each buffer.
+ * \param flags buffer allocation flags.
+ * \param agp_offset offset in the AGP aperture 
+ *
+ * \return number of buffers allocated, negative on error.
+ *
+ * \internal
+ * This function is a wrapper around DRM_IOCTL_ADD_BUFS ioctl.
+ *
+ * \sa drm_buf_desc.
+ */
 int drmAddBufs(int fd, int count, int size, drmBufDescFlags flags,
 	       int agp_offset)
 {
@@ -647,6 +886,21 @@ int drmMarkBufs(int fd, double low, double high)
     return 0;
 }
 
+/**
+ * Free buffers.
+ *
+ * \param fd file descriptor.
+ * \param count number of buffers to free.
+ * \param list list of buffers to be freed.
+ *
+ * \return zero on success, or a negative value on failure.
+ * 
+ * \note This function is primarily used for debugging.
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_FREE_BUFS ioctl, passing
+ * the arguments in a drm_buf_free structure.
+ */
 int drmFreeBufs(int fd, int count, int *list)
 {
     drm_buf_free_t request;
@@ -657,6 +911,15 @@ int drmFreeBufs(int fd, int count, int *list)
     return 0;
 }
 
+
+/**
+ * Close the device.
+ *
+ * \param fd file descriptor.
+ *
+ * \internal
+ * This function closes the file descriptor.
+ */
 int drmClose(int fd)
 {
     unsigned long key    = drmGetKeyFromFd(fd);
@@ -673,6 +936,21 @@ int drmClose(int fd)
     return close(fd);
 }
 
+
+/**
+ * Map a region of memory.
+ *
+ * \param fd file descriptor.
+ * \param handle handle returned by drmAddMap().
+ * \param size size in bytes. Must match the size used by drmAddMap().
+ * \param address will contain the user-space virtual address where the mapping
+ * begins.
+ *
+ * \return zero on success, or a negative value on failure.
+ * 
+ * \internal
+ * This function is a wrapper for mmap().
+ */
 int drmMap(int fd,
 	   drmHandle handle,
 	   drmSize size,
@@ -692,6 +970,18 @@ int drmMap(int fd,
     return 0;
 }
 
+
+/**
+ * Unmap mappings obtained with drmMap().
+ *
+ * \param address address as given by drmMap().
+ * \param size size in bytes. Must match the size used by drmMap().
+ * 
+ * \return zero on success, or a negative value on failure.
+ *
+ * \internal
+ * This function is a wrapper for unmap().
+ */
 int drmUnmap(drmAddress address, drmSize size)
 {
     return munmap(address, size);
@@ -733,6 +1023,21 @@ drmBufInfoPtr drmGetBufInfo(int fd)
     return NULL;
 }
 
+/**
+ * Map all DMA buffers into client-virtual space.
+ *
+ * \param fd file descriptor.
+ *
+ * \return a pointer to a ::drmBufMap structure.
+ *
+ * \note The client may not use these buffers until obtaining buffer indices
+ * with drmDMA().
+ * 
+ * \internal
+ * 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.
+ */ 
 drmBufMapPtr drmMapBufs(int fd)
 {
     drm_buf_map_t bufs;
@@ -767,6 +1072,15 @@ drmBufMapPtr drmMapBufs(int fd)
     return NULL;
 }
 
+
+/**
+ * Unmap buffers allocated with drmMapBufs().
+ *
+ * \return zero on success, or negative value on failure.
+ *
+ * \internal
+ * Calls munmap() for every buffer stored in \p bufs.
+ */
 int drmUnmapBufs(drmBufMapPtr bufs)
 {
     int i;
@@ -777,8 +1091,21 @@ int drmUnmapBufs(drmBufMapPtr bufs)
     return 0;
 }
 
+
 #define DRM_DMA_RETRY		16
 
+/**
+ * Reserve DMA buffers.
+ *
+ * \param fd file descriptor.
+ * \param request 
+ * 
+ * \return zero on success, or a negative value on failure.
+ *
+ * \internal
+ * Assemble the arguments into a drm_dma structure and keeps issuing the
+ * DRM_IOCTL_DMA ioctl until success or until maximum number of retries.
+ */
 int drmDMA(int fd, drmDMAReqPtr request)
 {
     drm_dma_t dma;
@@ -807,6 +1134,21 @@ int drmDMA(int fd, drmDMAReqPtr request)
     }
 }
 
+
+/**
+ * Obtain heavyweight hardware lock.
+ *
+ * \param fd file descriptor.
+ * \param context context.
+ * \param flags flags that determine the sate of the hardware when the function
+ * returns.
+ * 
+ * \return always zero.
+ * 
+ * \internal
+ * This function translates the arguments into a drm_lock structure and issue
+ * the DRM_IOCTL_LOCK ioctl until the lock is successfully acquired.
+ */
 int drmGetLock(int fd, drmContext context, drmLockFlags flags)
 {
     drm_lock_t lock;
@@ -825,6 +1167,20 @@ int drmGetLock(int fd, drmContext context, drmLockFlags flags)
     return 0;
 }
 
+static void (*drm_unlock_callback)( void ) = 0;
+
+/**
+ * Release the hardware lock.
+ *
+ * \param fd file descriptor.
+ * \param context context.
+ * 
+ * \return zero on success, or a negative value on failure.
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_UNLOCK ioctl, passing the
+ * argument in a drm_lock structure.
+ */
 int drmUnlock(int fd, drmContext context)
 {
     drm_lock_t lock;
@@ -868,6 +1224,24 @@ void drmFreeReservedContextList(drmContextPtr pt)
     drmFree(pt);
 }
 
+/**
+ * Create context.
+ *
+ * Used by the X server during GLXContext initialization. This causes
+ * per-context kernel-level resources to be allocated.
+ *
+ * \param fd file descriptor.
+ * \param handle is set on success. To be used by the client when requesting DMA
+ * dispatch with drmDMA().
+ * 
+ * \return zero on success, or a negative value on failure.
+ * 
+ * \note May only be called by root.
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_ADD_CTX ioctl, passing the
+ * argument in a drm_ctx structure.
+ */
 int drmCreateContext(int fd, drmContextPtr handle)
 {
     drm_ctx_t ctx;
@@ -919,6 +1293,23 @@ int drmGetContextFlags(int fd, drmContext context, drmContextFlagsPtr flags)
     return 0;
 }
 
+/**
+ * Destroy context.
+ *
+ * Free any kernel-level resources allocated with drmCreateContext() associated
+ * with the context.
+ * 
+ * \param fd file descriptor.
+ * \param handle handle given by drmCreateContext().
+ * 
+ * \return zero on success, or a negative value on failure.
+ * 
+ * \note May only be called by root.
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_RM_CTX ioctl, passing the
+ * argument in a drm_ctx structure.
+ */
 int drmDestroyContext(int fd, drmContext handle)
 {
     drm_ctx_t ctx;
@@ -943,18 +1334,54 @@ int drmDestroyDrawable(int fd, drmDrawable handle)
     return 0;
 }
 
+/**
+ * Acquire the AGP device.
+ *
+ * Must be called before any of the other AGP related calls.
+ *
+ * \param fd file descriptor.
+ * 
+ * \return zero on success, or a negative value on failure.
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_AGP_ACQUIRE ioctl.
+ */
 int drmAgpAcquire(int fd)
 {
     if (ioctl(fd, DRM_IOCTL_AGP_ACQUIRE, NULL)) return -errno;
     return 0;
 }
 
+
+/**
+ * Release the AGP device.
+ *
+ * \param fd file descriptor.
+ * 
+ * \return zero on success, or a negative value on failure.
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_AGP_RELEASE ioctl.
+ */
 int drmAgpRelease(int fd)
 {
     if (ioctl(fd, DRM_IOCTL_AGP_RELEASE, NULL)) return -errno;
     return 0;
 }
 
+
+/**
+ * Set the AGP mode.
+ *
+ * \param fd file descriptor.
+ * \param mode AGP mode.
+ * 
+ * \return zero on success, or a negative value on failure.
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_AGP_ENABLE ioctl, passing the
+ * argument in a drm_agp_mode structure.
+ */
 int drmAgpEnable(int fd, unsigned long mode)
 {
     drm_agp_mode_t m;
@@ -964,6 +1391,23 @@ int drmAgpEnable(int fd, unsigned long mode)
     return 0;
 }
 
+
+/**
+ * Allocate a chunk of AGP memory.
+ *
+ * \param fd file descriptor.
+ * \param size requested memory size in bytes. Will be rounded to page boundary.
+ * \param type type of memory to allocate.
+ * \param address if not zero, will be set to the physical address of the
+ * allocated memory.
+ * \param handle on success will be set to a handle of the allocated memory.
+ * 
+ * \return zero on success, or a negative value on failure.
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_AGP_ALLOC ioctl, passing the
+ * arguments in a drm_agp_buffer structure.
+ */
 int drmAgpAlloc(int fd, unsigned long size, unsigned long type,
 		unsigned long *address, unsigned long *handle)
 {
@@ -978,6 +1422,19 @@ int drmAgpAlloc(int fd, unsigned long size, unsigned long type,
     return 0;
 }
 
+
+/**
+ * Free a chunk of AGP memory.
+ *
+ * \param fd file descriptor.
+ * \param handle handle to the allocated memory, as given by drmAgpAllocate().
+ * 
+ * \return zero on success, or a negative value on failure.
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_AGP_FREE ioctl, passing the
+ * argument in a drm_agp_buffer structure.
+ */
 int drmAgpFree(int fd, unsigned long handle)
 {
     drm_agp_buffer_t b;
@@ -988,6 +1445,20 @@ int drmAgpFree(int fd, unsigned long handle)
     return 0;
 }
 
+
+/**
+ * Bind a chunk of AGP memory.
+ *
+ * \param fd file descriptor.
+ * \param handle handle to the allocated memory, as given by drmAgpAllocate().
+ * \param offset offset in bytes. It will round to page boundary.
+ * 
+ * \return zero on success, or a negative value on failure.
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_AGP_BIND ioctl, passing the
+ * argument in a drm_agp_binding structure.
+ */
 int drmAgpBind(int fd, unsigned long handle, unsigned long offset)
 {
     drm_agp_binding_t b;
@@ -998,6 +1469,19 @@ int drmAgpBind(int fd, unsigned long handle, unsigned long offset)
     return 0;
 }
 
+
+/**
+ * Unbind a chunk of AGP memory.
+ *
+ * \param fd file descriptor.
+ * \param handle handle to the allocated memory, as given by drmAgpAllocate().
+ * 
+ * \return zero on success, or a negative value on failure.
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_AGP_UNBIND ioctl, passing
+ * the argument in a drm_agp_binding structure.
+ */
 int drmAgpUnbind(int fd, unsigned long handle)
 {
     drm_agp_binding_t b;
@@ -1008,6 +1492,18 @@ int drmAgpUnbind(int fd, unsigned long handle)
     return 0;
 }
 
+
+/**
+ * Get AGP driver major version number.
+ *
+ * \param fd file descriptor.
+ * 
+ * \return major version number on success, or a negative value on failure..
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
+ * necessary information in a drm_agp_info structure.
+ */
 int drmAgpVersionMajor(int fd)
 {
     drm_agp_info_t i;
@@ -1016,6 +1512,18 @@ int drmAgpVersionMajor(int fd)
     return i.agp_version_major;
 }
 
+
+/**
+ * Get AGP driver minor version number.
+ *
+ * \param fd file descriptor.
+ * 
+ * \return minor version number on success, or a negative value on failure.
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
+ * necessary information in a drm_agp_info structure.
+ */
 int drmAgpVersionMinor(int fd)
 {
     drm_agp_info_t i;
@@ -1024,6 +1532,18 @@ int drmAgpVersionMinor(int fd)
     return i.agp_version_minor;
 }
 
+
+/**
+ * Get AGP mode.
+ *
+ * \param fd file descriptor.
+ * 
+ * \return mode on success, or zero on failure.
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
+ * necessary information in a drm_agp_info structure.
+ */
 unsigned long drmAgpGetMode(int fd)
 {
     drm_agp_info_t i;
@@ -1032,6 +1552,18 @@ unsigned long drmAgpGetMode(int fd)
     return i.mode;
 }
 
+
+/**
+ * Get AGP aperture base.
+ *
+ * \param fd file descriptor.
+ * 
+ * \return aperture base on success, zero on failure.
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
+ * necessary information in a drm_agp_info structure.
+ */
 unsigned long drmAgpBase(int fd)
 {
     drm_agp_info_t i;
@@ -1040,6 +1572,18 @@ unsigned long drmAgpBase(int fd)
     return i.aperture_base;
 }
 
+
+/**
+ * Get AGP aperture size.
+ *
+ * \param fd file descriptor.
+ * 
+ * \return aperture size on success, zero on failure.
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
+ * necessary information in a drm_agp_info structure.
+ */
 unsigned long drmAgpSize(int fd)
 {
     drm_agp_info_t i;
@@ -1048,6 +1592,18 @@ unsigned long drmAgpSize(int fd)
     return i.aperture_size;
 }
 
+
+/**
+ * Get used AGP memory.
+ *
+ * \param fd file descriptor.
+ * 
+ * \return memory used on success, or zero on failure.
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
+ * necessary information in a drm_agp_info structure.
+ */
 unsigned long drmAgpMemoryUsed(int fd)
 {
     drm_agp_info_t i;
@@ -1056,6 +1612,18 @@ unsigned long drmAgpMemoryUsed(int fd)
     return i.memory_used;
 }
 
+
+/**
+ * Get available AGP memory.
+ *
+ * \param fd file descriptor.
+ * 
+ * \return memory available on success, or zero on failure.
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
+ * necessary information in a drm_agp_info structure.
+ */
 unsigned long drmAgpMemoryAvail(int fd)
 {
     drm_agp_info_t i;
@@ -1064,6 +1632,18 @@ unsigned long drmAgpMemoryAvail(int fd)
     return i.memory_allowed;
 }
 
+
+/**
+ * Get hardware vendor ID.
+ *
+ * \param fd file descriptor.
+ * 
+ * \return vendor ID on success, or zero on failure.
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
+ * necessary information in a drm_agp_info structure.
+ */
 unsigned int drmAgpVendorId(int fd)
 {
     drm_agp_info_t i;
@@ -1072,6 +1652,18 @@ unsigned int drmAgpVendorId(int fd)
     return i.id_vendor;
 }
 
+
+/**
+ * Get hardware device ID.
+ *
+ * \param fd file descriptor.
+ * 
+ * \return zero on success, or zero on failure.
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
+ * necessary information in a drm_agp_info structure.
+ */
 unsigned int drmAgpDeviceId(int fd)
 {
     drm_agp_info_t i;
@@ -1102,6 +1694,17 @@ int drmScatterGatherFree(int fd, unsigned long handle)
     return 0;
 }
 
+/**
+ * Wait for VBLANK.
+ *
+ * \param fd file descriptor.
+ * \param vbl pointer to a drmVBlank structure.
+ * 
+ * \return zero on success, or a negative value on failure.
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_WAIT_VBLANK ioctl.
+ */
 int drmWaitVBlank(int fd, drmVBlankPtr vbl)
 {
     int ret;
@@ -1130,6 +1733,18 @@ int drmError(int err, const char *label)
     return 1;
 }
 
+/**
+ * Install IRQ handler.
+ *
+ * \param fd file descriptor.
+ * \param irq IRQ number.
+ * 
+ * \return zero on success, or a negative value on failure.
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_CONTROL ioctl, passing the
+ * argument in a drm_control structure.
+ */
 int drmCtlInstHandler(int fd, int irq)
 {
     drm_control_t ctl;
@@ -1140,6 +1755,18 @@ int drmCtlInstHandler(int fd, int irq)
     return 0;
 }
 
+
+/**
+ * Uninstall IRQ handler.
+ *
+ * \param fd file descriptor.
+ * 
+ * \return zero on success, or a negative value on failure.
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_CONTROL ioctl, passing the
+ * argument in a drm_control structure.
+ */
 int drmCtlUninstHandler(int fd)
 {
     drm_control_t ctl;
@@ -1166,6 +1793,20 @@ int drmFinish(int fd, int context, drmLockFlags flags)
     return 0;
 }
 
+/**
+ * Get IRQ from bus ID.
+ *
+ * \param fd file descriptor.
+ * \param busnum bus number.
+ * \param devnum device number.
+ * \param funcnum function number.
+ * 
+ * \return IRQ number on success, or a negative value on failure.
+ * 
+ * \internal
+ * This function is a wrapper around the DRM_IOCTL_IRQ_BUSID ioctl, passing the
+ * arguments in a drm_irq_busid structure.
+ */
 int drmGetInterruptFromBusID(int fd, int busnum, int devnum, int funcnum)
 {
     drm_irq_busid_t p;
@@ -1382,6 +2023,18 @@ int drmGetStats(int fd, drmStatsT *stats)
     return 0;
 }
 
+/**
+ * Send a device-specific command.
+ *
+ * \param fd file descriptor.
+ * \param drmCommandIndex command index 
+ * 
+ * \return zero on success, or a negative value on failure.
+ * 
+ * \internal
+ * It issues a ioctl given by 
+ * \code DRM_COMMAND_BASE + drmCommandIndex \endcode.
+ */
 int drmCommandNone(int fd, unsigned long drmCommandIndex)
 {
     void *data = NULL; /* dummy */
@@ -1395,6 +2048,21 @@ int drmCommandNone(int fd, unsigned long drmCommandIndex)
     return 0;
 }
 
+
+/**
+ * Send a device-specific read command.
+ *
+ * \param fd file descriptor.
+ * \param drmCommandIndex command index 
+ * \param data destination pointer of the data to be read.
+ * \param size size of the data to be read.
+ * 
+ * \return zero on success, or a negative value on failure.
+ *
+ * \internal
+ * It issues a read ioctl given by 
+ * \code DRM_COMMAND_BASE + drmCommandIndex \endcode.
+ */
 int drmCommandRead(int fd, unsigned long drmCommandIndex,
                    void *data, unsigned long size )
 {
@@ -1409,6 +2077,21 @@ int drmCommandRead(int fd, unsigned long drmCommandIndex,
     return 0;
 }
 
+
+/**
+ * Send a device-specific write command.
+ *
+ * \param fd file descriptor.
+ * \param drmCommandIndex command index 
+ * \param data source pointer of the data to be written.
+ * \param size size of the data to be written.
+ * 
+ * \return zero on success, or a negative value on failure.
+ * 
+ * \internal
+ * It issues a write ioctl given by 
+ * \code DRM_COMMAND_BASE + drmCommandIndex \endcode.
+ */
 int drmCommandWrite(int fd, unsigned long drmCommandIndex,
                    void *data, unsigned long size )
 {
@@ -1423,6 +2106,21 @@ int drmCommandWrite(int fd, unsigned long drmCommandIndex,
     return 0;
 }
 
+
+/**
+ * Send a device-specific read-write command.
+ *
+ * \param fd file descriptor.
+ * \param drmCommandIndex command index 
+ * \param data source pointer of the data to be read and written.
+ * \param size size of the data to be read and written.
+ * 
+ * \return zero on success, or a negative value on failure.
+ * 
+ * \internal
+ * It issues a read-write ioctl given by 
+ * \code DRM_COMMAND_BASE + drmCommandIndex \endcode.
+ */
 int drmCommandWriteRead(int fd, unsigned long drmCommandIndex,
                    void *data, unsigned long size )
 {