klconflib.c

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

		break;
	}
	return(0);
}

#include "asm/sn/sn_private.h"
#ifndef CONFIG_IA64_SGI_IO
/*
 * Given a physical address get the name of memory dimm bank
 * in a hwgraph name format.
 */
void
membank_pathname_get(paddr_t paddr,char *name)
{
	cnodeid_t	cnode;
	char		slotname[SLOTNUM_MAXLENGTH];

	cnode = paddr_cnode(paddr);
	/* Make sure that we have a valid name buffer */
	if (!name)
		return;

	name[0] = 0;
	/* Make sure that the cnode is valid */
	if ((cnode == CNODEID_NONE) || (cnode > numnodes))
		return;
	/* Given a slotid(class:type) get the slotname */
#if defined (SN0)
	get_slotname(NODE_SLOTID(cnode),slotname);
	sprintf(name,
		"/hw/"EDGE_LBL_MODULE"/%M/"EDGE_LBL_SLOT"/%s/"EDGE_LBL_NODE
		"/"EDGE_LBL_MEMORY"/dimm_bank/%d",
		NODE_MODULEID(cnode),slotname,paddr_dimm(paddr));
#elif defined (CONFIG_SGI_IP35) || defined(CONFIG_IA64_SGI_SN1) || defined(CONFIG_IA64_GENERIC)
	sprintf(name,
		"/dev/hw/"EDGE_LBL_MODULE"/%M/"EDGE_LBL_NODE
		"/"EDGE_LBL_MEMORY"/dimm_bank/%d",
		NODE_MODULEID(cnode),paddr_dimm(paddr));
#endif
}



int
membank_check_mixed_hidensity(nasid_t nasid)
{
	lboard_t *brd;
	klmembnk_t *mem;
	int min_size = 1024, max_size = 0;
	int bank, mem_size;

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

	mem = (klmembnk_t *)find_first_component(brd, KLSTRUCT_MEMBNK);
	ASSERT(mem);


	for (mem_size = 0, bank = 0; bank < MD_MEM_BANKS; bank++) {
		mem_size = KLCONFIG_MEMBNK_SIZE(mem, bank);
		if (mem_size < min_size)
		    min_size = mem_size;
		if (mem_size > max_size)
		    max_size = mem_size;
	}
	
	if ((max_size == 512) && (max_size != min_size))
	    return 1;

	return 0;
}


int
mem_mixed_hidensity_banks(void)
{
	cnodeid_t cnode;
	nasid_t nasid;

	for (cnode = 0; cnode < maxnodes; cnode++) {
		nasid = COMPACT_TO_NASID_NODEID(cnode);
		if (nasid == INVALID_NASID)
		    continue;
		if (membank_check_mixed_hidensity(nasid))
		    return 1;
	}
	return 0;

}
#endif /* CONFIG_IA64_SGI_IO */

xwidgetnum_t
nodevertex_widgetnum_get(devfs_handle_t node_vtx)
{
	hubinfo_t hubinfo_p;

	hwgraph_info_get_LBL(node_vtx, INFO_LBL_NODE_INFO, 
			     (arbitrary_info_t *) &hubinfo_p);
	return(hubinfo_p->h_widgetid);
}

devfs_handle_t
nodevertex_xbow_peer_get(devfs_handle_t node_vtx)
{
	hubinfo_t hubinfo_p;
	nasid_t xbow_peer_nasid;
	cnodeid_t xbow_peer;

	hwgraph_info_get_LBL(node_vtx, INFO_LBL_NODE_INFO,
				     (arbitrary_info_t *) &hubinfo_p);
	xbow_peer_nasid = hubinfo_p->h_nodepda->xbow_peer;
	if(xbow_peer_nasid == INVALID_NASID) 
			return ( (devfs_handle_t)-1);
	xbow_peer = NASID_TO_COMPACT_NODEID(xbow_peer_nasid);
	return(NODEPDA(xbow_peer)->node_vertex);
}

/* NIC Sorting Support */

#define MAX_NICS_PER_STRING 	32
#define MAX_NIC_NAME_LEN	32

static char *
get_nic_string(lboard_t *lb)
{
        int         	i;
        klinfo_t    	*k = NULL ;
    	klconf_off_t    mfg_off = 0 ;
    	char            *mfg_nic = NULL ;

        for (i = 0; i < KLCF_NUM_COMPS(lb); i++) {
                k = KLCF_COMP(lb, i) ;
                switch(k->struct_type) {
                        case KLSTRUCT_BRI:
            			mfg_off = ((klbri_t *)k)->bri_mfg_nic ;
				break ;

                        case KLSTRUCT_HUB:
            			mfg_off = ((klhub_t *)k)->hub_mfg_nic ;
				break ;

                        case KLSTRUCT_ROU:
            			mfg_off = ((klrou_t *)k)->rou_mfg_nic ;
				break ;

                        case KLSTRUCT_GFX:
            			mfg_off = ((klgfx_t *)k)->gfx_mfg_nic ;
				break ;

                        case KLSTRUCT_TPU:
            			mfg_off = ((kltpu_t *)k)->tpu_mfg_nic ;
				break ;

                        case KLSTRUCT_GSN_A:
                        case KLSTRUCT_GSN_B:
            			mfg_off = ((klgsn_t *)k)->gsn_mfg_nic ;
				break ;

                        case KLSTRUCT_XTHD:
                                mfg_off = ((klxthd_t *)k)->xthd_mfg_nic ;
                                break;

			default:
				mfg_off = 0 ;
                                break ;
                }
		if (mfg_off)
			break ;
        }

	if ((mfg_off) && (k))
		mfg_nic = (char *)NODE_OFFSET_TO_K0(k->nasid, mfg_off) ;

        return mfg_nic ;
}

char *
get_first_string(char **ptrs, int n)
{
        int     i ;
        char    *tmpptr ;

        if ((ptrs == NULL) || (n == 0))
                return NULL ;

        tmpptr = ptrs[0] ;

        if (n == 1)
                return tmpptr ;

        for (i = 0 ; i < n ; i++) {
                if (strcmp(tmpptr, ptrs[i]) > 0)
                        tmpptr = ptrs[i] ;
        }

        return tmpptr ;
}

int
get_ptrs(char *idata, char **ptrs, int n, char *label)
{
        int     i = 0 ;
        char    *tmp = idata ;

        if ((ptrs == NULL) || (idata == NULL) || (label == NULL) || (n == 0))
                return 0 ;

        while  ( (tmp = strstr(tmp, label)) ){
                tmp += strlen(label) ;
                /* check for empty name field, and last NULL ptr */
                if ((i < (n-1)) && (*tmp != ';')) {
                        ptrs[i++] = tmp ;
                }
        }

        ptrs[i] = NULL ;

        return i ;
}

/*
 * sort_nic_names
 *
 * 	Does not really do sorting. Find the alphabetically lowest
 *	name among all the nic names found in a nic string.
 *
 * Return:
 *	Nothing
 *
 * Side Effects:
 *
 *	lb->brd_name gets the new name found
 */

static void
sort_nic_names(lboard_t *lb)
{
	char 	*nic_str ;
        char    *ptrs[MAX_NICS_PER_STRING] ;
        char    name[MAX_NIC_NAME_LEN] ;
        char    *tmp, *tmp1 ;

	*name = 0 ;

	/* Get the nic pointer from the lb */

	if ((nic_str = get_nic_string(lb)) == NULL)
		return ;

        tmp = get_first_string(ptrs,
                        get_ptrs(nic_str, ptrs, MAX_NICS_PER_STRING, "Name:")) ;

        if (tmp == NULL)
		return ;

        if  ( (tmp1 = strchr(tmp, ';')) ){
                strncpy(name, tmp, tmp1-tmp) ;
                name[tmp1-tmp] = 0 ;
        } else {
                strncpy(name, tmp, (sizeof(name) -1)) ;
                name[sizeof(name)-1] = 0 ;
        }

	strcpy(lb->brd_name, name) ;
}


#if defined(CONFIG_SGI_IP35) || defined(CONFIG_IA64_SGI_SN1) || defined(CONFIG_IA64_GENERIC)

char brick_types[MAX_BRICK_TYPES + 1] = "crikxdp789012345";

/*
 * Format a module id for printing.
 */
void
format_module_id(char *buffer, moduleid_t m, int fmt)
{
	int rack, position;
	char brickchar;

	rack = MODULE_GET_RACK(m);
	ASSERT(MODULE_GET_BTYPE(m) < MAX_BRICK_TYPES);
	brickchar = MODULE_GET_BTCHAR(m);
	position = MODULE_GET_BPOS(m);

	if (fmt == MODULE_FORMAT_BRIEF) {
	    /* Brief module number format, eg. 002c15 */

	    /* Decompress the rack number */
	    *buffer++ = '0' + RACK_GET_CLASS(rack);
	    *buffer++ = '0' + RACK_GET_GROUP(rack);
	    *buffer++ = '0' + RACK_GET_NUM(rack);

	    /* Add the brick type */
	    *buffer++ = brickchar;
	}
	else if (fmt == MODULE_FORMAT_LONG) {
	    /* Fuller hwgraph format, eg. rack/002/bay/15 */

	    strcpy(buffer, EDGE_LBL_RACK "/");  buffer += strlen(buffer);

	    *buffer++ = '0' + RACK_GET_CLASS(rack);
	    *buffer++ = '0' + RACK_GET_GROUP(rack);
	    *buffer++ = '0' + RACK_GET_NUM(rack);

	    strcpy(buffer, "/" EDGE_LBL_RPOS "/");  buffer += strlen(buffer);
	}

	/* Add the bay position, using at least two digits */
	if (position < 10)
	    *buffer++ = '0';
	sprintf(buffer, "%d", position);

}

/*
 * Parse a module id, in either brief or long form.
 * Returns < 0 on error.
 * The long form does not include a brick type, so it defaults to 0 (CBrick)
 */
int
parse_module_id(char *buffer)
{
	unsigned int	v, rack, bay, type, form;
	moduleid_t	m;
	char 		c;

	if (strstr(buffer, EDGE_LBL_RACK "/") == buffer) {
		form = MODULE_FORMAT_LONG;
		buffer += strlen(EDGE_LBL_RACK "/");

		/* A long module ID must be exactly 5 non-template chars. */
		if (strlen(buffer) != strlen("/" EDGE_LBL_RPOS "/") + 5)
			return -1;
	}
	else {
		form = MODULE_FORMAT_BRIEF;

		/* A brief module id must be exactly 6 characters */
		if (strlen(buffer) != 6)
			return -2;
	}

	/* The rack number must be exactly 3 digits */
	if (!(isdigit(buffer[0]) && isdigit(buffer[1]) && isdigit(buffer[2])))
		return -3;

	rack = 0;
	v = *buffer++ - '0';
	if (v > RACK_CLASS_MASK(rack) >> RACK_CLASS_SHFT(rack))
		return -4;
	RACK_ADD_CLASS(rack, v);

	v = *buffer++ - '0';
	if (v > RACK_GROUP_MASK(rack) >> RACK_GROUP_SHFT(rack))
		return -5;
	RACK_ADD_GROUP(rack, v);

	v = *buffer++ - '0';
	/* rack numbers are 1-based */
	if (v-1 > RACK_NUM_MASK(rack) >> RACK_NUM_SHFT(rack))
		return -6;
	RACK_ADD_NUM(rack, v);

	if (form == MODULE_FORMAT_BRIEF) {
		/* Next should be a module type character.  Accept ucase or lcase. */
		c = *buffer++;
		if (!isalpha(c))
			return -7;

		/* strchr() returns a pointer into brick_types[], or NULL */
		type = (unsigned int)(strchr(brick_types, tolower(c)) - brick_types);
		if (type > MODULE_BTYPE_MASK >> MODULE_BTYPE_SHFT)
			return -8;
	}
	else {
		/* Hardcode the module type, and skip over the boilerplate */
		type = MODULE_CBRICK;

		if (strstr(buffer, "/" EDGE_LBL_RPOS "/") != buffer)
			return -9;

		buffer += strlen("/" EDGE_LBL_RPOS "/");
	}
		
	/* The bay number is last.  Make sure it's exactly two digits */

	if (!(isdigit(buffer[0]) && isdigit(buffer[1]) && !buffer[2]))
		return -10;

	bay = 10 * (buffer[0] - '0') + (buffer[1] - '0');

	if (bay > MODULE_BPOS_MASK >> MODULE_BPOS_SHFT)
		return -11;

	m = RBT_TO_MODULE(rack, bay, type);

	/* avoid sign extending the moduleid_t */
	return (int)(unsigned short)m;
}

#else /* CONFIG_SGI_IP35 || CONFIG_IA64_SGI_SN1 */

/*
 * Format a module id for printing.
 */
void
format_module_id(char *buffer, moduleid_t m, int fmt)
{
    if (fmt == MODULE_FORMAT_BRIEF) {
		sprintf(buffer, "%d", m);
    }
    else if (fmt == MODULE_FORMAT_LONG) {
		sprintf(buffer, EDGE_LBL_MODULE "/%d", m);
    }
}

/*
 * Parse a module id, in either brief or long form.
 * Returns < 0 on error.
 */
int
parse_module_id(char *buffer)
{
    moduleid_t m;
    char c;

    if (strstr(buffer, EDGE_LBL_MODULE "/") == buffer)
	buffer += strlen(EDGE_LBL_MODULE "/");

    m = 0;
    while(c = *buffer++) {
	if (!isdigit(c))
	    return -1;
	m = 10 * m + (c - '0');
    }

    /* avoid sign extending the moduleid_t */
    return (int)(unsigned short)m;
}

#endif /* CONFIG_SGI_IP35 || CONFIG_IA64_SGI_SN1 */