/*
* NV-CONTROL versions 1.8 and 1.9 pack the target_type and target_id
* fields in reversed order. In order to talk to one of these servers,
* we need to swap these fields.
*/
static void XNVCTRLCheckTargetData(Display *dpy, XExtDisplayInfo *info,
int *target_type, int *target_id)
{
/* Find out what the server's NV-CONTROL version is and
* setup for swapping if we need to.
*/
if (info->data == NVCTRL_EXT_NEED_CHECK) {
int major, minor;
if (XNVCTRLQueryVersion(dpy, &major, &minor)) {
if (major == 1 &&
(minor == 8 || minor == 9)) {
info->data = NVCTRL_EXT_NEED_TARGET_SWAP;
} else {
info->data = NVCTRL_EXT_NEED_NOTHING;
}
} else {
info->data = NVCTRL_EXT_NEED_NOTHING;
}
}
/* We need to swap the target_type and target_id */
if (info->data == NVCTRL_EXT_NEED_TARGET_SWAP) {
int tmp;
tmp = *target_type;
*target_type = *target_id;
*target_id = tmp;
}
}
int CheckNVOpenGLSyncToVBlank(void)
{
MythXDisplay *d = OpenMythXDisplay();
if (!d)
return -1;
Display *dpy = d->GetDisplay();
int screen = d->GetScreen();
if (!XNVCTRLIsNvScreen(dpy, screen))
{
delete d;
return -1;
}
int major, minor;
if (!XNVCTRLQueryVersion(dpy, &major, &minor))
return -1;
int sync = NV_CTRL_SYNC_TO_VBLANK_OFF;
if (!XNVCTRLQueryAttribute(dpy, screen, 0, NV_CTRL_SYNC_TO_VBLANK, &sync))
{
delete d;
return -1;
}
if (!sync)
{
LOG(VB_GENERAL, LOG_WARNING, LOC + "OpenGL Sync to VBlank is disabled.");
LOG(VB_GENERAL, LOG_WARNING, LOC + "For best results enable this in NVidia settings or try running:");
LOG(VB_GENERAL, LOG_WARNING, LOC + "nvidia-settings -a \"SyncToVBlank=1\"");
}
if (!sync && getenv("__GL_SYNC_TO_VBLANK"))
{
LOG(VB_GENERAL, LOG_INFO, LOC +
"OpenGL Sync to VBlank enabled via __GL_SYNC_TO_VBLANK.");
sync = 1;
}
else if (!sync)
{
LOG(VB_GENERAL, LOG_WARNING, LOC +
"Alternatively try setting the '__GL_SYNC_TO_VBLANK' environment variable.");
}
return sync;
}
bool UINVControl::NVControlAvailable(Display *XDisplay)
{
QMutexLocker locker(gNVCtrlLock);
static bool available = false;
static bool checked = false;
if (checked || !XDisplay)
return available;
checked = true;
int event = 0;
int error = 0;
Bool ok = XNVCTRLQueryExtension(XDisplay, &event, &error);
if (ok != True)
{
LOG(VB_GENERAL, LOG_INFO, QString("NV-CONTROL X extension not available on display '%1'").arg(XDisplayName(NULL)));
return available;
}
int major = 0;
int minor = 0;
ok = XNVCTRLQueryVersion(XDisplay, &major, &minor);
if (ok != True)
{
LOG(VB_GENERAL, LOG_INFO, QString("NV-CONTROL X extension not available on display '%1'").arg(XDisplayName(NULL)));
return available;
}
available = true;
LOG(VB_GENERAL, LOG_INFO, QString("NV-CONTROL X extension version %1.%2 available on display '%3'")
.arg(major).arg(minor).arg(XDisplayName(NULL)));
return available;
}
static uintptr_t version_flags(Display *dpy, XExtDisplayInfo *info)
{
uintptr_t data = (uintptr_t)info->data;
/* If necessary, determine the NV-CONTROL version */
if (data & NVCTRL_EXT_NEED_CHECK) {
int major, minor;
data = 0;
if (XNVCTRLQueryVersion(dpy, &major, &minor)) {
data |= NVCTRL_EXT_EXISTS;
if (major == 1 && (minor == 8 || minor == 9)) {
data |= NVCTRL_EXT_NEED_TARGET_SWAP;
}
if ((major > 1) || ((major == 1) && (minor > 20))) {
data |= NVCTRL_EXT_64_BIT_ATTRIBUTES;
}
}
info->data = (XPointer)data;
}
return data;
}
/*
* Open a display connection, and make sure the NV-CONTROL X
* extension is present on the screen we want to use.
*/
static Bool setup(Display** dpy, int* screen) {
int major, minor;
Bool ret;
*dpy = XOpenDisplay(NULL);
if (!(*dpy)) {
fprintf(stderr, "Cannot open display '%s'.\n\n", XDisplayName(NULL));
return False;
}
*screen = GetNvXScreen(*dpy);
if (*screen == -1) {
return False;
}
ret = XNVCTRLQueryVersion(*dpy, &major, &minor);
if (ret != True) {
fprintf(stderr, "The NV-CONTROL X extension does not exist "
"on '%s'.\n\n", XDisplayName(NULL));
return False;
}
return True;
}
int GetNvidiaRates(t_screenrate& screenmap)
{
#ifdef USING_XRANDR
MythXDisplay *d = OpenMythXDisplay();
if (!d)
{
return -1;
}
Display *dpy;
bool ret;
int screen, display_devices, mask, major, minor, len, j;
char *str, *start;
int nDisplayDevice;
char *pMetaModes, *pModeLines[8], *tmp, *modeString;
char *modeLine, *modeName;
int MetaModeLen, ModeLineLen[8];
int thisMask;
int id;
int twinview = 0;
map<int, map<int,bool> > maprate;
memset(pModeLines, 0, sizeof(pModeLines));
memset(ModeLineLen, 0, sizeof(ModeLineLen));
/*
* Open a display connection, and make sure the NV-CONTROL X
* extension is present on the screen we want to use.
*/
dpy = d->GetDisplay();
screen = d->GetScreen();
if (!XNVCTRLIsNvScreen(dpy, screen))
{
LOG(VB_PLAYBACK, LOG_INFO,
QString("The NV-CONTROL X extension is not available on screen %1 "
"of '%2'.")
.arg(screen) .arg(XDisplayName(NULL)));
delete d;
return -1;
}
ret = XNVCTRLQueryVersion(dpy, &major, &minor);
if (ret != True)
{
LOG(VB_PLAYBACK, LOG_INFO,
QString("The NV-CONTROL X extension does not exist on '%1'.")
.arg(XDisplayName(NULL)));
delete d;
return -1;
}
ret = XNVCTRLQueryAttribute(dpy, screen, 0, NV_CTRL_DYNAMIC_TWINVIEW, &twinview);
if (!ret)
{
LOG(VB_PLAYBACK, LOG_ERR,
"Failed to query if Dynamic Twinview is enabled");
XCloseDisplay(dpy);
return -1;
}
if (!twinview)
{
LOG(VB_PLAYBACK, LOG_ERR, "Dynamic Twinview not enabled, ignoring");
delete d;
return 0;
}
/*
* query the connected display devices on this X screen and print
* basic information about each X screen
*/
ret = XNVCTRLQueryAttribute(dpy, screen, 0,
NV_CTRL_CONNECTED_DISPLAYS, &display_devices);
if (!ret)
{
LOG(VB_PLAYBACK, LOG_ERR,
"Failed to query the enabled Display Devices.");
delete d;
return -1;
}
/* first, we query the MetaModes on this X screen */
ret = XNVCTRLQueryBinaryData(dpy, screen, 0, // n/a
NV_CTRL_BINARY_DATA_METAMODES,
(unsigned char **)&pMetaModes, &MetaModeLen);
if (!ret)
{
LOG(VB_PLAYBACK, LOG_ERR,
"Failed to query the metamode on selected display device.");
delete d;
return -1;
}
/*
* then, we query the ModeLines for each display device on
* this X screen; we'll need these later
*/
nDisplayDevice = 0;
for (mask = 1; mask < (1 << 24); mask <<= 1)
{
if (!(display_devices & mask)) continue;
ret = XNVCTRLQueryBinaryData(dpy, screen, mask,
NV_CTRL_BINARY_DATA_MODELINES,
(unsigned char **)&str, &len);
if (!ret)
{
LOG(VB_PLAYBACK, LOG_ERR,
"Unknown error. Failed to query the enabled Display Devices.");
// Free Memory currently allocated
for (j=0; j < nDisplayDevice; ++j)
{
free(pModeLines[j]);
}
delete d;
return -1;
}
pModeLines[nDisplayDevice] = str;
ModeLineLen[nDisplayDevice] = len;
nDisplayDevice++;
}
/* now, parse each MetaMode */
str = start = pMetaModes;
for (j = 0; j < MetaModeLen - 1; ++j)
{
/*
* if we found the end of a line, treat the string from
* start to str[j] as a MetaMode
*/
if ((str[j] == '\0') && (str[j+1] != '\0'))
{
id = extract_id_string(start);
/*
* the MetaMode may be preceded with "token=value"
* pairs, separated by the main MetaMode with "::"; if
* "::" exists in the string, skip past it
*/
tmp = strstr(start, "::");
if (tmp)
{
tmp += 2;
}
else
{
tmp = start;
}
/* split the MetaMode string by comma */
char *strtok_state = NULL;
for (modeString = strtok_r(tmp, ",", &strtok_state);
modeString;
modeString = strtok_r(NULL, ",", &strtok_state))
{
/*
* retrieve the modeName and display device mask
* for this segment of the Metamode
*/
parse_mode_string(modeString, &modeName, &thisMask);
/* lookup the modeline that matches */
nDisplayDevice = 0;
if (thisMask)
{
for (mask = 1; mask < (1 << 24); mask <<= 1)
{
if (!(display_devices & mask)) continue;
if (thisMask & mask) break;
nDisplayDevice++;
}
}
modeLine = find_modeline(modeName,
pModeLines[nDisplayDevice],
ModeLineLen[nDisplayDevice]);
if (modeLine && !modeline_is_interlaced(modeLine))
{
int w, h, vfl, hfl, i, irate;
double dcl, r;
char *buf[256];
uint64_t key, key2;
// skip name
tmp = strchr(modeLine, '"');
tmp = strchr(tmp+1, '"') +1 ;
while (*tmp == ' ')
tmp++;
i = 0;
for (modeString = strtok_r(tmp, " ", &strtok_state);
modeString;
modeString = strtok_r(NULL, " ", &strtok_state))
{
buf[i++] = modeString;
}
w = strtol(buf[1], NULL, 10);
h = strtol(buf[5], NULL, 10);
vfl = strtol(buf[8], NULL, 10);
hfl = strtol(buf[4], NULL, 10);
h = strtol(buf[5], NULL, 10);
istringstream istr(buf[0]);
istr.imbue(locale("C"));
istr >> dcl;
r = (dcl * 1000000.0) / (vfl * hfl);
irate = (int) round(r * 1000.0);
key = DisplayResScreen::CalcKey(w, h, (double) id);
key2 = DisplayResScreen::CalcKey(w, h, 0.0);
// We need to eliminate duplicates, giving priority to the first entries found
if (maprate.find(key2) == maprate.end())
{
// First time we see this resolution, create a map for it
maprate[key2] = map<int, bool>();
}
if ((maprate[key2].find(irate) == maprate[key2].end()) &&
(screenmap.find(key) == screenmap.end()))
{
screenmap[key] = r;
maprate[key2][irate] = true;
}
}
free(modeName);
}
/* move to the next MetaMode */
start = &str[j+1];
}
int main(int argc, char *argv[])
{
Display *dpy;
Bool ret;
int major, minor;
int use_gvi = -1;
int i;
char *topology_str = NULL;
/*
* Open a display connection, and make sure the NV-CONTROL X
* extension is present on the screen we want to use.
*/
dpy = XOpenDisplay(NULL);
if (!dpy) {
printf("Cannot open display '%s'.\n", XDisplayName(NULL));
return 1;
}
/* Query the NV-CONTROL version */
ret = XNVCTRLQueryVersion(dpy, &major, &minor);
if (ret != True) {
printf("The NV-CONTROL X extension does not exist on '%s'.\n",
XDisplayName(NULL));
return 1;
}
/* Print some information */
printf("Using NV-CONTROL extension %d.%d on %s\n\n",
major, minor, XDisplayName(NULL));
/* See if user wants a specific GVI device */
for (i = 0; i < argc; i++) {
if ((strcmp(argv[i], "-g") == 0) && ((i+1) < argc)) {
use_gvi = strtol(argv[i+1], NULL, 10);
}
if ((strcmp(argv[i], "-c") == 0) && ((i+1) < argc)) {
topology_str = argv[i+1];
}
}
/* Do what the user wants */
ret = 0;
for (i = 0; i < argc; i++) {
if (strcmp(argv[i], "-q") == 0) {
do_query(dpy, use_gvi);
ret = 1;
break;
} else if (strcmp(argv[i], "-c") == 0) {
do_configure(dpy, use_gvi, topology_str);
ret = 1;
break;
} else if (strcmp(argv[i], "-l") == 0) {
do_listconfig(dpy, use_gvi);
ret = 1;
}
}
if (!ret) {
do_help();
}
return 0;
}
/**
* load initial data
*
* TODO:350:M: Implement nvCtrlTable data load
* This function will also be called by the cache helper to load
* the container again (after the container free function has been
* called to free the previous contents).
*
* @param container container to which items should be inserted
*
* @retval MFD_SUCCESS : success.
* @retval MFD_RESOURCE_UNAVAILABLE : Can't access data source
* @retval MFD_ERROR : other error.
*
* This function is called to load the index(es) (and data, optionally)
* for the every row in the data set.
*
* @remark
* While loading the data, the only important thing is the indexes.
* If access to your data is cheap/fast (e.g. you have a pointer to a
* structure in memory), it would make sense to update the data here.
* If, however, the accessing the data invovles more work (e.g. parsing
* some other existing data, or peforming calculations to derive the data),
* then you can limit yourself to setting the indexes and saving any
* information you will need later. Then use the saved information in
* nvCtrlTable_row_prep() for populating data.
*
* @note
* If you need consistency between rows (like you want statistics
* for each row to be from the same time frame), you should set all
* data here.
*
*/
int
nvCtrlTable_container_load(netsnmp_container *container)
{
nvCtrlTable_rowreq_ctx *rowreq_ctx;
size_t count = 0;
Display *dpy;
Bool ret;
int event_base, error_base, major, minor, gpus;
int gpu, retval, len;
char *str;
DEBUGMSGTL(("verbose:nvCtrlTable:nvCtrlTable_container_load", "called\n"));
/*
* open a connection to the X server indicated by the DISPLAY
* environment variable
*/
dpy = XOpenDisplay(NULL);
if (!dpy) {
DEBUGMSGTL(("nvCtrlTable:nvCtrlTable_container_load",
"Cannot open display '%s'.\n", XDisplayName(NULL)));
return MFD_RESOURCE_UNAVAILABLE;
}
/*
* check if the NV-CONTROL X extension is present on this X server
*/
ret = XNVCTRLQueryExtension(dpy, &event_base, &error_base);
if (ret != True) {
DEBUGMSGTL(("nvCtrlTable:nvCtrlTable_container_load",
"The NV-CONTROL X extension does not exist on '%s'.\n",
XDisplayName(NULL)));
return MFD_RESOURCE_UNAVAILABLE;
}
/*
* query the major and minor extension version
*/
ret = XNVCTRLQueryVersion(dpy, &major, &minor);
if (ret != True) {
DEBUGMSGTL(("nvCtrlTable:nvCtrlTable_container_load",
"The NV-CONTROL X extension does not exist on '%s'.\n",
XDisplayName(NULL)));
return MFD_RESOURCE_UNAVAILABLE;
}
/*
* query number of GPUs via the NV-CONTROL X extension; then, allocate
* a rowreq context, set the index(es) and data, and insert into the
* container.
*/
if (!XNVCTRLQueryTargetCount(dpy, NV_CTRL_TARGET_TYPE_GPU, &gpus)) {
snmp_log(LOG_ERR, "failed to query number of GPUs\n");
return MFD_ERROR;
}
for (gpu = 0; gpu < gpus; gpu++) {
rowreq_ctx = nvCtrlTable_allocate_rowreq_ctx();
if (NULL == rowreq_ctx) {
snmp_log(LOG_ERR, "memory allocation failed\n");
return MFD_RESOURCE_UNAVAILABLE;
}
if (MFD_SUCCESS != nvCtrlTable_indexes_set(rowreq_ctx, gpu)) {
snmp_log(LOG_ERR, "error setting index while loading"
"nvCtrlTable data.\n");
nvCtrlTable_release_rowreq_ctx(rowreq_ctx);
continue;
}
/*
* setup/save data for nvCtrlProductName
* nvCtrlProductName(2)/DisplayString/ASN_OCTET_STR/char(char)//L/A/w/e/R/d/H
*/
ret = XNVCTRLQueryTargetStringAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU,
gpu,
0,
NV_CTRL_STRING_PRODUCT_NAME,
&str);
if (ret) {
len = strlen(str);
if (sizeof(rowreq_ctx->data.nvCtrlProductName) < len) {
snmp_log(LOG_ERR,"not enough space for value\n");
return MFD_ERROR;
}
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_PRODUCT_NAME_FLAG;
rowreq_ctx->data.nvCtrlProductName_len = len;
memcpy(rowreq_ctx->data.nvCtrlProductName, str, len);
XFree(str);
}
/*
* setup/save data for nvCtrlVBiosVersion
* nvCtrlVBiosVersion(3)/DisplayString/ASN_OCTET_STR/char(char)//L/A/w/e/R/d/H
*/
ret = XNVCTRLQueryTargetStringAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU,
gpu,
0,
NV_CTRL_STRING_VBIOS_VERSION,
&str);
if (ret) {
len = strlen(str);
if (sizeof(rowreq_ctx->data.nvCtrlVBiosVersion) < len) {
snmp_log(LOG_ERR,"not enough space for value\n");
return MFD_ERROR;
}
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_VBIOS_VERSION_FLAG;
rowreq_ctx->data.nvCtrlVBiosVersion_len = len;
memcpy(rowreq_ctx->data.nvCtrlVBiosVersion, str, len);
XFree(str);
}
/*
* setup/save data for nvCtrlNvidiaDriverVersion
* nvCtrlNvidiaDriverVersion(4)/DisplayString/ASN_OCTET_STR/char(char)//L/A/w/e/R/d/H
*/
ret = XNVCTRLQueryTargetStringAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU,
gpu,
0,
NV_CTRL_STRING_NVIDIA_DRIVER_VERSION,
&str);
if (ret) {
len = strlen(str);
if (sizeof(rowreq_ctx->data.nvCtrlNvidiaDriverVersion) < len) {
snmp_log(LOG_ERR,"not enough space for value\n");
return MFD_ERROR;
}
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_NVIDIA_DRIVER_VERSION_FLAG;
rowreq_ctx->data.nvCtrlNvidiaDriverVersion_len = len;
memcpy(rowreq_ctx->data.nvCtrlNvidiaDriverVersion, str, len);
XFree(str);
}
/*
* setup/save data for nvCtrlVersion
* nvCtrlVersion(5)/DisplayString/ASN_OCTET_STR/char(char)//L/A/w/e/R/d/H
*/
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_VERSION_FLAG;
snprintf(rowreq_ctx->data.nvCtrlVersion, sizeof(rowreq_ctx->data.nvCtrlVersion), "%d.%d", major, minor);
rowreq_ctx->data.nvCtrlVersion_len = strlen(rowreq_ctx->data.nvCtrlVersion);
/*
* setup/save data for nvCtrlBusType
* nvCtrlBusType(6)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h
*/
ret = XNVCTRLQueryTargetAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU,
gpu,
0,
NV_CTRL_BUS_TYPE,
&retval);
if (ret) {
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_BUS_TYPE_FLAG;
rowreq_ctx->data.nvCtrlBusType = retval;
}
/*
* setup/save data for nvCtrlBusRate
* nvCtrlBusRate(7)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h
*/
ret = XNVCTRLQueryTargetAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU,
gpu,
0,
NV_CTRL_BUS_RATE,
&retval);
if (ret) {
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_BUS_RATE_FLAG;
rowreq_ctx->data.nvCtrlBusRate = retval;
}
/*
* setup/save data for nvCtrlVideoRam
* nvCtrlVideoRam(8)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h
*/
ret = XNVCTRLQueryTargetAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU,
gpu,
0,
NV_CTRL_VIDEO_RAM,
&retval);
if (ret) {
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_VIDEO_RAM_FLAG;
rowreq_ctx->data.nvCtrlVideoRam = retval;
}
/*
* setup/save data for nvCtrlIrq
* nvCtrlIrq(9)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h
*/
ret = XNVCTRLQueryTargetAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU,
gpu,
0,
NV_CTRL_IRQ,
&retval);
if (ret) {
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_IRQ_FLAG;
rowreq_ctx->data.nvCtrlIrq = retval;
}
/*
* setup/save data for nvCtrlGPUCoreTemp
* nvCtrlGPUCoreTemp(10)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h
*/
ret = XNVCTRLQueryTargetAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU,
gpu,
0,
NV_CTRL_GPU_CORE_TEMPERATURE,
&retval);
if (ret) {
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_CORE_TEMP_FLAG;
rowreq_ctx->data.nvCtrlGPUCoreTemp = retval;
}
/*
* setup/save data for nvCtrlGPUCoreThreshold
* nvCtrlGPUCoreThreshold(11)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h
*/
ret = XNVCTRLQueryTargetAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU,
gpu,
0,
NV_CTRL_GPU_CORE_THRESHOLD,
&retval);
if (ret) {
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_CORE_THRESHOLD_FLAG;
rowreq_ctx->data.nvCtrlGPUCoreThreshold = retval;
}
/*
* setup/save data for nvCtrlGPUDefaultCoreThreshold
* nvCtrlGPUDefaultCoreThreshold(12)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h
*/
ret = XNVCTRLQueryTargetAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU,
gpu,
0,
NV_CTRL_GPU_DEFAULT_CORE_THRESHOLD,
&retval);
if (ret) {
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_DEFAULT_CORE_THRESHOLD_FLAG;
rowreq_ctx->data.nvCtrlGPUDefaultCoreThreshold = retval;
}
/*
* setup/save data for nvCtrlGPUMaxCoreThreshold
* nvCtrlGPUMaxCoreThreshold(13)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h
*/
ret = XNVCTRLQueryTargetAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU,
gpu,
0,
NV_CTRL_GPU_MAX_CORE_THRESHOLD,
&retval);
if (ret) {
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_MAX_CORE_THRESHOLD_FLAG;
rowreq_ctx->data.nvCtrlGPUMaxCoreThreshold = retval;
}
/*
* setup/save data for nvCtrlGPUAmbientTemp
* nvCtrlGPUAmbientTemp(14)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h
*/
ret = XNVCTRLQueryTargetAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU,
gpu,
0,
NV_CTRL_AMBIENT_TEMPERATURE,
&retval);
if (ret) {
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_AMBIENT_TEMP_FLAG;
rowreq_ctx->data.nvCtrlGPUAmbientTemp = retval;
}
/*
* setup/save data for nvCtrlGPUOverclockingState
* nvCtrlGPUOverclockingState(15)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h
*/
ret = XNVCTRLQueryTargetAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU,
gpu,
0,
NV_CTRL_GPU_OVERCLOCKING_STATE,
&retval);
if (ret) {
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_OVERCLOCKING_STATE_FLAG;
rowreq_ctx->data.nvCtrlGPUOverclockingState = retval;
}
/*
* setup/save data for nvCtrlGPU2DGPUClockFreq
* nvCtrlGPU2DGPUClockFreq(16)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h
*/
ret = XNVCTRLQueryTargetAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU,
gpu,
0,
NV_CTRL_GPU_2D_CLOCK_FREQS,
&retval);
if (ret) {
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_2D_GPU_CLOCK_FREQ_FLAG;
rowreq_ctx->data.nvCtrlGPU2DGPUClockFreq = (retval >> 16) & 0xFFFF;
}
/*
* setup/save data for nvCtrlGPU2DMemClockFreq
* nvCtrlGPU2DMemClockFreq(17)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h
*/
if (ret) {
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_2D_MEM_CLOCK_FREQ_FLAG;
rowreq_ctx->data.nvCtrlGPU2DMemClockFreq = retval & 0xFFFF;
}
/*
* setup/save data for nvCtrlGPU3DGPUClockFreq
* nvCtrlGPU3DGPUClockFreq(18)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h
*/
ret = XNVCTRLQueryTargetAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU,
gpu,
0,
NV_CTRL_GPU_3D_CLOCK_FREQS,
&retval);
if (ret) {
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_3D_GPU_CLOCK_FREQ_FLAG;
rowreq_ctx->data.nvCtrlGPU3DGPUClockFreq = (retval >> 16) & 0xFFFF;
}
/*
* setup/save data for nvCtrlGPU3DMemClockFreq
* nvCtrlGPU3DMemClockFreq(19)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h
*/
if (ret) {
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_3D_MEM_CLOCK_FREQ_FLAG;
rowreq_ctx->data.nvCtrlGPU3DMemClockFreq = retval & 0xFFFF;
}
/*
* setup/save data for nvCtrlGPUDefault2DGPUClockFreq
* nvCtrlGPUDefault2DGPUClockFreq(20)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h
*/
ret = XNVCTRLQueryTargetAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU,
gpu,
0,
NV_CTRL_GPU_DEFAULT_2D_CLOCK_FREQS,
&retval);
if (ret) {
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_DEFAULT_2D_GPU_CLOCK_FREQ_FLAG;
rowreq_ctx->data.nvCtrlGPUDefault2DGPUClockFreq = (retval >> 16) & 0xFFFF;
}
/*
* setup/save data for nvCtrlGPUDefault2DMemClockFreq
* nvCtrlGPUDefault2DMemClockFreq(21)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h
*/
if (ret) {
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_DEFAULT_2D_MEM_CLOCK_FREQ_FLAG;
rowreq_ctx->data.nvCtrlGPUDefault2DMemClockFreq = retval & 0xFFFF;
}
/*
* setup/save data for nvCtrlGPUDefault3DGPUClockFreq
* nvCtrlGPUDefault3DGPUClockFreq(22)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h
*/
ret = XNVCTRLQueryTargetAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU,
gpu,
0,
NV_CTRL_GPU_DEFAULT_3D_CLOCK_FREQS,
&retval);
if (ret) {
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_DEFAULT_3D_GPU_CLOCK_FREQ_FLAG;
rowreq_ctx->data.nvCtrlGPUDefault3DGPUClockFreq = (retval >> 16) & 0xFFFF;
}
/*
* setup/save data for nvCtrlGPUDefault3DMemClockFreq
* nvCtrlGPUDefault3DMemClockFreq(23)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h
*/
if (ret) {
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_DEFAULT_3D_MEM_CLOCK_FREQ_FLAG;
rowreq_ctx->data.nvCtrlGPUDefault3DMemClockFreq = retval & 0xFFFF;
}
/*
* setup/save data for nvCtrlGPUCurrentGPUClockFreq
* nvCtrlGPUCurrentGPUClockFreq(24)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h
*/
ret = XNVCTRLQueryTargetAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU,
gpu,
0,
NV_CTRL_GPU_CURRENT_CLOCK_FREQS,
&retval);
if (ret) {
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_CURRENT_GPU_CLOCK_FREQ_FLAG;
rowreq_ctx->data.nvCtrlGPUCurrentGPUClockFreq = (retval >> 16) & 0xFFFF;
}
/*
* setup/save data for nvCtrlGPUCurrentMemClockFreq
* nvCtrlGPUCurrentMemClockFreq(25)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h
*/
if (ret) {
rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_CURRENT_MEM_CLOCK_FREQ_FLAG;
rowreq_ctx->data.nvCtrlGPUCurrentMemClockFreq = retval & 0xFFFF;
}
/*
* insert into table container
*/
CONTAINER_INSERT(container, rowreq_ctx);
++count;
}
/*
* close the display connection
*/
XCloseDisplay(dpy);
DEBUGMSGT(("verbose:nvCtrlTable:nvCtrlTable_container_load",
"inserted %d records\n", count));
return MFD_SUCCESS;
} /* nvCtrlTable_container_load */
int main(int argc, char *argv[])
{
Display *dpy;
Bool ret;
int screen, major, minor, len, i, j;
char *str, *start, *str0, *str1;
int *enabledDpyIds;
/*
* Open a display connection, and make sure the NV-CONTROL X
* extension is present on the screen we want to use.
*/
dpy = XOpenDisplay(NULL);
if (!dpy) {
fprintf(stderr, "Cannot open display '%s'.\n\n", XDisplayName(NULL));
return 1;
}
screen = GetNvXScreen(dpy);
ret = XNVCTRLQueryVersion(dpy, &major, &minor);
if (ret != True) {
fprintf(stderr, "The NV-CONTROL X extension does not exist "
"on '%s'.\n\n", XDisplayName(NULL));
return 1;
}
printf("\nUsing NV-CONTROL extension %d.%d on %s\n\n",
major, minor, XDisplayName(NULL));
/*
* query the enabled display devices on this X screen and print basic
* information about each X screen.
*/
ret = XNVCTRLQueryTargetBinaryData(dpy,
NV_CTRL_TARGET_TYPE_X_SCREEN,
screen,
0,
NV_CTRL_BINARY_DATA_DISPLAYS_ENABLED_ON_XSCREEN,
(unsigned char **) &enabledDpyIds,
&len);
if (!ret || (len < sizeof(enabledDpyIds[0]))) {
fprintf(stderr, "Failed to query the enabled Display Devices.\n\n");
return 1;
}
printf("Enabled Display Devices:\n");
for (i = 0; i < enabledDpyIds[0]; i++) {
int dpyId = enabledDpyIds[i+1];
print_display_id_and_name(dpy, dpyId, " ");
}
printf("\n");
/*
* perform the requested action, based on the specified
* commandline option
*/
if (argc <= 1) goto printHelp;
/*
* for each enabled display device on this X screen, query the list of
* modelines in the mode pool using NV_CTRL_BINARY_DATA_MODELINES, then
* print the results.
*/
if (strcmp(argv[1], "--print-modelines") == 0) {
for (i = 0; i < enabledDpyIds[0]; i++) {
int dpyId = enabledDpyIds[i+1];
ret = XNVCTRLQueryTargetBinaryData(dpy,
NV_CTRL_TARGET_TYPE_DISPLAY,
dpyId,
0,
NV_CTRL_BINARY_DATA_MODELINES,
(void *) &str, &len);
if (!ret) {
fprintf(stderr, "Failed to query ModeLines.\n\n");
return 1;
}
/*
* the returned data is in the form:
*
* "ModeLine 1\0ModeLine 2\0ModeLine 3\0Last ModeLine\0\0"
*
* so walk from one "\0" to the next to print each ModeLine.
*/
printf("Modelines for DPY-%d:\n", dpyId);
start = str;
for (j = 0; j < len; j++) {
if (str[j] == '\0') {
printf(" %s\n", start);
start = &str[j+1];
}
}
XFree(str);
}
}
/*
* for each enabled display device on this X screen, query the current
* modeline using NV_CTRL_STRING_CURRENT_MODELINE.
*/
else if (strcmp(argv[1], "--print-current-modeline") == 0) {
for (i = 0; i < enabledDpyIds[0]; i++) {
int dpyId = enabledDpyIds[i+1];
ret = XNVCTRLQueryTargetStringAttribute(dpy,
NV_CTRL_TARGET_TYPE_DISPLAY,
dpyId,
0,
NV_CTRL_STRING_CURRENT_MODELINE,
&str);
if (!ret) {
fprintf(stderr, "Failed to query current ModeLine.\n\n");
return 1;
}
printf("Current Modeline for DPY-%d:\n", dpyId);
printf(" %s\n\n", str);
XFree(str);
}
}
/*
* add the specified modeline to the mode pool for the specified
* display device, using NV_CTRL_STRING_ADD_MODELINE
*/
else if ((strcmp(argv[1], "--add-modeline") == 0) &&
argv[2] && argv[3]) {
int dpyId = strtol(argv[2], NULL, 0);
ret = XNVCTRLSetTargetStringAttribute(dpy,
NV_CTRL_TARGET_TYPE_DISPLAY,
dpyId,
0,
NV_CTRL_STRING_ADD_MODELINE,
argv[3]);
if (!ret) {
fprintf(stderr, "Failed to add the modeline \"%s\" to DPY-%d's "
"mode pool.\n\n", argv[3], dpyId);
return 1;
}
printf("Added modeline \"%s\" to DPY-%d's mode pool.\n\n",
argv[3], dpyId);
}
/*
* delete the specified modeline from the mode pool for the
* specified display device, using NV_CTRL_STRING_DELETE_MODELINE
*/
else if ((strcmp(argv[1], "--delete-modeline") == 0) &&
argv[2] && argv[3]) {
int dpyId = strtol(argv[2], NULL, 0);
ret = XNVCTRLSetTargetStringAttribute(dpy,
NV_CTRL_TARGET_TYPE_DISPLAY,
dpyId,
0,
NV_CTRL_STRING_DELETE_MODELINE,
argv[3]);
if (!ret) {
fprintf(stderr, "Failed to delete the mode \"%s\" from DPY-%d's "
"mode pool.\n\n", argv[3], dpyId);
return 1;
}
printf("Deleted modeline \"%s\" from DPY-%d's mode pool.\n\n",
argv[3], dpyId);
}
/*
* generate a GTF modeline using NV_CTRL_STRING_OPERATION_GTF_MODELINE
*/
else if ((strcmp(argv[1], "--generate-gtf-modeline") == 0) &&
argv[2] && argv[3] && argv[4]) {
char pGtfString[128];
char *pOut;
snprintf(pGtfString, 128, "width=%s, height=%s, refreshrate=%s",
argv[2], argv[3], argv[4]);
ret = XNVCTRLStringOperation(dpy,
NV_CTRL_TARGET_TYPE_X_SCREEN,
screen,
0,
NV_CTRL_STRING_OPERATION_GTF_MODELINE,
pGtfString,
&pOut);
if (!ret) {
fprintf(stderr, "Failed to generate GTF ModeLine from "
"\"%s\".\n\n", pGtfString);
return 1;
}
printf("GTF ModeLine from \"%s\": %s\n\n", pGtfString, pOut);
}
/*
* generate a CVT modeline using NV_CTRL_STRING_OPERATION_CVT_MODELINE
*/
else if ((strcmp(argv[1], "--generate-cvt-modeline") == 0) &&
argv[2] && argv[3] && argv[4] && argv[5]) {
char pCvtString[128];
char *pOut;
snprintf(pCvtString, 128, "width=%s, height=%s, refreshrate=%s, "
"reduced-blanking=%s",
argv[2], argv[3], argv[4], argv[5]);
ret = XNVCTRLStringOperation(dpy,
NV_CTRL_TARGET_TYPE_X_SCREEN,
screen,
0,
NV_CTRL_STRING_OPERATION_CVT_MODELINE,
pCvtString,
&pOut);
if (!ret) {
fprintf(stderr, "Failed to generate CVT ModeLine from "
"\"%s\".\n\n", pCvtString);
return 1;
}
printf("CVT ModeLine from \"%s\": %s\n\n", pCvtString, pOut);
}
/*
* query the MetaModes for the X screen, using
* NV_CTRL_BINARY_DATA_METAMODES.
*/
else if (strcmp(argv[1], "--print-metamodes") == 0) {
/* get list of metamodes */
ret = XNVCTRLQueryBinaryData(dpy, screen, 0, // n/a
NV_CTRL_BINARY_DATA_METAMODES,
(void *) &str, &len);
if (!ret) {
fprintf(stderr, "Failed to query MetaModes.\n\n");
return 1;
}
/*
* the returned data is in the form:
*
* "MetaMode 1\0MetaMode 2\0MetaMode 3\0Last MetaMode\0\0"
*
* so walk from one "\0" to the next to print each MetaMode.
*/
printf("MetaModes:\n");
start = str;
for (j = 0; j < len; j++) {
if (str[j] == '\0') {
printf(" %s\n", start);
start = &str[j+1];
}
}
XFree(str);
}
/*
* query the MetaModes for the X screen, using
* NV_CTRL_BINARY_DATA_METAMODES_VERSION_2.
*/
else if (strcmp(argv[1], "--print-metamodes-version2") == 0) {
/* get list of metamodes */
ret = XNVCTRLQueryBinaryData(dpy, screen, 0, // n/a
NV_CTRL_BINARY_DATA_METAMODES_VERSION_2,
(void *) &str, &len);
if (!ret) {
fprintf(stderr, "Failed to query MetaModes.\n\n");
return 1;
}
/*
* the returned data is in the form:
*
* "MetaMode 1\0MetaMode 2\0MetaMode 3\0Last MetaMode\0\0"
*
* so walk from one "\0" to the next to print each MetaMode.
*/
printf("MetaModes:\n");
start = str;
for (j = 0; j < len; j++) {
if (str[j] == '\0') {
printf(" %s\n", start);
start = &str[j+1];
}
}
XFree(str);
}
/*
* query the currently in use MetaMode. Note that an alternative
* way to accomplish this is to use XRandR to query the current
* mode's refresh rate, and then match the refresh rate to the id
* reported in the returned NV_CTRL_BINARY_DATA_METAMODES data.
*/
else if (strcmp(argv[1], "--print-current-metamode") == 0) {
ret = XNVCTRLQueryStringAttribute(dpy, screen, 0,
NV_CTRL_STRING_CURRENT_METAMODE,
&str);
if (!ret) {
fprintf(stderr, "Failed to query the current MetaMode.\n\n");
return 1;
}
printf("current metamode: \"%s\"\n\n", str);
XFree(str);
}
/*
* query the currently in use MetaMode. Note that an alternative
* way to accomplish this is to use XRandR to query the current
* mode's refresh rate, and then match the refresh rate to the id
* reported in the returned NV_CTRL_BINARY_DATA_METAMODES_VERSION_2 data.
*/
else if (strcmp(argv[1], "--print-current-metamode-version2") == 0) {
ret = XNVCTRLQueryStringAttribute(dpy, screen, 0,
NV_CTRL_STRING_CURRENT_METAMODE_VERSION_2,
&str);
if (!ret) {
fprintf(stderr, "Failed to query the current MetaMode.\n\n");
return 1;
}
printf("current metamode: \"%s\"\n\n", str);
XFree(str);
}
/*
* add the given MetaMode to X screen's list of MetaModes, using
* NV_CTRL_STRING_OPERATION_ADD_METAMODE; example MetaMode string:
*
* "nvidia-auto-select, nvidia-auto-select"
*
* The output string will contain "id=#" which indicates the
* unique identifier for this MetaMode. You can then use XRandR
* to switch to this mode by matching the identifier with the
* refresh rate reported via XRandR.
*
* For example:
*
* $ ./nv-control-dpy --add-metamode \
* "nvidia-auto-select, nvidia-auto-select"
*
* Using NV-CONTROL extension 1.12 on :0
* Enabled Display Devices:
* DPY-0 : EIZO F931
* DPY-1 : ViewSonic P815-4
*
* Added MetaMode "nvidia-auto-select, nvidia-auto-select";
* pOut: "id=52"
*
* $ xrandr -q
* SZ: Pixels Physical Refresh
* 0 3200 x 1200 ( 821mm x 302mm ) 51 52
* *1 1600 x 600 ( 821mm x 302mm ) *50
* Current rotation - normal
* Current reflection - none
* Rotations possible - normal
* Reflections possible - none
*
* $ xrandr -s 0 -r 52
*/
else if ((strcmp(argv[1], "--add-metamode") == 0) && (argv[2])) {
char *pOut;
ret = XNVCTRLStringOperation(dpy,
NV_CTRL_TARGET_TYPE_X_SCREEN,
screen,
0,
NV_CTRL_STRING_OPERATION_ADD_METAMODE,
argv[2],
&pOut);
if (!ret) {
fprintf(stderr, "Failed to add the MetaMode \"%s\".\n\n",
argv[2]);
return 1;
}
printf("Added MetaMode \"%s\"; pOut: \"%s\"\n\n", argv[2], pOut);
XFree(pOut);
}
/*
* delete the given MetaMode from the X screen's list of
* MetaModes, using NV_CTRL_STRING_DELETE_METAMODE
*/
else if ((strcmp(argv[1], "--delete-metamode") == 0) && (argv[1])) {
ret = XNVCTRLSetStringAttribute(dpy,
screen,
0,
NV_CTRL_STRING_DELETE_METAMODE,
argv[2]);
if (!ret) {
fprintf(stderr, "Failed to delete the MetaMode.\n\n");
return 1;
}
printf("Deleted MetaMode \"%s\".\n\n", argv[2]);
}
/*
* query the valid frequency ranges for each display device, using
* NV_CTRL_STRING_VALID_HORIZ_SYNC_RANGES and
* NV_CTRL_STRING_VALID_VERT_REFRESH_RANGES
*/
else if (strcmp(argv[1], "--get-valid-freq-ranges") == 0) {
for (i = 0; i < enabledDpyIds[0]; i++) {
int dpyId = enabledDpyIds[i+1];
ret = XNVCTRLQueryTargetStringAttribute
(dpy, NV_CTRL_TARGET_TYPE_DISPLAY, dpyId, 0,
NV_CTRL_STRING_VALID_HORIZ_SYNC_RANGES,
&str0);
if (!ret) {
fprintf(stderr, "Failed to query HorizSync for DPY-%d.\n\n",
dpyId);
return 1;
}
ret = XNVCTRLQueryTargetStringAttribute
(dpy, NV_CTRL_TARGET_TYPE_DISPLAY, dpyId, 0,
NV_CTRL_STRING_VALID_VERT_REFRESH_RANGES,
&str1);
if (!ret) {
fprintf(stderr, "Failed to query VertRefresh for DPY-%d.\n\n",
dpyId);
XFree(str0);
return 1;
}
printf("frequency information for DPY-%d:\n", dpyId);
printf(" HorizSync : \"%s\"\n", str0);
printf(" VertRefresh : \"%s\"\n\n", str1);
XFree(str0);
XFree(str1);
}
}
/*
* attempt to build the modepool for each display device; this
* will fail for any display device that already has a modepool
*/
else if (strcmp(argv[1], "--build-modepool") == 0) {
for (i = 0; i < enabledDpyIds[0]; i++) {
int dpyId = enabledDpyIds[i+1];
ret = XNVCTRLStringOperation
(dpy,
NV_CTRL_TARGET_TYPE_DISPLAY,
dpyId,
0,
NV_CTRL_STRING_OPERATION_BUILD_MODEPOOL,
argv[2],
&str0);
if (!ret) {
fprintf(stderr, "Failed to build modepool for DPY-%d (it most "
"likely already has a modepool).\n\n", dpyId);
} else {
printf("Built modepool for DPY-%d.\n\n", dpyId);
}
}
}
/*
* query the assigned display devices on this X screen; these are the
* display devices that are available to the X screen for use by MetaModes.
*/
else if (strcmp(argv[1], "--get-assigned-dpys") == 0) {
int *pData = NULL;
int len;
ret = XNVCTRLQueryTargetBinaryData(dpy,
NV_CTRL_TARGET_TYPE_X_SCREEN,
screen,
0,
NV_CTRL_BINARY_DATA_DISPLAYS_ASSIGNED_TO_XSCREEN,
(unsigned char **) &pData,
&len);
if (!ret || (len < sizeof(pData[0]))) {
fprintf(stderr, "failed to query the assigned display "
"devices.\n\n");
return 1;
}
printf("Assigned display devices:\n");
for (i = 0; i < pData[0]; i++) {
int dpyId = pData[i+1];
printf(" DPY-%d\n", dpyId);
}
printf("\n");
XFree(pData);
}
/*
* query information about the GPUs in the system
*/
else if (strcmp(argv[1], "--query-gpus") == 0) {
int num_gpus, num_screens, i;
int *pData;
printf("GPU Information:\n");
/* Get the number of gpus in the system */
ret = XNVCTRLQueryTargetCount(dpy, NV_CTRL_TARGET_TYPE_GPU,
&num_gpus);
if (!ret) {
fprintf(stderr, "Failed to query number of gpus.\n\n");
return 1;
}
printf(" number of GPUs: %d\n", num_gpus);
/* List the X screen number of all X screens driven by each gpu */
for (i = 0; i < num_gpus; i++) {
ret = XNVCTRLQueryTargetBinaryData
(dpy,
NV_CTRL_TARGET_TYPE_GPU,
i, // target_id
0,
NV_CTRL_BINARY_DATA_XSCREENS_USING_GPU,
(unsigned char **) &pData,
&len);
if (!ret || (len < sizeof(pData[0]))) {
fprintf(stderr, "Failed to query list of X Screens\n");
return 1;
}
printf(" number of X screens using GPU %d: %d\n", i, pData[0]);
/* List X Screen number of all X Screens driven by this GPU. */
printf(" Indices of X screens using GPU %d: ", i);
for (j = 1; j <= pData[0]; j++) {
printf(" %d", pData[j]);
}
printf("\n");
XFree(pData);
}
/* Get the number of X Screens in the system
*
* NOTE: If Xinerama is enabled, ScreenCount(dpy) will return 1,
* where as querying the screen count information from
* NV-CONTROL will return the number of underlying X Screens.
*/
ret = XNVCTRLQueryTargetCount(dpy, NV_CTRL_TARGET_TYPE_X_SCREEN,
&num_screens);
if (!ret) {
fprintf(stderr, "Failed to query number of X Screens\n\n");
return 1;
}
printf("\n");
printf(" number of X screens (ScreenCount): %d\n",
ScreenCount(dpy));
printf(" number of X screens (NV-CONTROL): %d\n\n",
num_screens);
for (i = 0; i < num_screens; i++) {
ret = XNVCTRLQueryTargetBinaryData
(dpy,
NV_CTRL_TARGET_TYPE_X_SCREEN,
i, // target_id
0,
NV_CTRL_BINARY_DATA_GPUS_USED_BY_XSCREEN,
(unsigned char **) &pData,
&len);
if (!ret || (len < sizeof(pData[0]))) {
fprintf(stderr, "Failed to query list of gpus\n\n");
return 1;
}
printf(" number of GPUs used by X screen %d: %d\n", i,
pData[0]);
/* List gpu number of all gpus driven by this X screen */
printf(" Indices of GPUs used by X screen %d: ", i);
for (j = 1; j <= pData[0]; j++) {
printf(" %d", pData[j]);
}
printf("\n");
XFree(pData);
}
printf("\n");
}
/*
* probe for any newly connected display devices
*/
else if (strcmp(argv[1], "--probe-dpys") == 0) {
int num_gpus, i;
printf("Display Device Probed Information:\n\n");
/* Get the number of gpus in the system */
ret = XNVCTRLQueryTargetCount(dpy, NV_CTRL_TARGET_TYPE_GPU,
&num_gpus);
if (!ret) {
fprintf(stderr, "Failed to query number of gpus\n\n");
return 1;
}
printf(" number of GPUs: %d\n", num_gpus);
/* Probe and list the Display devices */
for (i = 0; i < num_gpus; i++) {
int deprecated;
int *pData;
/* Get the gpu name */
ret = XNVCTRLQueryTargetStringAttribute
(dpy, NV_CTRL_TARGET_TYPE_GPU, i, 0,
NV_CTRL_STRING_PRODUCT_NAME, &str);
if (!ret) {
fprintf(stderr, "Failed to query gpu name\n\n");
return 1;
}
/* Probe the GPU for new/old display devices */
ret = XNVCTRLQueryTargetAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU, i,
0,
NV_CTRL_PROBE_DISPLAYS,
&deprecated);
if (!ret) {
fprintf(stderr, "Failed to probe the enabled Display "
"Devices on GPU-%d (%s).\n\n", i, str);
return 1;
}
printf(" display devices on GPU-%d (%s):\n", i, str);
XFree(str);
/* Report results */
ret = XNVCTRLQueryTargetBinaryData(dpy,
NV_CTRL_TARGET_TYPE_GPU, i,
0,
NV_CTRL_BINARY_DATA_DISPLAYS_CONNECTED_TO_GPU,
(unsigned char **) &pData,
&len);
if (!ret || (len < sizeof(pData[0]))) {
fprintf(stderr, "Failed to query the connected Display Devices.\n\n");
return 1;
}
for (j = 0; j < pData[0]; j++) {
int dpyId = pData[j+1];
print_display_id_and_name(dpy, dpyId, " ");
}
printf("\n");
}
printf("\n");
}
/*
* query the nvidiaXineramaInfoOrder
*/
else if (strcmp(argv[1], "--query-nvidia-xinerama-info-order") == 0) {
ret = XNVCTRLQueryTargetStringAttribute
(dpy, NV_CTRL_TARGET_TYPE_X_SCREEN, screen, 0,
NV_CTRL_STRING_NVIDIA_XINERAMA_INFO_ORDER, &str);
if (!ret) {
fprintf(stderr, "Failed to query nvidiaXineramaInfoOrder.\n\n");
return 1;
}
printf("nvidiaXineramaInfoOrder: %s\n\n", str);
}
/*
* assign the nvidiaXineramaInfoOrder
*/
else if ((strcmp(argv[1], "--assign-nvidia-xinerama-info-order")== 0)
&& argv[2]) {
ret = XNVCTRLSetStringAttribute
(dpy,
screen,
0,
NV_CTRL_STRING_NVIDIA_XINERAMA_INFO_ORDER,
argv[2]);
if (!ret) {
fprintf(stderr, "Failed to assign "
"nvidiaXineramaInfoOrder = \"%s\".\n\n", argv[2]);
return 1;
}
printf("assigned nvidiaXineramaInfoOrder: \"%s\"\n\n",
argv[2]);
}
/*
* use NV_CTRL_MAX_SCREEN_WIDTH and NV_CTRL_MAX_SCREEN_HEIGHT to
* query the maximum screen dimensions on each GPU in the system
*/
else if (strcmp(argv[1], "--max-screen-size") == 0) {
int num_gpus, i, width, height;
/* Get the number of gpus in the system */
ret = XNVCTRLQueryTargetCount(dpy, NV_CTRL_TARGET_TYPE_GPU,
&num_gpus);
if (!ret) {
fprintf(stderr, "Failed to query number of gpus.\n\n");
return 1;
}
for (i = 0; i < num_gpus; i++) {
ret = XNVCTRLQueryTargetAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU,
i,
0,
NV_CTRL_MAX_SCREEN_WIDTH,
&width);
if (!ret) {
fprintf(stderr, "Failed to query the maximum screen "
"width on GPU-%d\n\n", i);
return 1;
}
ret = XNVCTRLQueryTargetAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU,
i,
0,
NV_CTRL_MAX_SCREEN_HEIGHT,
&height);
if (!ret) {
fprintf(stderr, "Failed to query the maximum screen "
"height on GPU-%d.\n\n", i);
return 1;
}
printf("GPU-%d: maximum X screen size: %d x %d.\n\n",
i, width, height);
}
}
/*
* demonstrate how to use NV-CONTROL to query what modelines are
* used by the MetaModes of the X screen: we first query all the
* MetaModes, parse out the display device names and mode names,
* and then lookup the modelines associated with those mode names
* on those display devices
*
* this could be implemented much more efficiently, but
* demonstrates the general idea
*/
else if (strcmp(argv[1], "--print-used-modelines") == 0) {
char *pMetaModes, *pModeLines[8], *tmp, *modeString;
char *modeLine, *modeName, *noWhiteSpace;
int MetaModeLen, ModeLineLen[8], ModeLineDpyId[8];
int dpyId;
/* first, we query the MetaModes on this X screen */
XNVCTRLQueryBinaryData(dpy, screen, 0,
NV_CTRL_BINARY_DATA_METAMODES_VERSION_2,
(void *) &pMetaModes, &MetaModeLen);
/*
* then, we query the ModeLines for each display device on
* this X screen; we'll need these later
*/
for (i = 0; i < enabledDpyIds[0]; i++) {
dpyId = enabledDpyIds[i+1];
XNVCTRLQueryTargetBinaryData(dpy, NV_CTRL_TARGET_TYPE_DISPLAY,
dpyId,
0,
NV_CTRL_BINARY_DATA_MODELINES,
(void *) &str, &len);
pModeLines[i] = str;
ModeLineLen[i] = len;
ModeLineDpyId[i] = dpyId;
}
/* now, parse each MetaMode */
str = start = pMetaModes;
for (j = 0; j < MetaModeLen - 1; j++) {
/*
* if we found the end of a line, treat the string from
* start to str[j] as a MetaMode
*/
if ((str[j] == '\0') && (str[j+1] != '\0')) {
printf("MetaMode: %s\n", start);
/*
* remove any white space from the string to make
* parsing easier
*/
noWhiteSpace = remove_whitespace(start);
/*
* the MetaMode may be preceded with "token=value"
* pairs, separated by the main MetaMode with "::"; if
* "::" exists in the string, skip past it
*/
tmp = strstr(noWhiteSpace, "::");
if (tmp) {
tmp += 2;
} else {
tmp = noWhiteSpace;
}
/* Parse each mode from the metamode */
for (modeString = mode_strtok(tmp);
modeString;
modeString = mode_strtok(NULL)) {
/*
* retrieve the modeName and display device id
* for this segment of the Metamode
*/
if (!parse_mode_string(modeString, &modeName, &dpyId)) {
fprintf(stderr, " Failed to parse mode string '%s'."
"\n\n",
modeString);
continue;
}
/* lookup the modeline that matches */
for (i = 0; i < enabledDpyIds[0]; i++) {
if (ModeLineDpyId[i] == dpyId) {
break;
}
}
if ( i >= enabledDpyIds[0] ) {
fprintf(stderr, " Failed to find modelines for "
"DPY-%d.\n\n",
dpyId);
continue;
}
modeLine = find_modeline(modeName,
pModeLines[i],
ModeLineLen[i]);
printf(" DPY-%d: %s\n", dpyId, modeLine);
}
printf("\n");
free(noWhiteSpace);
/* move to the next MetaMode */
start = &str[j+1];
}
}
}
/* Display all names each display device goes by
*/
else if (strcmp(argv[1], "--print-display-names") == 0) {
int *pData;
int len, i;
printf("Display Device Information:\n");
ret = XNVCTRLQueryTargetBinaryData(dpy,
NV_CTRL_TARGET_TYPE_GPU,
0,
0,
NV_CTRL_BINARY_DATA_DISPLAY_TARGETS,
(unsigned char **) &pData,
&len);
if (!ret || (len < sizeof(pData[0]))) {
fprintf(stderr, "Failed to query number of display devices.\n\n");
return 1;
}
printf(" number of display devices: %d\n", pData[0]);
for (i = 1; i <= pData[0]; i++) {
printf("\n Display Device: %d\n", pData[i]);
print_display_name(dpy, pData[i],
NV_CTRL_STRING_DISPLAY_NAME_TYPE_BASENAME,
"Type Basename");
print_display_name(dpy, pData[i],
NV_CTRL_STRING_DISPLAY_NAME_TYPE_ID,
"Type ID");
print_display_name(dpy, pData[i],
NV_CTRL_STRING_DISPLAY_NAME_DP_GUID,
"DP GUID");
print_display_name(dpy, pData[i],
NV_CTRL_STRING_DISPLAY_NAME_EDID_HASH,
"EDID HASH");
print_display_name(dpy, pData[i],
NV_CTRL_STRING_DISPLAY_NAME_TARGET_INDEX,
"Target Index");
print_display_name(dpy, pData[i],
NV_CTRL_STRING_DISPLAY_NAME_RANDR,
"RANDR");
}
}
/*
* print help information
*/
else {
printHelp:
printf("\nnv-control-dpy [options]:\n\n");
printf(" ModeLine options:\n\n");
printf(" --print-modelines: print the modelines in the mode pool "
"for each Display Device.\n\n");
printf(" --print-current-modeline: print the current modeline "
"for each Display Device.\n\n");
printf(" --add-modeline [dpy id] [modeline]: "
"add new modeline.\n\n");
printf(" --delete-modeline [dpy id] [modename]: "
"delete modeline with modename.\n\n");
printf(" --generate-gtf-modeline [width] [height] [refreshrate]:"
" use the GTF formula"
" to generate a modeline for the specified parameters.\n\n");
printf(" --generate-cvt-modeline [width] [height] [refreshrate]"
" [reduced-blanking]: use the CVT formula"
" to generate a modeline for the specified parameters.\n\n");
printf(" MetaMode options:\n\n");
printf(" --print-metamodes: print the current MetaModes for the "
"X screen\n\n");
printf(" --print-metamodes-version2: print the current MetaModes for "
"the X screen with extended information\n\n");
printf(" --add-metamode [metamode]: add the specified "
"MetaMode to the X screen's list of MetaModes.\n\n");
printf(" --delete-metamode [metamode]: delete the specified MetaMode "
"from the X screen's list of MetaModes.\n\n");
printf(" --print-current-metamode: print the current MetaMode.\n\n");
printf(" --print-current-metamode-version2: print the current "
"MetaMode with extended information.\n\n");
printf(" Misc options:\n\n");
printf(" --get-valid-freq-ranges: query the valid frequency "
"information for each display device.\n\n");
printf(" --build-modepool: build a modepool for any display device "
"that does not already have one.\n\n");
printf(" --get-assigned-dpys: query the assigned display device for "
"this X screen\n\n");
printf(" --query-gpus: print GPU information and relationship to "
"X screens.\n\n");
printf(" --probe-dpys: probe GPUs for new display devices\n\n");
printf(" --query-nvidia-xinerama-info-order: query the "
"nvidiaXineramaInfoOrder.\n\n");
printf(" --assign-nvidia-xinerama-info-order [order]: assign the "
"nvidiaXineramaInfoOrder.\n\n");
printf(" --max-screen-size: query the maximum screen size "
"on all GPUs in the system\n\n");
printf(" --print-used-modelines: print the modeline for each display "
"device for each MetaMode on the X screen.\n\n");
printf(" --print-display-names: print all the names associated with "
"each display device on the server\n\n");
}
return 0;
}
int main(void)
{
Display *dpy;
Bool ret;
int event_base, error_base, major, minor, screens, i;
char *str;
/*
* open a connection to the X server indicated by the DISPLAY
* environment variable
*/
dpy = XOpenDisplay(NULL);
if (!dpy) {
fprintf(stderr, "Cannot open display '%s'.\n", XDisplayName(NULL));
return 1;
}
/*
* check if the NV-CONTROL X extension is present on this X server
*/
ret = XNVCTRLQueryExtension(dpy, &event_base, &error_base);
if (ret != True) {
fprintf(stderr, "The NV-CONTROL X extension does not exist on '%s'.\n",
XDisplayName(NULL));
return 1;
}
/*
* query the major and minor extension version
*/
ret = XNVCTRLQueryVersion(dpy, &major, &minor);
if (ret != True) {
fprintf(stderr, "The NV-CONTROL X extension does not exist on '%s'.\n",
XDisplayName(NULL));
return 1;
}
/*
* print statistics thus far
*/
printf("NV-CONTROL X extension present\n");
printf(" version : %d.%d\n", major, minor);
printf(" event base : %d\n", event_base);
printf(" error base : %d\n", error_base);
/*
* loop over each screen, and determine if each screen is
* controlled by the NVIDIA X driver (and thus supports the
* NV-CONTROL X extension); then, query the string attributes on
* the screen.
*/
screens = ScreenCount(dpy);
for (i = 0; i < screens; i++) {
if (XNVCTRLIsNvScreen(dpy, i)) {
printf("Screen %d supports the NV-CONTROL X extension\n", i);
ret = XNVCTRLQueryStringAttribute(dpy, i,
0, /* XXX not curently used */
NV_CTRL_STRING_PRODUCT_NAME,
&str);
if (ret) {
printf(" GPU : %s\n", str);
XFree(str);
}
ret = XNVCTRLQueryStringAttribute(dpy, i,
0, /* XXX not curently used */
NV_CTRL_STRING_VBIOS_VERSION,
&str);
if (ret) {
printf(" VideoBIOS : %s\n", str);
XFree(str);
}
ret = XNVCTRLQueryStringAttribute(dpy, i,
0, /* XXX not curently used */
NV_CTRL_STRING_NVIDIA_DRIVER_VERSION,
&str);
if (ret) {
printf(" Driver version : %s\n", str);
XFree(str);
}
}
}
/*
* print attribute permission and type information.
*/
printf("Attributes (Integers):\n");
for (i = 0; i < NV_CTRL_LAST_ATTRIBUTE; i++) {
const char *name = attr2str(i, attr_int_table);
if (name) {
NVCTRLAttributePermissionsRec perms;
printf(" (%3d) [Perms: ", i);
memset(&perms, 0, sizeof(NVCTRLAttributePermissionsRec));
XNVCTRLQueryAttributePermissions(dpy, i, &perms);
print_perms(&perms);
printf("] [ ");
printf("%-32s", GetAttrTypeName(perms.type));
printf("] - %s\n", name);
}
}
printf("Attributes (Strings):\n");
for (i = 0; i < NV_CTRL_STRING_LAST_ATTRIBUTE; i++) {
const char *name = attr2str(i, attr_str_table);
if (name) {
NVCTRLAttributePermissionsRec perms;
printf(" (%3d) [Perms: ", i);
memset(&perms, 0, sizeof(NVCTRLAttributePermissionsRec));
XNVCTRLQueryStringAttributePermissions(dpy, i, &perms);
print_perms(&perms);
printf("] [ ");
printf("%-32s", GetAttrTypeName(perms.type));
printf("] - %s\n", name);
}
}
printf("Attributes (Binary Data):\n");
for (i = 0; i < NV_CTRL_BINARY_DATA_LAST_ATTRIBUTE; i++) {
const char *name = attr2str(i, attr_bin_table);
if (name) {
NVCTRLAttributePermissionsRec perms;
printf(" (%3d) [Perms: ", i);
memset(&perms, 0, sizeof(NVCTRLAttributePermissionsRec));
XNVCTRLQueryBinaryDataAttributePermissions(dpy, i, &perms);
print_perms(&perms);
printf("] [ ");
printf("%-32s", GetAttrTypeName(perms.type));
printf("] - %s\n", name);
}
}
printf("Attributes (String Operations):\n");
for (i = 0; i < NV_CTRL_STRING_OPERATION_LAST_ATTRIBUTE; i++) {
const char *name = attr2str(i, attr_strop_table);
if (name) {
NVCTRLAttributePermissionsRec perms;
printf(" (%3d) [Perms: ", i);
memset(&perms, 0, sizeof(NVCTRLAttributePermissionsRec));
XNVCTRLQueryStringOperationAttributePermissions(dpy, i, &perms);
print_perms(&perms);
printf("] [ ");
printf("%-32s", GetAttrTypeName(perms.type));
printf("] - %s\n", name);
}
}
/*
* close the display connection
*/
XCloseDisplay(dpy);
return 0;
}
int main(int argc, char *argv[])
{
Display *dpy;
Bool ret;
int screen, display_devices, mask, major, minor;
char *str;
int nDisplayDevice;
/*
* Open a display connection, and make sure the NV-CONTROL X
* extension is present on the screen we want to use.
*/
dpy = XOpenDisplay(NULL);
if (!dpy) {
fprintf(stderr, "Cannot open display '%s'.\n\n", XDisplayName(NULL));
return 1;
}
screen = GetNvXScreen(dpy);
ret = XNVCTRLQueryVersion(dpy, &major, &minor);
if (ret != True) {
fprintf(stderr, "The NV-CONTROL X extension does not exist on '%s'.\n\n", XDisplayName(NULL));
return 1;
}
/*
* query the connected display devices on this X screen and print
* basic information about each X screen
*/
ret = XNVCTRLQueryAttribute(dpy, screen, 0,
NV_CTRL_CONNECTED_DISPLAYS, &display_devices);
if (!ret) {
fprintf(stderr, "Failed to query the enabled Display Devices.\n\n");
return 1;
}
int pci_bus;
int pci_device;
int pci_func;
ret = XNVCTRLQueryTargetAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU, 0 /* Just query first GPU */,
0,
NV_CTRL_PCI_BUS,
&pci_bus);
ret = XNVCTRLQueryTargetAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU, 0 /* Just query first GPU */,
0,
NV_CTRL_PCI_DEVICE,
&pci_device);
ret = XNVCTRLQueryTargetAttribute(dpy,
NV_CTRL_TARGET_TYPE_GPU, 0 /* Just query first GPU */,
0,
NV_CTRL_PCI_FUNCTION,
&pci_func);
dbset("system.hardware.nvidia.busid=%i:%i:%i", pci_bus, pci_device, pci_func);
nDisplayDevice = 0;
for (mask = 1; mask < (1 << 24); mask <<= 1) {
if (display_devices & mask) {
XNVCTRLQueryStringAttribute(dpy, screen, mask,
NV_CTRL_STRING_DISPLAY_DEVICE_NAME,
&str);
dbset("system.x11.display.%i.device=%s" , nDisplayDevice, display_device_name(mask));
dbset("system.x11.display.%i.mode.0=nvidia-auto-select", nDisplayDevice);
dbset("system.x11.display.%i.default=nvidia-auto-select", nDisplayDevice);
printf("%i:%s:0x%08x:%s\n", nDisplayDevice, display_device_name(mask), mask, str);
nDisplayDevice++;
}
}
if (nDisplayDevice > 1) { // more than one screen found
dbset("system.x11.dualhead.enabled=1");
} else {
dbset("system.x11.dualhead.enabled=0");
}
char *dummy;
for (; nDisplayDevice <= 3; nDisplayDevice++) {
if (asprintf(&dummy, "system.x11.display.%i", nDisplayDevice) >= 0) {
dbremove(dummy);
free(dummy);
}
}
return 0;
}
/*
================
Sys_GetVideoRam
returns in megabytes
open your own display connection for the query and close it
using the one shared with GLimp_Init is not stable
================
*/
int Sys_GetVideoRam( void ) {
#ifdef USE_SDL
return 128;
#else
static int run_once = 0;
int major, minor, value;
Display *l_dpy;
int l_scrnum;
if ( run_once ) {
return run_once;
}
if ( sys_videoRam.GetInteger() ) {
run_once = sys_videoRam.GetInteger();
return sys_videoRam.GetInteger();
}
// try a few strategies to guess the amount of video ram
common->Printf( "guessing video ram ( use +set sys_videoRam to force ) ..\n" );
if ( !GLimp_OpenDisplay( ) ) {
run_once = 64;
return run_once;
}
l_dpy = dpy;
l_scrnum = scrnum;
// go for nvidia ext first
if ( XNVCTRLQueryVersion( l_dpy, &major, &minor ) ) {
common->Printf( "found XNVCtrl extension %d.%d\n", major, minor );
if ( XNVCTRLIsNvScreen( l_dpy, l_scrnum ) ) {
if ( XNVCTRLQueryAttribute( l_dpy, l_scrnum, 0, NV_CTRL_VIDEO_RAM, &value ) ) {
run_once = value / 1024;
return run_once;
} else {
common->Printf( "XNVCtrlQueryAttribute NV_CTRL_VIDEO_RAM failed\n" );
}
} else {
common->Printf( "default screen %d is not controlled by NVIDIA driver\n", l_scrnum );
}
}
// try ATI /proc read ( for the lack of a better option )
int fd;
if ( ( fd = open( "/proc/dri/0/umm", O_RDONLY ) ) != -1 ) {
int len;
char umm_buf[ 1024 ];
char *line;
if ( ( len = read( fd, umm_buf, 1024 ) ) != -1 ) {
// should be way enough to get the full file
// grab "free LFB = " line and "free Inv = " lines
umm_buf[ len-1 ] = '\0';
line = umm_buf;
line = strtok( umm_buf, "\n" );
int total = 0;
while ( line ) {
if ( strlen( line ) >= 13 && strstr( line, "max LFB =" ) == line ) {
total += atoi( line + 12 );
} else if ( strlen( line ) >= 13 && strstr( line, "max Inv =" ) == line ) {
total += atoi( line + 12 );
}
line = strtok( NULL, "\n" );
}
if ( total ) {
run_once = total / 1048576;
// round to the lower 16Mb
run_once &= ~15;
return run_once;
}
} else {
common->Printf( "read /proc/dri/0/umm failed: %s\n", strerror( errno ) );
}
}
common->Printf( "guess failed, return default low-end VRAM setting ( 64MB VRAM )\n" );
run_once = 64;
return run_once;
#endif
}
