/*
* xv_sync_to_display_radio_button_label() - create the label for the radio
* button widget specified.
*/
static gchar *xv_sync_to_display_radio_button_label(CtkXVideo *ctk_xvideo,
gint display_id)
{
CtrlTarget *ctrl_target;
ReturnStatus ret;
char *name = NULL;
char *randr = NULL;
gchar *label;
ctrl_target = NvCtrlGetTarget(ctk_xvideo->ctrl_target->system,
DISPLAY_TARGET, display_id);
if (ctrl_target) {
ret = NvCtrlGetStringAttribute(ctrl_target,
NV_CTRL_STRING_DISPLAY_DEVICE_NAME,
&name);
if (ret != NvCtrlSuccess) {
name = NULL;
}
ret = NvCtrlGetStringAttribute(ctrl_target,
NV_CTRL_STRING_DISPLAY_NAME_RANDR,
&randr);
if (ret != NvCtrlSuccess) {
randr = NULL;
}
}
if (name && randr) {
label = g_strdup_printf("%s (%s)", name, randr);
} else {
label = g_strdup_printf("%s",
name ? name : (randr ? randr : "Unknown"));
}
free(name);
free(randr);
return label;
}
static gboolean update_tv_encoder_info(InfoEntry *entry)
{
CtkDisplayDevice *ctk_object = entry->ctk_object;
CtrlTarget *ctrl_target = ctk_object->ctrl_target;
ReturnStatus ret;
char *str;
ret = NvCtrlGetStringAttribute(ctrl_target,
NV_CTRL_STRING_TV_ENCODER_NAME,
&str);
if (ret != NvCtrlSuccess) {
return FALSE;
}
gtk_label_set_text(GTK_LABEL(entry->txt), str);
free(str);
return TRUE;
}
void print_glxinfo(const char *display_name)
{
int screen;
CtrlHandles *h;
CtrlHandleTarget *t;
ReturnStatus status = NvCtrlSuccess;
char *direct_rendering = NULL;
char *glx_extensions = NULL;
char *server_vendor = NULL;
char *server_version = NULL;
char *server_extensions = NULL;
char *client_vendor = NULL;
char *client_version = NULL;
char *client_extensions = NULL;
char *opengl_vendor = NULL;
char *opengl_renderer = NULL;
char *opengl_version = NULL;
char *opengl_extensions = NULL;
GLXFBConfigAttr *fbconfig_attribs = NULL;
char *formated_ext_str = NULL;
h = nv_alloc_ctrl_handles(display_name);
if ( h == NULL ) {
return;
}
/* Print information for each screen */
for (screen = 0; screen < h->targets[X_SCREEN_TARGET].n; screen++) {
t = &h->targets[X_SCREEN_TARGET].t[screen];
/* No screen, move on */
if ( !t->h ) continue;
nv_msg(NULL, "GLX Information for %s:", t->name);
/* Get GLX information */
status = NvCtrlGetStringAttribute(t->h,
NV_CTRL_STRING_GLX_DIRECT_RENDERING,
&direct_rendering);
if ( status != NvCtrlSuccess &&
status != NvCtrlNoAttribute ) { goto finish; }
status = NvCtrlGetStringAttribute(t->h,
NV_CTRL_STRING_GLX_GLX_EXTENSIONS,
&glx_extensions);
if ( status != NvCtrlSuccess &&
status != NvCtrlNoAttribute ) { goto finish; }
if ( glx_extensions != NULL ) {
formated_ext_str = format_extension_list(glx_extensions);
if ( formated_ext_str != NULL ) {
free(glx_extensions);
glx_extensions = formated_ext_str;
}
}
/* Get server GLX information */
status = NvCtrlGetStringAttribute(t->h,
NV_CTRL_STRING_GLX_SERVER_VENDOR,
&server_vendor);
if ( status != NvCtrlSuccess &&
status != NvCtrlNoAttribute ) { goto finish; }
status = NvCtrlGetStringAttribute(t->h,
NV_CTRL_STRING_GLX_SERVER_VERSION,
&server_version);
if ( status != NvCtrlSuccess &&
status != NvCtrlNoAttribute ) { goto finish; }
status = NvCtrlGetStringAttribute(t->h,
NV_CTRL_STRING_GLX_SERVER_EXTENSIONS,
&server_extensions);
if ( status != NvCtrlSuccess &&
status != NvCtrlNoAttribute ) { goto finish; }
if ( server_extensions != NULL ) {
formated_ext_str = format_extension_list(server_extensions);
if ( formated_ext_str != NULL ) {
free(server_extensions);
server_extensions = formated_ext_str;
}
}
/* Get client GLX information */
status = NvCtrlGetStringAttribute(t->h,
NV_CTRL_STRING_GLX_CLIENT_VENDOR,
&client_vendor);
if ( status != NvCtrlSuccess &&
status != NvCtrlNoAttribute ) { goto finish; }
status = NvCtrlGetStringAttribute(t->h,
NV_CTRL_STRING_GLX_CLIENT_VERSION,
&client_version);
if ( status != NvCtrlSuccess &&
status != NvCtrlNoAttribute ) { goto finish; }
status = NvCtrlGetStringAttribute(t->h,
NV_CTRL_STRING_GLX_CLIENT_EXTENSIONS,
&client_extensions);
if ( status != NvCtrlSuccess &&
status != NvCtrlNoAttribute ) { goto finish; }
if ( client_extensions != NULL ) {
formated_ext_str = format_extension_list(client_extensions);
if ( formated_ext_str != NULL ) {
free(client_extensions);
client_extensions = formated_ext_str;
}
}
/* Get OpenGL information */
status = NvCtrlGetStringAttribute(t->h,
NV_CTRL_STRING_GLX_OPENGL_VENDOR,
&opengl_vendor);
if ( status != NvCtrlSuccess &&
status != NvCtrlNoAttribute ) { goto finish; }
status = NvCtrlGetStringAttribute(t->h,
NV_CTRL_STRING_GLX_OPENGL_RENDERER,
&opengl_renderer);
if ( status != NvCtrlSuccess &&
status != NvCtrlNoAttribute ) { goto finish; }
status = NvCtrlGetStringAttribute(t->h,
NV_CTRL_STRING_GLX_OPENGL_VERSION,
&opengl_version);
if ( status != NvCtrlSuccess &&
status != NvCtrlNoAttribute ) { goto finish; }
status = NvCtrlGetStringAttribute(t->h,
NV_CTRL_STRING_GLX_OPENGL_EXTENSIONS,
&opengl_extensions);
if ( status != NvCtrlSuccess &&
status != NvCtrlNoAttribute ) { goto finish; }
if ( opengl_extensions != NULL ) {
formated_ext_str = format_extension_list(opengl_extensions);
if ( formated_ext_str != NULL ) {
free(opengl_extensions);
opengl_extensions = formated_ext_str;
}
}
/* Get FBConfig information */
status = NvCtrlGetVoidAttribute(t->h,
NV_CTRL_ATTR_GLX_FBCONFIG_ATTRIBS,
(void *)(&fbconfig_attribs));
if ( status != NvCtrlSuccess &&
status != NvCtrlNoAttribute ) { goto finish; }
/* Print results */
nv_msg(TAB, "direct rendering: %s", NULL_TO_EMPTY(direct_rendering));
nv_msg(TAB, "GLX extensions:");
nv_msg(" ", NULL_TO_EMPTY(glx_extensions));
nv_msg(" ", "\n");
nv_msg(TAB, "server glx vendor string: %s",
NULL_TO_EMPTY(server_vendor));
nv_msg(TAB, "server glx version string: %s",
NULL_TO_EMPTY(server_version));
nv_msg(TAB, "server glx extensions:");
nv_msg(" ", NULL_TO_EMPTY(server_extensions));
nv_msg(" ", "\n");
nv_msg(TAB, "client glx vendor string: %s",
NULL_TO_EMPTY(client_vendor));
nv_msg(TAB, "client glx version string: %s",
NULL_TO_EMPTY(client_version));
nv_msg(TAB, "client glx extensions:");
nv_msg(" ", NULL_TO_EMPTY(client_extensions));
nv_msg(" ", "\n");
nv_msg(TAB, "OpenGL vendor string: %s",
NULL_TO_EMPTY(opengl_vendor));
nv_msg(TAB, "OpenGL renderer string: %s",
NULL_TO_EMPTY(opengl_renderer));
nv_msg(TAB, "OpenGL version string: %s",
NULL_TO_EMPTY(opengl_version));
nv_msg(TAB, "OpenGL extensions:");
nv_msg(" ", NULL_TO_EMPTY(opengl_extensions));
#ifdef GLX_VERSION_1_3
if ( fbconfig_attribs != NULL ) {
nv_msg(" ", "\n");
print_fbconfig_attribs(fbconfig_attribs);
}
#endif
fflush(stdout);
/* Free memory used */
SAFE_FREE(server_vendor);
SAFE_FREE(server_version);
SAFE_FREE(server_extensions);
SAFE_FREE(client_vendor);
SAFE_FREE(client_version);
SAFE_FREE(client_extensions);
SAFE_FREE(direct_rendering);
SAFE_FREE(glx_extensions);
SAFE_FREE(opengl_vendor);
SAFE_FREE(opengl_renderer);
SAFE_FREE(opengl_version);
SAFE_FREE(opengl_extensions);
SAFE_FREE(fbconfig_attribs);
} /* Done looking at all screens */
/* Fall through */
finish:
if ( status == NvCtrlError ) {
nv_error_msg("Error fetching GLX Information: %s",
NvCtrlAttributesStrError(status) );
}
/* Free any leftover memory used */
SAFE_FREE(server_vendor);
SAFE_FREE(server_version);
SAFE_FREE(server_extensions);
SAFE_FREE(client_vendor);
SAFE_FREE(client_version);
SAFE_FREE(client_extensions);
SAFE_FREE(direct_rendering);
SAFE_FREE(glx_extensions);
SAFE_FREE(opengl_vendor);
SAFE_FREE(opengl_renderer);
SAFE_FREE(opengl_version);
SAFE_FREE(opengl_extensions);
SAFE_FREE(fbconfig_attribs);
nv_free_ctrl_handles(h);
} /* print_glxinfo() */
/*
* CTK VCS (Visual Computing System) widget creation
*
*/
GtkWidget* ctk_vcs_new(NvCtrlAttributeHandle *handle,
CtkConfig *ctk_config)
{
GObject *object;
CtkVcs *ctk_object;
GtkWidget *label;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *event;
GtkWidget *banner;
GtkWidget *hseparator;
GtkWidget *table;
GtkWidget *scrollWin;
GtkWidget *checkbutton;
gchar *product_name;
gchar *serial_number;
gchar *build_date;
gchar *product_id;
gchar *firmware_version;
gchar *hardware_version;
gint current_row;
gboolean high_perf_mode;
ReturnStatus ret;
gchar *s;
char *psu_str = NULL;
PSUEntry psuEntry;
GtkWidget *vbox_scroll, *hbox_scroll;
/*
* get the static string data that we will display below
*/
/* Product Name */
ret = NvCtrlGetStringAttribute(handle,
NV_CTRL_STRING_VCSC_PRODUCT_NAME,
&product_name);
if (ret != NvCtrlSuccess) {
product_name = g_strdup("Unable to determine");
}
/* Serial Number */
ret = NvCtrlGetStringAttribute(handle,
NV_CTRL_STRING_VCSC_SERIAL_NUMBER,
&serial_number);
if (ret != NvCtrlSuccess) {
serial_number = g_strdup("Unable to determine");
}
/* Build Date */
ret = NvCtrlGetStringAttribute(handle,
NV_CTRL_STRING_VCSC_BUILD_DATE,
&build_date);
if (ret != NvCtrlSuccess) {
build_date = g_strdup("Unable to determine");
}
/* Product ID */
ret = NvCtrlGetStringAttribute(handle,
NV_CTRL_STRING_VCSC_PRODUCT_ID,
&product_id);
if (ret != NvCtrlSuccess) {
product_id = g_strdup("Unable to determine");
}
/* Firmware Version */
ret = NvCtrlGetStringAttribute(handle,
NV_CTRL_STRING_VCSC_FIRMWARE_VERSION,
&firmware_version);
if (ret != NvCtrlSuccess) {
firmware_version = g_strdup("Unable to determine");
}
/* Hardware Version */
ret = NvCtrlGetStringAttribute(handle,
NV_CTRL_STRING_VCSC_HARDWARE_VERSION,
&hardware_version);
if (ret != NvCtrlSuccess) {
hardware_version = g_strdup("Unable to determine");
}
/* now, create the object */
object = g_object_new(CTK_TYPE_VCS, NULL);
ctk_object = CTK_VCS(object);
/* cache the attribute handle */
ctk_object->handle = handle;
ctk_object->ctk_config = ctk_config;
/* set container properties of the object */
gtk_box_set_spacing(GTK_BOX(ctk_object), 10);
/* banner */
banner = ctk_banner_image_new(BANNER_ARTWORK_VCS);
gtk_box_pack_start(GTK_BOX(ctk_object), banner, FALSE, FALSE, 0);
/*
* This displays basic System information, including
* display name, Operating system type and the NVIDIA driver version.
*/
vbox = gtk_vbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(ctk_object), vbox, TRUE, TRUE, 0);
/* General purpose error dialog */
ctk_object->error_dialog = create_error_dialog(ctk_object);
if (NvCtrlGetAttribute(ctk_object->handle, NV_CTRL_VCSC_HIGH_PERF_MODE,
&high_perf_mode) == NvCtrlSuccess) {
hbox = gtk_hbox_new(FALSE, 0);
checkbutton = gtk_check_button_new_with_label("Enable High Performance Mode");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), high_perf_mode);
g_signal_connect(G_OBJECT(checkbutton), "toggled",
G_CALLBACK(vcs_perf_checkbox_toggled),
(gpointer) ctk_object);
gtk_box_pack_start(GTK_BOX(hbox), checkbutton, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
}
/* Create the Scrolling Window */
scrollWin = gtk_scrolled_window_new(NULL, NULL);
hbox_scroll = gtk_hbox_new(FALSE, 0);
vbox_scroll = gtk_vbox_new(FALSE, 5);
event = gtk_event_box_new();
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollWin),
GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_widget_modify_fg(event, GTK_STATE_NORMAL, &(event->style->text[GTK_STATE_NORMAL]));
gtk_widget_modify_bg(event, GTK_STATE_NORMAL, &(event->style->base[GTK_STATE_NORMAL]));
gtk_container_add(GTK_CONTAINER(event), hbox_scroll);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollWin),
event);
gtk_box_pack_start(GTK_BOX(hbox_scroll), vbox_scroll, TRUE, TRUE, 5);
gtk_widget_set_size_request(scrollWin, -1, 50);
gtk_box_pack_start(GTK_BOX(vbox), scrollWin, TRUE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0);
label = gtk_label_new("VCS Information");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
hseparator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5);
table = gtk_table_new(5, 2, FALSE);
gtk_box_pack_start(GTK_BOX(vbox_scroll), table, FALSE, FALSE, 0);
gtk_table_set_row_spacings(GTK_TABLE(table), 3);
gtk_table_set_col_spacings(GTK_TABLE(table), 15);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
add_table_row(table, 0,
0, 0.5, "Product Name:", 0, 0.5, product_name);
add_table_row(table, 1,
0, 0.5, "Serial Number:", 0, 0.5, serial_number);
add_table_row(table, 2,
0, 0.5, "Build Date:", 0, 0.5, build_date);
add_table_row(table, 3,
0, 0.5, "Product ID:", 0, 0.5, product_id);
add_table_row(table, 4,
0, 0.5, "Firmware version:", 0, 0.5, firmware_version);
add_table_row(table, 5,
0, 0.5, "Hardware version:", 0, 0.5, hardware_version);
g_free(product_name);
g_free(serial_number);
g_free(build_date);
g_free(product_id);
g_free(firmware_version);
g_free(hardware_version);
/* Query Canoas 2.0 specific details */
if ((NvCtrlGetAttribute(ctk_object->handle, NV_CTRL_VCSC_HIGH_PERF_MODE,
&high_perf_mode) == NvCtrlSuccess) &&
(NvCtrlGetStringAttribute(ctk_object->handle,
NV_CTRL_STRING_VCSC_PSU_INFO,
&psu_str) == NvCtrlSuccess)) {
GtkWidget *vbox_padding;
/* Show the additonal queried information */
/* Populate scrolling window with data */
vbox_padding = gtk_vbox_new(FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_scroll), vbox_padding, FALSE, FALSE, 1);
gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0);
label = gtk_label_new("VCS Thermal Information");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
hseparator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5);
table = gtk_table_new(3, 2, FALSE);
gtk_box_pack_start(GTK_BOX(vbox_scroll), table, FALSE, FALSE, 0);
gtk_table_set_row_spacings(GTK_TABLE(table), 3);
gtk_table_set_col_spacings(GTK_TABLE(table), 15);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
label = gtk_label_new("Intake Temperature:");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
ctk_object->intake_temp = label;
label = gtk_label_new("Exhaust Temperature:");
/* This is the current largest label. Get its size */
gtk_widget_size_request(label, &ctk_object->req);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, 1, 2,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
ctk_object->exhaust_temp = label;
label = gtk_label_new("Board Temperature:");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 2, 3,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, 2, 3,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
ctk_object->board_temp = label;
/* Populate table for PSU information */
psuEntry.psu_current = -1;
psuEntry.psu_power = -1;
psuEntry.psu_voltage = -1;
psuEntry.psu_state = -1;
if (psu_str) {
parse_token_value_pairs(psu_str, apply_psu_entry_token, &psuEntry);
}
vbox_padding = gtk_vbox_new(FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_scroll), vbox_padding, FALSE, FALSE, 1);
gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0);
label = gtk_label_new("VCS Power Supply Unit Information");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
hseparator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5);
table = gtk_table_new(4, 2, FALSE);
gtk_box_pack_start(GTK_BOX(vbox_scroll), table, FALSE, FALSE, 0);
gtk_table_set_row_spacings(GTK_TABLE(table), 3);
gtk_table_set_col_spacings(GTK_TABLE(table), 15);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
label = gtk_label_new("PSU State:");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_widget_set_size_request(label, ctk_object->req.width, -1);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
ctk_object->psu_state = label;
label = gtk_label_new("PSU Current:");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_widget_set_size_request(label, ctk_object->req.width, -1);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, 1, 2,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
ctk_object->psu_current = label;
current_row = 2;
if (psuEntry.psu_power != -1) {
label = gtk_label_new("PSU Power:");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_widget_set_size_request(label, ctk_object->req.width, -1);
gtk_table_attach(GTK_TABLE(table), label, 0, 1,
current_row, current_row + 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2,
current_row, current_row + 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
ctk_object->psu_power = label;
current_row++;
}
if (psuEntry.psu_voltage != -1) {
label = gtk_label_new("PSU Voltage:");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_widget_set_size_request(label, ctk_object->req.width, -1);
gtk_table_attach(GTK_TABLE(table), label, 0, 1,
current_row, current_row + 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2,
current_row, current_row + 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
ctk_object->psu_voltage = label;
}
/* Create container for fan status table */
vbox_padding = gtk_vbox_new(FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_scroll), vbox_padding, FALSE, FALSE, 1);
gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0);
label = gtk_label_new("VCS Fan Status");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
hseparator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0);
ctk_object->fan_status_container = hbox;
/* Register a timer callback to update the dynamic information */
s = g_strdup_printf("VCS Monitor (VCS %d)",
NvCtrlGetTargetId(ctk_object->handle));
ctk_config_add_timer(ctk_object->ctk_config,
DEFAULT_UPDATE_VCS_INFO_TIME_INTERVAL,
s,
(GSourceFunc) update_vcs_info,
(gpointer) ctk_object);
g_free(s);
update_vcs_info(ctk_object);
}
gtk_widget_show_all(GTK_WIDGET(object));
return GTK_WIDGET(object);
}
static gboolean update_fan_status(CtkVcs *ctk_object)
{
gint ret;
char *fan_entry_str = NULL;
char *tokens;
GtkWidget *table;
GtkWidget *label;
FanEntry current_fan;
gchar output_str[16];
gint current_row;
if (!ctk_object->fan_status_container) {
return FALSE;
}
ret = NvCtrlGetStringAttribute(ctk_object->handle,
NV_CTRL_STRING_VCSC_FAN_STATUS,
&fan_entry_str);
if (ret != NvCtrlSuccess) {
return FALSE;
}
ctk_empty_container(ctk_object->fan_status_container);
/* Generate the new table */
table = gtk_table_new(1, 3, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 3);
gtk_table_set_col_spacings(GTK_TABLE(table), 15);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
gtk_box_pack_start(GTK_BOX(ctk_object->fan_status_container),
table, FALSE, FALSE, 0);
label = gtk_label_new("Fan Number");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_widget_set_size_request(label, ctk_object->req.width, -1);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new("Fan Speed");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new("Fan Status");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 2, 3, 0, 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
/* Parse string of fan entries and populate table */
current_row = 1;
for (tokens = strtok(fan_entry_str, ";");
tokens;
tokens = strtok(NULL, ";")) {
/* Invalidate fan entry */
current_fan.fan_number = -1;
current_fan.fan_speed = -1;
current_fan.fan_failed = -1;
parse_token_value_pairs(tokens, apply_fan_entry_token, ¤t_fan);
if ((current_fan.fan_number != -1) &&
(current_fan.fan_speed != -1) &&
(current_fan.fan_failed != -1)) {
gtk_table_resize(GTK_TABLE(table), current_row + 1, 3);
g_snprintf(output_str, 16, "%d", current_fan.fan_number);
label = gtk_label_new(output_str);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_widget_set_size_request(label, ctk_object->req.width, -1);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, current_row,
current_row + 1, GTK_FILL,
GTK_FILL | GTK_EXPAND, 5, 0);
g_snprintf(output_str, 16, "%d rpm", current_fan.fan_speed);
label = gtk_label_new(output_str);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, current_row,
current_row + 1, GTK_FILL,
GTK_FILL | GTK_EXPAND, 5, 0);
if (!current_fan.fan_failed) {
g_snprintf(output_str, 16, "Ok");
} else {
g_snprintf(output_str, 16, "Failed");
}
label = gtk_label_new(output_str);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 2, 3, current_row,
current_row + 1, GTK_FILL,
GTK_FILL | GTK_EXPAND, 5, 0);
current_row++;
} else {
nv_warning_msg("Incomplete Fan Entry (fan=%d, speed=%d, failFlag=%d)",
current_fan.fan_number,
current_fan.fan_speed,
current_fan.fan_failed);
}
}
gtk_widget_show_all(table);
XFree(fan_entry_str);
return TRUE;
}
static gboolean update_vcs_info(gpointer user_data)
{
char output_str[16];
char *temp_str = NULL;
char *psu_str = NULL;
CtkVcs *ctk_object = CTK_VCS(user_data);
ThermalEntry thermEntry;
PSUEntry psuEntry;
gboolean high_perf_mode;
/* These queries should always succeed for Canoas 2.0 and above */
if ((NvCtrlGetAttribute(ctk_object->handle, NV_CTRL_VCSC_HIGH_PERF_MODE,
&high_perf_mode) != NvCtrlSuccess) ||
(NvCtrlGetStringAttribute(ctk_object->handle,
NV_CTRL_STRING_VCSC_TEMPERATURES,
&temp_str) != NvCtrlSuccess) ||
(NvCtrlGetStringAttribute(ctk_object->handle,
NV_CTRL_STRING_VCSC_PSU_INFO,
&psu_str) != NvCtrlSuccess)) {
return FALSE;
}
/* Extract out thermal and PSU entry tokens */
/* First Invalidate thermal and psu entries */
thermEntry.intake_temp = -1;
thermEntry.exhaust_temp = -1;
thermEntry.board_temp = -1;
psuEntry.psu_current = -1;
psuEntry.psu_power = -1;
psuEntry.psu_voltage = -1;
psuEntry.psu_state = -1;
if (temp_str) {
parse_token_value_pairs(temp_str, apply_thermal_entry_token, &thermEntry);
}
if (psu_str) {
parse_token_value_pairs(psu_str, apply_psu_entry_token, &psuEntry);
}
if ((thermEntry.intake_temp != -1) &&
(thermEntry.exhaust_temp != -1) &&
(thermEntry.board_temp != -1)) {
if (ctk_object->intake_temp) {
g_snprintf(output_str, 16, "%d C", thermEntry.intake_temp);
gtk_label_set_text(GTK_LABEL(ctk_object->intake_temp), output_str);
}
if (ctk_object->exhaust_temp) {
g_snprintf(output_str, 16, "%d C", thermEntry.exhaust_temp);
gtk_label_set_text(GTK_LABEL(ctk_object->exhaust_temp), output_str);
}
if (ctk_object->board_temp) {
g_snprintf(output_str, 16, "%d C", thermEntry.board_temp);
gtk_label_set_text(GTK_LABEL(ctk_object->board_temp), output_str);
}
}
if ((psuEntry.psu_current != -1) &&
(psuEntry.psu_state != -1)) {
if (ctk_object->psu_current) {
g_snprintf(output_str, 16, "%d A", psuEntry.psu_current);
gtk_label_set_text(GTK_LABEL(ctk_object->psu_current), output_str);
}
if (ctk_object->psu_state) {
switch (psuEntry.psu_state) {
case VCS_PSU_STATE_NORMAL:
g_snprintf(output_str, 16, "Normal");
break;
case VCS_PSU_STATE_ABNORMAL:
g_snprintf(output_str, 16, "Abnormal");
break;
default:
g_snprintf(output_str, 16, "Unknown");
break;
}
gtk_label_set_text(GTK_LABEL(ctk_object->psu_state), output_str);
}
}
if (ctk_object->psu_power && psuEntry.psu_power != -1) {
g_snprintf(output_str, 16, "%d W", psuEntry.psu_power);
gtk_label_set_text(GTK_LABEL(ctk_object->psu_power), output_str);
}
if (ctk_object->psu_voltage && psuEntry.psu_voltage != -1) {
g_snprintf(output_str, 16, "%d V", psuEntry.psu_voltage);
gtk_label_set_text(GTK_LABEL(ctk_object->psu_voltage), output_str);
}
if (!update_fan_status(ctk_object)) {
return FALSE;
}
return TRUE;
}