Merge branch 'incl_adl' into bfgminer

Conflicts:
	make-release

ADL/adl_defines.h

@@ -0,0 +1,762 @@
+#ifndef ADL_DEFINES_H_
+#define ADL_DEFINES_H_
+
+enum {
+	ADL_FALSE = 0,
+	ADL_TRUE  = 1,
+};
+
+#define ADL_MAX_CHAR           4096
+#define ADL_MAX_PATH            256
+#define ADL_MAX_ADAPTERS        150
+#define ADL_MAX_DISPLAYS        150
+#define ADL_MAX_DEVICENAME       32
+#define ADL_ADAPTER_INDEX_ALL    -1
+#define ADL_MAIN_API_OPTION_NONE  0
+
+enum {
+	ADL_DDC_OPTION_SWITCHDDC2     = 1,
+	ADL_DDC_OPTION_RESTORECOMMAND = 2,
+};
+
+enum {
+	ADL_DL_I2C_ACTIONREAD               = 1,
+	ADL_DL_I2C_ACTIONWRITE              = 2,
+	ADL_DL_I2C_ACTIONREAD_REPEATEDSTART = 3,
+};
+
+enum {
+	ADL_OK_WAIT                    = 4,
+	ADL_OK_RESTART                 = 3,
+	ADL_OK_MODE_CHANGE             = 2,
+	ADL_OK_WARNING                 = 1,
+	ADL_OK                         = 0,
+	ADL_ERR                        = -1,
+	ADL_ERR_NOT_INIT               = -2,
+	ADL_ERR_INVALID_PARAM          = -3,
+	ADL_ERR_INVALID_PARAM_SIZE     = -4,
+	ADL_ERR_INVALID_ADL_IDX        = -5,
+	ADL_ERR_INVALID_CONTROLLER_IDX = -6,
+	ADL_ERR_INVALID_DIPLAY_IDX     = -7,
+	ADL_ERR_NOT_SUPPORTED          = -8,
+	ADL_ERR_NULL_POINTER           = -9,
+	ADL_ERR_DISABLED_ADAPTER       = -10,
+	ADL_ERR_INVALID_CALLBACK       = -11,
+	ADL_ERR_RESOURCE_CONFLICT      = -12,
+};
+
+enum {
+	ADL_DT_MONITOR            = 0,
+	ADL_DT_TELEVISION         = 1,
+	ADL_DT_LCD_PANEL          = 2,
+	ADL_DT_DIGITAL_FLAT_PANEL = 3,
+	ADL_DT_COMPONENT_VIDEO    = 4,
+	ADL_DT_PROJECTOR          = 5,
+};
+
+enum {
+	ADL_DOT_UNKNOWN   = 0,
+	ADL_DOT_COMPOSITE = 1,
+	ADL_DOT_SVIDEO    = 2,
+	ADL_DOT_ANALOG    = 3,
+	ADL_DOT_DIGITAL   = 4,
+};
+
+enum {
+	ADL_DISPLAY_COLOR_BRIGHTNESS  = (1 << 0),
+	ADL_DISPLAY_COLOR_CONTRAST    = (1 << 1),
+	ADL_DISPLAY_COLOR_SATURATION  = (1 << 2),
+	ADL_DISPLAY_COLOR_HUE         = (1 << 3),
+	ADL_DISPLAY_COLOR_TEMPERATURE = (1 << 4),
+	ADL_DISPLAY_COLOR_TEMPERATURE_SOURCE_EDID = (1 << 5),
+	ADL_DISPLAY_COLOR_TEMPERATURE_SOURCE_USER = (1 << 6),
+};
+
+enum {
+	ADL_DISPLAY_ADJUST_OVERSCAN  = (1 << 0),
+	ADL_DISPLAY_ADJUST_VERT_POS  = (1 << 1),
+	ADL_DISPLAY_ADJUST_HOR_POS   = (1 << 2),
+	ADL_DISPLAY_ADJUST_VERT_SIZE = (1 << 3),
+	ADL_DISPLAY_ADJUST_HOR_SIZE  = (1 << 4),
+	ADL_DISPLAY_ADJUST_SIZEPOS   = (ADL_DISPLAY_ADJUST_VERT_POS | ADL_DISPLAY_ADJUST_HOR_POS | ADL_DISPLAY_ADJUST_VERT_SIZE | ADL_DISPLAY_ADJUST_HOR_SIZE),
+	ADL_DISPLAY_CUSTOMMODES      = (1 << 5),
+	ADL_DISPLAY_ADJUST_UNDERSCAN = (1 << 6),
+};
+
+enum {
+	ADL_DESKTOPCONFIG_UNKNOWN    = 0,
+	ADL_DESKTOPCONFIG_SINGLE     = (1 << 0),
+	ADL_DESKTOPCONFIG_CLONE      = (1 << 2),
+	ADL_DESKTOPCONFIG_BIGDESK_H  = (1 << 4),
+	ADL_DESKTOPCONFIG_BIGDESK_V  = (1 << 5),
+	ADL_DESKTOPCONFIG_BIGDESK_HR = (1 << 6),
+	ADL_DESKTOPCONFIG_BIGDESK_VR = (1 << 7),
+	ADL_DESKTOPCONFIG_RANDR12    = (1 << 8),
+};
+
+#define ADL_MAX_DISPLAY_NAME  256
+
+enum {
+	ADL_DISPLAYDDCINFOEX_FLAG_PROJECTORDEVICE  = (1 << 0),
+	ADL_DISPLAYDDCINFOEX_FLAG_EDIDEXTENSION    = (1 << 1),
+	ADL_DISPLAYDDCINFOEX_FLAG_DIGITALDEVICE    = (1 << 2),
+	ADL_DISPLAYDDCINFOEX_FLAG_HDMIAUDIODEVICE  = (1 << 3),
+	ADL_DISPLAYDDCINFOEX_FLAG_SUPPORTS_AI      = (1 << 4),
+	ADL_DISPLAYDDCINFOEX_FLAG_SUPPORT_xvYCC601 = (1 << 5),
+	ADL_DISPLAYDDCINFOEX_FLAG_SUPPORT_xvYCC709 = (1 << 6),
+};
+
+enum {
+	ADL_DISPLAY_CONTYPE_UNKNOWN                 =  0,
+	ADL_DISPLAY_CONTYPE_VGA                     =  1,
+	ADL_DISPLAY_CONTYPE_DVI_D                   =  2,
+	ADL_DISPLAY_CONTYPE_DVI_I                   =  3,
+	ADL_DISPLAY_CONTYPE_ATICVDONGLE_NTSC        =  4,
+	ADL_DISPLAY_CONTYPE_ATICVDONGLE_JPN         =  5,
+	ADL_DISPLAY_CONTYPE_ATICVDONGLE_NONI2C_JPN  =  6,
+	ADL_DISPLAY_CONTYPE_ATICVDONGLE_NONI2C_NTSC =  7,
+	ADL_DISPLAY_CONTYPE_HDMI_TYPE_A             = 10,
+	ADL_DISPLAY_CONTYPE_HDMI_TYPE_B             = 11,
+	ADL_DISPLAY_CONTYPE_SVIDEO                  = 12,
+	ADL_DISPLAY_CONTYPE_COMPOSITE               = 13,
+	ADL_DISPLAY_CONTYPE_RCA_3COMPONENT          = 14,
+	ADL_DISPLAY_CONTYPE_DISPLAYPORT             = 15,
+};
+
+enum {
+	ADL_TV_STANDARDS = (1 << 0),
+	ADL_TV_SCART     = (1 << 1),
+};
+
+enum {
+	ADL_STANDARD_NTSC_M       = (1 <<  0),
+	ADL_STANDARD_NTSC_JPN     = (1 <<  1),
+	ADL_STANDARD_NTSC_N       = (1 <<  2),
+	ADL_STANDARD_PAL_B        = (1 <<  3),
+	ADL_STANDARD_PAL_COMB_N   = (1 <<  4),
+	ADL_STANDARD_PAL_D        = (1 <<  5),
+	ADL_STANDARD_PAL_G        = (1 <<  6),
+	ADL_STANDARD_PAL_H        = (1 <<  7),
+	ADL_STANDARD_PAL_I        = (1 <<  8),
+	ADL_STANDARD_PAL_K        = (1 <<  9),
+	ADL_STANDARD_PAL_K1       = (1 << 10),
+	ADL_STANDARD_PAL_L        = (1 << 11),
+	ADL_STANDARD_PAL_M        = (1 << 12),
+	ADL_STANDARD_PAL_N        = (1 << 13),
+	ADL_STANDARD_PAL_SECAM_D  = (1 << 14),
+	ADL_STANDARD_PAL_SECAM_K  = (1 << 15),
+	ADL_STANDARD_PAL_SECAM_K1 = (1 << 16),
+	ADL_STANDARD_PAL_SECAM_L  = (1 << 17),
+};
+
+enum {
+	ADL_CUSTOMIZEDMODEFLAG_MODESUPPORTED  = (1 << 0),
+	ADL_CUSTOMIZEDMODEFLAG_NOTDELETETABLE = (1 << 1),
+	ADL_CUSTOMIZEDMODEFLAG_INSERTBYDRIVER = (1 << 2),
+	ADL_CUSTOMIZEDMODEFLAG_INTERLACED     = (1 << 3),
+	ADL_CUSTOMIZEDMODEFLAG_BASEMODE       = (1 << 4),
+};
+
+enum {
+	ADL_DISPLAY_CV_DONGLE_D1 = (1 << 0),
+	ADL_DISPLAY_CV_DONGLE_D2 = (1 << 1),
+	ADL_DISPLAY_CV_DONGLE_D3 = (1 << 2),
+	ADL_DISPLAY_CV_DONGLE_D4 = (1 << 3),
+	ADL_DISPLAY_CV_DONGLE_D5 = (1 << 4),
+};
+
+enum {
+	ADL_DISPLAY_CV_DONGLE_480I    = (1 <<  0),
+	ADL_DISPLAY_CV_DONGLE_480P    = (1 <<  1),
+	ADL_DISPLAY_CV_DONGLE_540P    = (1 <<  2),
+	ADL_DISPLAY_CV_DONGLE_720P    = (1 <<  3),
+	ADL_DISPLAY_CV_DONGLE_1080I   = (1 <<  4),
+	ADL_DISPLAY_CV_DONGLE_1080P   = (1 <<  5),
+	ADL_DISPLAY_CV_DONGLE_16_9    = (1 <<  6),
+	ADL_DISPLAY_CV_DONGLE_720P50  = (1 <<  7),
+	ADL_DISPLAY_CV_DONGLE_1080I25 = (1 <<  8),
+	ADL_DISPLAY_CV_DONGLE_576I25  = (1 <<  9),
+	ADL_DISPLAY_CV_DONGLE_576P50  = (1 << 10),
+	ADL_DISPLAY_CV_DONGLE_1080P24 = (1 << 11),
+	ADL_DISPLAY_CV_DONGLE_1080P25 = (1 << 12),
+	ADL_DISPLAY_CV_DONGLE_1080P30 = (1 << 13),
+	ADL_DISPLAY_CV_DONGLE_1080P50 = (1 << 14),
+};
+
+enum {
+	ADL_DISPLAY_FORMAT_FORCE_720P    = (1 <<  0),
+	ADL_DISPLAY_FORMAT_FORCE_1080I   = (1 <<  1),
+	ADL_DISPLAY_FORMAT_FORCE_1080P   = (1 <<  2),
+	ADL_DISPLAY_FORMAT_FORCE_720P50  = (1 <<  3),
+	ADL_DISPLAY_FORMAT_FORCE_1080I25 = (1 <<  4),
+	ADL_DISPLAY_FORMAT_FORCE_576I25  = (1 <<  5),
+	ADL_DISPLAY_FORMAT_FORCE_576P50  = (1 <<  6),
+	ADL_DISPLAY_FORMAT_FORCE_1080P24 = (1 <<  7),
+	ADL_DISPLAY_FORMAT_FORCE_1080P25 = (1 <<  8),
+	ADL_DISPLAY_FORMAT_FORCE_1080P30 = (1 <<  9),
+	ADL_DISPLAY_FORMAT_FORCE_1080P50 = (1 << 10),
+};
+
+enum {
+	ADL_DISPLAY_FORMAT_CVDONGLEOVERIDE           = (1 << 0),
+	ADL_DISPLAY_FORMAT_CVMODEUNDERSCAN           = (1 << 1),
+	ADL_DISPLAY_FORMAT_FORCECONNECT_SUPPORTED    = (1 << 2),
+	ADL_DISPLAY_FORMAT_RESTRICT_FORMAT_SELECTION = (1 << 3),
+	ADL_DISPLAY_FORMAT_SETASPECRATIO             = (1 << 4),
+	ADL_DISPLAY_FORMAT_FORCEMODES                = (1 << 5),
+	ADL_DISPLAY_FORMAT_LCDRTCCOEFF               = (1 << 6),
+};
+
+enum {
+	ADL_PM_PARAM_DONT_CHANGE = 0,
+};
+
+enum {
+	ADL_BUSTYPE_PCI       = 0,
+	ADL_BUSTYPE_AGP       = 1,
+	ADL_BUSTYPE_PCIE      = 2,
+	ADL_BUSTYPE_PCIE_GEN2 = 3,
+};
+
+enum {
+	ADL_STEREO_OFF             = 0,
+	ADL_STEREO_ACTIVE          = (1 << 1),
+	ADL_STEREO_SUPPORTED       = (1 << 2),
+	ADL_STEREO_BLUE_LINE       = (1 << 3),
+	ADL_STEREO_PASSIVE         = (1 << 6),
+	ADL_STEREO_PASSIVE_HORIZ   = (1 << 7),
+	ADL_STEREO_PASSIVE_VERT    = (1 << 8),
+	ADL_STEREO_AUTO_HORIZONTAL = (1 << 30),
+	ADL_STEREO_AUTO_VERTICAL   = (1 << 31),
+};
+
+enum {
+	ADL_WORKSTATION_LOADBALANCING_SUPPORTED = 1,
+	ADL_WORKSTATION_LOADBALANCING_AVAILABLE = 2,
+};
+
+enum {
+	ADL_WORKSTATION_LOADBALANCING_DISABLED  = 0,
+	ADL_WORKSTATION_LOADBALANCING_ENABLED   = 1,
+};
+
+enum {
+	ADL_CONTEXT_SPEED_UNFORCED  = 0,
+	ADL_CONTEXT_SPEED_FORCEHIGH = 1,
+	ADL_CONTEXT_SPEED_FORCELOW  = 2,
+};
+
+enum {
+	ADL_ADAPTER_SPEEDCAPS_SUPPORTED = (1 << 0),
+};
+
+enum {
+	ADL_GLSYNC_PORT_UNKNOWN   = 0,
+	ADL_GLSYNC_PORT_BNC       = 1,
+	ADL_GLSYNC_PORT_RJ45PORT1 = 2,
+	ADL_GLSYNC_PORT_RJ45PORT2 = 3,
+};
+
+enum {
+	ADL_GLSYNC_CONFIGMASK_NONE          = 0,
+	ADL_GLSYNC_CONFIGMASK_SIGNALSOURCE  = (1 << 0),
+	ADL_GLSYNC_CONFIGMASK_SYNCFIELD     = (1 << 1),
+	ADL_GLSYNC_CONFIGMASK_SAMPLERATE    = (1 << 2),
+	ADL_GLSYNC_CONFIGMASK_SYNCDELAY     = (1 << 3),
+	ADL_GLSYNC_CONFIGMASK_TRIGGEREDGE   = (1 << 4),
+	ADL_GLSYNC_CONFIGMASK_SCANRATECOEFF = (1 << 5),
+	ADL_GLSYNC_CONFIGMASK_FRAMELOCKCNTL = (1 << 6),
+};
+
+enum {
+	ADL_GLSYNC_FRAMELOCKCNTL_NONE               = 0,
+	ADL_GLSYNC_FRAMELOCKCNTL_ENABLE             = (1 << 0),
+	ADL_GLSYNC_FRAMELOCKCNTL_DISABLE            = (1 << 1),
+	ADL_GLSYNC_FRAMELOCKCNTL_SWAP_COUNTER_RESET = (1 << 2),
+	ADL_GLSYNC_FRAMELOCKCNTL_SWAP_COUNTER_ACK   = (1 << 3),
+	ADL_GLSYNC_FRAMELOCKCNTL_STATE_ENABLE       = (1 << 0),
+};
+
+enum {
+	ADL_GLSYNC_COUNTER_SWAP = (1 << 0),
+};
+
+enum {
+	ADL_GLSYNC_SIGNALSOURCE_UNDEFINED = 0x0100,
+	ADL_GLSYNC_SIGNALSOURCE_FREERUN   = 0x0101,
+	ADL_GLSYNC_SIGNALSOURCE_BNCPORT   = 0x0102,
+	ADL_GLSYNC_SIGNALSOURCE_RJ45PORT1 = 0x0103,
+	ADL_GLSYNC_SIGNALSOURCE_RJ45PORT2 = 0x0104,
+};
+
+enum {
+	ADL_GLSYNC_SIGNALTYPE_UNDEFINED =  0,
+	ADL_GLSYNC_SIGNALTYPE_480I      =  1,
+	ADL_GLSYNC_SIGNALTYPE_576I      =  2,
+	ADL_GLSYNC_SIGNALTYPE_480P      =  3,
+	ADL_GLSYNC_SIGNALTYPE_576P      =  4,
+	ADL_GLSYNC_SIGNALTYPE_720P      =  5,
+	ADL_GLSYNC_SIGNALTYPE_1080P     =  6,
+	ADL_GLSYNC_SIGNALTYPE_1080I     =  7,
+	ADL_GLSYNC_SIGNALTYPE_SDI       =  8,
+	ADL_GLSYNC_SIGNALTYPE_TTL       =  9,
+	ADL_GLSYNC_SIGNALTYPE_ANALOG    = 10,
+};
+
+enum {
+	ADL_GLSYNC_SYNCFIELD_UNDEFINED = 0,
+	ADL_GLSYNC_SYNCFIELD_BOTH      = 1,
+	ADL_GLSYNC_SYNCFIELD_1         = 2,
+};
+
+enum {
+	ADL_GLSYNC_TRIGGEREDGE_UNDEFINED = 0,
+	ADL_GLSYNC_TRIGGEREDGE_RISING    = 1,
+	ADL_GLSYNC_TRIGGEREDGE_FALLING   = 2,
+	ADL_GLSYNC_TRIGGEREDGE_BOTH      = 3,
+};
+
+enum {
+	ADL_GLSYNC_SCANRATECOEFF_UNDEFINED =  0,
+	ADL_GLSYNC_SCANRATECOEFF_x5        =  1,
+	ADL_GLSYNC_SCANRATECOEFF_x4        =  2,
+	ADL_GLSYNC_SCANRATECOEFF_x3        =  3,
+	ADL_GLSYNC_SCANRATECOEFF_x5_DIV_2  =  4,
+	ADL_GLSYNC_SCANRATECOEFF_x2        =  5,
+	ADL_GLSYNC_SCANRATECOEFF_x3_DIV_2  =  6,
+	ADL_GLSYNC_SCANRATECOEFF_x5_DIV_4  =  7,
+	ADL_GLSYNC_SCANRATECOEFF_x1        =  8,
+	ADL_GLSYNC_SCANRATECOEFF_x4_DIV_5  =  9,
+	ADL_GLSYNC_SCANRATECOEFF_x2_DIV_3  = 10,
+	ADL_GLSYNC_SCANRATECOEFF_x1_DIV_2  = 11,
+	ADL_GLSYNC_SCANRATECOEFF_x2_DIV_5  = 12,
+	ADL_GLSYNC_SCANRATECOEFF_x1_DIV_3  = 13,
+	ADL_GLSYNC_SCANRATECOEFF_x1_DIV_4  = 14,
+	ADL_GLSYNC_SCANRATECOEFF_x1_DIV_5  = 15,
+};
+
+enum {
+	ADL_GLSYNC_PORTSTATE_UNDEFINED = 0,
+	ADL_GLSYNC_PORTSTATE_NOCABLE   = 1,
+	ADL_GLSYNC_PORTSTATE_IDLE      = 2,
+	ADL_GLSYNC_PORTSTATE_INPUT     = 3,
+	ADL_GLSYNC_PORTSTATE_OUTPUT    = 4,
+};
+
+enum {
+	ADL_GLSYNC_LEDTYPE_BNC        = 0,
+	ADL_GLSYNC_LEDTYPE_RJ45_LEFT  = 0,
+	ADL_GLSYNC_LEDTYPE_RJ45_RIGHT = 1,
+};
+
+enum {
+	ADL_GLSYNC_LEDCOLOR_UNDEFINED   = 0,
+	ADL_GLSYNC_LEDCOLOR_NOLIGHT     = 1,
+	ADL_GLSYNC_LEDCOLOR_YELLOW      = 2,
+	ADL_GLSYNC_LEDCOLOR_RED         = 3,
+	ADL_GLSYNC_LEDCOLOR_GREEN       = 4,
+	ADL_GLSYNC_LEDCOLOR_FLASH_GREEN = 5,
+};
+
+enum {
+	ADL_GLSYNC_PORTCNTL_NONE   = 0,
+	ADL_GLSYNC_PORTCNTL_OUTPUT = 1,
+};
+
+enum {
+	ADL_GLSYNC_MODECNTL_NONE         = 0,
+	ADL_GLSYNC_MODECNTL_GENLOCK      = 1,
+	ADL_GLSYNC_MODECNTL_TIMINGSERVER = 2,
+};
+
+enum {
+	ADL_GLSYNC_MODECNTL_STATUS_NONE             = 0,
+	ADL_GLSYNC_MODECNTL_STATUS_GENLOCK          = (1 << 0),
+	ADL_GLSYNC_MODECNTL_STATUS_SETMODE_REQUIRED = (1 << 1),
+	ADL_GLSYNC_MODECNTL_STATUS_GENLOCK_ALLOWED  = (1 << 2),
+};
+
+#define ADL_MAX_GLSYNC_PORTS      8
+#define ADL_MAX_GLSYNC_PORT_LEDS  8
+
+enum {
+	ADL_XFIREX_STATE_NOINTERCONNECT             = (1 <<  0),
+	ADL_XFIREX_STATE_DOWNGRADEPIPES             = (1 <<  1),
+	ADL_XFIREX_STATE_DOWNGRADEMEM               = (1 <<  2),
+	ADL_XFIREX_STATE_REVERSERECOMMENDED         = (1 <<  3),
+	ADL_XFIREX_STATE_3DACTIVE                   = (1 <<  4),
+	ADL_XFIREX_STATE_MASTERONSLAVE              = (1 <<  5),
+	ADL_XFIREX_STATE_NODISPLAYCONNECT           = (1 <<  6),
+	ADL_XFIREX_STATE_NOPRIMARYVIEW              = (1 <<  7),
+	ADL_XFIREX_STATE_DOWNGRADEVISMEM            = (1 <<  8),
+	ADL_XFIREX_STATE_LESSTHAN8LANE_MASTER       = (1 <<  9),
+	ADL_XFIREX_STATE_LESSTHAN8LANE_SLAVE        = (1 << 10),
+	ADL_XFIREX_STATE_PEERTOPEERFAILED           = (1 << 11),
+	ADL_XFIREX_STATE_MEMISDOWNGRADED            = (1 << 16),
+	ADL_XFIREX_STATE_PIPESDOWNGRADED            = (1 << 17),
+	ADL_XFIREX_STATE_XFIREXACTIVE               = (1 << 18),
+	ADL_XFIREX_STATE_VISMEMISDOWNGRADED         = (1 << 19),
+	ADL_XFIREX_STATE_INVALIDINTERCONNECTION     = (1 << 20),
+	ADL_XFIREX_STATE_NONP2PMODE                 = (1 << 21),
+	ADL_XFIREX_STATE_DOWNGRADEMEMBANKS          = (1 << 22),
+	ADL_XFIREX_STATE_MEMBANKSDOWNGRADED         = (1 << 23),
+	ADL_XFIREX_STATE_DUALDISPLAYSALLOWED        = (1 << 24),
+	ADL_XFIREX_STATE_P2P_APERTURE_MAPPING       = (1 << 25),
+	ADL_XFIREX_STATE_P2PFLUSH_REQUIRED = ADL_XFIREX_STATE_P2P_APERTURE_MAPPING,
+	ADL_XFIREX_STATE_XSP_CONNECTED              = (1 << 26),
+	ADL_XFIREX_STATE_ENABLE_CF_REBOOT_REQUIRED  = (1 << 27),
+	ADL_XFIREX_STATE_DISABLE_CF_REBOOT_REQUIRED = (1 << 28),
+	ADL_XFIREX_STATE_DRV_HANDLE_DOWNGRADE_KEY   = (1 << 29),
+	ADL_XFIREX_STATE_CF_RECONFIG_REQUIRED       = (1 << 30),
+	ADL_XFIREX_STATE_ERRORGETTINGSTATUS         = (1 << 31),
+};
+
+enum {
+	ADL_DISPLAY_PIXELFORMAT_UNKNOWN           = 0,
+	ADL_DISPLAY_PIXELFORMAT_RGB               = (1 << 0),
+	ADL_DISPLAY_PIXELFORMAT_YCRCB444          = (1 << 1),
+	ADL_DISPLAY_PIXELFORMAT_YCRCB422          = (1 << 2),
+	ADL_DISPLAY_PIXELFORMAT_RGB_LIMITED_RANGE = (1 << 3),
+	ADL_DISPLAY_PIXELFORMAT_RGB_FULL_RANGE = ADL_DISPLAY_PIXELFORMAT_RGB
+};
+
+enum {
+	ADL_DL_DISPLAYCONFIG_CONTYPE_UNKNOWN      = 0,
+	ADL_DL_DISPLAYCONFIG_CONTYPE_CV_NONI2C_JP = 1,
+	ADL_DL_DISPLAYCONFIG_CONTYPE_CV_JPN       = 2,
+	ADL_DL_DISPLAYCONFIG_CONTYPE_CV_NA        = 3,
+	ADL_DL_DISPLAYCONFIG_CONTYPE_CV_NONI2C_NA = 4,
+	ADL_DL_DISPLAYCONFIG_CONTYPE_VGA          = 5,
+	ADL_DL_DISPLAYCONFIG_CONTYPE_DVI_D        = 6,
+	ADL_DL_DISPLAYCONFIG_CONTYPE_DVI_I        = 7,
+	ADL_DL_DISPLAYCONFIG_CONTYPE_HDMI_TYPE_A  = 8,
+	ADL_DL_DISPLAYCONFIG_CONTYPE_HDMI_TYPE_B  = 9,
+	ADL_DL_DISPLAYCONFIG_CONTYPE_DISPLAYPORT  = 10,
+};
+
+enum {
+	ADL_DISPLAY_DISPLAYINFO_DISPLAYCONNECTED   = (1 << 0),
+	ADL_DISPLAY_DISPLAYINFO_DISPLAYMAPPED      = (1 << 1),
+	ADL_DISPLAY_DISPLAYINFO_NONLOCAL           = (1 << 2),
+	ADL_DISPLAY_DISPLAYINFO_FORCIBLESUPPORTED  = (1 << 3),
+	ADL_DISPLAY_DISPLAYINFO_GENLOCKSUPPORTED   = (1 << 4),
+	ADL_DISPLAY_DISPLAYINFO_MULTIVPU_SUPPORTED = (1 << 5),
+	ADL_DISPLAY_DISPLAYINFO_MANNER_SUPPORTED_SINGLE       = (1 << 8),
+	ADL_DISPLAY_DISPLAYINFO_MANNER_SUPPORTED_CLONE        = (1 << 9),
+	ADL_DISPLAY_DISPLAYINFO_MANNER_SUPPORTED_2VSTRETCH    = (1 << 10),
+	ADL_DISPLAY_DISPLAYINFO_MANNER_SUPPORTED_2HSTRETCH    = (1 << 11),
+	ADL_DISPLAY_DISPLAYINFO_MANNER_SUPPORTED_EXTENDED     = (1 << 12),
+	ADL_DISPLAY_DISPLAYINFO_MANNER_SUPPORTED_NSTRETCH1GPU = (1 << 16),
+	ADL_DISPLAY_DISPLAYINFO_MANNER_SUPPORTED_NSTRETCHNGPU = (1 << 17),
+	ADL_DISPLAY_DISPLAYINFO_MANNER_SUPPORTED_RESERVED2    = (1 << 18),
+	ADL_DISPLAY_DISPLAYINFO_MANNER_SUPPORTED_RESERVED3    = (1 << 19),
+};
+
+enum {
+	ADL_ADAPTER_DISPLAYCAP_MANNER_SUPPORTED_NOTACTIVE    = (1 << 0),
+	ADL_ADAPTER_DISPLAYCAP_MANNER_SUPPORTED_SINGLE       = (1 << 1),
+	ADL_ADAPTER_DISPLAYCAP_MANNER_SUPPORTED_CLONE        = (1 << 2),
+	ADL_ADAPTER_DISPLAYCAP_MANNER_SUPPORTED_NSTRETCH1GPU = (1 << 3),
+	ADL_ADAPTER_DISPLAYCAP_MANNER_SUPPORTED_NSTRETCHNGPU = (1 << 4),
+	ADL_ADAPTER_DISPLAYCAP_MANNER_SUPPORTED_2VSTRETCH    = (1 << 5),
+	ADL_ADAPTER_DISPLAYCAP_MANNER_SUPPORTED_2HSTRETCH    = (1 << 6),
+	ADL_ADAPTER_DISPLAYCAP_MANNER_SUPPORTED_EXTENDED     = (1 << 7),
+	ADL_ADAPTER_DISPLAYCAP_PREFERDISPLAY_SUPPORTED       = (1 << 8),
+	ADL_ADAPTER_DISPLAYCAP_BEZEL_SUPPORTED               = (1 << 9),
+};
+
+enum {
+	ADL_DISPLAY_DISPLAYMAP_MANNER_RESERVED  = (1 << 0),
+	ADL_DISPLAY_DISPLAYMAP_MANNER_NOTACTIVE = (1 << 1),
+	ADL_DISPLAY_DISPLAYMAP_MANNER_SINGLE    = (1 << 2),
+	ADL_DISPLAY_DISPLAYMAP_MANNER_CLONE     = (1 << 3),
+	ADL_DISPLAY_DISPLAYMAP_MANNER_RESERVED1 = (1 << 4),
+	ADL_DISPLAY_DISPLAYMAP_MANNER_HSTRETCH  = (1 << 5),
+	ADL_DISPLAY_DISPLAYMAP_MANNER_VSTRETCH  = (1 << 6),
+	ADL_DISPLAY_DISPLAYMAP_MANNER_VLD       = (1 << 7),
+};
+
+enum {
+	ADL_DISPLAY_DISPLAYMAP_OPTION_GPUINFO = 1,
+};
+
+enum {
+	ADL_DISPLAY_DISPLAYTARGET_PREFERRED = 1,
+};
+
+enum {
+	ADL_DISPLAY_POSSIBLEMAPRESULT_VALID          = 1,
+	ADL_DISPLAY_POSSIBLEMAPRESULT_BEZELSUPPORTED = 2,
+};
+
+enum {
+	ADL_DISPLAY_MODE_COLOURFORMAT_565          = (1 << 0),
+	ADL_DISPLAY_MODE_COLOURFORMAT_8888         = (1 << 1),
+	ADL_DISPLAY_MODE_ORIENTATION_SUPPORTED_000 = (1 << 2),
+	ADL_DISPLAY_MODE_ORIENTATION_SUPPORTED_090 = (1 << 3),
+	ADL_DISPLAY_MODE_ORIENTATION_SUPPORTED_180 = (1 << 4),
+	ADL_DISPLAY_MODE_ORIENTATION_SUPPORTED_270 = (1 << 5),
+	ADL_DISPLAY_MODE_REFRESHRATE_ROUNDED       = (1 << 6),
+	ADL_DISPLAY_MODE_REFRESHRATE_ONLY          = (1 << 7),
+};
+
+enum {
+	ADL_DISPLAY_MODE_PROGRESSIVE_FLAG = 0,
+	ADL_DISPLAY_MODE_INTERLACED_FLAG  = 2,
+};
+
+#define ADL_OSMODEINFOXPOS_DEFAULT    -640
+#define ADL_OSMODEINFOYPOS_DEFAULT       0
+#define ADL_OSMODEINFOXRES_DEFAULT     640
+#define ADL_OSMODEINFOYRES_DEFAULT     480
+#define ADL_OSMODEINFOXRES_DEFAULT800  800
+#define ADL_OSMODEINFOYRES_DEFAULT600  600
+#define ADL_OSMODEINFOREFRESHRATE_DEFAULT  60
+#define ADL_OSMODEINFOCOLOURDEPTH_DEFAULT     8
+#define ADL_OSMODEINFOCOLOURDEPTH_DEFAULT16  16
+#define ADL_OSMODEINFOCOLOURDEPTH_DEFAULT24  24
+#define ADL_OSMODEINFOCOLOURDEPTH_DEFAULT32  32
+#define ADL_OSMODEINFOORIENTATION_DEFAULT       0
+#define ADL_OSMODEINFOORIENTATION_DEFAULT_WIN7  DISPLAYCONFIG_ROTATION_FORCE_UINT32
+#define ADL_OSMODEFLAG_DEFAULT  0
+
+enum ADLPurposeCode {
+	ADL_PURPOSECODE_NORMAL = 0,
+	ADL_PURPOSECODE_HIDE_MODE_SWITCH,
+	ADL_PURPOSECODE_MODE_SWITCH,
+	ADL_PURPOSECODE_ATTATCH_DEVICE,
+	ADL_PURPOSECODE_DETACH_DEVICE,
+	ADL_PURPOSECODE_SETPRIMARY_DEVICE,
+	ADL_PURPOSECODE_GDI_ROTATION,
+	ADL_PURPOSECODE_ATI_ROTATION,
+};
+
+enum ADLAngle {
+	ADL_ANGLE_LANDSCAPE   =   0,
+	ADL_ANGLE_ROTATERIGHT =  90,
+	ADL_ANGLE_ROTATE180   = 180,
+	ADL_ANGLE_ROTATELEFT  = 270,
+};
+
+enum ADLOrientationDataType {
+	ADL_ORIENTATIONTYPE_OSDATATYPE,
+	ADL_ORIENTATIONTYPE_NONOSDATATYPE
+};
+
+enum ADLPanningMode {
+	ADL_PANNINGMODE_NO_PANNING              = 0,
+	ADL_PANNINGMODE_AT_LEAST_ONE_NO_PANNING = 1,
+	ADL_PANNINGMODE_ALLOW_PANNING           = 2,
+};
+
+enum ADLLARGEDESKTOPTYPE {
+	ADL_LARGEDESKTOPTYPE_NORMALDESKTOP      = 0,
+	ADL_LARGEDESKTOPTYPE_PSEUDOLARGEDESKTOP = 1,
+	ADL_LARGEDESKTOPTYPE_VERYLARGEDESKTOP   = 2,
+};
+
+#define ADL_I2C_MAJOR_API_REV          1
+#define ADL_I2C_MINOR_DEFAULT_API_REV  0
+#define ADL_I2C_MINOR_OEM_API_REV      1
+
+enum {
+	ADL_DL_I2C_LINE_OEM        = 1,
+	ADL_DL_I2C_LINE_OD_CONTROL = 2,
+	ADL_DL_I2C_LINE_OEM2       = 3,
+};
+
+#define ADL_DL_I2C_MAXDATASIZE       0x00000040
+#define ADL_DL_I2C_MAXWRITEDATASIZE  0x0000000C
+#define ADL_DL_I2C_MAXADDRESSLENGTH  0x00000006
+#define ADL_DL_I2C_MAXOFFSETLENGTH   0x00000004
+
+enum {
+	ADL_DL_DISPLAYPROPERTY_TYPE_UNKNOWN             = 0,
+	ADL_DL_DISPLAYPROPERTY_TYPE_EXPANSIONMODE       = 1,
+	ADL_DL_DISPLAYPROPERTY_TYPE_USEUNDERSCANSCALING = 2,
+};
+
+enum {
+	ADL_DL_DISPLAYPROPERTY_EXPANSIONMODE_CENTER      = 0,
+	ADL_DL_DISPLAYPROPERTY_EXPANSIONMODE_FULLSCREEN  = 1,
+	ADL_DL_DISPLAYPROPERTY_EXPANSIONMODE_ASPECTRATIO = 2,
+};
+
+enum {
+	ADL_DL_DISPLAY_DITHER_UNKNOWN  = 0,
+	ADL_DL_DISPLAY_DITHER_DISABLED = 1,
+	ADL_DL_DISPLAY_DITHER_ENABLED  = 2,
+};
+
+#define ADL_MAX_EDIDDATA_SIZE  256
+#define ADL_MAX_EDID_EXTENSION_BLOCKS  3
+
+enum {
+	ADL_DL_CONTROLLER_OVERLAY_ALPHA       = 0,
+	ADL_DL_CONTROLLER_OVERLAY_ALPHAPERPIX = 1,
+};
+
+enum {
+	ADL_DL_DISPLAY_DATA_PACKET__INFO_PACKET_RESET = 0,
+	ADL_DL_DISPLAY_DATA_PACKET__INFO_PACKET_SET   = 1,
+};
+
+enum {
+	ADL_DL_DISPLAY_DATA_PACKET__TYPE__AVI        = (1 << 0),
+	ADL_DL_DISPLAY_DATA_PACKET__TYPE__RESERVED   = (1 << 1),
+	ADL_DL_DISPLAY_DATA_PACKET__TYPE__VENDORINFO = (1 << 2),
+};
+
+enum {
+	ADL_GAMUT_MATRIX_SD = 1,
+	ADL_GAMUT_MATRIX_HD = 2,
+};
+
+enum {
+	ADL_DL_CLOCKINFO_FLAG_FULLSCREEN3DONLY   = (1 << 0),
+	ADL_DL_CLOCKINFO_FLAG_ALWAYSFULLSCREEN3D = (1 << 1),
+	ADL_DL_CLOCKINFO_FLAG_VPURECOVERYREDUCED = (1 << 2),
+	ADL_DL_CLOCKINFO_FLAG_THERMALPROTECTION  = (1 << 3),
+};
+
+enum {
+	ADL_DL_POWERXPRESS_GPU_INTEGRATED = 1,
+	ADL_DL_POWERXPRESS_GPU_DISCRETE   = 2,
+};
+
+enum {
+	ADL_DL_POWERXPRESS_SWITCH_RESULT_STARTED  = 1,
+	ADL_DL_POWERXPRESS_SWITCH_RESULT_DECLINED = 2,
+	ADL_DL_POWERXPRESS_SWITCH_RESULT_ALREADY  = 3,
+};
+
+#define ADL_DL_POWERXPRESS_VERSION_MAJOR  2
+#define ADL_DL_POWERXPRESS_VERSION_MINOR  0
+#define ADL_DL_POWERXPRESS_VERSION  (((ADL_DL_POWERXPRESS_VERSION_MAJOR) << 16) | ADL_DL_POWERXPRESS_VERSION_MINOR)
+
+enum {
+	ADL_DL_THERMAL_DOMAIN_OTHER = 0,
+	ADL_DL_THERMAL_DOMAIN_GPU   = 1,
+};
+
+enum {
+	ADL_DL_THERMAL_FLAG_INTERRUPT  = 1,
+	ADL_DL_THERMAL_FLAG_FANCONTROL = 2,
+};
+
+enum {
+	ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ  = (1 << 0),
+	ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE = (1 << 1),
+	ADL_DL_FANCTRL_SUPPORTS_RPM_READ      = (1 << 2),
+	ADL_DL_FANCTRL_SUPPORTS_RPM_WRITE     = (1 << 3),
+};
+
+enum {
+	ADL_DL_FANCTRL_SPEED_TYPE_PERCENT = 1,
+	ADL_DL_FANCTRL_SPEED_TYPE_RPM     = 2,
+};
+
+enum {
+	ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED = 1,
+};
+
+#define ADL_DL_MAX_MVPU_ADAPTERS  4
+
+enum {
+	MVPU_ADAPTER_0 = (1 << 0),
+	MVPU_ADAPTER_1 = (1 << 1),
+	MVPU_ADAPTER_2 = (1 << 2),
+	MVPU_ADAPTER_3 = (1 << 3),
+};
+
+#define ADL_DL_MAX_REGISTRY_PATH  256
+
+enum {
+	ADL_DL_MVPU_STATUS_OFF = 0,
+	ADL_DL_MVPU_STATUS_ON  = 1,
+};
+
+enum {
+	ADL_ASIC_UNDEFINED  = 0,
+	ADL_ASIC_DISCRETE   = (1 << 0),
+	ADL_ASIC_INTEGRATED = (1 << 1),
+	ADL_ASIC_FIREGL     = (1 << 2),
+	ADL_ASIC_FIREMV     = (1 << 3),
+	ADL_ASIC_XGP        = (1 << 4),
+	ADL_ASIC_FUSION     = (1 << 5),
+};
+
+enum {
+	ADL_DL_TIMINGFLAG_DOUBLE_SCAN     = (1 << 0),
+	ADL_DL_TIMINGFLAG_INTERLACED      = (1 << 1),
+	ADL_DL_TIMINGFLAG_H_SYNC_POLARITY = (1 << 2),
+	ADL_DL_TIMINGFLAG_V_SYNC_POLARITY = (1 << 3),
+};
+
+enum {
+	ADL_DL_MODETIMING_STANDARD_CVT            = (1 << 0),
+	ADL_DL_MODETIMING_STANDARD_GTF            = (1 << 1),
+	ADL_DL_MODETIMING_STANDARD_DMT            = (1 << 2),
+	ADL_DL_MODETIMING_STANDARD_CUSTOM         = (1 << 3),
+	ADL_DL_MODETIMING_STANDARD_DRIVER_DEFAULT = (1 << 4),
+};
+
+enum {
+	ADL_XSERVERINFO_XINERAMAACTIVE   = (1 << 0),
+	ADL_XSERVERINFO_RANDR12SUPPORTED = (1 << 1),
+};
+
+enum {
+	ADL_CONTROLLERVECTOR_0 = 1,
+	ADL_CONTROLLERVECTOR_1 = 2,
+};
+
+enum {
+	ADL_DISPLAY_SLSGRID_ORIENTATION_000 = (1 << 0),
+	ADL_DISPLAY_SLSGRID_ORIENTATION_090 = (1 << 1),
+	ADL_DISPLAY_SLSGRID_ORIENTATION_180 = (1 << 2),
+	ADL_DISPLAY_SLSGRID_ORIENTATION_270 = (1 << 3),
+};
+
+enum {
+	ADL_DISPLAY_SLSGRID_CAP_OPTION_RELATIVETO_LANDSCAPE    = (1 << 0),
+	ADL_DISPLAY_SLSGRID_CAP_OPTION_RELATIVETO_CURRENTANGLE = (1 << 1),
+	ADL_DISPLAY_SLSGRID_PORTAIT_MODE                       = (1 << 2),
+};
+
+enum {
+	ADL_DISPLAY_SLSMAPCONFIG_GET_OPTION_RELATIVETO_LANDSCAPE    = 1,
+	ADL_DISPLAY_SLSMAPCONFIG_GET_OPTION_RELATIVETO_CURRENTANGLE = 2,
+};
+
+enum {
+	ADL_DISPLAY_SLSMAPCONFIG_CREATE_OPTION_RELATIVETO_LANDSCAPE    = 1,
+	ADL_DISPLAY_SLSMAPCONFIG_CREATE_OPTION_RELATIVETO_CURRENTANGLE = 2,
+};
+
+enum {
+	ADL_DISPLAY_SLSMAPCONFIG_REARRANGE_OPTION_RELATIVETO_LANDSCAPE    = 1,
+	ADL_DISPLAY_SLSMAPCONFIG_REARRANGE_OPTION_RELATIVETO_CURRENTANGLE = 2,
+};
+
+enum {
+	ADL_DISPLAY_SLSGRID_RELATIVETO_LANDSCAPE    = 0x10,
+	ADL_DISPLAY_SLSGRID_RELATIVETO_CURRENTANGLE = 0x20,
+};
+
+enum {
+	ADL_DISPLAY_SLSMAP_BEZELMODE       = (1 << 4),
+	ADL_DISPLAY_SLSMAP_DISPLAYARRANGED = (1 << 1),
+	ADL_DISPLAY_SLSMAP_CURRENTCONFIG   = (1 << 2),
+};
+
+enum {
+	ADL_DISPLAY_SLSMAPINDEXLIST_OPTION_ACTIVE = 1,
+};
+
+enum {
+	ADL_DISPLAY_BEZELOFFSET_STEPBYSTEPSET = (1 << 2),
+	ADL_DISPLAY_BEZELOFFSET_COMMIT        = (1 << 3),
+};
+
+#endif /* ADL_DEFINES_H_ */

ADL/adl_sdk.h

@@ -0,0 +1,12 @@
+#ifndef ADL_SDK_H_
+#define ADL_SDK_H_
+
+#include "adl_structures.h"
+
+typedef void*(
+#ifdef WIN32
+	__stdcall
+#endif
+*ADL_MAIN_MALLOC_CALLBACK)(int);
+
+#endif /* ADL_SDK_H_ */

ADL/adl_structures.h

@@ -0,0 +1,552 @@
+#ifndef ADL_STRUCTURES_H_
+#define ADL_STRUCTURES_H_
+
+#include "adl_defines.h"
+
+typedef struct AdapterInfo {
+	int iSize;
+	int iAdapterIndex;
+	char strUDID[ADL_MAX_PATH];
+	int iBusNumber;
+	int iDeviceNumber;
+	int iFunctionNumber;
+	int iVendorID;
+	char strAdapterName[ADL_MAX_PATH];
+	char strDisplayName[ADL_MAX_PATH];
+	int iPresent;
+
+#ifdef WIN32
+	int iExist;
+	char strDriverPath[ADL_MAX_PATH];
+	char strDriverPathExt[ADL_MAX_PATH];
+	char strPNPString[ADL_MAX_PATH];
+	int iOSDisplayIndex;
+#elif !defined(__APPLE__) /* Linux */
+	int iXScreenNum;
+	int iDrvIndex;
+	char strXScreenConfigName[ADL_MAX_PATH];
+#endif /* Linux */
+} AdapterInfo, *LPAdapterInfo;
+
+#if !(defined(WIN32) || defined(__APPLE__))
+typedef struct XScreenInfo {
+	int iXScreenNum;
+	char strXScreenConfigName[ADL_MAX_PATH];
+} XScreenInfo, *LPXScreenInfo;
+#endif /* Linux */
+
+typedef struct ADLMemoryInfo {
+	long long iMemorySize;
+	char strMemoryType[ADL_MAX_PATH];
+	long long iMemoryBandwidth;
+} ADLMemoryInfo, *LPADLMemoryInfo;
+
+typedef struct ADLDDCInfo {
+	int ulSize;
+	int ulSupportsDDC;
+	int ulManufacturerID;
+	int ulProductID;
+	char cDisplayName[ADL_MAX_DISPLAY_NAME];
+	int ulMaxHResolution;
+	int ulMaxVResolution;
+	int ulMaxRefresh;
+	int ulPTMCx;
+	int ulPTMCy;
+	int ulPTMRefreshRate;
+	int ulDDCInfoFlag;
+} ADLDDCInfo, *LPADLDDCInfo;
+
+typedef struct ADLGamma {
+	float fRed;
+	float fGreen;
+	float fBlue;
+} ADLGamma, *LPADLGamma;
+
+typedef struct ADLCustomMode {
+	int iFlags;
+	int iModeWidth;
+	int iModeHeight;
+	int iBaseModeWidth;
+	int iBaseModeHeight;
+	int iRefreshRate;
+} ADLCustomMode, *LPADLCustomMode;
+
+typedef struct ADLGetClocksOUT {
+	long ulHighCoreClock;
+	long ulHighMemoryClock;
+	long ulHighVddc;
+	long ulCoreMin;
+	long ulCoreMax;
+	long ulMemoryMin;
+	long ulMemoryMax;
+	long ulActivityPercent;
+	long ulCurrentCoreClock;
+	long ulCurrentMemoryClock;
+	long ulReserved;
+} ADLGetClocksOUT;
+
+typedef struct ADLDisplayConfig {
+	long ulSize;
+	long ulConnectorType;
+	long ulDeviceData;
+	long ulOverridedDeviceData;
+	long ulReserved;
+} ADLDisplayConfig;
+
+typedef struct ADLDisplayID {
+	int iDisplayLogicalIndex;
+	int iDisplayPhysicalIndex;
+	int iDisplayLogicalAdapterIndex;
+	int iDisplayPhysicalAdapterIndex;
+} ADLDisplayID, *LPADLDisplayID;
+
+typedef struct ADLDisplayInfo {
+	ADLDisplayID displayID;
+	int iDisplayControllerIndex;
+	char strDisplayName[ADL_MAX_PATH];
+	char strDisplayManufacturerName[ADL_MAX_PATH];
+	int iDisplayType;
+	int iDisplayOutputType;
+	int iDisplayConnector;
+	int iDisplayInfoMask;
+	int iDisplayInfoValue;
+} ADLDisplayInfo, *LPADLDisplayInfo;
+
+typedef struct ADLDisplayMode {
+	int iPelsHeight;
+	int iPelsWidth;
+	int iBitsPerPel;
+	int iDisplayFrequency;
+} ADLDisplayMode;
+
+typedef struct ADLDetailedTiming {
+	int iSize;
+	short sTimingFlags;
+	short sHTotal;
+	short sHDisplay;
+	short sHSyncStart;
+	short sHSyncWidth;
+	short sVTotal;
+	short sVDisplay;
+	short sVSyncStart;
+	short sVSyncWidth;
+	short sPixelClock;
+	short sHOverscanRight;
+	short sHOverscanLeft;
+	short sVOverscanBottom;
+	short sVOverscanTop;
+	short sOverscan8B;
+	short sOverscanGR;
+} ADLDetailedTiming;
+
+typedef struct ADLDisplayModeInfo {
+	int iTimingStandard;
+	int iPossibleStandard;
+	int iRefreshRate;
+	int iPelsWidth;
+	int iPelsHeight;
+	ADLDetailedTiming sDetailedTiming;
+} ADLDisplayModeInfo;
+
+typedef struct ADLDisplayProperty {
+	int iSize;
+	int iPropertyType;
+	int iExpansionMode;
+	int iSupport;
+	int iCurrent;
+	int iDefault;
+} ADLDisplayProperty;
+
+typedef struct ADLClockInfo {
+	int iCoreClock;
+	int iMemoryClock;
+} ADLClockInfo, *LPADLClockInfo;
+
+typedef struct ADLI2C {
+	int iSize;
+	int iLine;
+	int iAddress;
+	int iOffset;
+	int iAction;
+	int iSpeed;
+	int iDataSize;
+	char *pcData;
+} ADLI2C;
+
+typedef struct ADLDisplayEDIDData {
+	int iSize;
+	int iFlag;
+	int iEDIDSize;
+	int iBlockIndex;
+	char cEDIDData[ADL_MAX_EDIDDATA_SIZE];
+	int iReserved[4];
+} ADLDisplayEDIDData;
+
+typedef struct ADLControllerOverlayInput {
+	int iSize;
+	int iOverlayAdjust;
+	int iValue;
+	int iReserved;
+} ADLControllerOverlayInput;
+
+typedef struct ADLAdjustmentinfo {
+	int iDefault;
+	int iMin;
+	int iMax;
+	int iStep;
+} ADLAdjustmentinfo;
+
+typedef struct ADLControllerOverlayInfo {
+	int iSize;
+	ADLAdjustmentinfo  sOverlayInfo;
+	int iReserved[3];
+} ADLControllerOverlayInfo;
+
+typedef struct ADLGLSyncModuleID {
+	int iModuleID;
+	int iGlSyncGPUPort;
+	int iFWBootSectorVersion;
+	int iFWUserSectorVersion;
+} ADLGLSyncModuleID , *LPADLGLSyncModuleID;
+
+typedef struct ADLGLSyncPortCaps {
+	int iPortType;
+	int iNumOfLEDs;
+} ADLGLSyncPortCaps, *LPADLGLSyncPortCaps;
+
+typedef struct ADLGLSyncGenlockConfig {
+	int iValidMask;
+	int iSyncDelay;
+	int iFramelockCntlVector;
+	int iSignalSource;
+	int iSampleRate;
+	int iSyncField;
+	int iTriggerEdge;
+	int iScanRateCoeff;
+} ADLGLSyncGenlockConfig, *LPADLGLSyncGenlockConfig;
+
+typedef struct ADLGlSyncPortInfo {
+	int iPortType;
+	int iNumOfLEDs;
+	int iPortState;
+	int iFrequency;
+	int iSignalType;
+	int iSignalSource;
+} ADLGlSyncPortInfo, *LPADLGlSyncPortInfo;
+
+typedef struct ADLGlSyncPortControl {
+	int iPortType;
+	int iControlVector;
+	int iSignalSource;
+} ADLGlSyncPortControl;
+
+typedef struct ADLGlSyncMode {
+	int iControlVector;
+	int iStatusVector;
+	int iGLSyncConnectorIndex;
+} ADLGlSyncMode, *LPADLGlSyncMode;
+
+typedef struct ADLGlSyncMode2 {
+	int iControlVector;
+	int iStatusVector;
+	int iGLSyncConnectorIndex;
+	int iDisplayIndex;
+} ADLGlSyncMode2, *LPADLGlSyncMode2;
+
+typedef struct ADLInfoPacket {
+	char hb0;
+	char hb1;
+	char hb2;
+	char sb[28];
+} ADLInfoPacket;
+
+typedef struct ADLAVIInfoPacket {
+	char bPB3_ITC;
+	char bPB5;
+} ADLAVIInfoPacket;
+
+typedef struct ADLODClockSetting {
+	int iDefaultClock;
+	int iCurrentClock;
+	int iMaxClock;
+	int iMinClock;
+	int iRequestedClock;
+	int iStepClock;
+} ADLODClockSetting;
+
+typedef struct ADLAdapterODClockInfo {
+	int iSize;
+	int iFlags;
+	ADLODClockSetting sMemoryClock;
+	ADLODClockSetting sEngineClock;
+} ADLAdapterODClockInfo;
+
+typedef struct ADLAdapterODClockConfig {
+	int iSize;
+	int iFlags;
+	int iMemoryClock;
+	int iEngineClock;
+} ADLAdapterODClockConfig;
+
+typedef struct ADLPMActivity {
+	int iSize;
+	int iEngineClock;
+	int iMemoryClock;
+	int iVddc;
+	int iActivityPercent;
+	int iCurrentPerformanceLevel;
+	int iCurrentBusSpeed;
+	int iCurrentBusLanes;
+	int iMaximumBusLanes;
+	int iReserved;
+} ADLPMActivity;
+
+typedef struct ADLThermalControllerInfo {
+	int iSize;
+	int iThermalDomain;
+	int iDomainIndex;
+	int iFlags;
+} ADLThermalControllerInfo;
+
+typedef struct ADLTemperature {
+	int iSize;
+	int iTemperature;
+} ADLTemperature;
+
+typedef struct ADLFanSpeedInfo {
+	int iSize;
+	int iFlags;
+	int iMinPercent;
+	int iMaxPercent;
+	int iMinRPM;
+	int iMaxRPM;
+} ADLFanSpeedInfo;
+
+typedef struct ADLFanSpeedValue {
+	int iSize;
+	int iSpeedType;
+	int iFanSpeed;
+	int iFlags;
+} ADLFanSpeedValue;
+
+typedef struct ADLODParameterRange {
+	int iMin;
+	int iMax;
+	int iStep;
+} ADLODParameterRange;
+
+typedef struct ADLODParameters {
+	int iSize;
+	int iNumberOfPerformanceLevels;
+	int iActivityReportingSupported;
+	int iDiscretePerformanceLevels;
+	int iReserved;
+	ADLODParameterRange sEngineClock;
+	ADLODParameterRange sMemoryClock;
+	ADLODParameterRange sVddc;
+} ADLODParameters;
+
+typedef struct ADLODPerformanceLevel {
+	int iEngineClock;
+	int iMemoryClock;
+	int iVddc;
+} ADLODPerformanceLevel;
+
+typedef struct ADLODPerformanceLevels {
+	int iSize;
+	int iReserved;
+	ADLODPerformanceLevel aLevels[1];
+} ADLODPerformanceLevels;
+
+typedef struct ADLCrossfireComb {
+	int iNumLinkAdapter;
+	int iAdaptLink[3];
+} ADLCrossfireComb;
+
+typedef struct ADLCrossfireInfo {
+	int iErrorCode;
+	int iState;
+	int iSupported;
+} ADLCrossfireInfo;
+
+typedef struct ADLBiosInfo {
+	char strPartNumber[ADL_MAX_PATH];
+	char strVersion[ADL_MAX_PATH];
+	char strDate[ADL_MAX_PATH];
+} ADLBiosInfo, *LPADLBiosInfo;
+
+typedef struct ADLAdapterLocation {
+	int iBus;
+	int iDevice;
+	int iFunction;
+} ADLAdapterLocation;
+
+typedef struct ADLMVPUCaps {
+	int iSize;
+	int iAdapterCount;
+	int iPossibleMVPUMasters;
+	int iPossibleMVPUSlaves;
+	char cAdapterPath[ADL_DL_MAX_MVPU_ADAPTERS][ADL_DL_MAX_REGISTRY_PATH];
+} ADLMVPUCaps;
+
+typedef struct ADLMVPUStatus {
+	int iSize;
+	int iActiveAdapterCount;
+	int iStatus;
+	ADLAdapterLocation aAdapterLocation[ADL_DL_MAX_MVPU_ADAPTERS];
+} ADLMVPUStatus;
+
+typedef struct ADLActivatableSource {
+	int iAdapterIndex;
+	int iNumActivatableSources;
+	int iActivatableSourceMask;
+	int iActivatableSourceValue;
+} ADLActivatableSource, *LPADLActivatableSource;
+
+typedef struct ADLMode {
+	int iAdapterIndex;
+	ADLDisplayID displayID;
+	int iXPos;
+	int iYPos;
+	int iXRes;
+	int iYRes;
+	int iColourDepth;
+	float fRefreshRate;
+	int iOrientation;
+	int iModeFlag;
+	int iModeMask;
+	int iModeValue;
+} ADLMode, *LPADLMode;
+
+typedef struct ADLDisplayTarget {
+	ADLDisplayID displayID;
+	int iDisplayMapIndex;
+	int iDisplayTargetMask;
+	int iDisplayTargetValue;
+} ADLDisplayTarget, *LPADLDisplayTarget;
+
+typedef struct tagADLBezelTransientMode {
+	int iAdapterIndex;
+	int iSLSMapIndex;
+	int iSLSModeIndex;
+	ADLMode displayMode;
+	int iNumBezelOffset;
+	int iFirstBezelOffsetArrayIndex;
+	int iSLSBezelTransientModeMask;
+	int iSLSBezelTransientModeValue;
+} ADLBezelTransientMode, *LPADLBezelTransientMode;
+
+typedef struct ADLAdapterDisplayCap {
+	int iAdapterIndex;
+	int iAdapterDisplayCapMask;
+	int iAdapterDisplayCapValue;
+} ADLAdapterDisplayCap, *LPADLAdapterDisplayCap;
+
+typedef struct ADLDisplayMap {
+	int iDisplayMapIndex;
+	ADLMode displayMode;
+	int iNumDisplayTarget;
+	int iFirstDisplayTargetArrayIndex;
+	int iDisplayMapMask;
+	int iDisplayMapValue;
+} ADLDisplayMap, *LPADLDisplayMap;
+
+typedef struct ADLPossibleMap {
+	int iIndex;
+	int iAdapterIndex;
+	int iNumDisplayMap;
+	ADLDisplayMap* displayMap;
+	int iNumDisplayTarget;
+	ADLDisplayTarget* displayTarget;
+} ADLPossibleMap, *LPADLPossibleMap;
+
+typedef struct ADLPossibleMapping {
+	int iDisplayIndex;
+	int iDisplayControllerIndex;
+	int iDisplayMannerSupported;
+} ADLPossibleMapping, *LPADLPossibleMapping;
+
+typedef struct ADLPossibleMapResult {
+	int iIndex;
+	int iPossibleMapResultMask;
+	int iPossibleMapResultValue;
+} ADLPossibleMapResult, *LPADLPossibleMapResult;
+
+typedef struct ADLSLSGrid {
+	int iAdapterIndex;
+	int iSLSGridIndex;
+	int iSLSGridRow;
+	int iSLSGridColumn;
+	int iSLSGridMask;
+	int iSLSGridValue;
+} ADLSLSGrid, *LPADLSLSGrid;
+
+typedef struct ADLSLSMap {
+	int iAdapterIndex;
+	int iSLSMapIndex;
+	ADLSLSGrid grid;
+	int iSurfaceMapIndex;
+	int iOrientation;
+	int iNumSLSTarget;
+	int iFirstSLSTargetArrayIndex;
+	int iNumNativeMode;
+	int iFirstNativeModeArrayIndex;
+	int iNumBezelMode;
+	int iFirstBezelModeArrayIndex;
+	int iNumBezelOffset;
+	int iFirstBezelOffsetArrayIndex;
+	int iSLSMapMask;
+	int iSLSMapValue;
+} ADLSLSMap, *LPADLSLSMap;
+
+typedef struct ADLSLSOffset {
+	int iAdapterIndex;
+	int iSLSMapIndex;
+	ADLDisplayID displayID;
+	int iBezelModeIndex;
+	int iBezelOffsetX;
+	int iBezelOffsetY;
+	int iDisplayWidth;
+	int iDisplayHeight;
+	int iBezelOffsetMask;
+	int iBezelffsetValue;
+} ADLSLSOffset, *LPADLSLSOffset;
+
+typedef struct ADLSLSMode {
+	int iAdapterIndex;
+	int iSLSMapIndex;
+	int iSLSModeIndex;
+	ADLMode displayMode;
+	int iSLSNativeModeMask;
+	int iSLSNativeModeValue;
+} ADLSLSMode, *LPADLSLSMode;
+
+typedef struct ADLPossibleSLSMap {
+	int iSLSMapIndex;
+	int iNumSLSMap;
+	ADLSLSMap* lpSLSMap;
+	int iNumSLSTarget;
+	ADLDisplayTarget* lpDisplayTarget;
+} ADLPossibleSLSMap, *LPADLPossibleSLSMap;
+
+typedef struct ADLSLSTarget {
+	int iAdapterIndex;
+	int iSLSMapIndex;
+	ADLDisplayTarget displayTarget;
+	int iSLSGridPositionX;
+	int iSLSGridPositionY;
+	ADLMode viewSize;
+	int iSLSTargetMask;
+	int iSLSTargetValue;
+} ADLSLSTarget, *LPADLSLSTarget;
+
+typedef struct ADLBezelOffsetSteppingSize {
+	int iAdapterIndex;
+	int iSLSMapIndex;
+	int iBezelOffsetSteppingSizeX;
+	int iBezelOffsetSteppingSizeY;
+	int iBezelOffsetSteppingSizeMask;
+	int iBezelOffsetSteppingSizeValue;
+} ADLBezelOffsetSteppingSize, *LPADLBezelOffsetSteppingSize;
+
+#endif /* ADL_STRUCTURES_H_ */

ADL_SDK/.gitignore

@@ -1,3 +0,0 @@
-adl_defines.h
-adl_sdk.h
-adl_structures.h

ADL_SDK/readme.txt

@@ -1,3 +0,0 @@
-Please insert AMD ADL files adl_defines.h adl_sdk.h adl_structures.h here.
-They can be found here:
-http://developer.amd.com/sdks/ADLSDK/Pages/default.aspx

Makefile.am

@@ -8,7 +8,7 @@ JANSSON_INCLUDES=
 endif
 
 EXTRA_DIST	= example.conf m4/gnulib-cache.m4 linux-usb-bfgminer \
-		  ADL_SDK/readme.txt api-example.php miner.php	\
+		  api-example.php miner.php	\
 		  API.class API.java api-example.c windows-build.txt \
 		  bitstreams/* API-README FPGA-README SCRYPT-README
 

README

@@ -49,9 +49,6 @@ Dependencies:
 	AMD APP SDK		http://developer.amd.com/sdks/AMDAPPSDK
 	(This sdk is mandatory for GPU mining)
 
-	AMD ADL SDK		http://developer.amd.com/sdks/ADLSDK
-	(This sdk is mandatory for ATI GPU monitoring & clocking)
-
 	libudev headers
 	(This is only required for FPGA auto-detection and is linux only)
 
@@ -62,7 +59,7 @@ Dependencies:
 BFGMiner specific configuration options:
 	--enable-cpumining      Build with cpu mining support(default disabled)
 	--disable-opencl        Build without support for OpenCL (default enabled)
-	--disable-adl           Override detection and disable building with adl
+	--disable-adl           Build without ADL monitoring (default enabled)
 	--disable-bitforce      Compile support for BitForce (default enabled)
 	--disable-icarus        Compile support for Icarus (default enabled)
 	--disable-modminer      Compile support for ModMiner (default enabled)
@@ -77,10 +74,6 @@ Basic *nix build instructions:
 	install it so just keep track of where it is if you're not installing
 	the include files and library files into the system directory.
 	(Do NOT install the ati amd sdk if you are on nvidia.)
-	To build with GPU monitoring & clocking support:
-	Extract the AMD ADL SDK, latest version - there is also no official
-	place for these files. Copy all the *.h files in the "include"
-	directory into BFGMiner's ADL_SDK directory.
 
 The easiest way to install the ATI AMD SPP sdk on linux is to actually put it
 into a system location. Then building will be simpler. Download the correct

adl.c

@@ -20,7 +20,7 @@
 #endif
 
 #include "miner.h"
-#include "ADL_SDK/adl_sdk.h"
+#include "ADL/adl_sdk.h"
 #include "compat.h"
 
 #if defined (__linux)
@@ -33,6 +33,10 @@
 #endif
 #include "adl_functions.h"
 
+#ifndef WIN32
+#define __stdcall
+#endif
+
 #ifndef HAVE_CURSES
 #define wlogprint(...)  applog(LOG_WARNING, __VA_ARGS__)
 #endif

adl_functions.h

@@ -38,7 +38,7 @@
  #include <tchar.h>
 #endif
 
-#include "ADL_SDK/adl_sdk.h"
+#include "ADL/adl_sdk.h"
 
 // Definitions of the used function pointers. Add more if you use other ADL APIs
 

configure.ac

@@ -121,6 +121,8 @@ AC_ARG_ENABLE([opencl],
 	)
 if test "x$opencl" = xyes; then
 	AC_DEFINE([HAVE_OPENCL], [1], [Defined to 1 if OpenCL support is wanted])
+else
+	DLOPEN_FLAGS=""
 fi
 AM_CONDITIONAL([HAVE_OPENCL], [test x$opencl = xyes])
 
@@ -130,27 +132,20 @@ PTHREAD_LIBS=-lpthread
 
 AC_CHECK_LIB(jansson, json_loads, request_jansson=false, request_jansson=true)
 
+if test "x$opencl" = xyes; then
+	adl="yes"
+	
 AC_ARG_ENABLE([adl],
-	[AC_HELP_STRING([--disable-adl],[Override detection and disable building with adl])],
+	[AC_HELP_STRING([--disable-adl],[Build without ADL monitoring (default enabled)])],
 	[adl=$enableval]
 	)
 
-if test "x$opencl" = xyes; then
-	if test "x$adl" != xno; then
-		if test -f ADL_SDK/adl_sdk.h; then
-			have_adl=true
-		else
-			have_adl=false
-		fi
-		if test x$have_adl = xtrue
+	if test x$adl = xyes
 		then
 			AC_DEFINE([HAVE_ADL], [1], [Defined if ADL headers were found])
-		else
-			DLOPEN_FLAGS=""
 		fi
-	fi
 else
-	DLOPEN_FLAGS=""
+	adl="no"
 fi
 
 AC_ARG_ENABLE([bitforce],
@@ -420,14 +415,12 @@ else
 	echo "  OpenCL...............: Disabled"
 fi
 
-if test "x$adl" != xno; then
-	if test x$have_adl = xtrue; then
-		echo "    ADL................: SDK found, GPU monitoring support enabled"
-	else
-		echo "    ADL................: SDK NOT found, GPU monitoring support DISABLED"
-	fi
+if test "x$adl" = xyes; then
+	echo "    ADL.monitoring.....: Enabled"
+elif test "x$opencl" = xyes; then
+	echo "    ADL.monitoring.....: Disabled"
 else
-	echo "    ADL................: Detection overrided. GPU monitoring support DISABLED"
+	echo "    ADL.monitoring.....: n/a"
 fi
 
 if test "x$bitforce" = xyes; then

make-release

@@ -37,7 +37,6 @@ for txt in AUTHORS COPYING NEWS README API-README FPGA-README SCRYPT-README; do
 	cp -v "$txt" "$OUTDIR/${txt}.txt"
 done
 cp -av "bitstreams" "$OUTDIR/"
-cp -av "$IDIR/"ADL_SDK/adl_{defines,sdk,structures}.h "ADL_SDK/"
 NOCONFIGURE=1 \
 ./autogen.sh
 ./configure \

miner.h

@@ -81,7 +81,7 @@ void *alloca (size_t);
 
 
 #ifdef HAVE_ADL
- #include "ADL_SDK/adl_sdk.h"
+ #include "ADL/adl_sdk.h"
 #endif
 
 #ifdef HAVE_LIBUSB

windows-build.txt

@@ -101,16 +101,6 @@ Note: If you are on a 32 bit version of windows "Program Files (x86)" will be
 "Program Files".
 Note2: If you update your APP SDK later you might want to recopy the above files 
 
-**************************************************************************************
-* Install AMD ADL SDK, latest version (only if you want GPU monitoring)              *
-**************************************************************************************
-Note: You do not need to install the AMD ADL SDK if you are only using Nvidia GPU's	
-Go to this url ==> http://developer.amd.com/sdks/ADLSDK/Pages/default.aspx
-Download and unzip the file you downloaded.
-Pull adl_defines.h, adl_sdk.h, and adl_structures.h out of the include folder 
-Put those files into the ADL_SDK folder in your source tree as shown below.
-\MinGW\msys\1.0\home\(folder with your user name)\bfgminer-x.x.x\ADL_SDK
-
 **************************************************************************************
 * Install GTK-WIN, required for Pkg-config in the next step                          *
 **************************************************************************************
@@ -196,24 +186,11 @@ If you simply just want to update the source after you have already cloned, type
 
 Now you can get the latest source directly from github.
 
-**************************************************************************************
-* Optional - Make a .sh file to automate copying over ADL files                      *
-**************************************************************************************
-Make a folder/directory in your home folder and name it ADL_SDK.
- (ref:  \MinGW\msys\1.0\home\(folder with your user name)\ADL_SDK)
-Copy the ADL .h files into that folder/directory.
-Open your favorite text editor and type the following into it.
- cp -av ../ADL_SDK/*.h ADL_SDK
-Save the file as "adl.sh" and then place the file into "\MinGW\msys\1.0\bin".
-From now on when your current working directory is the bfgminer source directory
-You can simply type "adl.sh" and it will place the ADL header files into place
-For you. Make sure you never remove the ADL_SDK folder from your home folder.
-
 **************************************************************************************
 * Some ./configure options                                                           *
 **************************************************************************************
---disable-opencl        Override detection and disable building with opencl
---disable-adl           Override detection and disable building with adl
+--disable-opencl        Build without support for OpenCL (default enabled)
+--disable-adl           Build without ADL monitoring (default enabled)
 --enable-bitforce       Compile support for BitForce FPGAs(default disabled)
 --enable-icarus         Compile support for Icarus Board(default disabled)