klconflib.c

Linux内核源代码 为压缩文件 是<<Linux内核>>一书中的源代码

{
	lboard_t *brd;

	brd = find_lboard((lboard_t *)KL_CONFIG_INFO(nasid), KLTYPE_IP27);

	if (!brd)
		return INVALID_MODULE;
	else
		return brd->brd_module;
}


#ifndef CONFIG_IA64_SGI_IO
#if 1
/*
 *  find_gfxpipe(#)
 *
 *  XXXmacko
 *  This is only used by graphics drivers, and should be moved
 *  over to gfx/kern/graphics/SN0 as soon as it's convenient.
 */
static klgfx_t *graphics_pipe_list = NULL;
static devfs_handle_t hwgraph_all_gfxids = GRAPH_VERTEX_NONE;

void
setup_gfxpipe_link(devfs_handle_t vhdl,int pipenum)
{
	char idbuf[8];
	extern graph_hdl_t hwgraph;

	graph_info_add_LBL(hwgraph, vhdl, INFO_LBL_GFXID, INFO_DESC_EXPORT, 
		(arbitrary_info_t)pipenum);
	if (hwgraph_all_gfxids == GRAPH_VERTEX_NONE)
		hwgraph_path_add(hwgraph_root, EDGE_LBL_GFX, &hwgraph_all_gfxids);
	sprintf(idbuf, "%d", pipenum);
	hwgraph_edge_add(hwgraph_all_gfxids, vhdl, idbuf);

}
#endif

/* 
 * find the pipenum'th logical graphics pipe (KLCLASS_GFX)
 */
lboard_t *
find_gfxpipe(int pipenum)
{
        gda_t           *gdap;
        cnodeid_t       cnode;
        nasid_t         nasid;
        lboard_t        *lb;
	klgfx_t		*kg,**pkg;
	int		i;

        gdap = (gda_t *)GDA_ADDR(get_nasid());
        if (gdap->g_magic != GDA_MAGIC)
        	return NULL;

	if (!graphics_pipe_list) {
		/* for all nodes */
        	for (cnode = 0; cnode < MAX_COMPACT_NODES; cnode ++) {
                	nasid = gdap->g_nasidtable[cnode];
                	if (nasid == INVALID_NASID)
                        	continue;
			lb = KL_CONFIG_INFO(nasid) ;
			while (lb = find_lboard_class(lb, KLCLASS_GFX)) {
				moduleid_t kgm, pkgm;
				int	kgs, pkgs;

#if defined(DEBUG) && (defined(CONFIG_SGI_IP35) || defined(CONFIG_IA64_SGI_SN1 || defined(CONFIG_IA64_GENERIC))) && defined(BRINGUP)
				printf("find_gfxpipe(): PIPE: %s mod %M slot %d\n",lb?lb->brd_name:"!LBRD",
					lb->brd_module,lb->brd_slot);
#endif
				/* insert lb into list */
				if (!(kg = (klgfx_t*)find_first_component(lb,KLSTRUCT_GFX))) {
					lb = KLCF_NEXT(lb);
					continue;
				}
				/* set moduleslot now that we have brd_module set */
				kg->moduleslot = (lb->brd_module << 8) | SLOTNUM_GETSLOT(lb->brd_slot);
				/* make sure board has device flag set */
				kg->gfx_info.flags |= KLINFO_DEVICE;
				if (kg->cookie < KLGFX_COOKIE) {
				    kg->gfx_next_pipe = NULL;
				    kg->cookie = KLGFX_COOKIE;
				}

				kgm = kg->moduleslot>>8;
				kgs = kg->moduleslot&0xff;
				pkg = &graphics_pipe_list;
				while (*pkg) {
					pkgm = (*pkg)->moduleslot>>8;
					pkgs = (*pkg)->moduleslot&0xff;

					if (!(MODULE_CMP(kgm, pkgm) > 0 ||
					      (MODULE_CMP(kgm, pkgm) == 0 &&
					       kgs > pkgs)))
					    break;

					pkg = &(*pkg)->gfx_next_pipe;
				}
				kg->gfx_next_pipe = *pkg;
				*pkg = kg;
				lb = KLCF_NEXT(lb);
			}
		}
#ifdef FIND_GFXPIPE_DEBUG
		i = 0;
		kg = graphics_pipe_list;
		while (kg) {
			lboard_t *lb;
#if defined(CONFIG_SGI_IP35) || defined(CONFIG_IA64_SGI_SN1) || defined(CONFIG_IA64_GENERIC)
			lb = find_lboard_class(KL_CONFIG_INFO(kg->gfx_info.nasid), KLCLASS_GFX);
#else
#error Need to figure out how to find graphics boards ...
#endif
#if defined(SUPPORT_PRINTING_M_FORMAT)
			printf("find_gfxpipe(): %s pipe %d mod %M slot %d\n",lb?lb->brd_name:"!LBRD",i,
				(kg->moduleslot>>8),(kg->moduleslot&0xff));
#else
			printf("find_gfxpipe(): %s pipe %d mod 0x%x slot %d\n",lb?lb->brd_name:"!LBRD",i,
				(kg->moduleslot>>8),(kg->moduleslot&0xff));
#endif
			kg = kg->gfx_next_pipe;
			i++;
		}
#endif
        }

	i = 0;
	kg = graphics_pipe_list;
	while (kg && (i < pipenum)) {
		kg = kg->gfx_next_pipe;
		i++;
		}

	if (!kg) return NULL;

#if defined(SN0)
	return find_lboard_modslot(KL_CONFIG_INFO(kg->gfx_info.nasid),
				(kg->moduleslot>>8),
				SLOTNUM_XTALK_CLASS|(kg->moduleslot&0xff));
#elif defined(CONFIG_SGI_IP35) || defined(CONFIG_IA64_SGI_SN1) || defined(CONFIG_IA64_GENERIC)
	return find_lboard_class(KL_CONFIG_INFO(kg->gfx_info.nasid), KLCLASS_GFX);
#else
#error Need to figure out how to find graphics boards ...
#endif
}
#endif


#define MHZ	1000000

#ifndef CONFIG_IA64_SGI_IO
uint
cpu_cycles_adjust(uint orig_cycles)
{
	klcpu_t *acpu;
	uint speed;

	acpu  = nasid_slice_to_cpuinfo(get_nasid(), get_slice());

	if (acpu == NULL) return orig_cycles;

	/*
	 * cpu cycles seem to be half of the real value, hack and mult by 2
	 * for now.
	 */
	speed = (orig_cycles * 2) / MHZ;

	/*
	 * if the cpu thinks its running at some random speed nowhere close 
	 * the programmed speed, do nothing.
	 */
	if ((speed < (acpu->cpu_speed - 2)) || (speed > (acpu->cpu_speed + 2)))
	    return orig_cycles;
	return (acpu->cpu_speed * MHZ/2);
}
#endif /* CONFIG_IA64_SGI_IO */

/* Get the canonical hardware graph name for the given pci component
 * on the given io board.
 */
void
device_component_canonical_name_get(lboard_t 	*brd,
				    klinfo_t 	*component,
				    char 	*name)
{
	moduleid_t 	modnum;
	slotid_t 	slot;
	char 		board_name[20];
#ifdef SN0
	char 		slot_name[SLOTNUM_MAXLENGTH];
#endif

	ASSERT(brd);

	/* Get the module number of this board */
	modnum = brd->brd_module;

	/* Convert the [ CLASS | TYPE ] kind of slotid
	 * into a string 
	 */
	slot = brd->brd_slot;
#ifdef SN0
	get_slotname(slot, slot_name);

	ASSERT(modnum >= 0);
#else
	ASSERT(modnum != MODULE_UNKNOWN && modnum != INVALID_MODULE);
#endif

	/* Get the io board name  */
	if (!brd || (brd->brd_sversion < 2)) {
		strcpy(name, EDGE_LBL_XWIDGET);
	} else {
		nic_name_convert(brd->brd_name, board_name);
	}

	/* Give out the canonical  name of the pci device*/
#ifdef SN0
	sprintf(name, 
		"/hw/"EDGE_LBL_MODULE "/%M/"EDGE_LBL_SLOT"/%s/%s/"
		EDGE_LBL_PCI"/%d", 
		modnum, slot_name, board_name,KLCF_BRIDGE_W_ID(component));
#elif defined (CONFIG_SGI_IP35)  || defined(CONFIG_IA64_SGI_SN1) || defined(CONFIG_IA64_GENERIC)
	sprintf(name, 
		"/dev/hw/"EDGE_LBL_MODULE "/%x/"EDGE_LBL_SLOT"/%s/"
		EDGE_LBL_PCI"/%d", 
		modnum, board_name,KLCF_BRIDGE_W_ID(component));
#endif
	
}

/*
 * Get the serial number of the main  component of a board
 * Returns 0 if a valid serial number is found
 * 1 otherwise.
 * Assumptions: Nic manufacturing string  has the following format
 *			*Serial:<serial_number>;*
 */
static int
component_serial_number_get(lboard_t 		*board,
			    klconf_off_t 	mfg_nic_offset,
			    char		*serial_number,
			    char		*key_pattern)
{

	char	*mfg_nic_string;
	char	*serial_string,*str;
	int	i;
	char	*serial_pattern = "Serial:";

	/* We have an error on a null mfg nic offset */
	if (!mfg_nic_offset)
		return(1);
	/* Get the hub's manufacturing nic information
	 * which is in the form of a pre-formatted string
	 */
	mfg_nic_string = 
		(char *)NODE_OFFSET_TO_K0(NASID_GET(board),
					  mfg_nic_offset);
	/* There is no manufacturing nic info */
	if (!mfg_nic_string)
		return(1);

	str = mfg_nic_string;
	/* Look for the key pattern first (if it is  specified)
	 * and then print the serial number corresponding to that.
	 */
	if (strcmp(key_pattern,"") && 
	    !(str = strstr(mfg_nic_string,key_pattern)))
		return(1);

	/* There is no serial number info in the manufacturing
	 * nic info
	 */
	if (!(serial_string = strstr(str,serial_pattern)))
		return(1);

	serial_string = serial_string + strlen(serial_pattern);
	/*  Copy the serial number information from the klconfig */
	i = 0;
	while (serial_string[i] != ';') {
		serial_number[i] = serial_string[i];
		i++;
	}
	serial_number[i] = 0;
	
	return(0);
}
/*
 * Get the serial number of a board
 * Returns 0 if a valid serial number is found
 * 1 otherwise.
 */

int
board_serial_number_get(lboard_t *board,char *serial_number)
{
	ASSERT(board && serial_number);
	if (!board || !serial_number)
		return(1);

	strcpy(serial_number,"");
	switch(KLCLASS(board->brd_type)) {
	case KLCLASS_CPU: {	/* Node board */
		klhub_t	*hub;
		
		/* Get the hub component information */
		hub = (klhub_t *)find_first_component(board,
						      KLSTRUCT_HUB);
		/* If we don't have a hub component on an IP27
		 * then we have a weird klconfig.
		 */
		if (!hub)
			return(1);
		/* Get the serial number information from
		 * the hub's manufacturing nic info
		 */
		if (component_serial_number_get(board,
						hub->hub_mfg_nic,
						serial_number,
#if defined(CONFIG_SGI_IP35) || defined(CONFIG_IA64_SGI_SN1) || defined(CONFIG_IA64_GENERIC)
						"IP35"))
#else
						"IP27"))
			/* Try with IP31 key if IP27 key fails */
			if (component_serial_number_get(board,
							hub->hub_mfg_nic,
							serial_number,
							"IP31"))
#endif /* CONFIG_SGI_IP35 || CONFIG_IA64_SGI_SN1 */
				return(1);
		break;
	}
	case KLCLASS_IO: {	/* IO board */
		if (KLTYPE(board->brd_type) == KLTYPE_TPU) {
		/* Special case for TPU boards */
			kltpu_t *tpu;	
		
			/* Get the tpu component information */
			tpu = (kltpu_t *)find_first_component(board,
						      KLSTRUCT_TPU);
			/* If we don't have a tpu component on a tpu board
			 * then we have a weird klconfig.
			 */
			if (!tpu)
				return(1);
			/* Get the serial number information from
			 * the tpu's manufacturing nic info
			 */
			if (component_serial_number_get(board,
						tpu->tpu_mfg_nic,
						serial_number,
						""))
				return(1);
			break;
		} else  if ((KLTYPE(board->brd_type) == KLTYPE_GSN_A) ||
		            (KLTYPE(board->brd_type) == KLTYPE_GSN_B)) {
		/* Special case for GSN boards */
			klgsn_t *gsn;	
		
			/* Get the gsn component information */
			gsn = (klgsn_t *)find_first_component(board,
			      ((KLTYPE(board->brd_type) == KLTYPE_GSN_A) ?
					KLSTRUCT_GSN_A : KLSTRUCT_GSN_B));
			/* If we don't have a gsn component on a gsn board
			 * then we have a weird klconfig.
			 */
			if (!gsn)
				return(1);
			/* Get the serial number information from
			 * the gsn's manufacturing nic info
			 */
			if (component_serial_number_get(board,
						gsn->gsn_mfg_nic,
						serial_number,
						""))
				return(1);
			break;
		} else {
		     	klbri_t	*bridge;
		
			/* Get the bridge component information */
			bridge = (klbri_t *)find_first_component(board,
							 KLSTRUCT_BRI);
			/* If we don't have a bridge component on an IO board
			 * then we have a weird klconfig.
			 */
			if (!bridge)
				return(1);
			/* Get the serial number information from
		 	 * the bridge's manufacturing nic info
			 */
			if (component_serial_number_get(board,
						bridge->bri_mfg_nic,
						serial_number,
						""))
				return(1);
			break;
		}
	}
	case KLCLASS_ROUTER: {	/* Router board */
		klrou_t *router;	
		
		/* Get the router component information */
		router = (klrou_t *)find_first_component(board,
							 KLSTRUCT_ROU);
		/* If we don't have a router component on a router board
		 * then we have a weird klconfig.
		 */
		if (!router)
			return(1);
		/* Get the serial number information from
		 * the router's manufacturing nic info
		 */
		if (component_serial_number_get(board,
						router->rou_mfg_nic,
						serial_number,
						""))
			return(1);
		break;
	}
	case KLCLASS_GFX: {	/* Gfx board */
		klgfx_t *graphics;
		
		/* Get the graphics component information */
		graphics = (klgfx_t *)find_first_component(board, KLSTRUCT_GFX);
		/* If we don't have a gfx component on a gfx board
		 * then we have a weird klconfig.
		 */
		if (!graphics)
			return(1);
		/* Get the serial number information from
		 * the graphics's manufacturing nic info
		 */
		if (component_serial_number_get(board,
						graphics->gfx_mfg_nic,
						serial_number,
						""))
			return(1);
		break;
	}
	default:
		strcpy(serial_number,"");