radeon: fix unused-function warning
[glsdk/libdrm.git] / xf86drmMode.c
1 /*
2  * \file xf86drmMode.c
3  * Header for DRM modesetting interface.
4  *
5  * \author Jakob Bornecrantz <wallbraker@gmail.com>
6  *
7  * \par Acknowledgements:
8  * Feb 2007, Dave Airlie <airlied@linux.ie>
9  */
11 /*
12  * Copyright (c) 2007-2008 Tungsten Graphics, Inc., Cedar Park, Texas.
13  * Copyright (c) 2007-2008 Dave Airlie <airlied@linux.ie>
14  * Copyright (c) 2007-2008 Jakob Bornecrantz <wallbraker@gmail.com>
15  *
16  * Permission is hereby granted, free of charge, to any person obtaining a
17  * copy of this software and associated documentation files (the "Software"),
18  * to deal in the Software without restriction, including without limitation
19  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
20  * and/or sell copies of the Software, and to permit persons to whom the
21  * Software is furnished to do so, subject to the following conditions:
22  *
23  * The above copyright notice and this permission notice shall be included in
24  * all copies or substantial portions of the Software.
25  *
26  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
27  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
28  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
29  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
30  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
31  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
32  * IN THE SOFTWARE.
33  *
34  */
36 /*
37  * TODO the types we are after are defined in diffrent headers on diffrent
38  * platforms find which headers to include to get uint32_t
39  */
40 #include <stdint.h>
41 #include <sys/ioctl.h>
42 #include <stdio.h>
44 #include "xf86drmMode.h"
45 #include "xf86drm.h"
46 #include <drm.h>
47 #include <string.h>
48 #include <dirent.h>
49 #include <unistd.h>
50 #include <errno.h>
52 #define U642VOID(x) ((void *)(unsigned long)(x))
53 #define VOID2U64(x) ((uint64_t)(unsigned long)(x))
55 static inline int DRM_IOCTL(int fd, unsigned long cmd, void *arg)
56 {
57         int ret = drmIoctl(fd, cmd, arg);
58         return ret < 0 ? -errno : ret;
59 }
61 /*
62  * Util functions
63  */
65 void* drmAllocCpy(void *array, int count, int entry_size)
66 {
67         char *r;
68         int i;
70         if (!count || !array || !entry_size)
71                 return 0;
73         if (!(r = drmMalloc(count*entry_size)))
74                 return 0;
76         for (i = 0; i < count; i++)
77                 memcpy(r+(entry_size*i), array+(entry_size*i), entry_size);
79         return r;
80 }
82 /*
83  * A couple of free functions.
84  */
86 void drmModeFreeModeInfo(drmModeModeInfoPtr ptr)
87 {
88         if (!ptr)
89                 return;
91         drmFree(ptr);
92 }
94 void drmModeFreeResources(drmModeResPtr ptr)
95 {
96         if (!ptr)
97                 return;
99         drmFree(ptr->fbs);
100         drmFree(ptr->crtcs);
101         drmFree(ptr->connectors);
102         drmFree(ptr->encoders);
103         drmFree(ptr);
107 void drmModeFreeFB(drmModeFBPtr ptr)
109         if (!ptr)
110                 return;
112         /* we might add more frees later. */
113         drmFree(ptr);
116 void drmModeFreeCrtc(drmModeCrtcPtr ptr)
118         if (!ptr)
119                 return;
121         drmFree(ptr);
125 void drmModeFreeConnector(drmModeConnectorPtr ptr)
127         if (!ptr)
128                 return;
130         drmFree(ptr->encoders);
131         drmFree(ptr->prop_values);
132         drmFree(ptr->props);
133         drmFree(ptr->modes);
134         drmFree(ptr);
138 void drmModeFreeEncoder(drmModeEncoderPtr ptr)
140         drmFree(ptr);
143 /*
144  * ModeSetting functions.
145  */
147 drmModeResPtr drmModeGetResources(int fd)
149         struct drm_mode_card_res res, counts;
150         drmModeResPtr r = 0;
152 retry:
153         memset(&res, 0, sizeof(struct drm_mode_card_res));
154         if (drmIoctl(fd, DRM_IOCTL_MODE_GETRESOURCES, &res))
155                 return 0;
157         counts = res;
159         if (res.count_fbs) {
160                 res.fb_id_ptr = VOID2U64(drmMalloc(res.count_fbs*sizeof(uint32_t)));
161                 if (!res.fb_id_ptr)
162                         goto err_allocs;
163         }
164         if (res.count_crtcs) {
165                 res.crtc_id_ptr = VOID2U64(drmMalloc(res.count_crtcs*sizeof(uint32_t)));
166                 if (!res.crtc_id_ptr)
167                         goto err_allocs;
168         }
169         if (res.count_connectors) {
170                 res.connector_id_ptr = VOID2U64(drmMalloc(res.count_connectors*sizeof(uint32_t)));
171                 if (!res.connector_id_ptr)
172                         goto err_allocs;
173         }
174         if (res.count_encoders) {
175                 res.encoder_id_ptr = VOID2U64(drmMalloc(res.count_encoders*sizeof(uint32_t)));
176                 if (!res.encoder_id_ptr)
177                         goto err_allocs;
178         }
180         if (drmIoctl(fd, DRM_IOCTL_MODE_GETRESOURCES, &res))
181                 goto err_allocs;
183         /* The number of available connectors and etc may have changed with a
184          * hotplug event in between the ioctls, in which case the field is
185          * silently ignored by the kernel.
186          */
187         if (counts.count_fbs < res.count_fbs ||
188             counts.count_crtcs < res.count_crtcs ||
189             counts.count_connectors < res.count_connectors ||
190             counts.count_encoders < res.count_encoders)
191         {
192                 drmFree(U642VOID(res.fb_id_ptr));
193                 drmFree(U642VOID(res.crtc_id_ptr));
194                 drmFree(U642VOID(res.connector_id_ptr));
195                 drmFree(U642VOID(res.encoder_id_ptr));
197                 goto retry;
198         }
200         /*
201          * return
202          */
203         if (!(r = drmMalloc(sizeof(*r))))
204                 goto err_allocs;
206         r->min_width     = res.min_width;
207         r->max_width     = res.max_width;
208         r->min_height    = res.min_height;
209         r->max_height    = res.max_height;
210         r->count_fbs     = res.count_fbs;
211         r->count_crtcs   = res.count_crtcs;
212         r->count_connectors = res.count_connectors;
213         r->count_encoders = res.count_encoders;
215         r->fbs        = drmAllocCpy(U642VOID(res.fb_id_ptr), res.count_fbs, sizeof(uint32_t));
216         r->crtcs      = drmAllocCpy(U642VOID(res.crtc_id_ptr), res.count_crtcs, sizeof(uint32_t));
217         r->connectors = drmAllocCpy(U642VOID(res.connector_id_ptr), res.count_connectors, sizeof(uint32_t));
218         r->encoders   = drmAllocCpy(U642VOID(res.encoder_id_ptr), res.count_encoders, sizeof(uint32_t));
219         if ((res.count_fbs && !r->fbs) ||
220             (res.count_crtcs && !r->crtcs) ||
221             (res.count_connectors && !r->connectors) ||
222             (res.count_encoders && !r->encoders))
223         {
224                 drmFree(r->fbs);
225                 drmFree(r->crtcs);
226                 drmFree(r->connectors);
227                 drmFree(r->encoders);
228                 drmFree(r);
229                 r = 0;
230         }
232 err_allocs:
233         drmFree(U642VOID(res.fb_id_ptr));
234         drmFree(U642VOID(res.crtc_id_ptr));
235         drmFree(U642VOID(res.connector_id_ptr));
236         drmFree(U642VOID(res.encoder_id_ptr));
238         return r;
241 int drmModeAddFB(int fd, uint32_t width, uint32_t height, uint8_t depth,
242                  uint8_t bpp, uint32_t pitch, uint32_t bo_handle,
243                  uint32_t *buf_id)
245         struct drm_mode_fb_cmd f;
246         int ret;
248         f.width  = width;
249         f.height = height;
250         f.pitch  = pitch;
251         f.bpp    = bpp;
252         f.depth  = depth;
253         f.handle = bo_handle;
255         if ((ret = DRM_IOCTL(fd, DRM_IOCTL_MODE_ADDFB, &f)))
256                 return ret;
258         *buf_id = f.fb_id;
259         return 0;
262 int drmModeAddFB2(int fd, uint32_t width, uint32_t height,
263                   uint32_t pixel_format, uint32_t bo_handles[4],
264                   uint32_t pitches[4], uint32_t offsets[4],
265                   uint32_t *buf_id, uint32_t flags)
267         struct drm_mode_fb_cmd2 f;
268         int ret;
270         f.width  = width;
271         f.height = height;
272         f.pixel_format = pixel_format;
273         f.flags = flags;
274         memcpy(f.handles, bo_handles, 4 * sizeof(bo_handles[0]));
275         memcpy(f.pitches, pitches, 4 * sizeof(pitches[0]));
276         memcpy(f.offsets, offsets, 4 * sizeof(offsets[0]));
278         if ((ret = DRM_IOCTL(fd, DRM_IOCTL_MODE_ADDFB2, &f)))
279                 return ret;
281         *buf_id = f.fb_id;
282         return 0;
285 int drmModeRmFB(int fd, uint32_t bufferId)
287         return DRM_IOCTL(fd, DRM_IOCTL_MODE_RMFB, &bufferId);
292 drmModeFBPtr drmModeGetFB(int fd, uint32_t buf)
294         struct drm_mode_fb_cmd info;
295         drmModeFBPtr r;
297         info.fb_id = buf;
299         if (drmIoctl(fd, DRM_IOCTL_MODE_GETFB, &info))
300                 return NULL;
302         if (!(r = drmMalloc(sizeof(*r))))
303                 return NULL;
305         r->fb_id = info.fb_id;
306         r->width = info.width;
307         r->height = info.height;
308         r->pitch = info.pitch;
309         r->bpp = info.bpp;
310         r->handle = info.handle;
311         r->depth = info.depth;
313         return r;
316 int drmModeDirtyFB(int fd, uint32_t bufferId,
317                    drmModeClipPtr clips, uint32_t num_clips)
319         struct drm_mode_fb_dirty_cmd dirty = { 0 };
321         dirty.fb_id = bufferId;
322         dirty.clips_ptr = VOID2U64(clips);
323         dirty.num_clips = num_clips;
325         return DRM_IOCTL(fd, DRM_IOCTL_MODE_DIRTYFB, &dirty);
329 /*
330  * Crtc functions
331  */
333 drmModeCrtcPtr drmModeGetCrtc(int fd, uint32_t crtcId)
335         struct drm_mode_crtc crtc;
336         drmModeCrtcPtr r;
338         crtc.crtc_id = crtcId;
340         if (drmIoctl(fd, DRM_IOCTL_MODE_GETCRTC, &crtc))
341                 return 0;
343         /*
344          * return
345          */
347         if (!(r = drmMalloc(sizeof(*r))))
348                 return 0;
350         r->crtc_id         = crtc.crtc_id;
351         r->x               = crtc.x;
352         r->y               = crtc.y;
353         r->mode_valid      = crtc.mode_valid;
354         if (r->mode_valid) {
355                 memcpy(&r->mode, &crtc.mode, sizeof(struct drm_mode_modeinfo));
356                 r->width = crtc.mode.hdisplay;
357                 r->height = crtc.mode.vdisplay;
358         }
359         r->buffer_id       = crtc.fb_id;
360         r->gamma_size      = crtc.gamma_size;
361         return r;
365 int drmModeSetCrtc(int fd, uint32_t crtcId, uint32_t bufferId,
366                    uint32_t x, uint32_t y, uint32_t *connectors, int count,
367                    drmModeModeInfoPtr mode)
369         struct drm_mode_crtc crtc;
371         crtc.x             = x;
372         crtc.y             = y;
373         crtc.crtc_id       = crtcId;
374         crtc.fb_id         = bufferId;
375         crtc.set_connectors_ptr = VOID2U64(connectors);
376         crtc.count_connectors = count;
377         if (mode) {
378           memcpy(&crtc.mode, mode, sizeof(struct drm_mode_modeinfo));
379           crtc.mode_valid = 1;
380         } else
381           crtc.mode_valid = 0;
383         return DRM_IOCTL(fd, DRM_IOCTL_MODE_SETCRTC, &crtc);
386 /*
387  * Cursor manipulation
388  */
390 int drmModeSetCursor(int fd, uint32_t crtcId, uint32_t bo_handle, uint32_t width, uint32_t height)
392         struct drm_mode_cursor arg;
394         arg.flags = DRM_MODE_CURSOR_BO;
395         arg.crtc_id = crtcId;
396         arg.width = width;
397         arg.height = height;
398         arg.handle = bo_handle;
400         return DRM_IOCTL(fd, DRM_IOCTL_MODE_CURSOR, &arg);
403 int drmModeMoveCursor(int fd, uint32_t crtcId, int x, int y)
405         struct drm_mode_cursor arg;
407         arg.flags = DRM_MODE_CURSOR_MOVE;
408         arg.crtc_id = crtcId;
409         arg.x = x;
410         arg.y = y;
412         return DRM_IOCTL(fd, DRM_IOCTL_MODE_CURSOR, &arg);
415 /*
416  * Encoder get
417  */
418 drmModeEncoderPtr drmModeGetEncoder(int fd, uint32_t encoder_id)
420         struct drm_mode_get_encoder enc;
421         drmModeEncoderPtr r = NULL;
423         enc.encoder_id = encoder_id;
424         enc.encoder_type = 0;
425         enc.possible_crtcs = 0;
426         enc.possible_clones = 0;
428         if (drmIoctl(fd, DRM_IOCTL_MODE_GETENCODER, &enc))
429                 return 0;
431         if (!(r = drmMalloc(sizeof(*r))))
432                 return 0;
434         r->encoder_id = enc.encoder_id;
435         r->crtc_id = enc.crtc_id;
436         r->encoder_type = enc.encoder_type;
437         r->possible_crtcs = enc.possible_crtcs;
438         r->possible_clones = enc.possible_clones;
440         return r;
443 /*
444  * Connector manipulation
445  */
447 drmModeConnectorPtr drmModeGetConnector(int fd, uint32_t connector_id)
449         struct drm_mode_get_connector conn, counts;
450         drmModeConnectorPtr r = NULL;
452 retry:
453         memset(&conn, 0, sizeof(struct drm_mode_get_connector));
454         conn.connector_id = connector_id;
456         if (drmIoctl(fd, DRM_IOCTL_MODE_GETCONNECTOR, &conn))
457                 return 0;
459         counts = conn;
461         if (conn.count_props) {
462                 conn.props_ptr = VOID2U64(drmMalloc(conn.count_props*sizeof(uint32_t)));
463                 if (!conn.props_ptr)
464                         goto err_allocs;
465                 conn.prop_values_ptr = VOID2U64(drmMalloc(conn.count_props*sizeof(uint64_t)));
466                 if (!conn.prop_values_ptr)
467                         goto err_allocs;
468         }
470         if (conn.count_modes) {
471                 conn.modes_ptr = VOID2U64(drmMalloc(conn.count_modes*sizeof(struct drm_mode_modeinfo)));
472                 if (!conn.modes_ptr)
473                         goto err_allocs;
474         }
476         if (conn.count_encoders) {
477                 conn.encoders_ptr = VOID2U64(drmMalloc(conn.count_encoders*sizeof(uint32_t)));
478                 if (!conn.encoders_ptr)
479                         goto err_allocs;
480         }
482         if (drmIoctl(fd, DRM_IOCTL_MODE_GETCONNECTOR, &conn))
483                 goto err_allocs;
485         /* The number of available connectors and etc may have changed with a
486          * hotplug event in between the ioctls, in which case the field is
487          * silently ignored by the kernel.
488          */
489         if (counts.count_props < conn.count_props ||
490             counts.count_modes < conn.count_modes ||
491             counts.count_encoders < conn.count_encoders) {
492                 drmFree(U642VOID(conn.props_ptr));
493                 drmFree(U642VOID(conn.prop_values_ptr));
494                 drmFree(U642VOID(conn.modes_ptr));
495                 drmFree(U642VOID(conn.encoders_ptr));
497                 goto retry;
498         }
500         if(!(r = drmMalloc(sizeof(*r)))) {
501                 goto err_allocs;
502         }
504         r->connector_id = conn.connector_id;
505         r->encoder_id = conn.encoder_id;
506         r->connection   = conn.connection;
507         r->mmWidth      = conn.mm_width;
508         r->mmHeight     = conn.mm_height;
509         /* convert subpixel from kernel to userspace */
510         r->subpixel     = conn.subpixel + 1;
511         r->count_modes  = conn.count_modes;
512         r->count_props  = conn.count_props;
513         r->props        = drmAllocCpy(U642VOID(conn.props_ptr), conn.count_props, sizeof(uint32_t));
514         r->prop_values  = drmAllocCpy(U642VOID(conn.prop_values_ptr), conn.count_props, sizeof(uint64_t));
515         r->modes        = drmAllocCpy(U642VOID(conn.modes_ptr), conn.count_modes, sizeof(struct drm_mode_modeinfo));
516         r->count_encoders = conn.count_encoders;
517         r->encoders     = drmAllocCpy(U642VOID(conn.encoders_ptr), conn.count_encoders, sizeof(uint32_t));
518         r->connector_type  = conn.connector_type;
519         r->connector_type_id = conn.connector_type_id;
521         if ((r->count_props && !r->props) ||
522             (r->count_props && !r->prop_values) ||
523             (r->count_modes && !r->modes) ||
524             (r->count_encoders && !r->encoders)) {
525                 drmFree(r->props);
526                 drmFree(r->prop_values);
527                 drmFree(r->modes);
528                 drmFree(r->encoders);
529                 drmFree(r);
530                 r = 0;
531         }
533 err_allocs:
534         drmFree(U642VOID(conn.prop_values_ptr));
535         drmFree(U642VOID(conn.props_ptr));
536         drmFree(U642VOID(conn.modes_ptr));
537         drmFree(U642VOID(conn.encoders_ptr));
539         return r;
542 int drmModeAttachMode(int fd, uint32_t connector_id, drmModeModeInfoPtr mode_info)
544         struct drm_mode_mode_cmd res;
546         memcpy(&res.mode, mode_info, sizeof(struct drm_mode_modeinfo));
547         res.connector_id = connector_id;
549         return DRM_IOCTL(fd, DRM_IOCTL_MODE_ATTACHMODE, &res);
552 int drmModeDetachMode(int fd, uint32_t connector_id, drmModeModeInfoPtr mode_info)
554         struct drm_mode_mode_cmd res;
556         memcpy(&res.mode, mode_info, sizeof(struct drm_mode_modeinfo));
557         res.connector_id = connector_id;
559         return DRM_IOCTL(fd, DRM_IOCTL_MODE_DETACHMODE, &res);
563 drmModePropertyPtr drmModeGetProperty(int fd, uint32_t property_id)
565         struct drm_mode_get_property prop;
566         drmModePropertyPtr r;
568         prop.prop_id = property_id;
569         prop.count_enum_blobs = 0;
570         prop.count_values = 0;
571         prop.flags = 0;
572         prop.enum_blob_ptr = 0;
573         prop.values_ptr = 0;
575         if (drmIoctl(fd, DRM_IOCTL_MODE_GETPROPERTY, &prop))
576                 return 0;
578         if (prop.count_values)
579                 prop.values_ptr = VOID2U64(drmMalloc(prop.count_values * sizeof(uint64_t)));
581         if (prop.count_enum_blobs && (prop.flags & (DRM_MODE_PROP_ENUM | DRM_MODE_PROP_BITMASK)))
582                 prop.enum_blob_ptr = VOID2U64(drmMalloc(prop.count_enum_blobs * sizeof(struct drm_mode_property_enum)));
584         if (prop.count_enum_blobs && (prop.flags & DRM_MODE_PROP_BLOB)) {
585                 prop.values_ptr = VOID2U64(drmMalloc(prop.count_enum_blobs * sizeof(uint32_t)));
586                 prop.enum_blob_ptr = VOID2U64(drmMalloc(prop.count_enum_blobs * sizeof(uint32_t)));
587         }
589         if (drmIoctl(fd, DRM_IOCTL_MODE_GETPROPERTY, &prop)) {
590                 r = NULL;
591                 goto err_allocs;
592         }
594         if (!(r = drmMalloc(sizeof(*r))))
595                 return NULL;
597         r->prop_id = prop.prop_id;
598         r->count_values = prop.count_values;
600         r->flags = prop.flags;
601         if (prop.count_values)
602                 r->values = drmAllocCpy(U642VOID(prop.values_ptr), prop.count_values, sizeof(uint64_t));
603         if (prop.flags & (DRM_MODE_PROP_ENUM | DRM_MODE_PROP_BITMASK)) {
604                 r->count_enums = prop.count_enum_blobs;
605                 r->enums = drmAllocCpy(U642VOID(prop.enum_blob_ptr), prop.count_enum_blobs, sizeof(struct drm_mode_property_enum));
606         } else if (prop.flags & DRM_MODE_PROP_BLOB) {
607                 r->values = drmAllocCpy(U642VOID(prop.values_ptr), prop.count_enum_blobs, sizeof(uint32_t));
608                 r->blob_ids = drmAllocCpy(U642VOID(prop.enum_blob_ptr), prop.count_enum_blobs, sizeof(uint32_t));
609                 r->count_blobs = prop.count_enum_blobs;
610         }
611         strncpy(r->name, prop.name, DRM_PROP_NAME_LEN);
612         r->name[DRM_PROP_NAME_LEN-1] = 0;
614 err_allocs:
615         drmFree(U642VOID(prop.values_ptr));
616         drmFree(U642VOID(prop.enum_blob_ptr));
618         return r;
621 void drmModeFreeProperty(drmModePropertyPtr ptr)
623         if (!ptr)
624                 return;
626         drmFree(ptr->values);
627         drmFree(ptr->enums);
628         drmFree(ptr);
631 drmModePropertyBlobPtr drmModeGetPropertyBlob(int fd, uint32_t blob_id)
633         struct drm_mode_get_blob blob;
634         drmModePropertyBlobPtr r;
636         blob.length = 0;
637         blob.data = 0;
638         blob.blob_id = blob_id;
640         if (drmIoctl(fd, DRM_IOCTL_MODE_GETPROPBLOB, &blob))
641                 return NULL;
643         if (blob.length)
644                 blob.data = VOID2U64(drmMalloc(blob.length));
646         if (drmIoctl(fd, DRM_IOCTL_MODE_GETPROPBLOB, &blob)) {
647                 r = NULL;
648                 goto err_allocs;
649         }
651         if (!(r = drmMalloc(sizeof(*r))))
652                 goto err_allocs;
654         r->id = blob.blob_id;
655         r->length = blob.length;
656         r->data = drmAllocCpy(U642VOID(blob.data), 1, blob.length);
658 err_allocs:
659         drmFree(U642VOID(blob.data));
660         return r;
663 void drmModeFreePropertyBlob(drmModePropertyBlobPtr ptr)
665         if (!ptr)
666                 return;
668         drmFree(ptr->data);
669         drmFree(ptr);
672 int drmModeConnectorSetProperty(int fd, uint32_t connector_id, uint32_t property_id,
673                              uint64_t value)
675         struct drm_mode_connector_set_property osp;
677         osp.connector_id = connector_id;
678         osp.prop_id = property_id;
679         osp.value = value;
681         return DRM_IOCTL(fd, DRM_IOCTL_MODE_SETPROPERTY, &osp);
684 /*
685  * checks if a modesetting capable driver has attached to the pci id
686  * returns 0 if modesetting supported.
687  *  -EINVAL or invalid bus id
688  *  -ENOSYS if no modesetting support
689 */
690 int drmCheckModesettingSupported(const char *busid)
692 #ifdef __linux__
693         char pci_dev_dir[1024];
694         int domain, bus, dev, func;
695         DIR *sysdir;
696         struct dirent *dent;
697         int found = 0, ret;
699         ret = sscanf(busid, "pci:%04x:%02x:%02x.%d", &domain, &bus, &dev, &func);
700         if (ret != 4)
701                 return -EINVAL;
703         sprintf(pci_dev_dir, "/sys/bus/pci/devices/%04x:%02x:%02x.%d/drm",
704                 domain, bus, dev, func);
706         sysdir = opendir(pci_dev_dir);
707         if (sysdir) {
708                 dent = readdir(sysdir);
709                 while (dent) {
710                         if (!strncmp(dent->d_name, "controlD", 8)) {
711                                 found = 1;
712                                 break;
713                         }
715                         dent = readdir(sysdir);
716                 }
717                 closedir(sysdir);
718                 if (found)
719                         return 0;
720         }
722         sprintf(pci_dev_dir, "/sys/bus/pci/devices/%04x:%02x:%02x.%d/",
723                 domain, bus, dev, func);
725         sysdir = opendir(pci_dev_dir);
726         if (!sysdir)
727                 return -EINVAL;
729         dent = readdir(sysdir);
730         while (dent) {
731                 if (!strncmp(dent->d_name, "drm:controlD", 12)) {
732                         found = 1;
733                         break;
734                 }
736                 dent = readdir(sysdir);
737         }
739         closedir(sysdir);
740         if (found)
741                 return 0;
742 #endif
743         return -ENOSYS;
747 int drmModeCrtcGetGamma(int fd, uint32_t crtc_id, uint32_t size,
748                         uint16_t *red, uint16_t *green, uint16_t *blue)
750         struct drm_mode_crtc_lut l;
752         l.crtc_id = crtc_id;
753         l.gamma_size = size;
754         l.red = VOID2U64(red);
755         l.green = VOID2U64(green);
756         l.blue = VOID2U64(blue);
758         return DRM_IOCTL(fd, DRM_IOCTL_MODE_GETGAMMA, &l);
761 int drmModeCrtcSetGamma(int fd, uint32_t crtc_id, uint32_t size,
762                         uint16_t *red, uint16_t *green, uint16_t *blue)
764         struct drm_mode_crtc_lut l;
766         l.crtc_id = crtc_id;
767         l.gamma_size = size;
768         l.red = VOID2U64(red);
769         l.green = VOID2U64(green);
770         l.blue = VOID2U64(blue);
772         return DRM_IOCTL(fd, DRM_IOCTL_MODE_SETGAMMA, &l);
775 int drmHandleEvent(int fd, drmEventContextPtr evctx)
777         char buffer[1024];
778         int len, i;
779         struct drm_event *e;
780         struct drm_event_vblank *vblank;
781         
782         /* The DRM read semantics guarantees that we always get only
783          * complete events. */
785         len = read(fd, buffer, sizeof buffer);
786         if (len == 0)
787                 return 0;
788         if (len < sizeof *e)
789                 return -1;
791         i = 0;
792         while (i < len) {
793                 e = (struct drm_event *) &buffer[i];
794                 switch (e->type) {
795                 case DRM_EVENT_VBLANK:
796                         if (evctx->version < 1 ||
797                             evctx->vblank_handler == NULL)
798                                 break;
799                         vblank = (struct drm_event_vblank *) e;
800                         evctx->vblank_handler(fd,
801                                               vblank->sequence, 
802                                               vblank->tv_sec,
803                                               vblank->tv_usec,
804                                               U642VOID (vblank->user_data));
805                         break;
806                 case DRM_EVENT_FLIP_COMPLETE:
807                         if (evctx->version < 2 ||
808                             evctx->page_flip_handler == NULL)
809                                 break;
810                         vblank = (struct drm_event_vblank *) e;
811                         evctx->page_flip_handler(fd,
812                                                  vblank->sequence,
813                                                  vblank->tv_sec,
814                                                  vblank->tv_usec,
815                                                  U642VOID (vblank->user_data));
816                         break;
817                 default:
818                         break;
819                 }
820                 i += e->length;
821         }
823         return 0;
826 int drmModePageFlip(int fd, uint32_t crtc_id, uint32_t fb_id,
827                     uint32_t flags, void *user_data)
829         struct drm_mode_crtc_page_flip flip;
831         flip.fb_id = fb_id;
832         flip.crtc_id = crtc_id;
833         flip.user_data = VOID2U64(user_data);
834         flip.flags = flags;
835         flip.reserved = 0;
837         return DRM_IOCTL(fd, DRM_IOCTL_MODE_PAGE_FLIP, &flip);
840 int drmModeSetPlane(int fd, uint32_t plane_id, uint32_t crtc_id,
841                     uint32_t fb_id, uint32_t flags,
842                     uint32_t crtc_x, uint32_t crtc_y,
843                     uint32_t crtc_w, uint32_t crtc_h,
844                     uint32_t src_x, uint32_t src_y,
845                     uint32_t src_w, uint32_t src_h)
848         struct drm_mode_set_plane s;
850         s.plane_id = plane_id;
851         s.crtc_id = crtc_id;
852         s.fb_id = fb_id;
853         s.flags = flags;
854         s.crtc_x = crtc_x;
855         s.crtc_y = crtc_y;
856         s.crtc_w = crtc_w;
857         s.crtc_h = crtc_h;
858         s.src_x = src_x;
859         s.src_y = src_y;
860         s.src_w = src_w;
861         s.src_h = src_h;
863         return DRM_IOCTL(fd, DRM_IOCTL_MODE_SETPLANE, &s);
867 drmModePlanePtr drmModeGetPlane(int fd, uint32_t plane_id)
869         struct drm_mode_get_plane ovr, counts;
870         drmModePlanePtr r = 0;
872 retry:
873         memset(&ovr, 0, sizeof(struct drm_mode_get_plane));
874         ovr.plane_id = plane_id;
875         if (drmIoctl(fd, DRM_IOCTL_MODE_GETPLANE, &ovr))
876                 return 0;
878         counts = ovr;
880         if (ovr.count_format_types) {
881                 ovr.format_type_ptr = VOID2U64(drmMalloc(ovr.count_format_types *
882                                                          sizeof(uint32_t)));
883                 if (!ovr.format_type_ptr)
884                         goto err_allocs;
885         }
887         if (drmIoctl(fd, DRM_IOCTL_MODE_GETPLANE, &ovr))
888                 goto err_allocs;
890         if (counts.count_format_types < ovr.count_format_types) {
891                 drmFree(U642VOID(ovr.format_type_ptr));
892                 goto retry;
893         }
895         if (!(r = drmMalloc(sizeof(*r))))
896                 goto err_allocs;
898         r->count_formats = ovr.count_format_types;
899         r->plane_id = ovr.plane_id;
900         r->crtc_id = ovr.crtc_id;
901         r->fb_id = ovr.fb_id;
902         r->possible_crtcs = ovr.possible_crtcs;
903         r->gamma_size = ovr.gamma_size;
904         r->formats = drmAllocCpy(U642VOID(ovr.format_type_ptr),
905                                  ovr.count_format_types, sizeof(uint32_t));
906         if (ovr.count_format_types && !r->formats) {
907                 drmFree(r->formats);
908                 drmFree(r);
909                 r = 0;
910         }
912 err_allocs:
913         drmFree(U642VOID(ovr.format_type_ptr));
915         return r;
918 void drmModeFreePlane(drmModePlanePtr ptr)
920         if (!ptr)
921                 return;
923         drmFree(ptr->formats);
924         drmFree(ptr);
927 drmModePlaneResPtr drmModeGetPlaneResources(int fd)
929         struct drm_mode_get_plane_res res, counts;
930         drmModePlaneResPtr r = 0;
932 retry:
933         memset(&res, 0, sizeof(struct drm_mode_get_plane_res));
934         if (drmIoctl(fd, DRM_IOCTL_MODE_GETPLANERESOURCES, &res))
935                 return 0;
937         counts = res;
939         if (res.count_planes) {
940                 res.plane_id_ptr = VOID2U64(drmMalloc(res.count_planes *
941                                                         sizeof(uint32_t)));
942                 if (!res.plane_id_ptr)
943                         goto err_allocs;
944         }
946         if (drmIoctl(fd, DRM_IOCTL_MODE_GETPLANERESOURCES, &res))
947                 goto err_allocs;
949         if (counts.count_planes < res.count_planes) {
950                 drmFree(U642VOID(res.plane_id_ptr));
951                 goto retry;
952         }
954         if (!(r = drmMalloc(sizeof(*r))))
955                 goto err_allocs;
957         r->count_planes = res.count_planes;
958         r->planes = drmAllocCpy(U642VOID(res.plane_id_ptr),
959                                   res.count_planes, sizeof(uint32_t));
960         if (res.count_planes && !r->planes) {
961                 drmFree(r->planes);
962                 drmFree(r);
963                 r = 0;
964         }
966 err_allocs:
967         drmFree(U642VOID(res.plane_id_ptr));
969         return r;
972 void drmModeFreePlaneResources(drmModePlaneResPtr ptr)
974         if (!ptr)
975                 return;
977         drmFree(ptr->planes);
978         drmFree(ptr);
981 drmModeObjectPropertiesPtr drmModeObjectGetProperties(int fd,
982                                                       uint32_t object_id,
983                                                       uint32_t object_type)
985         struct drm_mode_obj_get_properties properties;
986         drmModeObjectPropertiesPtr ret = NULL;
987         uint32_t count;
989 retry:
990         memset(&properties, 0, sizeof(struct drm_mode_obj_get_properties));
991         properties.obj_id = object_id;
992         properties.obj_type = object_type;
994         if (drmIoctl(fd, DRM_IOCTL_MODE_OBJ_GETPROPERTIES, &properties))
995                 return 0;
997         count = properties.count_props;
999         if (count) {
1000                 properties.props_ptr = VOID2U64(drmMalloc(count *
1001                                                           sizeof(uint32_t)));
1002                 if (!properties.props_ptr)
1003                         goto err_allocs;
1004                 properties.prop_values_ptr = VOID2U64(drmMalloc(count *
1005                                                       sizeof(uint64_t)));
1006                 if (!properties.prop_values_ptr)
1007                         goto err_allocs;
1008         }
1010         if (drmIoctl(fd, DRM_IOCTL_MODE_OBJ_GETPROPERTIES, &properties))
1011                 goto err_allocs;
1013         if (count < properties.count_props) {
1014                 drmFree(U642VOID(properties.props_ptr));
1015                 drmFree(U642VOID(properties.prop_values_ptr));
1016                 goto retry;
1017         }
1018         count = properties.count_props;
1020         ret = drmMalloc(sizeof(*ret));
1021         if (!ret)
1022                 goto err_allocs;
1024         ret->count_props = count;
1025         ret->props = drmAllocCpy(U642VOID(properties.props_ptr),
1026                                  count, sizeof(uint32_t));
1027         ret->prop_values = drmAllocCpy(U642VOID(properties.prop_values_ptr),
1028                                        count, sizeof(uint64_t));
1029         if (ret->count_props && (!ret->props || !ret->prop_values)) {
1030                 drmFree(ret->props);
1031                 drmFree(ret->prop_values);
1032                 drmFree(ret);
1033                 ret = NULL;
1034         }
1036 err_allocs:
1037         drmFree(U642VOID(properties.props_ptr));
1038         drmFree(U642VOID(properties.prop_values_ptr));
1039         return ret;
1042 void drmModeFreeObjectProperties(drmModeObjectPropertiesPtr ptr)
1044         if (!ptr)
1045                 return;
1046         drmFree(ptr->props);
1047         drmFree(ptr->prop_values);
1048         drmFree(ptr);
1051 int drmModeObjectSetProperty(int fd, uint32_t object_id, uint32_t object_type,
1052                              uint32_t property_id, uint64_t value)
1054         struct drm_mode_obj_set_property prop;
1056         prop.value = value;
1057         prop.prop_id = property_id;
1058         prop.obj_id = object_id;
1059         prop.obj_type = object_type;
1061         return DRM_IOCTL(fd, DRM_IOCTL_MODE_OBJ_SETPROPERTY, &prop);