xf86drmMode.c revision d2d361cddd2bdf8f1bf627b9ebe8ca802156f8af
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 */ 10 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 */ 35 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 41#ifdef HAVE_CONFIG_H 42#include "config.h" 43#endif 44 45#include <limits.h> 46#include <stdint.h> 47#include <stdlib.h> 48#include <sys/ioctl.h> 49#ifdef HAVE_SYS_SYSCTL_H 50#include <sys/sysctl.h> 51#endif 52#include <stdio.h> 53#include <stdbool.h> 54 55#include "xf86drmMode.h" 56#include "xf86drm.h" 57#include <drm.h> 58#include <string.h> 59#include <dirent.h> 60#include <unistd.h> 61#include <errno.h> 62 63#define memclear(s) memset(&s, 0, sizeof(s)) 64 65#define U642VOID(x) ((void *)(unsigned long)(x)) 66#define VOID2U64(x) ((uint64_t)(unsigned long)(x)) 67 68static inline int DRM_IOCTL(int fd, unsigned long cmd, void *arg) 69{ 70 int ret = drmIoctl(fd, cmd, arg); 71 return ret < 0 ? -errno : ret; 72} 73 74/* 75 * Util functions 76 */ 77 78static void* drmAllocCpy(char *array, int count, int entry_size) 79{ 80 char *r; 81 int i; 82 83 if (!count || !array || !entry_size) 84 return 0; 85 86 if (!(r = drmMalloc(count*entry_size))) 87 return 0; 88 89 for (i = 0; i < count; i++) 90 memcpy(r+(entry_size*i), array+(entry_size*i), entry_size); 91 92 return r; 93} 94 95/* 96 * A couple of free functions. 97 */ 98 99void drmModeFreeModeInfo(drmModeModeInfoPtr ptr) 100{ 101 if (!ptr) 102 return; 103 104 drmFree(ptr); 105} 106 107void drmModeFreeResources(drmModeResPtr ptr) 108{ 109 if (!ptr) 110 return; 111 112 drmFree(ptr->fbs); 113 drmFree(ptr->crtcs); 114 drmFree(ptr->connectors); 115 drmFree(ptr->encoders); 116 drmFree(ptr); 117} 118 119void drmModeFreeFB(drmModeFBPtr ptr) 120{ 121 if (!ptr) 122 return; 123 124 /* we might add more frees later. */ 125 drmFree(ptr); 126} 127 128void drmModeFreeCrtc(drmModeCrtcPtr ptr) 129{ 130 if (!ptr) 131 return; 132 133 drmFree(ptr); 134} 135 136void drmModeFreeConnector(drmModeConnectorPtr ptr) 137{ 138 if (!ptr) 139 return; 140 141 drmFree(ptr->encoders); 142 drmFree(ptr->prop_values); 143 drmFree(ptr->props); 144 drmFree(ptr->modes); 145 drmFree(ptr); 146} 147 148void drmModeFreeEncoder(drmModeEncoderPtr ptr) 149{ 150 drmFree(ptr); 151} 152 153/* 154 * ModeSetting functions. 155 */ 156 157drmModeResPtr drmModeGetResources(int fd) 158{ 159 struct drm_mode_card_res res, counts; 160 drmModeResPtr r = 0; 161 162retry: 163 memclear(res); 164 if (drmIoctl(fd, DRM_IOCTL_MODE_GETRESOURCES, &res)) 165 return 0; 166 167 counts = res; 168 169 if (res.count_fbs) { 170 res.fb_id_ptr = VOID2U64(drmMalloc(res.count_fbs*sizeof(uint32_t))); 171 if (!res.fb_id_ptr) 172 goto err_allocs; 173 } 174 if (res.count_crtcs) { 175 res.crtc_id_ptr = VOID2U64(drmMalloc(res.count_crtcs*sizeof(uint32_t))); 176 if (!res.crtc_id_ptr) 177 goto err_allocs; 178 } 179 if (res.count_connectors) { 180 res.connector_id_ptr = VOID2U64(drmMalloc(res.count_connectors*sizeof(uint32_t))); 181 if (!res.connector_id_ptr) 182 goto err_allocs; 183 } 184 if (res.count_encoders) { 185 res.encoder_id_ptr = VOID2U64(drmMalloc(res.count_encoders*sizeof(uint32_t))); 186 if (!res.encoder_id_ptr) 187 goto err_allocs; 188 } 189 190 if (drmIoctl(fd, DRM_IOCTL_MODE_GETRESOURCES, &res)) 191 goto err_allocs; 192 193 /* The number of available connectors and etc may have changed with a 194 * hotplug event in between the ioctls, in which case the field is 195 * silently ignored by the kernel. 196 */ 197 if (counts.count_fbs < res.count_fbs || 198 counts.count_crtcs < res.count_crtcs || 199 counts.count_connectors < res.count_connectors || 200 counts.count_encoders < res.count_encoders) 201 { 202 drmFree(U642VOID(res.fb_id_ptr)); 203 drmFree(U642VOID(res.crtc_id_ptr)); 204 drmFree(U642VOID(res.connector_id_ptr)); 205 drmFree(U642VOID(res.encoder_id_ptr)); 206 207 goto retry; 208 } 209 210 /* 211 * return 212 */ 213 if (!(r = drmMalloc(sizeof(*r)))) 214 goto err_allocs; 215 216 r->min_width = res.min_width; 217 r->max_width = res.max_width; 218 r->min_height = res.min_height; 219 r->max_height = res.max_height; 220 r->count_fbs = res.count_fbs; 221 r->count_crtcs = res.count_crtcs; 222 r->count_connectors = res.count_connectors; 223 r->count_encoders = res.count_encoders; 224 225 r->fbs = drmAllocCpy(U642VOID(res.fb_id_ptr), res.count_fbs, sizeof(uint32_t)); 226 r->crtcs = drmAllocCpy(U642VOID(res.crtc_id_ptr), res.count_crtcs, sizeof(uint32_t)); 227 r->connectors = drmAllocCpy(U642VOID(res.connector_id_ptr), res.count_connectors, sizeof(uint32_t)); 228 r->encoders = drmAllocCpy(U642VOID(res.encoder_id_ptr), res.count_encoders, sizeof(uint32_t)); 229 if ((res.count_fbs && !r->fbs) || 230 (res.count_crtcs && !r->crtcs) || 231 (res.count_connectors && !r->connectors) || 232 (res.count_encoders && !r->encoders)) 233 { 234 drmFree(r->fbs); 235 drmFree(r->crtcs); 236 drmFree(r->connectors); 237 drmFree(r->encoders); 238 drmFree(r); 239 r = 0; 240 } 241 242err_allocs: 243 drmFree(U642VOID(res.fb_id_ptr)); 244 drmFree(U642VOID(res.crtc_id_ptr)); 245 drmFree(U642VOID(res.connector_id_ptr)); 246 drmFree(U642VOID(res.encoder_id_ptr)); 247 248 return r; 249} 250 251int drmModeAddFB(int fd, uint32_t width, uint32_t height, uint8_t depth, 252 uint8_t bpp, uint32_t pitch, uint32_t bo_handle, 253 uint32_t *buf_id) 254{ 255 struct drm_mode_fb_cmd f; 256 int ret; 257 258 memclear(f); 259 f.width = width; 260 f.height = height; 261 f.pitch = pitch; 262 f.bpp = bpp; 263 f.depth = depth; 264 f.handle = bo_handle; 265 266 if ((ret = DRM_IOCTL(fd, DRM_IOCTL_MODE_ADDFB, &f))) 267 return ret; 268 269 *buf_id = f.fb_id; 270 return 0; 271} 272 273int drmModeAddFB2(int fd, uint32_t width, uint32_t height, 274 uint32_t pixel_format, uint32_t bo_handles[4], 275 uint32_t pitches[4], uint32_t offsets[4], 276 uint32_t *buf_id, uint32_t flags) 277{ 278 struct drm_mode_fb_cmd2 f; 279 int ret; 280 281 memclear(f); 282 f.width = width; 283 f.height = height; 284 f.pixel_format = pixel_format; 285 f.flags = flags; 286 memcpy(f.handles, bo_handles, 4 * sizeof(bo_handles[0])); 287 memcpy(f.pitches, pitches, 4 * sizeof(pitches[0])); 288 memcpy(f.offsets, offsets, 4 * sizeof(offsets[0])); 289 290 if ((ret = DRM_IOCTL(fd, DRM_IOCTL_MODE_ADDFB2, &f))) 291 return ret; 292 293 *buf_id = f.fb_id; 294 return 0; 295} 296 297int drmModeRmFB(int fd, uint32_t bufferId) 298{ 299 return DRM_IOCTL(fd, DRM_IOCTL_MODE_RMFB, &bufferId); 300} 301 302drmModeFBPtr drmModeGetFB(int fd, uint32_t buf) 303{ 304 struct drm_mode_fb_cmd info; 305 drmModeFBPtr r; 306 307 memclear(info); 308 info.fb_id = buf; 309 310 if (drmIoctl(fd, DRM_IOCTL_MODE_GETFB, &info)) 311 return NULL; 312 313 if (!(r = drmMalloc(sizeof(*r)))) 314 return NULL; 315 316 r->fb_id = info.fb_id; 317 r->width = info.width; 318 r->height = info.height; 319 r->pitch = info.pitch; 320 r->bpp = info.bpp; 321 r->handle = info.handle; 322 r->depth = info.depth; 323 324 return r; 325} 326 327int drmModeDirtyFB(int fd, uint32_t bufferId, 328 drmModeClipPtr clips, uint32_t num_clips) 329{ 330 struct drm_mode_fb_dirty_cmd dirty; 331 332 memclear(dirty); 333 dirty.fb_id = bufferId; 334 dirty.clips_ptr = VOID2U64(clips); 335 dirty.num_clips = num_clips; 336 337 return DRM_IOCTL(fd, DRM_IOCTL_MODE_DIRTYFB, &dirty); 338} 339 340/* 341 * Crtc functions 342 */ 343 344drmModeCrtcPtr drmModeGetCrtc(int fd, uint32_t crtcId) 345{ 346 struct drm_mode_crtc crtc; 347 drmModeCrtcPtr r; 348 349 memclear(crtc); 350 crtc.crtc_id = crtcId; 351 352 if (drmIoctl(fd, DRM_IOCTL_MODE_GETCRTC, &crtc)) 353 return 0; 354 355 /* 356 * return 357 */ 358 359 if (!(r = drmMalloc(sizeof(*r)))) 360 return 0; 361 362 r->crtc_id = crtc.crtc_id; 363 r->x = crtc.x; 364 r->y = crtc.y; 365 r->mode_valid = crtc.mode_valid; 366 if (r->mode_valid) { 367 memcpy(&r->mode, &crtc.mode, sizeof(struct drm_mode_modeinfo)); 368 r->width = crtc.mode.hdisplay; 369 r->height = crtc.mode.vdisplay; 370 } 371 r->buffer_id = crtc.fb_id; 372 r->gamma_size = crtc.gamma_size; 373 return r; 374} 375 376int drmModeSetCrtc(int fd, uint32_t crtcId, uint32_t bufferId, 377 uint32_t x, uint32_t y, uint32_t *connectors, int count, 378 drmModeModeInfoPtr mode) 379{ 380 struct drm_mode_crtc crtc; 381 382 memclear(crtc); 383 crtc.x = x; 384 crtc.y = y; 385 crtc.crtc_id = crtcId; 386 crtc.fb_id = bufferId; 387 crtc.set_connectors_ptr = VOID2U64(connectors); 388 crtc.count_connectors = count; 389 if (mode) { 390 memcpy(&crtc.mode, mode, sizeof(struct drm_mode_modeinfo)); 391 crtc.mode_valid = 1; 392 } 393 394 return DRM_IOCTL(fd, DRM_IOCTL_MODE_SETCRTC, &crtc); 395} 396 397/* 398 * Cursor manipulation 399 */ 400 401int drmModeSetCursor(int fd, uint32_t crtcId, uint32_t bo_handle, uint32_t width, uint32_t height) 402{ 403 struct drm_mode_cursor arg; 404 405 memclear(arg); 406 arg.flags = DRM_MODE_CURSOR_BO; 407 arg.crtc_id = crtcId; 408 arg.width = width; 409 arg.height = height; 410 arg.handle = bo_handle; 411 412 return DRM_IOCTL(fd, DRM_IOCTL_MODE_CURSOR, &arg); 413} 414 415int drmModeSetCursor2(int fd, uint32_t crtcId, uint32_t bo_handle, uint32_t width, uint32_t height, int32_t hot_x, int32_t hot_y) 416{ 417 struct drm_mode_cursor2 arg; 418 419 memclear(arg); 420 arg.flags = DRM_MODE_CURSOR_BO; 421 arg.crtc_id = crtcId; 422 arg.width = width; 423 arg.height = height; 424 arg.handle = bo_handle; 425 arg.hot_x = hot_x; 426 arg.hot_y = hot_y; 427 428 return DRM_IOCTL(fd, DRM_IOCTL_MODE_CURSOR2, &arg); 429} 430 431int drmModeMoveCursor(int fd, uint32_t crtcId, int x, int y) 432{ 433 struct drm_mode_cursor arg; 434 435 memclear(arg); 436 arg.flags = DRM_MODE_CURSOR_MOVE; 437 arg.crtc_id = crtcId; 438 arg.x = x; 439 arg.y = y; 440 441 return DRM_IOCTL(fd, DRM_IOCTL_MODE_CURSOR, &arg); 442} 443 444/* 445 * Encoder get 446 */ 447drmModeEncoderPtr drmModeGetEncoder(int fd, uint32_t encoder_id) 448{ 449 struct drm_mode_get_encoder enc; 450 drmModeEncoderPtr r = NULL; 451 452 memclear(enc); 453 enc.encoder_id = encoder_id; 454 455 if (drmIoctl(fd, DRM_IOCTL_MODE_GETENCODER, &enc)) 456 return 0; 457 458 if (!(r = drmMalloc(sizeof(*r)))) 459 return 0; 460 461 r->encoder_id = enc.encoder_id; 462 r->crtc_id = enc.crtc_id; 463 r->encoder_type = enc.encoder_type; 464 r->possible_crtcs = enc.possible_crtcs; 465 r->possible_clones = enc.possible_clones; 466 467 return r; 468} 469 470/* 471 * Connector manipulation 472 */ 473static drmModeConnectorPtr 474_drmModeGetConnector(int fd, uint32_t connector_id, int probe) 475{ 476 struct drm_mode_get_connector conn, counts; 477 drmModeConnectorPtr r = NULL; 478 479 memclear(conn); 480 conn.connector_id = connector_id; 481 if (!probe) { 482 conn.count_modes = 1; 483 conn.modes_ptr = VOID2U64(drmMalloc(sizeof(struct drm_mode_modeinfo))); 484 } 485 486 if (drmIoctl(fd, DRM_IOCTL_MODE_GETCONNECTOR, &conn)) 487 return 0; 488 489retry: 490 counts = conn; 491 492 if (conn.count_props) { 493 conn.props_ptr = VOID2U64(drmMalloc(conn.count_props*sizeof(uint32_t))); 494 if (!conn.props_ptr) 495 goto err_allocs; 496 conn.prop_values_ptr = VOID2U64(drmMalloc(conn.count_props*sizeof(uint64_t))); 497 if (!conn.prop_values_ptr) 498 goto err_allocs; 499 } 500 501 if (conn.count_modes) { 502 conn.modes_ptr = VOID2U64(drmMalloc(conn.count_modes*sizeof(struct drm_mode_modeinfo))); 503 if (!conn.modes_ptr) 504 goto err_allocs; 505 } else { 506 conn.count_modes = 1; 507 conn.modes_ptr = VOID2U64(drmMalloc(sizeof(struct drm_mode_modeinfo))); 508 } 509 510 if (conn.count_encoders) { 511 conn.encoders_ptr = VOID2U64(drmMalloc(conn.count_encoders*sizeof(uint32_t))); 512 if (!conn.encoders_ptr) 513 goto err_allocs; 514 } 515 516 if (drmIoctl(fd, DRM_IOCTL_MODE_GETCONNECTOR, &conn)) 517 goto err_allocs; 518 519 /* The number of available connectors and etc may have changed with a 520 * hotplug event in between the ioctls, in which case the field is 521 * silently ignored by the kernel. 522 */ 523 if (counts.count_props < conn.count_props || 524 counts.count_modes < conn.count_modes || 525 counts.count_encoders < conn.count_encoders) { 526 drmFree(U642VOID(conn.props_ptr)); 527 drmFree(U642VOID(conn.prop_values_ptr)); 528 drmFree(U642VOID(conn.modes_ptr)); 529 drmFree(U642VOID(conn.encoders_ptr)); 530 531 goto retry; 532 } 533 534 if(!(r = drmMalloc(sizeof(*r)))) { 535 goto err_allocs; 536 } 537 538 r->connector_id = conn.connector_id; 539 r->encoder_id = conn.encoder_id; 540 r->connection = conn.connection; 541 r->mmWidth = conn.mm_width; 542 r->mmHeight = conn.mm_height; 543 /* convert subpixel from kernel to userspace */ 544 r->subpixel = conn.subpixel + 1; 545 r->count_modes = conn.count_modes; 546 r->count_props = conn.count_props; 547 r->props = drmAllocCpy(U642VOID(conn.props_ptr), conn.count_props, sizeof(uint32_t)); 548 r->prop_values = drmAllocCpy(U642VOID(conn.prop_values_ptr), conn.count_props, sizeof(uint64_t)); 549 r->modes = drmAllocCpy(U642VOID(conn.modes_ptr), conn.count_modes, sizeof(struct drm_mode_modeinfo)); 550 r->count_encoders = conn.count_encoders; 551 r->encoders = drmAllocCpy(U642VOID(conn.encoders_ptr), conn.count_encoders, sizeof(uint32_t)); 552 r->connector_type = conn.connector_type; 553 r->connector_type_id = conn.connector_type_id; 554 555 if ((r->count_props && !r->props) || 556 (r->count_props && !r->prop_values) || 557 (r->count_modes && !r->modes) || 558 (r->count_encoders && !r->encoders)) { 559 drmFree(r->props); 560 drmFree(r->prop_values); 561 drmFree(r->modes); 562 drmFree(r->encoders); 563 drmFree(r); 564 r = 0; 565 } 566 567err_allocs: 568 drmFree(U642VOID(conn.prop_values_ptr)); 569 drmFree(U642VOID(conn.props_ptr)); 570 drmFree(U642VOID(conn.modes_ptr)); 571 drmFree(U642VOID(conn.encoders_ptr)); 572 573 return r; 574} 575 576drmModeConnectorPtr drmModeGetConnector(int fd, uint32_t connector_id) 577{ 578 return _drmModeGetConnector(fd, connector_id, 1); 579} 580 581drmModeConnectorPtr drmModeGetConnectorCurrent(int fd, uint32_t connector_id) 582{ 583 return _drmModeGetConnector(fd, connector_id, 0); 584} 585 586int drmModeAttachMode(int fd, uint32_t connector_id, drmModeModeInfoPtr mode_info) 587{ 588 struct drm_mode_mode_cmd res; 589 590 memclear(res); 591 memcpy(&res.mode, mode_info, sizeof(struct drm_mode_modeinfo)); 592 res.connector_id = connector_id; 593 594 return DRM_IOCTL(fd, DRM_IOCTL_MODE_ATTACHMODE, &res); 595} 596 597int drmModeDetachMode(int fd, uint32_t connector_id, drmModeModeInfoPtr mode_info) 598{ 599 struct drm_mode_mode_cmd res; 600 601 memclear(res); 602 memcpy(&res.mode, mode_info, sizeof(struct drm_mode_modeinfo)); 603 res.connector_id = connector_id; 604 605 return DRM_IOCTL(fd, DRM_IOCTL_MODE_DETACHMODE, &res); 606} 607 608drmModePropertyPtr drmModeGetProperty(int fd, uint32_t property_id) 609{ 610 struct drm_mode_get_property prop; 611 drmModePropertyPtr r; 612 613 memclear(prop); 614 prop.prop_id = property_id; 615 616 if (drmIoctl(fd, DRM_IOCTL_MODE_GETPROPERTY, &prop)) 617 return 0; 618 619 if (prop.count_values) 620 prop.values_ptr = VOID2U64(drmMalloc(prop.count_values * sizeof(uint64_t))); 621 622 if (prop.count_enum_blobs && (prop.flags & (DRM_MODE_PROP_ENUM | DRM_MODE_PROP_BITMASK))) 623 prop.enum_blob_ptr = VOID2U64(drmMalloc(prop.count_enum_blobs * sizeof(struct drm_mode_property_enum))); 624 625 if (prop.count_enum_blobs && (prop.flags & DRM_MODE_PROP_BLOB)) { 626 prop.values_ptr = VOID2U64(drmMalloc(prop.count_enum_blobs * sizeof(uint32_t))); 627 prop.enum_blob_ptr = VOID2U64(drmMalloc(prop.count_enum_blobs * sizeof(uint32_t))); 628 } 629 630 if (drmIoctl(fd, DRM_IOCTL_MODE_GETPROPERTY, &prop)) { 631 r = NULL; 632 goto err_allocs; 633 } 634 635 if (!(r = drmMalloc(sizeof(*r)))) 636 return NULL; 637 638 r->prop_id = prop.prop_id; 639 r->count_values = prop.count_values; 640 641 r->flags = prop.flags; 642 if (prop.count_values) 643 r->values = drmAllocCpy(U642VOID(prop.values_ptr), prop.count_values, sizeof(uint64_t)); 644 if (prop.flags & (DRM_MODE_PROP_ENUM | DRM_MODE_PROP_BITMASK)) { 645 r->count_enums = prop.count_enum_blobs; 646 r->enums = drmAllocCpy(U642VOID(prop.enum_blob_ptr), prop.count_enum_blobs, sizeof(struct drm_mode_property_enum)); 647 } else if (prop.flags & DRM_MODE_PROP_BLOB) { 648 r->values = drmAllocCpy(U642VOID(prop.values_ptr), prop.count_enum_blobs, sizeof(uint32_t)); 649 r->blob_ids = drmAllocCpy(U642VOID(prop.enum_blob_ptr), prop.count_enum_blobs, sizeof(uint32_t)); 650 r->count_blobs = prop.count_enum_blobs; 651 } 652 strncpy(r->name, prop.name, DRM_PROP_NAME_LEN); 653 r->name[DRM_PROP_NAME_LEN-1] = 0; 654 655err_allocs: 656 drmFree(U642VOID(prop.values_ptr)); 657 drmFree(U642VOID(prop.enum_blob_ptr)); 658 659 return r; 660} 661 662void drmModeFreeProperty(drmModePropertyPtr ptr) 663{ 664 if (!ptr) 665 return; 666 667 drmFree(ptr->values); 668 drmFree(ptr->enums); 669 drmFree(ptr); 670} 671 672drmModePropertyBlobPtr drmModeGetPropertyBlob(int fd, uint32_t blob_id) 673{ 674 struct drm_mode_get_blob blob; 675 drmModePropertyBlobPtr r; 676 677 memclear(blob); 678 blob.blob_id = blob_id; 679 680 if (drmIoctl(fd, DRM_IOCTL_MODE_GETPROPBLOB, &blob)) 681 return NULL; 682 683 if (blob.length) 684 blob.data = VOID2U64(drmMalloc(blob.length)); 685 686 if (drmIoctl(fd, DRM_IOCTL_MODE_GETPROPBLOB, &blob)) { 687 r = NULL; 688 goto err_allocs; 689 } 690 691 if (!(r = drmMalloc(sizeof(*r)))) 692 goto err_allocs; 693 694 r->id = blob.blob_id; 695 r->length = blob.length; 696 r->data = drmAllocCpy(U642VOID(blob.data), 1, blob.length); 697 698err_allocs: 699 drmFree(U642VOID(blob.data)); 700 return r; 701} 702 703void drmModeFreePropertyBlob(drmModePropertyBlobPtr ptr) 704{ 705 if (!ptr) 706 return; 707 708 drmFree(ptr->data); 709 drmFree(ptr); 710} 711 712int drmModeConnectorSetProperty(int fd, uint32_t connector_id, uint32_t property_id, 713 uint64_t value) 714{ 715 struct drm_mode_connector_set_property osp; 716 717 memclear(osp); 718 osp.connector_id = connector_id; 719 osp.prop_id = property_id; 720 osp.value = value; 721 722 return DRM_IOCTL(fd, DRM_IOCTL_MODE_SETPROPERTY, &osp); 723} 724 725/* 726 * checks if a modesetting capable driver has attached to the pci id 727 * returns 0 if modesetting supported. 728 * -EINVAL or invalid bus id 729 * -ENOSYS if no modesetting support 730*/ 731int drmCheckModesettingSupported(const char *busid) 732{ 733#if defined (__linux__) 734 char pci_dev_dir[1024]; 735 int domain, bus, dev, func; 736 DIR *sysdir; 737 struct dirent *dent; 738 int found = 0, ret; 739 740 ret = sscanf(busid, "pci:%04x:%02x:%02x.%d", &domain, &bus, &dev, &func); 741 if (ret != 4) 742 return -EINVAL; 743 744 sprintf(pci_dev_dir, "/sys/bus/pci/devices/%04x:%02x:%02x.%d/drm", 745 domain, bus, dev, func); 746 747 sysdir = opendir(pci_dev_dir); 748 if (sysdir) { 749 dent = readdir(sysdir); 750 while (dent) { 751 if (!strncmp(dent->d_name, "controlD", 8)) { 752 found = 1; 753 break; 754 } 755 756 dent = readdir(sysdir); 757 } 758 closedir(sysdir); 759 if (found) 760 return 0; 761 } 762 763 sprintf(pci_dev_dir, "/sys/bus/pci/devices/%04x:%02x:%02x.%d/", 764 domain, bus, dev, func); 765 766 sysdir = opendir(pci_dev_dir); 767 if (!sysdir) 768 return -EINVAL; 769 770 dent = readdir(sysdir); 771 while (dent) { 772 if (!strncmp(dent->d_name, "drm:controlD", 12)) { 773 found = 1; 774 break; 775 } 776 777 dent = readdir(sysdir); 778 } 779 780 closedir(sysdir); 781 if (found) 782 return 0; 783#elif defined (__FreeBSD__) || defined (__FreeBSD_kernel__) 784 char kbusid[1024], sbusid[1024]; 785 char oid[128]; 786 int domain, bus, dev, func; 787 int i, modesetting, ret; 788 size_t len; 789 790 ret = sscanf(busid, "pci:%04x:%02x:%02x.%d", &domain, &bus, &dev, 791 &func); 792 if (ret != 4) 793 return -EINVAL; 794 snprintf(kbusid, sizeof(kbusid), "pci:%04x:%02x:%02x.%d", domain, bus, 795 dev, func); 796 797 /* How many GPUs do we expect in the machine ? */ 798 for (i = 0; i < 16; i++) { 799 snprintf(oid, sizeof(oid), "hw.dri.%d.busid", i); 800 len = sizeof(sbusid); 801 ret = sysctlbyname(oid, sbusid, &len, NULL, 0); 802 if (ret == -1) { 803 if (errno == ENOENT) 804 continue; 805 return -EINVAL; 806 } 807 if (strcmp(sbusid, kbusid) != 0) 808 continue; 809 snprintf(oid, sizeof(oid), "hw.dri.%d.modesetting", i); 810 len = sizeof(modesetting); 811 ret = sysctlbyname(oid, &modesetting, &len, NULL, 0); 812 if (ret == -1 || len != sizeof(modesetting)) 813 return -EINVAL; 814 return (modesetting ? 0 : -ENOSYS); 815 } 816#elif defined(__DragonFly__) 817 return 0; 818#endif 819#ifdef __OpenBSD__ 820 int fd; 821 struct drm_mode_card_res res; 822 drmModeResPtr r = 0; 823 824 if ((fd = drmOpen(NULL, busid)) < 0) 825 return -EINVAL; 826 827 memset(&res, 0, sizeof(struct drm_mode_card_res)); 828 829 if (drmIoctl(fd, DRM_IOCTL_MODE_GETRESOURCES, &res)) { 830 drmClose(fd); 831 return -errno; 832 } 833 834 drmClose(fd); 835 return 0; 836#endif 837 return -ENOSYS; 838} 839 840int drmModeCrtcGetGamma(int fd, uint32_t crtc_id, uint32_t size, 841 uint16_t *red, uint16_t *green, uint16_t *blue) 842{ 843 struct drm_mode_crtc_lut l; 844 845 memclear(l); 846 l.crtc_id = crtc_id; 847 l.gamma_size = size; 848 l.red = VOID2U64(red); 849 l.green = VOID2U64(green); 850 l.blue = VOID2U64(blue); 851 852 return DRM_IOCTL(fd, DRM_IOCTL_MODE_GETGAMMA, &l); 853} 854 855int drmModeCrtcSetGamma(int fd, uint32_t crtc_id, uint32_t size, 856 uint16_t *red, uint16_t *green, uint16_t *blue) 857{ 858 struct drm_mode_crtc_lut l; 859 860 memclear(l); 861 l.crtc_id = crtc_id; 862 l.gamma_size = size; 863 l.red = VOID2U64(red); 864 l.green = VOID2U64(green); 865 l.blue = VOID2U64(blue); 866 867 return DRM_IOCTL(fd, DRM_IOCTL_MODE_SETGAMMA, &l); 868} 869 870int drmHandleEvent(int fd, drmEventContextPtr evctx) 871{ 872 char buffer[1024]; 873 int len, i; 874 struct drm_event *e; 875 struct drm_event_vblank *vblank; 876 877 /* The DRM read semantics guarantees that we always get only 878 * complete events. */ 879 880 len = read(fd, buffer, sizeof buffer); 881 if (len == 0) 882 return 0; 883 if (len < (int)sizeof *e) 884 return -1; 885 886 i = 0; 887 while (i < len) { 888 e = (struct drm_event *) &buffer[i]; 889 switch (e->type) { 890 case DRM_EVENT_VBLANK: 891 if (evctx->version < 1 || 892 evctx->vblank_handler == NULL) 893 break; 894 vblank = (struct drm_event_vblank *) e; 895 evctx->vblank_handler(fd, 896 vblank->sequence, 897 vblank->tv_sec, 898 vblank->tv_usec, 899 U642VOID (vblank->user_data)); 900 break; 901 case DRM_EVENT_FLIP_COMPLETE: 902 if (evctx->version < 2 || 903 evctx->page_flip_handler == NULL) 904 break; 905 vblank = (struct drm_event_vblank *) e; 906 evctx->page_flip_handler(fd, 907 vblank->sequence, 908 vblank->tv_sec, 909 vblank->tv_usec, 910 U642VOID (vblank->user_data)); 911 break; 912 default: 913 break; 914 } 915 i += e->length; 916 } 917 918 return 0; 919} 920 921int drmModePageFlip(int fd, uint32_t crtc_id, uint32_t fb_id, 922 uint32_t flags, void *user_data) 923{ 924 struct drm_mode_crtc_page_flip flip; 925 926 memclear(flip); 927 flip.fb_id = fb_id; 928 flip.crtc_id = crtc_id; 929 flip.user_data = VOID2U64(user_data); 930 flip.flags = flags; 931 932 return DRM_IOCTL(fd, DRM_IOCTL_MODE_PAGE_FLIP, &flip); 933} 934 935int drmModeSetPlane(int fd, uint32_t plane_id, uint32_t crtc_id, 936 uint32_t fb_id, uint32_t flags, 937 int32_t crtc_x, int32_t crtc_y, 938 uint32_t crtc_w, uint32_t crtc_h, 939 uint32_t src_x, uint32_t src_y, 940 uint32_t src_w, uint32_t src_h) 941{ 942 struct drm_mode_set_plane s; 943 944 memclear(s); 945 s.plane_id = plane_id; 946 s.crtc_id = crtc_id; 947 s.fb_id = fb_id; 948 s.flags = flags; 949 s.crtc_x = crtc_x; 950 s.crtc_y = crtc_y; 951 s.crtc_w = crtc_w; 952 s.crtc_h = crtc_h; 953 s.src_x = src_x; 954 s.src_y = src_y; 955 s.src_w = src_w; 956 s.src_h = src_h; 957 958 return DRM_IOCTL(fd, DRM_IOCTL_MODE_SETPLANE, &s); 959} 960 961drmModePlanePtr drmModeGetPlane(int fd, uint32_t plane_id) 962{ 963 struct drm_mode_get_plane ovr, counts; 964 drmModePlanePtr r = 0; 965 966retry: 967 memclear(ovr); 968 ovr.plane_id = plane_id; 969 if (drmIoctl(fd, DRM_IOCTL_MODE_GETPLANE, &ovr)) 970 return 0; 971 972 counts = ovr; 973 974 if (ovr.count_format_types) { 975 ovr.format_type_ptr = VOID2U64(drmMalloc(ovr.count_format_types * 976 sizeof(uint32_t))); 977 if (!ovr.format_type_ptr) 978 goto err_allocs; 979 } 980 981 if (drmIoctl(fd, DRM_IOCTL_MODE_GETPLANE, &ovr)) 982 goto err_allocs; 983 984 if (counts.count_format_types < ovr.count_format_types) { 985 drmFree(U642VOID(ovr.format_type_ptr)); 986 goto retry; 987 } 988 989 if (!(r = drmMalloc(sizeof(*r)))) 990 goto err_allocs; 991 992 r->count_formats = ovr.count_format_types; 993 r->plane_id = ovr.plane_id; 994 r->crtc_id = ovr.crtc_id; 995 r->fb_id = ovr.fb_id; 996 r->possible_crtcs = ovr.possible_crtcs; 997 r->gamma_size = ovr.gamma_size; 998 r->formats = drmAllocCpy(U642VOID(ovr.format_type_ptr), 999 ovr.count_format_types, sizeof(uint32_t)); 1000 if (ovr.count_format_types && !r->formats) { 1001 drmFree(r->formats); 1002 drmFree(r); 1003 r = 0; 1004 } 1005 1006err_allocs: 1007 drmFree(U642VOID(ovr.format_type_ptr)); 1008 1009 return r; 1010} 1011 1012void drmModeFreePlane(drmModePlanePtr ptr) 1013{ 1014 if (!ptr) 1015 return; 1016 1017 drmFree(ptr->formats); 1018 drmFree(ptr); 1019} 1020 1021drmModePlaneResPtr drmModeGetPlaneResources(int fd) 1022{ 1023 struct drm_mode_get_plane_res res, counts; 1024 drmModePlaneResPtr r = 0; 1025 1026retry: 1027 memclear(res); 1028 if (drmIoctl(fd, DRM_IOCTL_MODE_GETPLANERESOURCES, &res)) 1029 return 0; 1030 1031 counts = res; 1032 1033 if (res.count_planes) { 1034 res.plane_id_ptr = VOID2U64(drmMalloc(res.count_planes * 1035 sizeof(uint32_t))); 1036 if (!res.plane_id_ptr) 1037 goto err_allocs; 1038 } 1039 1040 if (drmIoctl(fd, DRM_IOCTL_MODE_GETPLANERESOURCES, &res)) 1041 goto err_allocs; 1042 1043 if (counts.count_planes < res.count_planes) { 1044 drmFree(U642VOID(res.plane_id_ptr)); 1045 goto retry; 1046 } 1047 1048 if (!(r = drmMalloc(sizeof(*r)))) 1049 goto err_allocs; 1050 1051 r->count_planes = res.count_planes; 1052 r->planes = drmAllocCpy(U642VOID(res.plane_id_ptr), 1053 res.count_planes, sizeof(uint32_t)); 1054 if (res.count_planes && !r->planes) { 1055 drmFree(r->planes); 1056 drmFree(r); 1057 r = 0; 1058 } 1059 1060err_allocs: 1061 drmFree(U642VOID(res.plane_id_ptr)); 1062 1063 return r; 1064} 1065 1066void drmModeFreePlaneResources(drmModePlaneResPtr ptr) 1067{ 1068 if (!ptr) 1069 return; 1070 1071 drmFree(ptr->planes); 1072 drmFree(ptr); 1073} 1074 1075drmModeObjectPropertiesPtr drmModeObjectGetProperties(int fd, 1076 uint32_t object_id, 1077 uint32_t object_type) 1078{ 1079 struct drm_mode_obj_get_properties properties; 1080 drmModeObjectPropertiesPtr ret = NULL; 1081 uint32_t count; 1082 1083retry: 1084 memclear(properties); 1085 properties.obj_id = object_id; 1086 properties.obj_type = object_type; 1087 1088 if (drmIoctl(fd, DRM_IOCTL_MODE_OBJ_GETPROPERTIES, &properties)) 1089 return 0; 1090 1091 count = properties.count_props; 1092 1093 if (count) { 1094 properties.props_ptr = VOID2U64(drmMalloc(count * 1095 sizeof(uint32_t))); 1096 if (!properties.props_ptr) 1097 goto err_allocs; 1098 properties.prop_values_ptr = VOID2U64(drmMalloc(count * 1099 sizeof(uint64_t))); 1100 if (!properties.prop_values_ptr) 1101 goto err_allocs; 1102 } 1103 1104 if (drmIoctl(fd, DRM_IOCTL_MODE_OBJ_GETPROPERTIES, &properties)) 1105 goto err_allocs; 1106 1107 if (count < properties.count_props) { 1108 drmFree(U642VOID(properties.props_ptr)); 1109 drmFree(U642VOID(properties.prop_values_ptr)); 1110 goto retry; 1111 } 1112 count = properties.count_props; 1113 1114 ret = drmMalloc(sizeof(*ret)); 1115 if (!ret) 1116 goto err_allocs; 1117 1118 ret->count_props = count; 1119 ret->props = drmAllocCpy(U642VOID(properties.props_ptr), 1120 count, sizeof(uint32_t)); 1121 ret->prop_values = drmAllocCpy(U642VOID(properties.prop_values_ptr), 1122 count, sizeof(uint64_t)); 1123 if (ret->count_props && (!ret->props || !ret->prop_values)) { 1124 drmFree(ret->props); 1125 drmFree(ret->prop_values); 1126 drmFree(ret); 1127 ret = NULL; 1128 } 1129 1130err_allocs: 1131 drmFree(U642VOID(properties.props_ptr)); 1132 drmFree(U642VOID(properties.prop_values_ptr)); 1133 return ret; 1134} 1135 1136void drmModeFreeObjectProperties(drmModeObjectPropertiesPtr ptr) 1137{ 1138 if (!ptr) 1139 return; 1140 drmFree(ptr->props); 1141 drmFree(ptr->prop_values); 1142 drmFree(ptr); 1143} 1144 1145int drmModeObjectSetProperty(int fd, uint32_t object_id, uint32_t object_type, 1146 uint32_t property_id, uint64_t value) 1147{ 1148 struct drm_mode_obj_set_property prop; 1149 1150 memclear(prop); 1151 prop.value = value; 1152 prop.prop_id = property_id; 1153 prop.obj_id = object_id; 1154 prop.obj_type = object_type; 1155 1156 return DRM_IOCTL(fd, DRM_IOCTL_MODE_OBJ_SETPROPERTY, &prop); 1157} 1158 1159typedef struct _drmModeAtomicReqItem drmModeAtomicReqItem, *drmModeAtomicReqItemPtr; 1160 1161struct _drmModeAtomicReqItem { 1162 uint32_t object_id; 1163 uint32_t property_id; 1164 uint64_t value; 1165}; 1166 1167struct _drmModeAtomicReq { 1168 uint32_t cursor; 1169 uint32_t size_items; 1170 drmModeAtomicReqItemPtr items; 1171}; 1172 1173drmModeAtomicReqPtr drmModeAtomicAlloc(void) 1174{ 1175 drmModeAtomicReqPtr req; 1176 1177 req = drmMalloc(sizeof *req); 1178 if (!req) 1179 return NULL; 1180 1181 req->items = NULL; 1182 req->cursor = 0; 1183 req->size_items = 0; 1184 1185 return req; 1186} 1187 1188drmModeAtomicReqPtr drmModeAtomicDuplicate(drmModeAtomicReqPtr old) 1189{ 1190 drmModeAtomicReqPtr new; 1191 1192 new = drmMalloc(sizeof *new); 1193 if (!new) 1194 return NULL; 1195 1196 new->cursor = old->cursor; 1197 new->size_items = old->size_items; 1198 1199 if (old->size_items) { 1200 new->items = drmMalloc(old->size_items * sizeof(*new->items)); 1201 if (!new->items) { 1202 free(new); 1203 return NULL; 1204 } 1205 memcpy(new->items, old->items, 1206 old->size_items * sizeof(*new->items)); 1207 } else { 1208 new->items = NULL; 1209 } 1210 1211 return new; 1212} 1213 1214int drmModeAtomicMerge(drmModeAtomicReqPtr base, drmModeAtomicReqPtr augment) 1215{ 1216 if (!augment || augment->cursor == 0) 1217 return 0; 1218 1219 if (base->cursor + augment->cursor >= base->size_items) { 1220 drmModeAtomicReqItemPtr new; 1221 int saved_size = base->size_items; 1222 1223 base->size_items = base->cursor + augment->cursor; 1224 new = realloc(base->items, 1225 base->size_items * sizeof(*base->items)); 1226 if (!new) { 1227 base->size_items = saved_size; 1228 return -ENOMEM; 1229 } 1230 base->items = new; 1231 } 1232 1233 memcpy(&base->items[base->cursor], augment->items, 1234 augment->cursor * sizeof(*augment->items)); 1235 base->cursor += augment->cursor; 1236 1237 return 0; 1238} 1239 1240int drmModeAtomicGetCursor(drmModeAtomicReqPtr req) 1241{ 1242 return req->cursor; 1243} 1244 1245void drmModeAtomicSetCursor(drmModeAtomicReqPtr req, int cursor) 1246{ 1247 req->cursor = cursor; 1248} 1249 1250int drmModeAtomicAddProperty(drmModeAtomicReqPtr req, 1251 uint32_t object_id, 1252 uint32_t property_id, 1253 uint64_t value) 1254{ 1255 if (req->cursor >= req->size_items) { 1256 drmModeAtomicReqItemPtr new; 1257 1258 req->size_items += 16; 1259 new = realloc(req->items, req->size_items * sizeof(*req->items)); 1260 if (!new) { 1261 req->size_items -= 16; 1262 return -ENOMEM; 1263 } 1264 req->items = new; 1265 } 1266 1267 req->items[req->cursor].object_id = object_id; 1268 req->items[req->cursor].property_id = property_id; 1269 req->items[req->cursor].value = value; 1270 req->cursor++; 1271 1272 return req->cursor; 1273} 1274 1275void drmModeAtomicFree(drmModeAtomicReqPtr req) 1276{ 1277 if (!req) 1278 return; 1279 1280 if (req->items) 1281 drmFree(req->items); 1282 drmFree(req); 1283} 1284 1285static int sort_req_list(const void *misc, const void *other) 1286{ 1287 const drmModeAtomicReqItem *first = misc; 1288 const drmModeAtomicReqItem *second = other; 1289 1290 if (first->object_id < second->object_id) 1291 return -1; 1292 else if (first->object_id > second->object_id) 1293 return 1; 1294 else 1295 return second->property_id - first->property_id; 1296} 1297 1298int drmModeAtomicCommit(int fd, drmModeAtomicReqPtr req, uint32_t flags, 1299 void *user_data) 1300{ 1301 drmModeAtomicReqPtr sorted; 1302 struct drm_mode_atomic atomic; 1303 uint32_t *objs_ptr = NULL; 1304 uint32_t *count_props_ptr = NULL; 1305 uint32_t *props_ptr = NULL; 1306 uint64_t *prop_values_ptr = NULL; 1307 uint32_t last_obj_id = 0; 1308 uint32_t i; 1309 int obj_idx = -1; 1310 int ret = -1; 1311 1312 if (req->cursor == 0) 1313 return 0; 1314 1315 sorted = drmModeAtomicDuplicate(req); 1316 if (sorted == NULL) 1317 return -ENOMEM; 1318 1319 memclear(atomic); 1320 1321 /* Sort the list by object ID, then by property ID. */ 1322 qsort(sorted->items, sorted->cursor, sizeof(*sorted->items), 1323 sort_req_list); 1324 1325 /* Now the list is sorted, eliminate duplicate property sets. */ 1326 for (i = 0; i < sorted->cursor; i++) { 1327 if (sorted->items[i].object_id != last_obj_id) { 1328 atomic.count_objs++; 1329 last_obj_id = sorted->items[i].object_id; 1330 } 1331 1332 if (i == sorted->cursor - 1) 1333 continue; 1334 1335 if (sorted->items[i].object_id != sorted->items[i + 1].object_id || 1336 sorted->items[i].property_id != sorted->items[i + 1].property_id) 1337 continue; 1338 1339 memmove(&sorted->items[i], &sorted->items[i + 1], 1340 (sorted->cursor - i - 1) * sizeof(*sorted->items)); 1341 sorted->cursor--; 1342 } 1343 1344 objs_ptr = drmMalloc(atomic.count_objs * sizeof objs_ptr[0]); 1345 if (!objs_ptr) { 1346 errno = ENOMEM; 1347 goto out; 1348 } 1349 1350 count_props_ptr = drmMalloc(atomic.count_objs * sizeof count_props_ptr[0]); 1351 if (!count_props_ptr) { 1352 errno = ENOMEM; 1353 goto out; 1354 } 1355 1356 props_ptr = drmMalloc(sorted->cursor * sizeof props_ptr[0]); 1357 if (!props_ptr) { 1358 errno = ENOMEM; 1359 goto out; 1360 } 1361 1362 prop_values_ptr = drmMalloc(sorted->cursor * sizeof prop_values_ptr[0]); 1363 if (!prop_values_ptr) { 1364 errno = ENOMEM; 1365 goto out; 1366 } 1367 1368 for (i = 0, last_obj_id = 0; i < sorted->cursor; i++) { 1369 if (sorted->items[i].object_id != last_obj_id) { 1370 obj_idx++; 1371 objs_ptr[obj_idx] = sorted->items[i].object_id; 1372 last_obj_id = objs_ptr[obj_idx]; 1373 } 1374 1375 count_props_ptr[obj_idx]++; 1376 props_ptr[i] = sorted->items[i].property_id; 1377 prop_values_ptr[i] = sorted->items[i].value; 1378 1379 } 1380 1381 atomic.flags = flags; 1382 atomic.objs_ptr = VOID2U64(objs_ptr); 1383 atomic.count_props_ptr = VOID2U64(count_props_ptr); 1384 atomic.props_ptr = VOID2U64(props_ptr); 1385 atomic.prop_values_ptr = VOID2U64(prop_values_ptr); 1386 atomic.user_data = VOID2U64(user_data); 1387 1388 ret = DRM_IOCTL(fd, DRM_IOCTL_MODE_ATOMIC, &atomic); 1389 1390out: 1391 drmFree(objs_ptr); 1392 drmFree(count_props_ptr); 1393 drmFree(props_ptr); 1394 drmFree(prop_values_ptr); 1395 drmModeAtomicFree(sorted); 1396 1397 return ret; 1398} 1399 1400int 1401drmModeCreatePropertyBlob(int fd, const void *data, size_t length, uint32_t *id) 1402{ 1403 struct drm_mode_create_blob create; 1404 int ret; 1405 1406 if (length >= 0xffffffff) 1407 return -ERANGE; 1408 1409 memclear(create); 1410 1411 create.length = length; 1412 create.data = (uintptr_t) data; 1413 create.blob_id = 0; 1414 *id = 0; 1415 1416 ret = DRM_IOCTL(fd, DRM_IOCTL_MODE_CREATEPROPBLOB, &create); 1417 if (ret != 0) 1418 return ret; 1419 1420 *id = create.blob_id; 1421 return 0; 1422} 1423 1424int 1425drmModeDestroyPropertyBlob(int fd, uint32_t id) 1426{ 1427 struct drm_mode_destroy_blob destroy; 1428 1429 memclear(destroy); 1430 destroy.blob_id = id; 1431 return DRM_IOCTL(fd, DRM_IOCTL_MODE_DESTROYPROPBLOB, &destroy); 1432} 1433