/* * nvidia-cfg * * Copyright (c) 2004 NVIDIA Corp. All rights reserved. * * NOTICE TO USER: The source code is copyrighted under U.S. and * international laws. NVIDIA, Corp. of Santa Clara, California owns * the copyright and as design patents pending on the design and * interface of the NV chips. Users and possessors of this source * code are hereby granted a nonexclusive, royalty-free copyright * and design patent license to use this code in individual and * commercial software. * * Any use of this source code must include, in the user documenta- * tion and internal comments to the code, notices to the end user * as follows: * * Copyright (c) 2004 NVIDIA Corp. NVIDIA design patents pending in * the U.S. and foreign countries. * * NVIDIA CORP. MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF * THIS SOURCE CODE FOR ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT * EXPRESS OR IMPLIED WARRANTY OF ANY KIND. NVIDIA, CORP. DISCLAIMS * ALL WARRANTIES WITH REGARD TO THIS SOURCE CODE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A * PARTICULAR PURPOSE. IN NO EVENT SHALL NVIDIA, CORP. BE LIABLE * FOR ANY SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOURCE CODE. * * * This header file defines the public interface to the * libnvidia-cfg.so library. */ #ifndef __NVIDIA_CFG_H__ #define __NVIDIA_CFG_H__ /* * NvCfgDevice - data structure containing bus:slot pairs * * This is deprecated; please use NvCfgPciDevice instead */ typedef struct { int bus; int slot; } NvCfgDevice; /* * NvCfgPciDevice - data structure identifying a device on the PCI bus */ typedef struct { int domain; int bus; int slot; int function; } NvCfgPciDevice; /* * NvCfgGSyncDeviceType - type of the GSync device */ typedef enum { NVCFG_TYPE_GSYNC2 = 1, NVCFG_TYPE_GSYNC3, NVCFG_TYPE_GSYNC4 } NvCfgGSyncDeviceType; #define NV_CFG_GSYNC_DEVICE_FIRMWARE_FORMAT_1 1 /* * NvCfgDisplayDeviceInformation - this data structure contains * various limits and other useful data parsed from the EDID. */ typedef struct { /* * The monitor name is the name of the monitor as specified by an * EDID 1.x Monitor Descriptors, or an EDID 2.x * Manufacturer/Product ID string. */ char monitor_name[64]; /* * The horiz_sync and vert_refresh ranges are retrieved from an * EDID 1.x Monitor Descriptor, or an EDID 2.x Range Limit. */ unsigned int min_horiz_sync; /* in Hz */ unsigned int max_horiz_sync; /* in Hz */ unsigned int min_vert_refresh; /* in Hz */ unsigned int max_vert_refresh; /* in Hz */ unsigned int max_pixel_clock; /* in kHz */ /* * The max xres, yres, and refresh, if not 0, are taken from the * largest mode in the EDID. */ unsigned int max_xres; /* in pixels */ unsigned int max_yres; /* in pixels */ unsigned int max_refresh; /* in Hz */ /* * the preferred xres, yres, and refresh, if not 0, are the values * specified by the EDID as the preferred timing mode of the * display device. */ unsigned int preferred_xres; /* in pixels */ unsigned int preferred_yres; /* in pixels */ unsigned int preferred_refresh; /* in Hz */ /* * the physical width and height, if not 0, are the physical * dimensions of the display device. */ unsigned int physical_width; /* in mm */ unsigned int physical_height; /* in mm */ } NvCfgDisplayDeviceInformation; /* * NvCfgDeviceHandle - this is an opaque handle identifying a * connection to an NVIDIA VGA adapter. */ typedef void * NvCfgDeviceHandle; /* * NvCfgGSyncHandle - this is an opaque handle identifying a * GSync device. */ typedef void * NvCfgGSyncHandle; /* * NvCfg Boolean values */ typedef enum { NVCFG_TRUE = 1, NVCFG_FALSE = 0, } NvCfgBool; /* * nvCfgGetDevices() - retrieve an array of NvCfgDevice's indicating * what PCI devices are present on the system. On success, NVCFG_TRUE * will be returned, n will contain the number of NVIDIA PCI VGA * adapters present in the system, and devs will be an allocated array * containing the bus address of each NVIDIA PCI VGA adapter. When * the caller is done, it should free the devs array. On failure, * NVCFG_FALSE will be returned. * * This is deprecated; please use nvCfgGetPciDevices() instead. */ NvCfgBool nvCfgGetDevices(int *n, NvCfgDevice **devs); /* * nvCfgGetPciDevices() - retrieve an array of NvCfgPciDevice's * indicating what PCI devices are present on the system. On success, * NVCFG_TRUE will be returned, n will contain the number of NVIDIA * PCI graphics devices present in the system, and devs will be an * allocated array containing the PCI domain:bus:slot:function * address of each NVIDIA PCI graphics device. When the caller is * done, it should free the devs array. On failure, NVCFG_FALSE will * be returned. */ NvCfgBool nvCfgGetPciDevices(int *n, NvCfgPciDevice **devs); /* * nvCfgOpenDevice() - open a connection to the NVIDIA device * identified by the bus:slot PCI address. On success, NVCFG_TRUE * will be returned and handle be assigned. On failure, NVCFG_FALSE * will be returned. * * This is deprecated; please use nvCfgOpenPciDevice() instead. */ NvCfgBool nvCfgOpenDevice(int bus, int slot, NvCfgDeviceHandle *handle); /* * nvCfgAttachPciDevice() - open a limited, display-less connection to * the NVIDIA device identified by the domain:bus:slot:function PCI * address. On success, NVCFG_TRUE will be returned and handle will be * assigned. On failure, NVCFG_FALSE will be returned. */ NvCfgBool nvCfgAttachPciDevice(int domain, int bus, int device, int function, NvCfgDeviceHandle *handle); /* * nvCfgOpenPciDevice() - open a connection to the NVIDIA device * identified by the domain:bus:slot:function PCI address. On * success, NVCFG_TRUE will be returned and handle will be assigned. * On failure, NVCFG_FALSE will be returned. */ NvCfgBool nvCfgOpenPciDevice(int domain, int bus, int device, int function, NvCfgDeviceHandle *handle); /* * nvCfgOpenAllPciDevices() - open a connection to each NVIDIA device * in the system. On success, NVCFG_TRUE will be returned, n will be * assigned the number of NVIDIA devices in the system, and handles * will be assigned with an allocated array of NvCfgDeviceHandles; * each element in the array is a handle to one of the NVIDIA devices * in the system. The caller should free the handles array when no * longer needed. On failure, NVCFG_FALSE will be returned. */ NvCfgBool nvCfgOpenAllPciDevices(int *n, NvCfgDeviceHandle **handles); /* * nvCfgDetachDevice() - close the previously opened limited, display-less * connection to an NVIDIA device created by nvCfgAttachPciDevice(). */ NvCfgBool nvCfgDetachDevice(NvCfgDeviceHandle handle); /* * nvCfgCloseDevice() - close the previously opened connection to an * NVIDIA device created by nvCfgOpenPciDevice(). */ NvCfgBool nvCfgCloseDevice(NvCfgDeviceHandle handle); /* * nvCfgCloseAllPciDevices() - close all the NVIDIA device connections * opened by a previous call to nvCfgOpenAllPciDevices(). */ NvCfgBool nvCfgCloseAllPciDevices(void); /* * nvCfgGetNumCRTCs() - return the number of CRTCs (aka "heads") * present on the specified NVIDIA device. On success, NVCFG_TRUE * will be returned and crtcs will be assigned. On failure, * NVCFG_FALSE will be returned. */ NvCfgBool nvCfgGetNumCRTCs(NvCfgDeviceHandle handle, int *crtcs); /* * nvCfgGetProductName() - return an allocated string containing the * product name of the specified NVIDIA device. It is the caller's * responsibility to free the returned string. On success, NVCFG_TRUE * will be returned and name will be assigned. On failure, * NVCFG_FALSE will be returned. */ NvCfgBool nvCfgGetProductName(NvCfgDeviceHandle handle, char **name); /* * nvCfgGetDeviceUUID() - return an allocated string containing the * global unique identifier of the specified NVIDIA device. It is the caller's * responsibility to free the returned string. On success, NVCFG_TRUE * will be returned and uuid will be assigned. On failure, * NVCFG_FALSE will be returned. */ NvCfgBool nvCfgGetDeviceUUID(NvCfgDeviceHandle handle, char **uuid); /* * nvCfgGetDisplayDevices() - retrieve a bitmask describing the * currently connected display devices: this "display device mask" is * an unsigned 32 bit value that identifies one or more display * devices. The first 8 bits each identify a CRT, the next 8 bits * each identify a TV, and the next 8 each identify a DFP. For * example, 0x1 refers to CRT-0, 0x3 refers to CRT-0 and CRT-1, * 0x10001 refers to CRT-0 and DFP-0, etc. On success, NVCFG_TRUE * will be returned and display_device_mask will be assigned. On * failure, NVCFG_FALSE will be returned. */ NvCfgBool nvCfgGetDisplayDevices(NvCfgDeviceHandle handle, unsigned int *display_device_mask); /* nvCfgGetSupportedDisplayDevices() - get all supported display devices, * not only connected ones. Interpretation of display_device_mask * parameter is the same as for nvCfgGetDisplayDevices() call. * On success, NVCFG_TRUE will be returned and display_device_mask will be * assigned. On failure, NVCFG_FALSE will be returned. */ NvCfgBool nvCfgGetSupportedDisplayDevices(NvCfgDeviceHandle handle, unsigned int *display_device_mask); /* * nvCfgGetEDIDData() - return an allocated byte array containing the * EDID for the specified display device, if any. On success, * NVCFG_TRUE will be returned and edidSize and edid will be assigned. * On failure, NVCFG_FALSE will be returned. It is the caller's * responsibility to free the allocated EDID. */ NvCfgBool nvCfgGetEDIDData(NvCfgDeviceHandle handle, unsigned int display_device, int *edidSize, void **edid); /* * nvCfgGetEDIDMonitorData() - Initialize the fields in the * NvCfgDisplayDeviceInformation data structure, using data from the * EDID. On success, NVCFG_TRUE will be returned and info will be * assigned. On failure, NVCFG_FALSE will be returned. */ NvCfgBool nvCfgGetEDID(NvCfgDeviceHandle handle, unsigned int display_device, NvCfgDisplayDeviceInformation *info); /* * nvCfgIsPrimaryDevice() - determines whether the specified NVIDIA * device is the primary device. On success, NVCFG_TRUE will be * returned and is_primary_device set to indicate whether the * device is the primary device. On failure, NVCFG_FALSE will be * returned. */ NvCfgBool nvCfgIsPrimaryDevice(NvCfgDeviceHandle handle, NvCfgBool *is_primary_device); /* * nvCfgGetTeslaSerialNumbers() - returns an allocated array of strings * containing the serial numbers of all NVIDIA Tesla/QuadroPlex devices * connected to the host, followed by a NULL character. It is the caller's * responsibility to free the returned array of strings. On success, * NVCFG_TRUE will be returned and serials will be assigned. On failure, * NVCFG_FALSE will be returned. * * Note that this function is deprecated and will always return an empty array * on recent drivers, since QuadroPlex devices are no longer supported. */ NvCfgBool nvCfgGetTeslaSerialNumbers(char ***serials); /* * nvCfgOpenAllGSyncDevices() - returns an array of NvCfgGSyncHandle's * indicating what GSync devices are present in the system. On success, * NVCFG_TRUE will be returned, n will contain the number of GSync devices * present in the system, and handles will be an allocated array containing * a handle for each of the GSync devices.The caller should free the * handles array when no longer needed. On failure, NVCFG_FALSE will be * returned. */ NvCfgBool nvCfgOpenAllGSyncDevices(int *n, NvCfgGSyncHandle **handles); /* * nvCfgCloseAllGSyncDevices() - close all the GSync device connections * opened by a previous call to nvCfgOpenAllGSyncDevices(). */ NvCfgBool nvCfgCloseAllGSyncDevices(void); /* * nvCfgGetGSyncDeviceType() - returns the type of GSync device referenced * by handle. */ NvCfgGSyncDeviceType nvCfgGetGSyncDeviceType(NvCfgGSyncHandle handle); /* * nvCfgGetGSyncDeviceFirmwareVersion() - returns the firmware major version of * the GSync device referenced by handle. */ int nvCfgGetGSyncDeviceFirmwareVersion(NvCfgGSyncHandle handle); /* * nvCfgGetGSyncDeviceFirmwareMinorVersion() - returns the firmware minor * version of the GSync device referenced by handle. */ int nvCfgGetGSyncDeviceFirmwareMinorVersion(NvCfgGSyncHandle handle); /* * nvCfgFlashGSyncDevice() - flashes the GSync device referenced by handle. * format contains the firmware format, newFirmwareImage contains the * new firmware image to be flashed, and size contains the size of * newFirmwareImage. On success, NVCFG_TRUE will be returned. * On failure, NVCFG_FALSE will be returned. */ NvCfgBool nvCfgFlashGSyncDevice(NvCfgGSyncHandle handle, int format, const unsigned char *newFirmwareImage, int size); /* * nvCfgDumpDisplayPortAuxLog() - dump the DisplayPort AUX channel log to the * system log. On success, NVCFG_TRUE will be returned. On failure, NVCFG_FALSE * will be returned. */ NvCfgBool nvCfgDumpDisplayPortAuxLog(NvCfgDeviceHandle handle); #endif /* __NVIDIA_CFG__ */