aboutsummaryrefslogblamecommitdiffstats
path: root/src/lib/gamma-linux-drm.c
blob: f192310376e7f262dc4aaafa079f6316c6341eeb (plain) (tree)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
















                                                                           

                                                                          

      

                   

                            
                           
                 
 
                   

                   
                     



                   
                   
                     






                            


                           


                       

 

   
                                                                         



                                     
                                                             



         
                                        


                  
     
                                   



                                
                                 


                            



                           
   
                                                    
   
                                                                           


                                                                                          



                                                              

                                                            

                                                                  
                               


                                
                                             
                                          
                                                        


                              
                                                     

                                  
                                    
                              
                                                 

                 



   
                                      
   
                                                 






                                                                         
                                                              



                                                                            






                                                    
                                                        


                                 
                                                       

                                                                              
                                                 

                                 
                                          



                                                 



   
                                              
   
                                


                                                                          
              



   
                                                                         
   
                                 
                                                                       
                                                            


                                                                         

                                             


 







                                                           
                                      


                                            
                                                            

                      
                                                          

                                             
                       
               
      
      

                                                    

                                                                                 
                                                          




                                                                   

                                                 



                                                                        

                                                                

                                  

                                             



                                                  



                                          


                                             


                                                







                                                                  


                                      


                            

   
                                           
   


                                                                                 
                                                                            
                                                                 


                                                                                                   
 
             
                                          

                          

              










                                                    

                          








                                                       
                                                

















                                                                     
                    

           


                                             
            



   
                                       
   
                                        



                                                                                    
                                    



                                                                      
                              


                        
                                      



                                                                      
                                





                          
                                                   
   
                                     


                                                                                    

                                                       

                                                          
             



   
                                                                              
   
                                      
                                                                       
                                                            


                                                                                   

                                             




   
                                      
   


                                                                                      
                                                                            
                                                                 



                                                                                                   
                                                            


                                         
                                                       
           



   
                                              
   
                                


                                                                          
              



   
                                                                           
   
                                 
                                                                       
                                                            


                                                                         

                                             


 
   
                                             
   



                                                                     
   
                                                                                                  






                                                                  




                                                                                        
                             






                                                                                                           
     
                                  
             
                       
                         
                                                                               
                                 
                                      



                                      

                                                  






                                        
                                              
   


                                                                                           
   
                                                                                                                     
 
                                                                  
                                                  
                                  
                             

                                                
                                                        
                            
                                 
     
                                  
                                                                                                           
                                         
                                                                                            
                                     

                                 
                               


 
   
                                     
   

                                                                                               
   

                                                                          
 



                                                             
  











                                                                         
  
               



















                                                                                                         


                                                         





                                       




                                                  





















                                                                         
  
               

















                                                                                                               
                                                                                        





                                                                                                           
                                                                                                 














                                                                                                            

     
                                 
                                                                                       
     



                                                                      
                                                          

                                                                                      
                                                 
      
                                                                                      


                                                                     

                                                                                 
                                                                                         

     

                                                                                   

 

   
                                                              
   



                                                                                                






                                                                                           

                                        
  
                                            

                                             

                                                                                  
                 

                                      
         


                                                                                                            

                                 
                                                         
                                              

                                                                                            

                                        
                                                                              
                                                                                         
                                                             
                                            

                                        

                                       
                                         

                                        
                               

                                
                                               
                                                   



   
                                 
   


                                                                                             




                                                                                                 

                                                                            
                                       

                        

            




                                                                             
                                                      
  
                                                                                   
                                                                                                      
  
                                                                   

                             
                       

                                                         

                                    
                                                    
                                                            



                                                                          

                

                                                              
                                                          

                                                     
                                                    
              
                                                                         






                                                                 
                 

                                       



                                                                                                    
                   
                                                                           
                                           
  
      
                            
                                                                                      
                               
                         
                                                            
                                                                        









                               



   
                                                                      
   

                                                                   
                                                                        
                                                             



                                                                                   
                                                                  

            
                                                     



                                               
                                 
                                                                                                
                                                                 
                                                 



   
                                                              
   

                                            
                                                                        
                                                             



                                                                                 
                                                                  

            
                                                     



                                             

                          

                                                                                          
                         


















                                                                           
                                                                              





                                              

 
/**
 * libgamma — Display server abstraction layer for gamma ramp adjustments
 * Copyright © 2014  Mattias Andrée (maandree@member.fsf.org)
 * 
 * This library is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef HAVE_LIBGAMMA_METHOD_LINUX_DRM
# error Compiling gamma-linux-drm.c without HAVE_LIBGAMMA_METHOD_LINUX_DRM
#endif

#define _GNU_SOURCE

#include "gamma-linux-drm.h"

#include "libgamma-error.h"
#include "edid.h"

#include <limits.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <grp.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>

#include <xf86drm.h>
#include <xf86drmMode.h>

#ifndef O_CLOEXEC
# define O_CLOEXEC  02000000
#endif
#ifndef NGROUPS_MAX
# define NGROUPS_MAX  65536
#endif
#ifndef PATH_MAX
# define PATH_MAX  4096
#endif



/**
 * Graphics card data for the Direct Rendering Manager adjustment method.
 */
typedef struct libgamma_drm_card_data
{
  /**
   * File descriptor for the connection to the graphics card.
   */
  int fd;
  
  /**
   * The graphics card's mode resources.
   */
  drmModeRes* res;
  
  /**
   * Resources for open connectors.
   */
  drmModeConnector** connectors;
  
  /**
   * Resources for open encoders.
   */
  drmModeEncoder** encoders;
  
} libgamma_drm_card_data_t;



/**
 * Return the capabilities of the adjustment method.
 * 
 * @param  this  The data structure to fill with the method's capabilities.
 */
void libgamma_linux_drm_method_capabilities(libgamma_method_capabilities_t* restrict this)
{
  /* Support for all information except gamma ramp support. */
  this->crtc_information = LIBGAMMA_CRTC_INFO_MACRO_EDID
			 | LIBGAMMA_CRTC_INFO_MACRO_VIEWPORT
			 | LIBGAMMA_CRTC_INFO_MACRO_RAMP
			 | LIBGAMMA_CRTC_INFO_SUBPIXEL_ORDER
			 | LIBGAMMA_CRTC_INFO_ACTIVE
			 | LIBGAMMA_CRTC_INFO_MACRO_CONNECTOR;
  /* DRM supports multiple partitions and CRTC:s but not sites. */
  this->default_site_known = 1;
  this->multiple_sites = 0;
  this->multiple_partitions = 1;
  this->multiple_crtcs = 1;
  /* Partitions are graphics cards in DRM. */
  this->partitions_are_graphics_cards = 1;
  /* Linux does not have system restore capabilities. */
  this->site_restore = 0;
  this->partition_restore = 0;
  this->crtc_restore = 0;
  /* Gamma ramp sizes are identical but not fixed. */
  this->identical_gamma_sizes = 1;
  this->fixed_gamma_size = 0;
  /* Gamma ramp depths are fixed. */
  this->fixed_gamma_depth = 1;
  /* DRM is a real non-faked adjustment method */
  this->real = 1;
  this->fake = 0;
}


/**
 * Initialise an allocated site state.
 * 
 * @param   this    The site state to initialise.
 * @param   site    The site identifier, unless it is `NULL` it must a
 *                  `free`:able. One the state is destroyed the library
 *                  will attempt to free it. There you should not free
 *                  it yourself, and it must not be a string constant
 *                  or allocate on the stack. Note however that it will
 *                  not be free:d if this function fails.
 * @return          Zero on success, otherwise (negative) the value of an
 *                  error identifier provided by this library.
 */
int libgamma_linux_drm_site_initialise(libgamma_site_state_t* restrict this,
				       char* restrict site)
{
  char pathname[PATH_MAX];
  struct stat _attr;
  
  if (site != NULL)
    return LIBGAMMA_NO_SUCH_SITE;
  
  /* Count the number of available graphics cards by
     `stat`:ing their existence in an API filesystem. */
  this->partitions_available = 0;
  for (;;)
    {
      /* Construct pathname of graphics card device. */
      snprintf(pathname, sizeof(pathname) / sizeof(char),
	       DRM_DEV_NAME, DRM_DIR_NAME, (int)(this->partitions_available));
      /* `stat` the graphics card's existence. */
      if (stat(pathname, &_attr))
	break;
      /* Move on to next graphics card. */
      if (this->partitions_available++ > INT_MAX)
	return LIBGAMMA_IMPOSSIBLE_AMOUNT;
    }
  return 0;
}


/**
 * Release all resources held by a site state.
 * 
 * @param  this  The site state.
 */
void libgamma_linux_drm_site_destroy(libgamma_site_state_t* restrict this)
{
  (void) this;
}


/**
 * Restore the gamma ramps all CRTC:s with a site to the system settings.
 * 
 * @param   this  The site state.
 * @return        Zero on success, otherwise (negative) the value of an
 *                error identifier provided by this library.
 */
int libgamma_linux_drm_site_restore(libgamma_site_state_t* restrict this)
{
  (void) this;
  return errno = ENOTSUP, LIBGAMMA_ERRNO_SET;
}


/**
 * Figure out why `open` failed for a graphics card
 * 
 * @param   pathname  The pathname of the error card
 * @return            The error code to report
 */
static int figure_out_card_open_error(const char* pathname)
{
  /* Check which the device exists. */
  if ((errno == ENXIO) || (errno == ENODEV))
    return LIBGAMMA_NO_SUCH_PARTITION;
  
  /* If we did not get access permission, figure out why. */
  if (errno == EACCES)
    {
#define __test(R, W) ((attr.st_mode & (R | W)) == (R | W))
      gid_t supplemental_groups[NGROUPS_MAX];
      struct group* group;
      struct stat attr;
      int i, n;
      
      
      /* Get permission requirement for the file. */
      if (stat(pathname, &attr) < 0)
	return errno == EACCES ? LIBGAMMA_NO_SUCH_PARTITION : LIBGAMMA_ERRNO_SET;
      
      /* Test owner's, group's and others' permissions. */
      if ((attr.st_uid == geteuid() && __test(S_IRUSR, S_IWUSR)) ||
	  (attr.st_gid == getegid() && __test(S_IRGRP, S_IWGRP)) ||
	  __test(S_IROTH, S_IWOTH))
	return LIBGAMMA_DEVICE_ACCESS_FAILED;
      
      /* The group should be "video", but perhaps
	 it is "root" to restrict users. */
      if (attr.st_gid == 0 /* root group */ || __test(S_IRGRP, S_IWGRP))
	return LIBGAMMA_DEVICE_RESTRICTED;
      
      
      /* Get the user's supplemental group membership list. */
      if ((n = getgroups(NGROUPS_MAX, supplemental_groups)) < 0)
	return LIBGAMMA_ERRNO_SET;
      
      /* Test whether any of the supplemental
	 group should be satisfactory. */
      for (i = 0; i < n; i++)
	if (supplemental_groups[i] == attr.st_gid)
	  break;
      
      /* If one of the supplemental groups
	 should be satisfactory, then we
	 do not know anything more than
	 that access failed. */
      if (i != n)
	return LIBGAMMA_DEVICE_ACCESS_FAILED;
      
      /* Otherwise, try to get the name of
	 the group that is required and
	 report the missing group membership. */
      errno = 0;
      group = getgrgid(attr.st_gid); /* TODO: Not thread-safe. */
      libgamma_group_gid = attr.st_gid;
      libgamma_group_name = group != NULL ? group->gr_name : NULL;
      return LIBGAMMA_DEVICE_REQUIRE_GROUP;
#undef __test
    }
  
  /* If we could not figure out what
     went wrong, just return the error
     we got. */
  return LIBGAMMA_ERRNO_SET;
}


/**
 * Initialise an allocated partition state.
 * 
 * @param   this       The partition state to initialise.
 * @param   site       The site state for the site that the partition belongs to.
 * @param   partition  The the index of the partition within the site.
 * @return             Zero on success, otherwise (negative) the value of an
 *                     error identifier provided by this library.
 */
int libgamma_linux_drm_partition_initialise(libgamma_partition_state_t* restrict this,
					    libgamma_site_state_t* restrict site, size_t partition)
{
  int rc = 0;
  libgamma_drm_card_data_t* restrict data;
  char pathname[PATH_MAX];
  
  (void) site;
  
  /* Check for partition index overflow. */
  if (partition > INT_MAX)
    return LIBGAMMA_NO_SUCH_PARTITION;
  
  /* Allocate and initialise graphics card data.  */
  this->data = NULL;
  data = malloc(sizeof(libgamma_drm_card_data_t));
  if (data == NULL)
    return LIBGAMMA_ERRNO_SET;
  data->fd = -1;
  data->res = NULL;
  data->encoders = NULL;
  data->connectors = NULL;
  
  /* Get the pathname for the graphics card. */
  snprintf(pathname, sizeof(pathname) / sizeof(char),
	   DRM_DEV_NAME, DRM_DIR_NAME, (int)partition);
  
  /* Acquire access to the graphics card. */
  data->fd = open(pathname, O_RDWR | O_CLOEXEC);
  if (data->fd < 0)
    {
      rc = figure_out_card_open_error(pathname);
      goto fail_data;
    }
  
  /* Acquire mode resources. */
  data->res = drmModeGetResources(data->fd);
  if (data->res == NULL)
    {
      rc = LIBGAMMA_ACQUIRING_MODE_RESOURCES_FAILED;
      goto fail_fd;
    }
  
  /* Get the number of CRTC:s that are available in the partition. */
  if (data->res->count_crtcs < 0)
    {
      rc = LIBGAMMA_NEGATIVE_CRTC_COUNT;
      goto fail_res;
    }
  this->crtcs_available = (size_t)(data->res->count_crtcs);
  this->data = data;
  return 0;
  
 fail_res:   drmModeFreeResources(data->res);
 fail_fd:    close(data->fd);
 fail_data:  free(data);
  return rc;
}


/**
 * Release all connectors and encoders.
 * 
 * @param  this  The graphics card data.
 */
static void release_connectors_and_encoders(libgamma_drm_card_data_t* restrict this)
{
  size_t i, n;
  /* Release individual encoders. */
  if (this->encoders != NULL)
    for (i = 0, n = (size_t)(this->res->count_connectors); i < n; i++)
      if (this->encoders[i] != NULL)
	drmModeFreeEncoder(this->encoders[i]);
  /* Release encoder array. */
  free(this->encoders);
  this->encoders = NULL;
  
  /* Release individual connectors. */
  if (this->connectors != NULL)
    for (i = 0, n = (size_t)(this->res->count_connectors); i < n; i++)
      if (this->connectors[i] != NULL)
	drmModeFreeConnector(this->connectors[i]);
  /* Release connector array. */
  free(this->connectors);
  this->connectors = NULL;
}


/**
 * Release all resources held by a partition state.
 * 
 * @param  this  The partition state.
 */
void libgamma_linux_drm_partition_destroy(libgamma_partition_state_t* restrict this)
{
  libgamma_drm_card_data_t* restrict data = this->data;
  release_connectors_and_encoders(data);
  if (data->res != NULL)  drmModeFreeResources(data->res);
  if (data->fd >= 0)      close(data->fd);
  free(data);
}


/**
 * Restore the gamma ramps all CRTC:s with a partition to the system settings.
 * 
 * @param   this  The partition state.
 * @return        Zero on success, otherwise (negative) the value of an
 *                error identifier provided by this library.
 */
int libgamma_linux_drm_partition_restore(libgamma_partition_state_t* restrict this)
{
  (void) this;
  return errno = ENOTSUP, LIBGAMMA_ERRNO_SET;
}



/**
 * Initialise an allocated CRTC state.
 * 
 * @param   this       The CRTC state to initialise.
 * @param   partition  The partition state for the partition that the CRTC belongs to.
 * @param   crtc       The the index of the CRTC within the site.
 * @return             Zero on success, otherwise (negative) the value of an
 *                     error identifier provided by this library.
 */
int libgamma_linux_drm_crtc_initialise(libgamma_crtc_state_t* restrict this,
				       libgamma_partition_state_t* restrict partition, size_t crtc)
{
  libgamma_drm_card_data_t* restrict card = partition->data;
  
  if (crtc >= partition->crtcs_available)
    return LIBGAMMA_NO_SUCH_CRTC;
  this->data = (void*)(size_t)(card->res->crtcs[crtc]);
  return 0;
}


/**
 * Release all resources held by a CRTC state.
 * 
 * @param  this  The CRTC state.
 */
void libgamma_linux_drm_crtc_destroy(libgamma_crtc_state_t* restrict this)
{
  (void) this;
}


/**
 * Restore the gamma ramps for a CRTC to the system settings for that CRTC.
 * 
 * @param   this  The CRTC state.
 * @return        Zero on success, otherwise (negative) the value of an
 *                error identifier provided by this library.
 */
int libgamma_linux_drm_crtc_restore(libgamma_crtc_state_t* restrict this)
{
  (void) this;
  return errno = ENOTSUP, LIBGAMMA_ERRNO_SET;
}


/**
 * Find the connector that a CRTC belongs to.
 * 
 * @param   this   The CRTC state.
 * @param   error  Output of the error value to store of error report
 *                 fields for data that requires the connector.
'* @return         The CRTC's conncetor, `NULL` on error.
 */
static drmModeConnector* find_connector(libgamma_crtc_state_t* restrict this, int* restrict error)
{
  uint32_t crtc_id = (uint32_t)(size_t)(this->data);
  libgamma_drm_card_data_t* restrict card = this->partition->data;
  size_t i, n = (size_t)(card->res->count_connectors);
  /* Open connectors and encoders if not already opened. */
  if (card->connectors == NULL)
    {
      /* Allocate connector and encoder arrays.
	 We use `calloc` so all non-loaded elements are `NULL` after an error. */
      if ((card->connectors = calloc(n, sizeof(drmModeConnector*))) == NULL)  goto fail;
      if ((card->encoders   = calloc(n, sizeof(drmModeEncoder*)))   == NULL)  goto fail;
      /* Fill connector and encoder arrays. */
      for (i = 0; i < n; i++)
	{
	  if ((card->connectors[i] = drmModeGetConnector(card->fd, card->res->connectors[i])) == NULL)
	    goto fail;
	  if ((card->connectors[i]->encoder_id != 0) &&
	      ((card->encoders[i] = drmModeGetEncoder(card->fd, card->connectors[i]->encoder_id)) == NULL))
	    goto fail;
	}
    }
  /* No error has occurred yet. */
  *error = 0;
  /* Find connector. */
  for (i = 0; i < n; i++)
    if ((card->encoders[i] != NULL) && (card->encoders[i]->crtc_id == crtc_id))
      return card->connectors[i];
  /* We did not find the connector. */
  *error = LIBGAMMA_CONNECTOR_UNKNOWN;
  return NULL;
  
 fail:
  /* Report the error that got us here, release
     resouces and exit with `NULL` for failure. */
  *error = errno;
  release_connectors_and_encoders(card);
  return NULL;
}


/**
 * Get the size of the gamma ramps for a CRTC.
 * 
 * @param   out   Instance of a data structure to fill with the information about the CRTC.
 * @param   crtc  The state of the CRTC whose information should be read.
 * @return        The value stored in `out->gamma_size_error`.
 */
static int get_gamma_ramp_size(libgamma_crtc_information_t* restrict out, const libgamma_crtc_state_t* restrict crtc)
{
  libgamma_drm_card_data_t* restrict card = crtc->partition->data;
  uint32_t crtc_id = card->res->crtcs[crtc->crtc];
  drmModeCrtc* restrict crtc_info;
  /* Get CRTC information. */
  errno = 0;
  crtc_info = drmModeGetCrtc(card->fd, crtc_id);
  out->gamma_size_error = crtc_info == NULL ? errno : 0;
  /* Get gamma ramp size. */
  if (out->gamma_size_error == 0)
    {
      /* Store gamma ramp size. */
      out->red_gamma_size = out->green_gamma_size = out->blue_gamma_size = (size_t)(crtc_info->gamma_size);
      /* Sanity check gamma ramp size. */
      out->gamma_size_error = crtc_info->gamma_size < 2 ? LIBGAMMA_SINGLETON_GAMMA_RAMP : 0;
      /* Release CRTC information. */
      drmModeFreeCrtc(crtc_info);
    }
  return out->gamma_size_error;
}


/**
 * Get the a monitor's subpixel order
 * 
 * @param  out        Instance of a data structure to fill with the information about the CRTC.
 * @param  connector  The connector.
 */
static void get_subpixel_order(libgamma_crtc_information_t* restrict out,
			       const drmModeConnector* restrict connector)
{
#define __select(value)					    \
  case DRM_MODE_SUBPIXEL_##value:			    \
    out->subpixel_order = LIBGAMMA_SUBPIXEL_ORDER_##value;  \
    break
  
  switch (connector->subpixel)
    {
    __select (UNKNOWN);
    __select (HORIZONTAL_RGB);
    __select (HORIZONTAL_BGR);
    __select (VERTICAL_RGB);
    __select (VERTICAL_BGR);
    __select (NONE);
    default:
      out->subpixel_order_error = LIBGAMMA_SUBPIXEL_ORDER_NOT_RECOGNISED;
      break;
    }
  
#undef __select
}


/**
 * Get a connector's type
 * 
 * @param  out                  Instance of a data structure to fill with the information about the CRTC.
 * @param  connector            The connector.
 * @param  connector_name_base  Output for the basename of the connector.
 */
static void get_connector_type(libgamma_crtc_information_t* restrict out,
			       const drmModeConnector* restrict connector,
			       const char** restrict connector_name_base)
{
#define __select(type, name)				   \
  case DRM_MODE_CONNECTOR_##type:			   \
    out->connector_type = LIBGAMMA_CONNECTOR_TYPE_##type;  \
    *connector_name_base = name;			   \
    break
  
  /* These may not have been included by <xf86drmMode.h>,
     but they should be available. Becuase we define them
     outself, it is best to test them last. */
#ifndef DRM_MODE_CONNECTOR_VIRTUAL
# define DRM_MODE_CONNECTOR_VIRTUAL  15
#endif
#ifndef DRM_MODE_CONNECTOR_DSI
# define DRM_MODE_CONNECTOR_DSI  16
#endif
  
  /* Translate connector type from DRM to libgamma
     and store connector basename. */
  switch (connector->connector_type)
    {
    __select (Unknown,      "Unknown"  );
    __select (VGA,          "VGA"      );
    __select (DVII,         "DVI-I"    );
    __select (DVID,         "DVI-D"    );
    __select (DVIA,         "DVI-A"    );
    __select (Composite,    "Composite");
    __select (SVIDEO,       "SVIDEO"   );
    __select (LVDS,         "LVDS"     );
    __select (Component,    "Component");
    __select (9PinDIN,      "DIN"      );
    __select (DisplayPort,  "DP"       );
    __select (HDMIA,        "HDMI-A"   );
    __select (HDMIB,        "HDMI-B"   );
    __select (TV,           "TV"       );
    __select (eDP,          "eDP"      );
    __select (VIRTUAL,      "VIRTUAL"  );
    __select (DSI,          "DSI"      );
    default:
      out->connector_type_error = LIBGAMMA_CONNECTOR_TYPE_NOT_RECOGNISED;
      out->connector_name_error = LIBGAMMA_CONNECTOR_TYPE_NOT_RECOGNISED;
      break;
    }
  
#undef __select
}


/**
 * Read information from the CRTC's conncetor.
 * 
 * @param   crtc       The state of the CRTC whose information should be read.
 * @param   out        Instance of a data structure to fill with the information about the CRTC.
 * @param   connector  The CRTC's connector.
 * @param   fields     OR:ed identifiers for the information about the CRTC that should be read.
 * @return             Non-zero if at least on error occured.
 */
static int read_connector_data(libgamma_crtc_state_t* restrict crtc, libgamma_crtc_information_t* restrict out,
			       const drmModeConnector* restrict connector, int32_t fields)
{
  const char* connector_name_base = NULL;
  
  /* Get some information that does not require too much work. */
  if ((fields & (LIBGAMMA_CRTC_INFO_MACRO_ACTIVE | LIBGAMMA_CRTC_INFO_MACRO_CONNECTOR)))
    {
      /* Get whether or not a monitor is plugged in. */
      out->active = connector->connection == DRM_MODE_CONNECTED;
      out->active_error = connector->connection == DRM_MODE_UNKNOWNCONNECTION ? LIBGAMMA_STATE_UNKNOWN : 0;
      if (out->active == 0)
	{
	  if ((fields & (LIBGAMMA_CRTC_INFO_MACRO_VIEWPORT | LIBGAMMA_CRTC_INFO_SUBPIXEL_ORDER)))
	    out->width_mm_error = out->height_mm_error = out->subpixel_order_error = LIBGAMMA_NOT_CONNECTED;
	  goto not_connected;
	}
      
      /* Get viewport dimension. */
      out->width_mm = connector->mmWidth;
      out->height_mm = connector->mmHeight;
      
      /* Get subpixel order. */
      get_subpixel_order(out, connector);
      
    not_connected:
      
      /* Get connector type. */
      get_connector_type(out, connector, &connector_name_base);
    }
  
  /* Get the connector's name. */
  if ((fields & LIBGAMMA_CRTC_INFO_CONNECTOR_NAME) && (out->connector_name_error == 0))
    {
      libgamma_drm_card_data_t* restrict card = crtc->partition->data;
      uint32_t type = connector->connector_type;
      size_t i, n = (size_t)(card->res->count_connectors), c = 0;
      
      /* Allocate memory for the name of the connector. */
      out->connector_name = malloc((strlen(connector_name_base) + 12) * sizeof(char));
      if (out->connector_name == NULL)
	return out->connector_name_error = errno;
      
      /* Get the number of connectors with the same type on the same graphics card. */
      for (i = 0; (i < n) && (card->connectors[i] != connector); i++)
	if (card->connectors[i]->connector_type == type)
	  c++;
      
      /* Construct and store connect name that is unique to the graphics card. */
      sprintf(out->connector_name, "%s-" PRIu32, connector_name_base, (uint32_t)(c + 1));
    }
  
  /* Did something go wrong? */
  return out->subpixel_order_error | out->active_error | out->connector_name_error;
}


/**
 * Get the extended display identification data for a monitor.
 * 
 * @param   crtc       The CRTC state.
 * @param   out        Instance of a data structure to fill with the information about the CRTC.
 * @param   connector  The CRTC's connector.
 * @reutnr             Non-zero on error.
 */
static int get_edid(libgamma_crtc_state_t* restrict crtc,
		    libgamma_crtc_information_t* restrict out, drmModeConnector* connector)
{
  libgamma_drm_card_data_t* restrict card = crtc->partition->data;
  int prop_n = connector->count_props;
  int prop_i;
  drmModePropertyRes* restrict prop;
  drmModePropertyBlobRes* restrict blob;
  
  /* Test all properies on the connector. */
  for (prop_i = 0; prop_i < prop_n; prop_i++)
    {
      /* Get output property, */
      if ((prop = drmModeGetProperty(card->fd, connector->props[prop_i])) == NULL)
	continue;
      /* Is this property the EDID? */
      if (!strcmp(prop->name, "EDID"))
	{
	  /* Get the property value. */
	  if ((blob = drmModeGetPropertyBlob(card->fd, (uint32_t)(connector->prop_values[prop_i]))) == NULL)
	    return drmModeFreeProperty(prop), out->edid_error = LIBGAMMA_PROPERTY_VALUE_QUERY_FAILED;
	  if (blob->data != NULL)
	    {
	      /* Get and store the length of the EDID. */
	      out->edid_length = blob->length;
	      /* Allocate memory for a copy of the EDID that is under our memory control. */
	      if ((out->edid = malloc(out->edid_length * sizeof(unsigned char))) == NULL)
		out->edid_error = errno;
	      else
		/* Copy the EDID so we can free resources that got us here. */
		memcpy(out->edid, blob->data, (size_t)(out->edid_length) * sizeof(char));
	      /* Free the propriety value and the propery. */
	      drmModeFreePropertyBlob(blob);
	      drmModeFreeProperty(prop);
	      /* Were we successful? */
	      return out->edid == NULL;
	    }
	  /* Free the propriety value. */
	  drmModeFreePropertyBlob(blob);
	}
      /* Free the propriety. */
      drmModeFreeProperty(prop);
    }
  /* If we get here, we did not find a EDID. */
  return out->edid_error = LIBGAMMA_EDID_NOT_FOUND;
}


/**
 * Read information about a CRTC.
 * 
 * @param   this    Instance of a data structure to fill with the information about the CRTC.
 * @param   crtc    The state of the CRTC whose information should be read.
 * @param   fields  OR:ed identifiers for the information about the CRTC that should be read.
 * @return          Zero on success, -1 on error. On error refer to the error reports in `this`.
 */
int libgamma_linux_drm_get_crtc_information(libgamma_crtc_information_t* restrict this,
					    libgamma_crtc_state_t* restrict crtc, int32_t fields)
{
#define _E(FIELD)  ((fields & FIELD) ? LIBGAMMA_CRTC_INFO_NOT_SUPPORTED : 0)
  int e = 0;
  drmModeConnector* restrict connector;
  int require_connector;
  int free_edid;
  int error;
  
  
  /* Wipe all error indicators. */
  memset(this, 0, sizeof(libgamma_crtc_information_t));
  
  /* We need to free the EDID after us if it is not explicitly requested.  */
  free_edid = (fields & LIBGAMMA_CRTC_INFO_EDID) == 0;
  
  /* Figure out whether we require the connector to get all information we want. */
  require_connector = fields & (LIBGAMMA_CRTC_INFO_MACRO_ACTIVE | LIBGAMMA_CRTC_INFO_MACRO_CONNECTOR);
  
  /* If we are not interested in the connector or monitor, jump. */
  if (require_connector == 0)
    goto cont;
  /* Find connector. */
  if ((connector = find_connector(crtc, &error)) == NULL)
    {
      perror("connector not found");
      abort();
      /* Store reported error in affected fields. */
      e |= this->width_mm_error      = this->height_mm_error
	 = this->connector_type      = this->subpixel_order_error
	 = this->active_error        = this->connector_name_error
	 = this->edid_error          = this->gamma_error
	 = this->width_mm_edid_error = this->height_mm_edid_error = error;
      goto cont;
    }
  
  /* Read connector data and monitor data, excluding EDID.. */
  e |= read_connector_data(crtc, this, connector, fields);
  
  /* If we do not want any EDID information, jump. */
  if ((fields & LIBGAMMA_CRTC_INFO_MACRO_EDID) == 0)
    goto cont;
  /* If there is not monitor that report error in EDID related fields. */
  if (this->active_error || (this->active == 0))
    {
      e |= this->edid_error = this->gamma_error
	 = this->width_mm_edid_error = this->height_mm_edid_error
	 = LIBGAMMA_NOT_CONNECTED;
      goto cont;
    }
  /* Get EDID. */
  e |= get_edid(crtc, this, connector);
  if (this->edid == NULL)
    {
      this->gamma_error = this->width_mm_edid_error = this->height_mm_edid_error = this->edid_error;
      goto cont;
    }
  /* Parse EDID. */
  if ((fields & (LIBGAMMA_CRTC_INFO_MACRO_EDID ^ LIBGAMMA_CRTC_INFO_EDID)))
    e |= libgamma_parse_edid(this, fields);
  
 cont:
  /* Get gamma ramp size. */
  e |= (fields & LIBGAMMA_CRTC_INFO_GAMMA_SIZE) ? get_gamma_ramp_size(this, crtc) : 0;
  /* Store gamma ramp depth. */
  this->gamma_depth = 16;
  /* X RandR does not support quering gamma ramp support. */
  e |= this->gamma_support_error = _E(LIBGAMMA_CRTC_INFO_GAMMA_SUPPORT);
  
  /* Free the EDID after us. */
  if (free_edid)
    {
      free(this->edid);
      this->edid = NULL;
    }
  
  return e ? -1 : 0;
#undef _E
}


/**
 * Get current the gamma ramps for a CRTC, 16-bit gamma-depth version.
 * 
 * @param   this   The CRTC state.
 * @param   ramps  The gamma ramps to fill with the current values.
 * @return         Zero on success, otherwise (negative) the value of an
 *                 error identifier provided by this library.
 */
int libgamma_linux_drm_crtc_get_gamma_ramps(libgamma_crtc_state_t* restrict this,
					    libgamma_gamma_ramps_t* restrict ramps)
{
  libgamma_drm_card_data_t* restrict card = this->partition->data;
  int r;
#ifdef DEBUG
  /* Gamma ramp sizes are identical but not fixed. */
  if ((ramps->red_size != ramps->green_size) ||
      (ramps->red_size != ramps->blue_size))
    return LIBGAMMA_MIXED_GAMMA_RAMP_SIZE;
#endif
  /* Read current gamma ramps. */
  r = drmModeCrtcGetGamma(card->fd, (uint32_t)(size_t)(this->data), (uint32_t)(ramps->red_size),
			  ramps->red, ramps->green, ramps->blue);
  return r ? LIBGAMMA_GAMMA_RAMP_READ_FAILED : 0;
}


/**
 * Set the gamma ramps for a CRTC, 16-bit gamma-depth version.
 * 
 * @param   this   The CRTC state.
 * @param   ramps  The gamma ramps to apply.
 * @return         Zero on success, otherwise (negative) the value of an
 *                 error identifier provided by this library.
 */
int libgamma_linux_drm_crtc_set_gamma_ramps(libgamma_crtc_state_t* restrict this,
					    libgamma_gamma_ramps_t ramps)
{
  libgamma_drm_card_data_t* restrict card = this->partition->data;
  int r;
#ifdef DEBUG
  /* Gamma ramp sizes are identical but not fixed. */
  if ((ramps.red_size != ramps.green_size) ||
      (ramps.red_size != ramps.blue_size))
    return LIBGAMMA_MIXED_GAMMA_RAMP_SIZE;
#endif
  
  /* Apply gamma ramps. */
  r = drmModeCrtcSetGamma(card->fd, (uint32_t)(size_t)(this->data),
			  (uint32_t)(ramps.red_size), ramps.red, ramps.green, ramps.blue);
  /* Check for errors. */
  if (r)
    switch (errno)
      {
      case EACCES:
      case EAGAIN:
      case EIO:
	/* Permission denied errors must be ignored, because we do not
	 * have permission to do this while a display server is active.
	 * We are also checking for some other error codes just in case. */
      case EBUSY:
      case EINPROGRESS:
	/* It is hard to find documentation for DRM (in fact all of this is
	 * just based on the functions names and some testing,) perhaps we
	 * could get this if we are updating to fast. */
	break;
      case EBADF:
      case ENODEV:
      case ENXIO:
	/* XXX: I have not actually tested removing my graphics card or,
	 *      monitor but I imagine either of these is what would happen. */
	return LIBGAMMA_GRAPHICS_CARD_REMOVED;

      default:
	return LIBGAMMA_ERRNO_SET;
      }
  return 0;
}