dlls/winemac.drv/cocoa_display.m

   1 /*
   2  * MACDRV Cocoa display settings
   3  *
   4  * Copyright 2011, 2012 Ken Thomases for CodeWeavers Inc.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22
  23 #import <AppKit/AppKit.h>
  24 #ifdef HAVE_MTLDEVICE_REGISTRYID
  25 #import <Metal/Metal.h>
  26 #endif
  27 #include "macdrv_cocoa.h"
  28
  29 static uint64_t dedicated_gpu_id;
  30 static uint64_t integrated_gpu_id;
  31
  32 /***********************************************************************
  33  *              convert_display_rect
  34  *
  35  * Converts an NSRect in Cocoa's y-goes-up-from-bottom coordinate system
  36  * to a CGRect in y-goes-down-from-top coordinates.
  37  */
  38 static inline void convert_display_rect(CGRect* out_rect, NSRect in_rect,
  39                                         NSRect primary_frame)
  40 {
  41     *out_rect = NSRectToCGRect(in_rect);
  42     out_rect->origin.y = NSMaxY(primary_frame) - NSMaxY(in_rect);
  43 }
  44
  45
  46 /***********************************************************************
  47  *              macdrv_get_displays
  48  *
  49  * Returns information about the displays.
  50  *
  51  * Returns 0 on success and *displays contains a newly-allocated array
  52  * of macdrv_display structures and *count contains the number of
  53  * elements in that array.  The first element of the array is the
  54  * primary display.  When the caller is done with the array, it should
  55  * use macdrv_free_displays() to deallocate it.
  56  *
  57  * Returns non-zero on failure and *displays and *count are unchanged.
  58  */
  59 int macdrv_get_displays(struct macdrv_display** displays, int* count)
  60 {
  61     int ret = -1;
  62     NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
  63
  64     NSArray* screens = [NSScreen screens];
  65     if (screens)
  66     {
  67         NSUInteger num_screens = [screens count];
  68         struct macdrv_display* disps = malloc(num_screens * sizeof(disps[0]));
  69
  70         if (disps)
  71         {
  72             NSRect primary_frame;
  73
  74             NSUInteger i;
  75             for (i = 0; i < num_screens; i++)
  76             {
  77                 NSScreen* screen = [screens objectAtIndex:i];
  78                 NSRect frame = [screen frame];
  79                 NSRect visible_frame = [screen visibleFrame];
  80
  81                 if (i == 0)
  82                     primary_frame = frame;
  83
  84                 disps[i].displayID = [[[screen deviceDescription] objectForKey:@"NSScreenNumber"] unsignedIntValue];
  85                 convert_display_rect(&disps[i].frame, frame, primary_frame);
  86                 convert_display_rect(&disps[i].work_frame, visible_frame,
  87                                      primary_frame);
  88                 disps[i].frame = cgrect_win_from_mac(disps[i].frame);
  89                 disps[i].work_frame = cgrect_win_from_mac(disps[i].work_frame);
  90             }
  91
  92             *displays = disps;
  93             *count = num_screens;
  94             ret = 0;
  95         }
  96     }
  97
  98     [pool release];
  99     return ret;
 100 }
 101
 102
 103 /***********************************************************************
 104  *              macdrv_free_displays
 105  *
 106  * Deallocates an array of macdrv_display structures previously returned
 107  * from macdrv_get_displays().
 108  */
 109 void macdrv_free_displays(struct macdrv_display* displays)
 110 {
 111     free(displays);
 112 }
 113
 114 /***********************************************************************
 115  *              get_entry_property_uint32
 116  *
 117  * Get an io registry entry property of type uint32 and store it in value parameter.
 118  *
 119  * Returns non-zero value on failure.
 120  */
 121 static int get_entry_property_uint32(io_registry_entry_t entry, CFStringRef property_name, uint32_t* value)
 122 {
 123     CFDataRef data = IORegistryEntrySearchCFProperty(entry, kIOServicePlane, property_name, kCFAllocatorDefault, 0);
 124     if (!data)
 125         return -1;
 126
 127     if (CFGetTypeID(data) != CFDataGetTypeID() || CFDataGetLength(data) != sizeof(uint32_t))
 128     {
 129         CFRelease(data);
 130         return -1;
 131     }
 132
 133     CFDataGetBytes(data, CFRangeMake(0, sizeof(uint32_t)), (UInt8*)value);
 134     CFRelease(data);
 135     return 0;
 136 }
 137
 138 /***********************************************************************
 139  *              get_entry_property_string
 140  *
 141  * Get an io registry entry property of type string and write it in buffer parameter.
 142  *
 143  * Returns non-zero value on failure.
 144  */
 145 static int get_entry_property_string(io_registry_entry_t entry, CFStringRef property_name, char* buffer,
 146                                      size_t buffer_size)
 147 {
 148     CFTypeRef type_ref;
 149     CFDataRef data_ref;
 150     CFStringRef string_ref;
 151     size_t length;
 152     int ret = -1;
 153
 154     type_ref = IORegistryEntrySearchCFProperty(entry, kIOServicePlane, property_name, kCFAllocatorDefault, 0);
 155     if (!type_ref)
 156         goto done;
 157
 158     if (CFGetTypeID(type_ref) == CFDataGetTypeID())
 159     {
 160         data_ref = type_ref;
 161         length = CFDataGetLength(data_ref);
 162         if (length + 1 > buffer_size)
 163             goto done;
 164         CFDataGetBytes(data_ref, CFRangeMake(0, length), (UInt8*)buffer);
 165         buffer[length] = 0;
 166     }
 167     else if (CFGetTypeID(type_ref) == CFStringGetTypeID())
 168     {
 169         string_ref = type_ref;
 170         if (!CFStringGetCString(string_ref, buffer, buffer_size, kCFStringEncodingUTF8))
 171             goto done;
 172     }
 173     else
 174         goto done;
 175
 176     ret = 0;
 177 done:
 178     if (type_ref)
 179         CFRelease(type_ref);
 180     return ret;
 181 }
 182
 183 /***********************************************************************
 184  *              macdrv_get_gpu_info_from_entry
 185  *
 186  * Starting from entry, search upwards to find the PCI GPU. And get GPU information from the PCI GPU entry.
 187  *
 188  * Returns non-zero value on failure.
 189  */
 190 static int macdrv_get_gpu_info_from_entry(struct macdrv_gpu* gpu, io_registry_entry_t entry)
 191 {
 192     io_registry_entry_t parent_entry;
 193     io_registry_entry_t gpu_entry;
 194     kern_return_t result;
 195     int ret = -1;
 196     char buffer[64];
 197     NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
 198
 199     gpu_entry = entry;
 200     while (![@"IOPCIDevice" isEqualToString:[(NSString*)IOObjectCopyClass(gpu_entry) autorelease]]
 201            || get_entry_property_string(gpu_entry, CFSTR("IOName"), buffer, sizeof(buffer))
 202            || strcmp(buffer, "display"))
 203     {
 204         result = IORegistryEntryGetParentEntry(gpu_entry, kIOServicePlane, &parent_entry);
 205         if (gpu_entry != entry)
 206             IOObjectRelease(gpu_entry);
 207         if (result != kIOReturnSuccess)
 208         {
 209             [pool release];
 210             return ret;
 211         }
 212
 213         gpu_entry = parent_entry;
 214     }
 215
 216     if (IORegistryEntryGetRegistryEntryID(gpu_entry, &gpu->id) != kIOReturnSuccess)
 217         goto done;
 218
 219     ret = 0;
 220
 221     get_entry_property_uint32(gpu_entry, CFSTR("vendor-id"), &gpu->vendor_id);
 222     get_entry_property_uint32(gpu_entry, CFSTR("device-id"), &gpu->device_id);
 223     get_entry_property_uint32(gpu_entry, CFSTR("subsystem-id"), &gpu->subsys_id);
 224     get_entry_property_uint32(gpu_entry, CFSTR("revision-id"), &gpu->revision_id);
 225     get_entry_property_string(gpu_entry, CFSTR("model"), gpu->name, sizeof(gpu->name));
 226
 227 done:
 228     if (gpu_entry != entry)
 229         IOObjectRelease(gpu_entry);
 230     [pool release];
 231     return ret;
 232 }
 233
 234 #ifdef HAVE_MTLDEVICE_REGISTRYID
 235
 236 /***********************************************************************
 237  *              macdrv_get_gpu_info_from_registry_id
 238  *
 239  * Get GPU information from a Metal device registry id.
 240  *
 241  * Returns non-zero value on failure.
 242  */
 243 static int macdrv_get_gpu_info_from_registry_id(struct macdrv_gpu* gpu, uint64_t registry_id)
 244 {
 245     int ret;
 246     io_registry_entry_t entry;
 247
 248     entry = IOServiceGetMatchingService(kIOMasterPortDefault, IORegistryEntryIDMatching(registry_id));
 249     ret = macdrv_get_gpu_info_from_entry(gpu, entry);
 250     IOObjectRelease(entry);
 251     return ret;
 252 }
 253
 254 /***********************************************************************
 255  *              macdrv_get_gpus_from_metal
 256  *
 257  * Get a list of GPUs from Metal.
 258  *
 259  * Returns non-zero value on failure with parameters unchanged and zero on success.
 260  */
 261 static int macdrv_get_gpus_from_metal(struct macdrv_gpu** new_gpus, int* count)
 262 {
 263     struct macdrv_gpu* gpus = NULL;
 264     struct macdrv_gpu primary_gpu;
 265     id<MTLDevice> primary_device;
 266     BOOL hide_integrated = FALSE;
 267     int primary_index = 0, i;
 268     int gpu_count = 0;
 269     int ret = -1;
 270     NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
 271
 272     /* Test if Metal is available */
 273     if (&MTLCopyAllDevices == NULL)
 274         goto done;
 275     NSArray<id<MTLDevice>>* devices = [MTLCopyAllDevices() autorelease];
 276     if (!devices.count || ![devices[0] respondsToSelector:@selector(registryID)])
 277         goto done;
 278
 279     gpus = calloc(devices.count, sizeof(*gpus));
 280     if (!gpus)
 281         goto done;
 282
 283     /* Use MTLCreateSystemDefaultDevice instead of CGDirectDisplayCopyCurrentMetalDevice(CGMainDisplayID()) to get
 284      * the primary GPU because we need to hide the integrated GPU for an automatic graphic switching pair to avoid apps
 285      * using the integrated GPU. This is the behavior of Windows on a Mac. */
 286     primary_device = [MTLCreateSystemDefaultDevice() autorelease];
 287     if (macdrv_get_gpu_info_from_registry_id(&primary_gpu, primary_device.registryID))
 288         goto done;
 289
 290     /* Hide the integrated GPU if the system default device is a dedicated GPU */
 291     if (!primary_device.isLowPower)
 292     {
 293         dedicated_gpu_id = primary_gpu.id;
 294         hide_integrated = TRUE;
 295     }
 296
 297     for (i = 0; i < devices.count; i++)
 298     {
 299         if (macdrv_get_gpu_info_from_registry_id(&gpus[gpu_count], devices[i].registryID))
 300             goto done;
 301
 302         if (hide_integrated && devices[i].isLowPower)
 303         {
 304             integrated_gpu_id = gpus[gpu_count].id;
 305             continue;
 306         }
 307
 308         if (gpus[gpu_count].id == primary_gpu.id)
 309             primary_index = gpu_count;
 310
 311         gpu_count++;
 312     }
 313
 314     /* Make sure the first GPU is primary */
 315     if (primary_index)
 316     {
 317         struct macdrv_gpu tmp;
 318         tmp = gpus[0];
 319         gpus[0] = gpus[primary_index];
 320         gpus[primary_index] = tmp;
 321     }
 322
 323     *new_gpus = gpus;
 324     *count = gpu_count;
 325     ret = 0;
 326 done:
 327     if (ret)
 328         macdrv_free_gpus(gpus);
 329     [pool release];
 330     return ret;
 331 }
 332
 333 #else
 334
 335 static int macdrv_get_gpus_from_metal(struct macdrv_gpu** new_gpus, int* count)
 336 {
 337     return -1;
 338 }
 339
 340 #endif
 341
 342 /***********************************************************************
 343  *              macdrv_get_gpu_info_from_display_id
 344  *
 345  * Get GPU information from a display id.
 346  * This is a fallback for 32bit build or older Mac OS version where Metal is unavailable.
 347  *
 348  * Returns non-zero value on failure.
 349  */
 350 static int macdrv_get_gpu_info_from_display_id(struct macdrv_gpu* gpu, CGDirectDisplayID display_id)
 351 {
 352     io_registry_entry_t entry = CGDisplayIOServicePort(display_id);
 353     return macdrv_get_gpu_info_from_entry(gpu, entry);
 354 }
 355
 356 /***********************************************************************
 357  *              macdrv_get_gpus_from_iokit
 358  *
 359  * Get a list of GPUs from IOKit.
 360  * This is a fallback for 32bit build or older Mac OS version where Metal is unavailable.
 361  *
 362  * Returns non-zero value on failure with parameters unchanged and zero on success.
 363  */
 364 static int macdrv_get_gpus_from_iokit(struct macdrv_gpu** new_gpus, int* count)
 365 {
 366     static const int MAX_GPUS = 4;
 367     struct macdrv_gpu primary_gpu = {0};
 368     io_registry_entry_t entry;
 369     io_iterator_t iterator;
 370     struct macdrv_gpu* gpus;
 371     int integrated_index = -1;
 372     int primary_index = 0;
 373     int gpu_count = 0;
 374     int ret = -1;
 375     int i;
 376
 377     gpus = calloc(MAX_GPUS, sizeof(*gpus));
 378     if (!gpus)
 379         goto done;
 380
 381     if (IOServiceGetMatchingServices(kIOMasterPortDefault, IOServiceMatching("IOPCIDevice"), &iterator)
 382         != kIOReturnSuccess)
 383         goto done;
 384
 385     while ((entry = IOIteratorNext(iterator)))
 386     {
 387         if (!macdrv_get_gpu_info_from_entry(&gpus[gpu_count], entry))
 388         {
 389             gpu_count++;
 390             assert(gpu_count < MAX_GPUS);
 391         }
 392         IOObjectRelease(entry);
 393     }
 394     IOObjectRelease(iterator);
 395
 396     macdrv_get_gpu_info_from_display_id(&primary_gpu, CGMainDisplayID());
 397
 398     /* If there are more than two GPUs and an Intel card exists,
 399      * assume an automatic graphics pair exists and hide the integrated GPU */
 400     if (gpu_count > 1)
 401     {
 402         for (i = 0; i < gpu_count; i++)
 403         {
 404             /* FIXME:
 405              * Find integrated GPU without Metal support.
 406              * Assuming integrated GPU vendor is Intel for now */
 407             if (gpus[i].vendor_id == 0x8086)
 408             {
 409                 integrated_gpu_id = gpus[i].id;
 410                 integrated_index = i;
 411             }
 412
 413             if (gpus[i].id == primary_gpu.id)
 414             {
 415                 primary_index = i;
 416             }
 417         }
 418
 419         if (integrated_index != -1)
 420         {
 421             if (integrated_index != gpu_count - 1)
 422                 gpus[integrated_index] = gpus[gpu_count - 1];
 423
 424             /* FIXME:
 425              * Find the dedicated GPU in an automatic graphics switching pair and use that as primary GPU.
 426              * Choose the first dedicated GPU as primary */
 427             if (primary_index == integrated_index)
 428                 primary_index = 0;
 429             else if (primary_index == gpu_count - 1)
 430                 primary_index = integrated_index;
 431
 432             dedicated_gpu_id = gpus[primary_index].id;
 433             gpu_count--;
 434         }
 435     }
 436
 437     /* Make sure the first GPU is primary */
 438     if (primary_index)
 439     {
 440         struct macdrv_gpu tmp;
 441         tmp = gpus[0];
 442         gpus[0] = gpus[primary_index];
 443         gpus[primary_index] = tmp;
 444     }
 445
 446     *new_gpus = gpus;
 447     *count = gpu_count;
 448     ret = 0;
 449 done:
 450     if (ret)
 451         macdrv_free_gpus(gpus);
 452     return ret;
 453 }
 454
 455 /***********************************************************************
 456  *              macdrv_get_gpus
 457  *
 458  * Get a list of GPUs currently in the system. The first GPU is primary.
 459  * Call macdrv_free_gpus() when you are done using the data.
 460  *
 461  * Returns non-zero value on failure with parameters unchanged and zero on success.
 462  */
 463 int macdrv_get_gpus(struct macdrv_gpu** new_gpus, int* count)
 464 {
 465     integrated_gpu_id = 0;
 466     dedicated_gpu_id = 0;
 467
 468     if (!macdrv_get_gpus_from_metal(new_gpus, count))
 469         return 0;
 470     else
 471         return macdrv_get_gpus_from_iokit(new_gpus, count);
 472 }
 473
 474 /***********************************************************************
 475  *              macdrv_free_gpus
 476  *
 477  * Frees a GPU list allocated from macdrv_get_gpus()
 478  */
 479 void macdrv_free_gpus(struct macdrv_gpu* gpus)
 480 {
 481     if (gpus)
 482         free(gpus);
 483 }
 484
 485 /***********************************************************************
 486  *              macdrv_get_adapters
 487  *
 488  * Get a list of adapters under gpu_id. The first adapter is primary if GPU is primary.
 489  * Call macdrv_free_adapters() when you are done using the data.
 490  *
 491  * Returns non-zero value on failure with parameters unchanged and zero on success.
 492  */
 493 int macdrv_get_adapters(uint64_t gpu_id, struct macdrv_adapter** new_adapters, int* count)
 494 {
 495     CGDirectDisplayID display_ids[16];
 496     uint32_t display_id_count;
 497     struct macdrv_adapter* adapters;
 498     struct macdrv_gpu gpu;
 499     int primary_index = 0;
 500     int adapter_count = 0;
 501     int ret = -1;
 502     uint32_t i;
 503
 504     if (CGGetOnlineDisplayList(sizeof(display_ids) / sizeof(display_ids[0]), display_ids, &display_id_count)
 505         != kCGErrorSuccess)
 506         return -1;
 507
 508     if (!display_id_count)
 509     {
 510         *new_adapters = NULL;
 511         *count = 0;
 512         return 0;
 513     }
 514
 515     /* Actual adapter count may be less */
 516     adapters = calloc(display_id_count, sizeof(*adapters));
 517     if (!adapters)
 518         return -1;
 519
 520     for (i = 0; i < display_id_count; i++)
 521     {
 522         /* Mirrored displays are under the same adapter with primary display, so they doesn't increase adapter count */
 523         if (CGDisplayMirrorsDisplay(display_ids[i]) != kCGNullDirectDisplay)
 524             continue;
 525
 526         if (macdrv_get_gpu_info_from_display_id(&gpu, display_ids[i]))
 527             goto done;
 528
 529         if (gpu.id == gpu_id || (gpu_id == dedicated_gpu_id && gpu.id == integrated_gpu_id))
 530         {
 531             adapters[adapter_count].id = display_ids[i];
 532
 533             if (CGDisplayIsMain(display_ids[i]))
 534             {
 535                 adapters[adapter_count].state_flags |= DISPLAY_DEVICE_PRIMARY_DEVICE;
 536                 primary_index = adapter_count;
 537             }
 538
 539             if (CGDisplayIsActive(display_ids[i]))
 540                 adapters[adapter_count].state_flags |= DISPLAY_DEVICE_ATTACHED_TO_DESKTOP;
 541
 542             adapter_count++;
 543         }
 544     }
 545
 546     /* Make sure the first adapter is primary if the GPU is primary */
 547     if (primary_index)
 548     {
 549         struct macdrv_adapter tmp;
 550         tmp = adapters[0];
 551         adapters[0] = adapters[primary_index];
 552         adapters[primary_index] = tmp;
 553     }
 554
 555     *new_adapters = adapters;
 556     *count = adapter_count;
 557     ret = 0;
 558 done:
 559     if (ret)
 560         macdrv_free_adapters(adapters);
 561     return ret;
 562 }
 563
 564 /***********************************************************************
 565  *              macdrv_free_adapters
 566  *
 567  * Frees an adapter list allocated from macdrv_get_adapters()
 568  */
 569 void macdrv_free_adapters(struct macdrv_adapter* adapters)
 570 {
 571     if (adapters)
 572         free(adapters);
 573 }
 574
 575 /***********************************************************************
 576  *              macdrv_get_monitors
 577  *
 578  * Get a list of monitors under adapter_id. The first monitor is primary if adapter is primary.
 579  * Call macdrv_free_monitors() when you are done using the data.
 580  *
 581  * Returns non-zero value on failure with parameters unchanged and zero on success.
 582  */
 583 int macdrv_get_monitors(uint32_t adapter_id, struct macdrv_monitor** new_monitors, int* count)
 584 {
 585     struct macdrv_monitor* monitors = NULL;
 586     struct macdrv_monitor* realloc_monitors;
 587     struct macdrv_display* displays = NULL;
 588     CGDirectDisplayID display_ids[16];
 589     uint32_t display_id_count;
 590     int primary_index = 0;
 591     int monitor_count = 0;
 592     int display_count;
 593     int capacity;
 594     int ret = -1;
 595     int i, j;
 596
 597     /* 2 should be enough for most cases */
 598     capacity = 2;
 599     monitors = calloc(capacity, sizeof(*monitors));
 600     if (!monitors)
 601         return -1;
 602
 603     /* Report an inactive monitor */
 604     if (!CGDisplayIsActive(adapter_id) && !CGDisplayIsInMirrorSet(adapter_id))
 605     {
 606         strcpy(monitors[monitor_count].name, "Generic Non-PnP Monitor");
 607         monitors[monitor_count].state_flags = DISPLAY_DEVICE_ATTACHED;
 608         monitor_count++;
 609     }
 610     /* Report active and mirrored monitors in the same mirroring set */
 611     else
 612     {
 613         if (CGGetOnlineDisplayList(sizeof(display_ids) / sizeof(display_ids[0]), display_ids, &display_id_count)
 614             != kCGErrorSuccess)
 615             goto done;
 616
 617         if (macdrv_get_displays(&displays, &display_count))
 618             goto done;
 619
 620         for (i = 0; i < display_id_count; i++)
 621         {
 622             if (display_ids[i] != adapter_id && CGDisplayMirrorsDisplay(display_ids[i]) != adapter_id)
 623                 continue;
 624
 625             /* Find and fill in monitor info */
 626             for (j = 0; j < display_count; j++)
 627             {
 628                 if (displays[j].displayID == display_ids[i]
 629                     || CGDisplayMirrorsDisplay(display_ids[i]) == displays[j].displayID)
 630                 {
 631                     /* Allocate more space if needed */
 632                     if (monitor_count >= capacity)
 633                     {
 634                         capacity *= 2;
 635                         realloc_monitors = realloc(monitors, sizeof(*monitors) * capacity);
 636                         if (!realloc_monitors)
 637                             goto done;
 638                         monitors = realloc_monitors;
 639                     }
 640
 641                     if (j == 0)
 642                         primary_index = monitor_count;
 643
 644                     strcpy(monitors[monitor_count].name, "Generic Non-PnP Monitor");
 645                     monitors[monitor_count].state_flags = DISPLAY_DEVICE_ATTACHED | DISPLAY_DEVICE_ACTIVE;
 646                     monitors[monitor_count].rc_monitor = displays[j].frame;
 647                     monitors[monitor_count].rc_work = displays[j].work_frame;
 648                     monitor_count++;
 649                     break;
 650                 }
 651             }
 652         }
 653
 654         /* Make sure the first monitor on primary adapter is primary */
 655         if (primary_index)
 656         {
 657             struct macdrv_monitor tmp;
 658             tmp = monitors[0];
 659             monitors[0] = monitors[primary_index];
 660             monitors[primary_index] = tmp;
 661         }
 662     }
 663
 664     *new_monitors = monitors;
 665     *count = monitor_count;
 666     ret = 0;
 667 done:
 668     if (displays)
 669         macdrv_free_displays(displays);
 670     if (ret)
 671         macdrv_free_monitors(monitors);
 672     return ret;
 673 }
 674
 675 /***********************************************************************
 676  *              macdrv_free_monitors
 677  *
 678  * Frees an monitor list allocated from macdrv_get_monitors()
 679  */
 680 void macdrv_free_monitors(struct macdrv_monitor* monitors)
 681 {
 682     if (monitors)
 683         free(monitors);
 684 }