build_tree.c

HP PCI热插拔代码GUI HP内部珍贵资料！

/*
 *    Compaq Hot Plug Controller Graphical User Interface 
 *    Copyright 2000, 2001 Compaq Computer Corporation
 *    All rights reserved.
 *
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
 *    NON INFRINGEMENT.  See the GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *    Please send all questions or concerns to [e-mail]
 */

#include "commonheader.h"
#include "build_tree.h"
#include "build_table.h"
#include "refresh_table.h"
#include "set_adapter.h"
#include "set_attention_status.h"
#include "set_driver.h"
#include "tree.h"
#include "interface.h"
#include "callbacks.h"

pci_tree_node* build_pci_adapter_tree_node();

// remove all the nodes from the tree and global root node array
void delete_tree(GtkCTree* tree)
{
	int index;

	for (index=0; index < MAXSLOTS; index++) {
		if (root_nodes[index] != 0)
			gtk_ctree_post_recursive(tree, root_nodes[index], remove_node, NULL);
	}
	
       	memset(&root_nodes, 0, sizeof(root_nodes));  // initialize global root array
}

// build the tree using a recursive visitation method
void build_tree(GtkCTree* tree)
{
	char* dir;

	load_pixmaps(tree);
	
	gtk_clist_set_row_height(GTK_CLIST(tree), 19);
	gtk_ctree_set_indent(tree, 25);

	dir = CPQPHPD_PROC_ROOT;

	gtk_clist_freeze(GTK_CLIST(tree));

	delete_tree(tree);

	// traverse the directory structure to build the respective tree
	walk_top_layer(tree, dir);
	
	if (g_node) {
		pci_tree_node* p_node = (pci_tree_node*) gtk_ctree_node_get_row_data(tree, g_node);
		set_adapter_button_status(g_node, p_node);
		set_driver_button_status(g_node, p_node);
		set_attention_status_button_status(g_node, p_node);
	}
	else { // no tree node selected
		set_adapter_button_status(NULL, NULL);
		set_driver_button_status(NULL, NULL);
		set_attention_status_button_status(NULL, NULL);
	}

	gtk_clist_thaw(GTK_CLIST(tree));
}

// re-build a single slot in the tree (occurs when a signal is received from the driver)
void build_tree_from_slot(GtkCTree* tree, int slot_number)
{
	gtk_clist_freeze(GTK_CLIST(tree));
	
	// remove the node from the tree
	if (root_nodes[slot_number-1] && root_paths[slot_number-1]) 
		gtk_ctree_post_recursive(tree, root_nodes[slot_number-1], remove_node, NULL);

	root_nodes[slot_number-1] = NULL;

	build_from_slot(tree, slot_number);
	
	if (root_nodes[slot_number-1] != 0) {
		gtk_ctree_pre_recursive(tree, root_nodes[slot_number-1], set_back_pointer, NULL);
		gtk_ctree_pre_recursive(tree, root_nodes[slot_number-1], render_node, NULL);
	}

	if (g_node) {	
		gtk_ctree_select(tree, g_node);
		build_table(g_table, g_node);
	}
	else {
		GtkCList* clist = GTK_CLIST(tree);
		
		gtk_ctree_select(tree, root_nodes[slot_number-1]);
		clist->focus_row = -1;				// remove errant focus 
		gtk_widget_draw(GTK_WIDGET(clist), NULL);	// repaint 
		
		refresh_table(g_table, root_nodes[slot_number-1]);
	}
	
	gtk_clist_thaw(GTK_CLIST(tree));
}

// build a pci tree node for an adapter (no proc entries are created for an adapter)
pci_tree_node* build_pci_adapter_tree_node()
{
      	pci_tree_node* pci_proc_node;
	public_adapter_info* adapter;

	pci_proc_node = (pci_tree_node*) malloc(sizeof(pci_tree_node));
	memset(pci_proc_node, 0, sizeof(pci_tree_node));

	adapter = (public_adapter_info*) malloc(sizeof(public_adapter_info));
	memset(adapter, 0, sizeof(public_adapter_info));
	
	pci_proc_node->type = 3;
	pci_proc_node->node_info = adapter;
	pci_proc_node->set_adapter = set_adapter_from_adapter;
	pci_proc_node->set_driver = set_driver_from_adapter;
	pci_proc_node->set_attention_status = set_attention_status_from_adapter;
	pci_proc_node->build_table_data = build_table_data_from_adapter;
	pci_proc_node->render_node = render_node_from_adapter;

	return pci_proc_node;	
}

// read information from the passed-in file and populate the appropriate fields
void build_pci_tree_node_helper(void* public_info, int type, char* dir, FILE* fd) 
{
	switch(type) {
		case 0:	// slot
		{
			public_slot_info* slot = (public_slot_info*) public_info;
		
			fscanf(fd, "%*s %d", &slot->slot_number);
			fscanf(fd, "%*s %d", &slot->is_hotpluggable);
			fscanf(fd, "%*s %d", &slot->power);
			fscanf(fd, "%*s %d", &slot->attention_status);
			fscanf(fd, "%*s %d", &slot->latch_status);
			fscanf(fd, "%*s %d", &slot->adapter_presence);
			fscanf(fd, "%*s %d", &slot->bit_mode);
				
			break;			
		}
		case 1:	// bus
		{
			public_bus_info* bus = (public_bus_info*) public_info;
			
			fscanf(fd, "%*s %d", &bus->bus_number);
			fscanf(fd, "%*s %d", &bus->current_speed);
			fscanf(fd, "%*s %d", &bus->supported_speed);
			
			break;
		}
		case 2:	// function
		{
			public_function_info* function = (public_function_info*) public_info;
		
			fscanf(fd, "%*s %d", &function->is_bridge);
			fscanf(fd, "%*s %d", &function->is_driverloaded); //bogus value (see below)
			fscanf(fd, "%*s %d", &function->supported_speed_mode);
			fscanf(fd, "%*s %[^\n]", function->device_name);
			fscanf(fd, "%*s %[^\n]", function->driver_name);
			fscanf(fd, "%*s %x", &function->vendor_id);
			fscanf(fd, "%*s %x", &function->device_id);
			fscanf(fd, "%*s %x", &function->subvendor_id);
			fscanf(fd, "%*s %x", &function->subdevice_id);
			fscanf(fd, "%*s %d", &function->bus_number);
			fscanf(fd, "%*s %d", &function->device_number);
			fscanf(fd, "%*s %d", &function->function_number);
			
			break;
		}
	}  // end switch
}

// build a pci tree node based on its type (using proc entries)
pci_tree_node* build_pci_tree_node(char* dir)
{
	int type;
	int i;
	FILE* fd;  // file descriptor
	char temp_buffer[MAXLEN];
      	pci_tree_node* pci_proc_node;
	
	// open .info file to extract necessary information for building the node
	sprintf(temp_buffer, "%s/%s/.info", CPQPHPD_PROC_ROOT, dir);

	//This kludge is to conceal latency issues for /proc
	for (i=0; i<4; i++) {
		fd = fopen(temp_buffer, "r");
		if (fd != NULL) break;
		sleep(1);
	}

	if (fd) {  // valid file descriptor
		fscanf(fd, "%*s %d", &type);

		pci_proc_node = (pci_tree_node*) malloc(sizeof(pci_tree_node));
		memset(pci_proc_node, 0, sizeof(pci_tree_node));
		strcpy(pci_proc_node->proc_path, temp_buffer);	
	
		switch(type) {
			case 0:	// slot
			{
				public_bus_info* bus = NULL;
				public_slot_info* slot = (public_slot_info*) malloc(sizeof(public_slot_info));
	
				memset(slot, 0, sizeof(public_slot_info));
				
				build_pci_tree_node_helper(slot, type, dir, fd);
	
				slot->bus = bus;
		
				pci_proc_node->type = type;
				pci_proc_node->node_info = slot;  // = void* return value
				pci_proc_node->set_adapter = set_adapter_from_slot;
				pci_proc_node->set_driver = set_driver_from_slot;
				pci_proc_node->set_attention_status = set_attention_status_from_slot;
				pci_proc_node->build_table_data = build_table_data_from_slot;
				pci_proc_node->render_node = render_node_from_slot;
				break;			
			}
			case 1:	// bus
			{
				public_bus_info* bus = (public_bus_info*) malloc(sizeof(public_bus_info));
				memset(bus, 0, sizeof(public_bus_info));
				
				build_pci_tree_node_helper(bus, type, dir, fd);
				
				pci_proc_node->type = type;
				pci_proc_node->node_info = bus;
		
				break;
			}
			case 2:	// function
			{
				public_function_info* function = (public_function_info*) malloc(sizeof(public_function_info));
				memset(function, 0, sizeof(public_function_info));
			
				build_pci_tree_node_helper(function, type, dir, fd);
					
				pci_proc_node->type = type;
				pci_proc_node->node_info = function;
				pci_proc_node->set_adapter = set_adapter_from_function;
				pci_proc_node->set_driver = set_driver_from_function;
				pci_proc_node->set_attention_status = set_attention_status_from_function;
				pci_proc_node->build_table_data = build_table_data_from_function;
				pci_proc_node->render_node = render_node_from_function;
					
				break;
			}
		}  // end switch
		fclose(fd);
	}

	return pci_proc_node;
}

// create a blank ctree node and store its respective pci tree node (list) in it
GtkCTreeNode* build_ctree_node(GtkCTree* tree, GtkCTreeNode* parent, GtkCTreeNode* sibling, pci_tree_node* pci_tree_node)
{
	GtkCTreeNode* node = gtk_ctree_insert_node(tree, parent, sibling, 0, 1, 0, 0, 0, 0, FALSE, TRUE);

	gtk_ctree_node_set_row_data(tree, node, pci_tree_node);
	if (pci_tree_node) pci_tree_node->node = node;

	return node;
}