 @@ -1686,26 +1686,63 @@ int drmUpdateDrawableInfo(int fd, drm_dr
     memclear(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;
+}
 int drmCrtcGetSequence(int fd, uint32_t crtcId, uint64_t *sequence, uint64_t *ns)
+{
     struct drm_crtc_get_sequence get_seq;
     int ret;
     memclear(get_seq);
     get_seq.crtc_id = crtcId;
     ret = drmIoctl(fd, DRM_IOCTL_CRTC_GET_SEQUENCE, &get_seq);
     if (ret)
         return ret;
     if (sequence)
         *sequence = get_seq.sequence;
     if (ns)
         *ns = get_seq.sequence_ns;
     return 0;
+}
 int drmCrtcQueueSequence(int fd, uint32_t crtcId, uint32_t flags, uint64_t sequence,
                          uint64_t *sequence_queued, uint64_t user_data)
+{
     struct drm_crtc_queue_sequence queue_seq;
     int ret;
     memclear(queue_seq);
     queue_seq.crtc_id = crtcId;
     queue_seq.flags = flags;
     queue_seq.sequence = sequence;
     queue_seq.user_data = user_data;
     ret = drmIoctl(fd, DRM_IOCTL_CRTC_QUEUE_SEQUENCE, &queue_seq);
     if (ret == 0 && sequence_queued)
         *sequence_queued = queue_seq.sequence;
     return ret;
+}
 /**
  * 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)
 @@ -4146,83 +4183,131 @@ char *drmGetDeviceNameFromFd2(int fd)
 #endif
+}
 int drmSyncobjCreate(int fd, uint32_t flags, uint32_t *handle)
+{
     struct drm_syncobj_create args;
     int ret;
     memclear(args);
     args.flags = flags;
     args.handle = 0;
     ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_CREATE, &args);
     if (ret)
-	return ret;
+        return ret;
     *handle = args.handle;
     return 0;
+}
 int drmSyncobjDestroy(int fd, uint32_t handle)
+{
     struct drm_syncobj_destroy args;
     memclear(args);
     args.handle = handle;
     return drmIoctl(fd, DRM_IOCTL_SYNCOBJ_DESTROY, &args);
+}
 int drmSyncobjHandleToFD(int fd, uint32_t handle, int *obj_fd)
+{
     struct drm_syncobj_handle args;
     int ret;
     memclear(args);
     args.fd = -1;
     args.handle = handle;
     ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_HANDLE_TO_FD, &args);
     if (ret)
-	return ret;
+        return ret;
     *obj_fd = args.fd;
     return 0;
+}
 int drmSyncobjFDToHandle(int fd, int obj_fd, uint32_t *handle)
+{
     struct drm_syncobj_handle args;
     int ret;
     memclear(args);
     args.fd = obj_fd;
     args.handle = 0;
     ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_FD_TO_HANDLE, &args);
     if (ret)
-	return ret;
+        return ret;
     *handle = args.handle;
     return 0;
+}
 int drmSyncobjImportSyncFile(int fd, uint32_t handle, int sync_file_fd)
+{
     struct drm_syncobj_handle args;
     memclear(args);
     args.fd = sync_file_fd;
     args.handle = handle;
     args.flags = DRM_SYNCOBJ_FD_TO_HANDLE_FLAGS_IMPORT_SYNC_FILE;
     return drmIoctl(fd, DRM_IOCTL_SYNCOBJ_FD_TO_HANDLE, &args);
+}
 int drmSyncobjExportSyncFile(int fd, uint32_t handle, int *sync_file_fd)
+{
     struct drm_syncobj_handle args;
     int ret;
     memclear(args);
     args.fd = -1;
     args.handle = handle;
     args.flags = DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_EXPORT_SYNC_FILE;
     ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_HANDLE_TO_FD, &args);
     if (ret)
-	return ret;
+        return ret;
     *sync_file_fd = args.fd;
     return 0;
+}
 int drmSyncobjWait(int fd, uint32_t *handles, unsigned num_handles,
                    int64_t timeout_nsec, unsigned flags,
                    uint32_t *first_signaled)
+{
     struct drm_syncobj_wait args;
     int ret;
     memclear(args);
     args.handles = (uintptr_t)handles;
     args.timeout_nsec = timeout_nsec;
     args.count_handles = num_handles;
     args.flags = flags;
     ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_WAIT, &args);
     if (ret < 0)
         return -errno;
     if (first_signaled)
         *first_signaled = args.first_signaled;
     return ret;
+}
 int drmSyncobjReset(int fd, const uint32_t *handles, uint32_t handle_count)
+{
     struct drm_syncobj_array args;
     int ret;
     memclear(args);
     args.handles = (uintptr_t)handles;
     args.count_handles = handle_count;
     ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_RESET, &args);
     return ret;
+}
 int drmSyncobjSignal(int fd, const uint32_t *handles, uint32_t handle_count)
+{
     struct drm_syncobj_array args;
     int ret;
     memclear(args);
     args.handles = (uintptr_t)handles;
     args.count_handles = handle_count;
     ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_SIGNAL, &args);
     return ret;
+}

 @@ -635,26 +635,32 @@ extern drm_context_t * drmGetReservedCon
 extern void          drmFreeReservedContextList(drm_context_t *);
 extern int           drmSwitchToContext(int fd, drm_context_t context);
 extern int           drmDestroyContext(int fd, drm_context_t handle);
 extern int           drmCreateDrawable(int fd, drm_drawable_t * handle);
 extern int           drmDestroyDrawable(int fd, drm_drawable_t handle);
 extern int           drmUpdateDrawableInfo(int fd, drm_drawable_t handle,
 					   drm_drawable_info_type_t type,
 					   unsigned int num, void *data);
 extern int           drmCtlInstHandler(int fd, int irq);
 extern int           drmCtlUninstHandler(int fd);
 extern int           drmSetClientCap(int fd, uint64_t capability,
 				     uint64_t value);
 extern int           drmCrtcGetSequence(int fd, uint32_t crtcId,
 					uint64_t *sequence, uint64_t *ns);
 extern int           drmCrtcQueueSequence(int fd, uint32_t crtcId,
 					  uint32_t flags, uint64_t sequence,
 					  uint64_t *sequence_queued,
 					  uint64_t user_data);
 /* General user-level programmer's API: authenticated client and/or X */
 extern int           drmMap(int fd,
 			    drm_handle_t handle,
 			    drmSize size,
 			    drmAddressPtr address);
 extern int           drmUnmap(drmAddress address, drmSize size);
 extern drmBufInfoPtr drmGetBufInfo(int fd);
 extern drmBufMapPtr  drmMapBufs(int fd);
 extern int           drmUnmapBufs(drmBufMapPtr bufs);
 extern int           drmDMA(int fd, drmDMAReqPtr request);
 extern int           drmFreeBufs(int fd, int count, int *list);
 extern int           drmGetLock(int fd,
 			        drm_context_t context,
 @@ -727,53 +733,57 @@ extern int  drmSLFirst(void *l, unsigned
 extern void drmSLDump(void *l);
 extern int  drmSLLookupNeighbors(void *l, unsigned long key,
 				 unsigned long *prev_key, void **prev_value,
 				 unsigned long *next_key, void **next_value);
 extern int drmOpenOnce(void *unused, const char *BusID, int *newlyopened);
 extern int drmOpenOnceWithType(const char *BusID, int *newlyopened, int type);
 extern void drmCloseOnce(int fd);
 extern void drmMsg(const char *format, ...) DRM_PRINTFLIKE(1, 2);
 extern int drmSetMaster(int fd);
 extern int drmDropMaster(int fd);
-#define DRM_EVENT_CONTEXT_VERSION 3
+#define DRM_EVENT_CONTEXT_VERSION 4
 typedef struct _drmEventContext {
 	/* This struct is versioned so we can add more pointers if we
 	 * add more events. */
 	int version;
 	void (*vblank_handler)(int fd,
 			       unsigned int sequence,
 			       unsigned int tv_sec,
 			       unsigned int tv_usec,
 			       void *user_data);
 	void (*page_flip_handler)(int fd,
 				  unsigned int sequence,
 				  unsigned int tv_sec,
 				  unsigned int tv_usec,
 				  void *user_data);
 	void (*page_flip_handler2)(int fd,
 				   unsigned int sequence,
 				   unsigned int tv_sec,
 				   unsigned int tv_usec,
 				   unsigned int crtc_id,
 				   void *user_data);
 	void (*sequence_handler)(int fd,
 				 uint64_t sequence,
 				 uint64_t ns,
 				 uint64_t user_data);
 } drmEventContext, *drmEventContextPtr;
 extern int drmHandleEvent(int fd, drmEventContextPtr evctx);
 extern char *drmGetDeviceNameFromFd(int fd);
 /* Improved version of drmGetDeviceNameFromFd which attributes for any type of
  * device/node - card, control or renderD.
  */
 extern char *drmGetDeviceNameFromFd2(int fd);
 extern int drmGetNodeTypeFromFd(int fd);
 extern int drmPrimeHandleToFD(int fd, uint32_t handle, uint32_t flags, int *prime_fd);
 @@ -859,19 +869,24 @@ extern void drmFreeDevices(drmDevicePtr
 #define DRM_DEVICE_GET_PCI_REVISION (1 << 0)
 extern int drmGetDevice2(int fd, uint32_t flags, drmDevicePtr *device);
 extern int drmGetDevices2(uint32_t flags, drmDevicePtr devices[], int max_devices);
 extern int drmDevicesEqual(drmDevicePtr a, drmDevicePtr b);
 extern int drmSyncobjCreate(int fd, uint32_t flags, uint32_t *handle);
 extern int drmSyncobjDestroy(int fd, uint32_t handle);
 extern int drmSyncobjHandleToFD(int fd, uint32_t handle, int *obj_fd);
 extern int drmSyncobjFDToHandle(int fd, int obj_fd, uint32_t *handle);
 extern int drmSyncobjImportSyncFile(int fd, uint32_t handle, int sync_file_fd);
 extern int drmSyncobjExportSyncFile(int fd, uint32_t handle, int *sync_file_fd);
 extern int drmSyncobjWait(int fd, uint32_t *handles, unsigned num_handles,
 			  int64_t timeout_nsec, unsigned flags,
 			  uint32_t *first_signaled);
 extern int drmSyncobjReset(int fd, const uint32_t *handles, uint32_t handle_count);
 extern int drmSyncobjSignal(int fd, const uint32_t *handles, uint32_t handle_count);
 #if defined(__cplusplus)
+}
 #endif
 #endif

 @@ -261,54 +261,54 @@ int drmModeAddFB(int fd, uint32_t width,
 	f.pitch  = pitch;
 	f.bpp    = bpp;
 	f.depth  = depth;
 	f.handle = bo_handle;
 	if ((ret = DRM_IOCTL(fd, DRM_IOCTL_MODE_ADDFB, &f)))
 		return ret;
 	*buf_id = f.fb_id;
 	return 0;
+}
 int drmModeAddFB2WithModifiers(int fd, uint32_t width, uint32_t height,
-                               uint32_t pixel_format, uint32_t bo_handles[4],
+                               uint32_t pixel_format, const uint32_t bo_handles[4],
-                               uint32_t pitches[4], uint32_t offsets[4],
+                               const uint32_t pitches[4], const uint32_t offsets[4],
-                               uint64_t modifier[4], uint32_t *buf_id, uint32_t flags)
+                               const uint64_t modifier[4], uint32_t *buf_id, uint32_t flags)
+{
 	struct drm_mode_fb_cmd2 f;
 	int ret;
 	memclear(f);
 	f.width  = width;
 	f.height = height;
 	f.pixel_format = pixel_format;
 	f.flags = flags;
 	memcpy(f.handles, bo_handles, 4 * sizeof(bo_handles[0]));
 	memcpy(f.pitches, pitches, 4 * sizeof(pitches[0]));
 	memcpy(f.offsets, offsets, 4 * sizeof(offsets[0]));
 	if (modifier)
 		memcpy(f.modifier, modifier, 4 * sizeof(modifier[0]));
 	if ((ret = DRM_IOCTL(fd, DRM_IOCTL_MODE_ADDFB2, &f)))
 		return ret;
 	*buf_id = f.fb_id;
 	return 0;
+}
 int drmModeAddFB2(int fd, uint32_t width, uint32_t height,
-                  uint32_t pixel_format, uint32_t bo_handles[4],
+                  uint32_t pixel_format, const uint32_t bo_handles[4],
-                  uint32_t pitches[4], uint32_t offsets[4],
+                  const uint32_t pitches[4], const uint32_t offsets[4],
                   uint32_t *buf_id, uint32_t flags)
+{
 	return drmModeAddFB2WithModifiers(fd, width, height,
 					  pixel_format, bo_handles,
 					  pitches, offsets, NULL,
 					  buf_id, flags);
+}
 int drmModeRmFB(int fd, uint32_t bufferId)
+{
 	return DRM_IOCTL(fd, DRM_IOCTL_MODE_RMFB, &bufferId);
+}
 @@ -892,26 +892,27 @@ int drmModeCrtcSetGamma(int fd, uint32_t
 	l.red = VOID2U64(red);
 	l.green = VOID2U64(green);
 	l.blue = VOID2U64(blue);
 	return DRM_IOCTL(fd, DRM_IOCTL_MODE_SETGAMMA, &l);
+}
 int drmHandleEvent(int fd, drmEventContextPtr evctx)
+{
 	char buffer[1024];
 	int len, i;
 	struct drm_event *e;
 	struct drm_event_vblank *vblank;
 	struct drm_event_crtc_sequence *seq;
 	void *user_data;
 	/* The DRM read semantics guarantees that we always get only
 	 * complete events. */
 	len = read(fd, buffer, sizeof buffer);
 	if (len == 0)
 		return 0;
 	if (len < (int)sizeof *e)
 		return -1;
 	i = 0;
 	while (i < len) {
 @@ -936,26 +937,34 @@ int drmHandleEvent(int fd, drmEventConte
 				evctx->page_flip_handler2(fd,
 							 vblank->sequence,
 							 vblank->tv_sec,
 							 vblank->tv_usec,
 							 vblank->crtc_id,
 							 user_data);
 			else if (evctx->version >= 2 && evctx->page_flip_handler)
 				evctx->page_flip_handler(fd,
 							 vblank->sequence,
 							 vblank->tv_sec,
 							 vblank->tv_usec,
 							 user_data);
 			break;
 		case DRM_EVENT_CRTC_SEQUENCE:
 			seq = (struct drm_event_crtc_sequence *) e;
 			if (evctx->version >= 4 && evctx->sequence_handler)
 				evctx->sequence_handler(fd,
 							seq->sequence,
 							seq->time_ns,
 							seq->user_data);
 			break;
 		default:
 			break;
+		}
 		i += e->length;
+	}
 	return 0;
+}
 int drmModePageFlip(int fd, uint32_t crtc_id, uint32_t fb_id,
 		    uint32_t flags, void *user_data)
+{
 	struct drm_mode_crtc_page_flip flip;
 @@ -1488,13 +1497,102 @@ drmModeCreatePropertyBlob(int fd, const
 	*id = create.blob_id;
 	return 0;
+}
 int
 drmModeDestroyPropertyBlob(int fd, uint32_t id)
+{
 	struct drm_mode_destroy_blob destroy;
 	memclear(destroy);
 	destroy.blob_id = id;
 	return DRM_IOCTL(fd, DRM_IOCTL_MODE_DESTROYPROPBLOB, &destroy);
+}
 int
 drmModeCreateLease(int fd, const uint32_t *objects, int num_objects, int flags, uint32_t *lessee_id)
+{
 	struct drm_mode_create_lease create;
 	int ret;
 	memclear(create);
 	create.object_ids = (uintptr_t) objects;
 	create.object_count = num_objects;
 	create.flags = flags;
 	ret = DRM_IOCTL(fd, DRM_IOCTL_MODE_CREATE_LEASE, &create);
 	if (ret == 0) {
 		*lessee_id = create.lessee_id;
 		return create.fd;
+	}
 	return -errno;
+}
 drmModeLesseeListPtr
 drmModeListLessees(int fd)
+{
 	struct drm_mode_list_lessees list;
 	uint32_t count;
 	drmModeLesseeListPtr ret;
 	memclear(list);
 	if (DRM_IOCTL(fd, DRM_IOCTL_MODE_LIST_LESSEES, &list))
 		return NULL;
 	count = list.count_lessees;
 	ret = drmMalloc(sizeof (drmModeLesseeListRes) + count * sizeof (ret->lessees[0]));
 	if (!ret)
 		return NULL;
 	list.lessees_ptr = VOID2U64(&ret->lessees[0]);
 	if (DRM_IOCTL(fd, DRM_IOCTL_MODE_LIST_LESSEES, &list)) {
 		drmFree(ret);
 		return NULL;
+	}
 	ret->count = count;
 	return ret;
+}
 drmModeObjectListPtr
 drmModeGetLease(int fd)
+{
 	struct drm_mode_get_lease get;
 	uint32_t count;
 	drmModeObjectListPtr ret;
 	memclear(get);
 	if (DRM_IOCTL(fd, DRM_IOCTL_MODE_GET_LEASE, &get))
 		return NULL;
 	count = get.count_objects;
 	ret = drmMalloc(sizeof (drmModeObjectListRes) + count * sizeof (ret->objects[0]));
 	if (!ret)
 		return NULL;
 	get.objects_ptr = VOID2U64(&ret->objects[0]);
 	if (DRM_IOCTL(fd, DRM_IOCTL_MODE_GET_LEASE, &get)) {
 		drmFree(ret);
 		return NULL;
+	}
 	ret->count = count;
 	return ret;
+}
 int
 drmModeRevokeLease(int fd, uint32_t lessee_id)
+{
 	struct drm_mode_revoke_lease revoke;
 	int ret;
 	memclear(revoke);
 	revoke.lessee_id = lessee_id;
 	ret = DRM_IOCTL(fd, DRM_IOCTL_MODE_REVOKE_LEASE, &revoke);
 	if (ret == 0)
 		return 0;
 	return -errno;
+}

 @@ -359,35 +359,36 @@ extern drmModeResPtr drmModeGetResources
 /**
  * Retrive information about framebuffer bufferId
  */
 extern drmModeFBPtr drmModeGetFB(int fd, uint32_t bufferId);
 /**
  * Creates a new framebuffer with an buffer object as its scanout buffer.
  */
 extern int drmModeAddFB(int fd, uint32_t width, uint32_t height, uint8_t depth,
 			uint8_t bpp, uint32_t pitch, uint32_t bo_handle,
 			uint32_t *buf_id);
 /* ...with a specific pixel format */
 extern int drmModeAddFB2(int fd, uint32_t width, uint32_t height,
-			 uint32_t pixel_format, uint32_t bo_handles[4],
+			 uint32_t pixel_format, const uint32_t bo_handles[4],
-			 uint32_t pitches[4], uint32_t offsets[4],
+			 const uint32_t pitches[4], const uint32_t offsets[4],
 			 uint32_t *buf_id, uint32_t flags);
 /* ...with format modifiers */
 int drmModeAddFB2WithModifiers(int fd, uint32_t width, uint32_t height,
-			       uint32_t pixel_format, uint32_t bo_handles[4],
+			       uint32_t pixel_format, const uint32_t bo_handles[4],
-			       uint32_t pitches[4], uint32_t offsets[4],
+			       const uint32_t pitches[4], const uint32_t offsets[4],
-			       uint64_t modifier[4], uint32_t *buf_id, uint32_t flags);
+			       const uint64_t modifier[4], uint32_t *buf_id,
 				   uint32_t flags);
 /**
  * Destroies the given framebuffer.
  */
 extern int drmModeRmFB(int fd, uint32_t bufferId);
 /**
  * Mark a region of a framebuffer as dirty.
  */
 extern int drmModeDirtyFB(int fd, uint32_t bufferId,
 			  drmModeClipPtr clips, uint32_t num_clips);
 @@ -510,19 +511,41 @@ extern void drmModeAtomicSetCursor(drmMo
 extern int drmModeAtomicAddProperty(drmModeAtomicReqPtr req,
 				    uint32_t object_id,
 				    uint32_t property_id,
 				    uint64_t value);
 extern int drmModeAtomicCommit(int fd,
 			       drmModeAtomicReqPtr req,
 			       uint32_t flags,
 			       void *user_data);
 extern int drmModeCreatePropertyBlob(int fd, const void *data, size_t size,
 				     uint32_t *id);
 extern int drmModeDestroyPropertyBlob(int fd, uint32_t id);
 /*
  * DRM mode lease APIs. These create and manage new drm_masters with
  * access to a subset of the available DRM resources
  */
 extern int drmModeCreateLease(int fd, const uint32_t *objects, int num_objects, int flags, uint32_t *lessee_id);
 typedef struct drmModeLesseeList {
 	uint32_t count;
 	uint32_t lessees[0];
 } drmModeLesseeListRes, *drmModeLesseeListPtr;
 extern drmModeLesseeListPtr drmModeListLessees(int fd);
 typedef struct drmModeObjectList {
 	uint32_t count;
 	uint32_t objects[0];
 } drmModeObjectListRes, *drmModeObjectListPtr;
 extern drmModeObjectListPtr drmModeGetLease(int fd);
 extern int drmModeRevokeLease(int fd, uint32_t lessee_id);
 #if defined(__cplusplus)
+}
 #endif
 #endif

 @@ -684,44 +684,85 @@ struct drm_set_client_cap {
 #define DRM_CLOEXEC O_CLOEXEC
 struct drm_prime_handle {
 	__u32 handle;
 	/** Flags.. only applicable for handle->fd */
 	__u32 flags;
 	/** Returned dmabuf file descriptor */
 	__s32 fd;
 };
 struct drm_syncobj_create {
 	__u32 handle;
 #define DRM_SYNCOBJ_CREATE_SIGNALED (1 << 0)
 	__u32 flags;
 };
 struct drm_syncobj_destroy {
 	__u32 handle;
 	__u32 pad;
 };
 #define DRM_SYNCOBJ_FD_TO_HANDLE_FLAGS_IMPORT_SYNC_FILE (1 << 0)
 #define DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_EXPORT_SYNC_FILE (1 << 0)
 struct drm_syncobj_handle {
 	__u32 handle;
 	__u32 flags;
 	__s32 fd;
 	__u32 pad;
 };
 #define DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL (1 << 0)
 #define DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT (1 << 1)
 struct drm_syncobj_wait {
 	__u64 handles;
 	/* absolute timeout */
 	__s64 timeout_nsec;
 	__u32 count_handles;
 	__u32 flags;
 	__u32 first_signaled; /* only valid when not waiting all */
 	__u32 pad;
 };
 struct drm_syncobj_array {
 	__u64 handles;
 	__u32 count_handles;
 	__u32 pad;
 };
 /* Query current scanout sequence number */
 struct drm_crtc_get_sequence {
 	__u32 crtc_id;		/* requested crtc_id */
 	__u32 active;		/* return: crtc output is active */
 	__u64 sequence;		/* return: most recent vblank sequence */
 	__s64 sequence_ns;	/* return: most recent time of first pixel out */
 };
 /* Queue event to be delivered at specified sequence. Time stamp marks
  * when the first pixel of the refresh cycle leaves the display engine
  * for the display
  */
 #define DRM_CRTC_SEQUENCE_RELATIVE		0x00000001	/* sequence is relative to current */
 #define DRM_CRTC_SEQUENCE_NEXT_ON_MISS		0x00000002	/* Use next sequence if we've missed */
 struct drm_crtc_queue_sequence {
 	__u32 crtc_id;
 	__u32 flags;
 	__u64 sequence;		/* on input, target sequence. on output, actual sequence */
 	__u64 user_data;	/* user data passed to event */
 };
 #if defined(__cplusplus)
+}
 #endif
 #include "drm_mode.h"
 #if defined(__cplusplus)
 extern "C" {
 #endif
 #define DRM_IOCTL_BASE			'd'
 #define DRM_IO(nr)			_IO(DRM_IOCTL_BASE,nr)
 #define DRM_IOR(nr,type)		_IOR(DRM_IOCTL_BASE,nr,type)
 @@ -784,26 +825,29 @@ extern "C" {
 #define DRM_IOCTL_AGP_RELEASE		DRM_IO(  0x31)
 #define DRM_IOCTL_AGP_ENABLE		DRM_IOW( 0x32, struct drm_agp_mode)
 #define DRM_IOCTL_AGP_INFO		DRM_IOR( 0x33, struct drm_agp_info)
 #define DRM_IOCTL_AGP_ALLOC		DRM_IOWR(0x34, struct drm_agp_buffer)
 #define DRM_IOCTL_AGP_FREE		DRM_IOW( 0x35, struct drm_agp_buffer)
 #define DRM_IOCTL_AGP_BIND		DRM_IOW( 0x36, struct drm_agp_binding)
 #define DRM_IOCTL_AGP_UNBIND		DRM_IOW( 0x37, struct drm_agp_binding)
 #define DRM_IOCTL_SG_ALLOC		DRM_IOWR(0x38, struct drm_scatter_gather)
 #define DRM_IOCTL_SG_FREE		DRM_IOW( 0x39, struct drm_scatter_gather)
 #define DRM_IOCTL_WAIT_VBLANK		DRM_IOWR(0x3a, union drm_wait_vblank)
 #define DRM_IOCTL_CRTC_GET_SEQUENCE	DRM_IOWR(0x3b, struct drm_crtc_get_sequence)
 #define DRM_IOCTL_CRTC_QUEUE_SEQUENCE	DRM_IOWR(0x3c, struct drm_crtc_queue_sequence)
 #define DRM_IOCTL_UPDATE_DRAW		DRM_IOW(0x3f, struct drm_update_draw)
 #define DRM_IOCTL_MODE_GETRESOURCES	DRM_IOWR(0xA0, struct drm_mode_card_res)
 #define DRM_IOCTL_MODE_GETCRTC		DRM_IOWR(0xA1, struct drm_mode_crtc)
 #define DRM_IOCTL_MODE_SETCRTC		DRM_IOWR(0xA2, struct drm_mode_crtc)
 #define DRM_IOCTL_MODE_CURSOR		DRM_IOWR(0xA3, struct drm_mode_cursor)
 #define DRM_IOCTL_MODE_GETGAMMA		DRM_IOWR(0xA4, struct drm_mode_crtc_lut)
 #define DRM_IOCTL_MODE_SETGAMMA		DRM_IOWR(0xA5, struct drm_mode_crtc_lut)
 #define DRM_IOCTL_MODE_GETENCODER	DRM_IOWR(0xA6, struct drm_mode_get_encoder)
 #define DRM_IOCTL_MODE_GETCONNECTOR	DRM_IOWR(0xA7, struct drm_mode_get_connector)
 #define DRM_IOCTL_MODE_ATTACHMODE	DRM_IOWR(0xA8, struct drm_mode_mode_cmd) /* deprecated (never worked) */
 #define DRM_IOCTL_MODE_DETACHMODE	DRM_IOWR(0xA9, struct drm_mode_mode_cmd) /* deprecated (never worked) */
 @@ -824,26 +868,34 @@ extern "C" {
 #define DRM_IOCTL_MODE_SETPLANE	DRM_IOWR(0xB7, struct drm_mode_set_plane)
 #define DRM_IOCTL_MODE_ADDFB2		DRM_IOWR(0xB8, struct drm_mode_fb_cmd2)
 #define DRM_IOCTL_MODE_OBJ_GETPROPERTIES	DRM_IOWR(0xB9, struct drm_mode_obj_get_properties)
 #define DRM_IOCTL_MODE_OBJ_SETPROPERTY	DRM_IOWR(0xBA, struct drm_mode_obj_set_property)
 #define DRM_IOCTL_MODE_CURSOR2		DRM_IOWR(0xBB, struct drm_mode_cursor2)
 #define DRM_IOCTL_MODE_ATOMIC		DRM_IOWR(0xBC, struct drm_mode_atomic)
 #define DRM_IOCTL_MODE_CREATEPROPBLOB	DRM_IOWR(0xBD, struct drm_mode_create_blob)
 #define DRM_IOCTL_MODE_DESTROYPROPBLOB	DRM_IOWR(0xBE, struct drm_mode_destroy_blob)
 #define DRM_IOCTL_SYNCOBJ_CREATE	DRM_IOWR(0xBF, struct drm_syncobj_create)
 #define DRM_IOCTL_SYNCOBJ_DESTROY	DRM_IOWR(0xC0, struct drm_syncobj_destroy)
 #define DRM_IOCTL_SYNCOBJ_HANDLE_TO_FD	DRM_IOWR(0xC1, struct drm_syncobj_handle)
 #define DRM_IOCTL_SYNCOBJ_FD_TO_HANDLE	DRM_IOWR(0xC2, struct drm_syncobj_handle)
 #define DRM_IOCTL_SYNCOBJ_WAIT		DRM_IOWR(0xC3, struct drm_syncobj_wait)
 #define DRM_IOCTL_SYNCOBJ_RESET		DRM_IOWR(0xC4, struct drm_syncobj_array)
 #define DRM_IOCTL_SYNCOBJ_SIGNAL	DRM_IOWR(0xC5, struct drm_syncobj_array)
 #define DRM_IOCTL_MODE_CREATE_LEASE	DRM_IOWR(0xC6, struct drm_mode_create_lease)
 #define DRM_IOCTL_MODE_LIST_LESSEES	DRM_IOWR(0xC7, struct drm_mode_list_lessees)
 #define DRM_IOCTL_MODE_GET_LEASE	DRM_IOWR(0xC8, struct drm_mode_get_lease)
 #define DRM_IOCTL_MODE_REVOKE_LEASE	DRM_IOWR(0xC9, struct drm_mode_revoke_lease)
 /**
  * Device specific ioctls should only be in their respective headers
  * The device specific ioctl range is from 0x40 to 0x9f.
  * Generic IOCTLS restart at 0xA0.
+ *
  * \sa drmCommandNone(), drmCommandRead(), drmCommandWrite(), and
  * drmCommandReadWrite().
  */
 #define DRM_COMMAND_BASE                0x40
 #define DRM_COMMAND_END			0xA0
 /**
 @@ -855,36 +907,47 @@ extern "C" {
  * events, that is, if for example the read buffer is 100 bytes, and
  * there are two 64 byte events pending, only one will be returned.
+ *
  * Event types 0 - 0x7fffffff are generic drm events, 0x80000000 and
  * up are chipset specific.
  */
 struct drm_event {
 	__u32 type;
 	__u32 length;
 };
 #define DRM_EVENT_VBLANK 0x01
 #define DRM_EVENT_FLIP_COMPLETE 0x02
 #define DRM_EVENT_CRTC_SEQUENCE	0x03
 struct drm_event_vblank {
 	struct drm_event base;
 	__u64 user_data;
 	__u32 tv_sec;
 	__u32 tv_usec;
 	__u32 sequence;
 	__u32 crtc_id; /* 0 on older kernels that do not support this */
 };
 /* Event delivered at sequence. Time stamp marks when the first pixel
  * of the refresh cycle leaves the display engine for the display
  */
 struct drm_event_crtc_sequence {
 	struct drm_event	base;
 	__u64			user_data;
 	__s64			time_ns;
 	__u64			sequence;
 };
 /* typedef area */
 typedef struct drm_clip_rect drm_clip_rect_t;
 typedef struct drm_drawable_info drm_drawable_info_t;
 typedef struct drm_tex_region drm_tex_region_t;
 typedef struct drm_hw_lock drm_hw_lock_t;
 typedef struct drm_version drm_version_t;
 typedef struct drm_unique drm_unique_t;
 typedef struct drm_list drm_list_t;
 typedef struct drm_block drm_block_t;
 typedef struct drm_control drm_control_t;
 typedef enum drm_map_type drm_map_type_t;
 typedef enum drm_map_flags drm_map_flags_t;
 typedef struct drm_ctx_priv_map drm_ctx_priv_map_t;

 @@ -57,27 +57,27 @@
 #ifndef ETIME
 #define ETIME ETIMEDOUT
 #endif
 #include "libdrm_macros.h"
 #include "libdrm_lists.h"
 #include "intel_bufmgr.h"
 #include "intel_bufmgr_priv.h"
 #include "intel_chipset.h"
 #include "string.h"
 #include "i915_drm.h"
 #include "uthash.h"
-#ifdef HAVE_VALGRIND
+#if HAVE_VALGRIND
 #include <valgrind.h>
 #include <memcheck.h>
 #define VG(x) x
 #else
 #define VG(x)
 #endif
 #define memclear(s) memset(&s, 0, sizeof(s))
 #define DBG(...) do {					\
 	if (bufmgr_gem->bufmgr.debug)			\
 		fprintf(stderr, __VA_ARGS__);		\
 } while (0)
 @@ -1618,27 +1618,27 @@ drm_intel_gem_bo_map_gtt(drm_intel_bo *b
  * This is used in the implementation of GL_ARB_map_buffer_range: The
  * user asks to create a buffer, then does a mapping, fills some
  * space, runs a drawing command, then asks to map it again without
  * synchronizing because it guarantees that it won't write over the
  * data that the GPU is busy using (or, more specifically, that if it
  * does write over the data, it acknowledges that rendering is
  * undefined).
  */
 int
 drm_intel_gem_bo_map_unsynchronized(drm_intel_bo *bo)
+{
 	drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
-#ifdef HAVE_VALGRIND
+#if HAVE_VALGRIND
 	drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 #endif
 	int ret;
 	/* If the CPU cache isn't coherent with the GTT, then use a
 	 * regular synchronized mapping.  The problem is that we don't
 	 * track where the buffer was last used on the CPU side in
 	 * terms of drm_intel_bo_map vs drm_intel_gem_bo_map_gtt, so
 	 * we would potentially corrupt the buffer even when the user
 	 * does reasonable things.
 	 */
 	if (!bufmgr_gem->has_llc)
 		return drm_intel_gem_bo_map_gtt(bo);

 @@ -241,26 +241,109 @@ static void dump_blob(struct device *dev
 	blob_data = blob->data;
 	for (i = 0; i < blob->length; i++) {
 		if (i % 16 == 0)
 			printf("\n\t\t\t");
 		printf("%.2hhx", blob_data[i]);
+	}
 	printf("\n");
 	drmModeFreePropertyBlob(blob);
+}
 static const char *modifier_to_string(uint64_t modifier)
+{
 	switch (modifier) {
 	case DRM_FORMAT_MOD_INVALID:
 		return "INVALID";
 	case DRM_FORMAT_MOD_LINEAR:
 		return "LINEAR";
 	case I915_FORMAT_MOD_X_TILED:
 		return "X_TILED";
 	case I915_FORMAT_MOD_Y_TILED:
 		return "Y_TILED";
 	case I915_FORMAT_MOD_Yf_TILED:
 		return "Yf_TILED";
 	case I915_FORMAT_MOD_Y_TILED_CCS:
 		return "Y_TILED_CCS";
 	case I915_FORMAT_MOD_Yf_TILED_CCS:
 		return "Yf_TILED_CCS";
 	case DRM_FORMAT_MOD_SAMSUNG_64_32_TILE:
 		return "SAMSUNG_64_32_TILE";
 	case DRM_FORMAT_MOD_VIVANTE_TILED:
 		return "VIVANTE_TILED";
 	case DRM_FORMAT_MOD_VIVANTE_SUPER_TILED:
 		return "VIVANTE_SUPER_TILED";
 	case DRM_FORMAT_MOD_VIVANTE_SPLIT_TILED:
 		return "VIVANTE_SPLIT_TILED";
 	case DRM_FORMAT_MOD_VIVANTE_SPLIT_SUPER_TILED:
 		return "VIVANTE_SPLIT_SUPER_TILED";
 	case DRM_FORMAT_MOD_NVIDIA_TEGRA_TILED:
 		return "NVIDIA_TEGRA_TILED";
 	case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(0):
 		return "NVIDIA_16BX2_BLOCK(0)";
 	case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(1):
 		return "NVIDIA_16BX2_BLOCK(1)";
 	case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(2):
 		return "NVIDIA_16BX2_BLOCK(2)";
 	case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(3):
 		return "NVIDIA_16BX2_BLOCK(3)";
 	case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(4):
 		return "NVIDIA_16BX2_BLOCK(4)";
 	case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(5):
 		return "NVIDIA_16BX2_BLOCK(5)";
 	case DRM_FORMAT_MOD_BROADCOM_VC4_T_TILED:
 		return "MOD_BROADCOM_VC4_T_TILED";
 	default:
 		return "(UNKNOWN MODIFIER)";
+	}
+}
 static void dump_in_formats(struct device *dev, uint32_t blob_id)
+{
 	uint32_t i, j;
 	drmModePropertyBlobPtr blob;
 	struct drm_format_modifier_blob *header;
 	uint32_t *formats;
 	struct drm_format_modifier *modifiers;
 	printf("\t\tin_formats blob decoded:\n");
 	blob = drmModeGetPropertyBlob(dev->fd, blob_id);
 	if (!blob) {
 		printf("\n");
 		return;
+	}
 	header = blob->data;
 	formats = (uint32_t *) ((char *) header + header->formats_offset);
 	modifiers = (struct drm_format_modifier *)
 		((char *) header + header->modifiers_offset);
 	for (i = 0; i < header->count_formats; i++) {
 		printf("\t\t\t");
 		dump_fourcc(formats[i]);
 		printf(": ");
 		for (j = 0; j < header->count_modifiers; j++) {
 			uint64_t mask = 1ULL << i;
 			if (modifiers[j].formats & mask)
 				printf(" %s", modifier_to_string(modifiers[j].modifier));
+		}
 		printf("\n");
+	}
 	drmModeFreePropertyBlob(blob);
+}
 static void dump_prop(struct device *dev, drmModePropertyPtr prop,
 		      uint32_t prop_id, uint64_t value)
+{
 	int i;
 	printf("\t%d", prop_id);
 	if (!prop) {
 		printf("\n");
 		return;
+	}
 	printf(" %s:\n", prop->name);
 	printf("\t\tflags:");
 @@ -318,26 +401,29 @@ static void dump_prop(struct device *dev
 			dump_blob(dev, prop->blob_ids[i]);
 		printf("\n");
 	} else {
 		assert(prop->count_blobs == 0);
+	}
 	printf("\t\tvalue:");
 	if (drm_property_type_is(prop, DRM_MODE_PROP_BLOB))
 		dump_blob(dev, value);
 	else if (drm_property_type_is(prop, DRM_MODE_PROP_SIGNED_RANGE))
 		printf(" %"PRId64"\n", value);
 	else
 		printf(" %"PRIu64"\n", value);
 	if (strcmp(prop->name, "IN_FORMATS") == 0)
 		dump_in_formats(dev, value);
+}
 static void dump_connectors(struct device *dev)
+{
 	int i, j;
 	printf("Connectors:\n");
 	printf("id\tencoder\tstatus\t\tname\t\tsize (mm)\tmodes\tencoders\n");
 	for (i = 0; i < dev->resources->res->count_connectors; i++) {
 		struct connector *_connector = &dev->resources->connectors[i];
 		drmModeConnector *connector = _connector->connector;
 		if (!connector)
 			continue;
 @@ -562,30 +648,33 @@ static struct resources *get_resources(s
 					strerror(errno));			\
 		}								\
 	} while (0)
 	get_resource(res, res, crtc, Crtc);
 	get_resource(res, res, encoder, Encoder);
 	get_resource(res, res, connector, Connector);
 	get_resource(res, res, fb, FB);
 	/* Set the name of all connectors based on the type name and the per-type ID. */
 	for (i = 0; i < res->res->count_connectors; i++) {
 		struct connector *connector = &res->connectors[i];
 		drmModeConnector *conn = connector->connector;
 		int num;
-		asprintf(&connector->name, "%s-%u",
+		num = asprintf(&connector->name, "%s-%u",
 			 util_lookup_connector_type_name(conn->connector_type),
 			 conn->connector_type_id);
 		if (num < 0)
 			goto error;
+	}
 #define get_properties(_res, __res, type, Type)					\
 	do {									\
 		for (i = 0; i < (int)(_res)->__res->count_##type##s; ++i) {	\
 			struct type *obj = &res->type##s[i];			\
 			unsigned int j;						\
 			obj->props =						\
 				drmModeObjectGetProperties(dev->fd, obj->type->type##_id, \
 							   DRM_MODE_OBJECT_##Type); \
 			if (!obj->props) {					\
 				fprintf(stderr,					\
 					"could not get %s %i properties: %s\n", \
 @@ -997,27 +1086,28 @@ static int set_plane(struct device *dev,
 	plane_id = p->plane_id;
 	for (i = 0; i < dev->resources->plane_res->count_planes; i++) {
 		ovr = dev->resources->planes[i].plane;
 		if (!ovr)
 			continue;
 		if (plane_id && plane_id != ovr->plane_id)
 			continue;
 		if (!format_support(ovr, p->fourcc))
 			continue;
-		if ((ovr->possible_crtcs & (1 << pipe)) && !ovr->crtc_id) {
+		if ((ovr->possible_crtcs & (1 << pipe)) &&
 		    (ovr->crtc_id == 0 || ovr->crtc_id == p->crtc_id)) {
 			plane_id = ovr->plane_id;
 			break;
+		}
+	}
 	if (i == dev->resources->plane_res->count_planes) {
 		fprintf(stderr, "no unused plane available for CRTC %u\n",
 			crtc->crtc->crtc_id);
 		return -1;
+	}
 	fprintf(stderr, "testing %dx%d@%s overlay plane %u\n",
 		p->w, p->h, p->format_str, plane_id);

 @@ -91,27 +91,27 @@ typedef struct {
 typedef struct { volatile LIBDRM_ATOMIC_TYPE atomic; } atomic_t;
 # define atomic_read(x) (int) ((x)->atomic)
 # define atomic_set(x, val) ((x)->atomic = (LIBDRM_ATOMIC_TYPE)(val))
 # define atomic_inc(x) (atomic_inc_uint (&(x)->atomic))
 # define atomic_inc_return(x) (atomic_inc_uint_nv(&(x)->atomic))
 # define atomic_dec_and_test(x) (atomic_dec_uint_nv(&(x)->atomic) == 0)
 # define atomic_add(x, v) (atomic_add_int(&(x)->atomic, (v)))
 # define atomic_dec(x, v) (atomic_add_int(&(x)->atomic, -(v)))
 # define atomic_cmpxchg(x, oldv, newv) atomic_cas_uint (&(x)->atomic, oldv, newv)
 #endif
-#if ! HAS_ATOMIC_OPS
+#if !defined(HAS_ATOMIC_OPS)
 #error libdrm requires atomic operations, please define them for your CPU/compiler.
 #endif
 static inline int atomic_add_unless(atomic_t *v, int add, int unless)
+{
 	int c, old;
 	c = atomic_read(v);
 	while (c != unless && (old = atomic_cmpxchg(v, c, c + add)) != c)
 		c = old;
 	return c == unless;
+}
 #endif