/* * * This file is subject to the terms and conditions of the GNU General Public * License. See the file "COPYING" in the main directory of this archive * for more details. * * Copyright (C) 2000 Silicon Graphics, Inc. * Copyright (C) 2000 by Jack Steiner (steiner@sgi.com) */ /* * WARNING: There is more than one copy of this file in different isms. * All copies must be kept exactly in sync. * Do not modify this file without also updating the following: * * irix/kern/io/eeprom.c * stand/arcs/lib/libsk/ml/eeprom.c * stand/arcs/lib/libkl/io/eeprom.c * * (from time to time they might not be in sync but that's due to bringup * activity - this comment is to remind us that they eventually have to * get back together) * * eeprom.c * * access to board-mounted EEPROMs via the L1 system controllers * */ /************************************************************************** * * * Copyright (C) 1999 Silicon Graphics, Inc. * * * * These coded instructions, statements, and computer programs contain * * unpublished proprietary information of Silicon Graphics, Inc., and * * are protected by Federal copyright law. They may not be disclosed * * to third parties or copied or duplicated in any form, in whole or * * in part, without the prior written consent of Silicon Graphics, Inc. * * * ************************************************************************** */ #include #include #include #include #include #include #include #include #include #include #include /* #include */ #include #include #include #include #include #if defined(EEPROM_DEBUG) #define db_printf(x) printk x #else #define db_printf(x) printk x #endif #define BCOPY(x,y,z) memcpy(y,x,z) #define UNDERSCORE 0 /* don't convert underscores to hyphens */ #define HYPHEN 1 /* convert underscores to hyphens */ void copy_ascii_field( char *to, char *from, int length, int change_underscore ); uint64_t generate_unique_id( char *sn, int sn_len ); uchar_t char_to_base36( char c ); int nicify( char *dst, eeprom_brd_record_t *src ); static void int64_to_hex_string( char *out, uint64_t val ); // extern int router_lock( net_vec_t, int, int ); // extern int router_unlock( net_vec_t ); #define ROUTER_LOCK(p) // router_lock(p, 10000, 3000000) #define ROUTER_UNLOCK(p) // router_unlock(p) #define IP27LOG_OVNIC "OverrideNIC" /* the following function converts an EEPROM record to a close facsimile * of the string returned by reading a Dallas Semiconductor NIC (see * one of the many incarnations of nic.c for details on that driver) */ int nicify( char *dst, eeprom_brd_record_t *src ) { int field_len; uint64_t unique_id; char *cur_dst = dst; eeprom_board_ia_t *board; board = src->board_ia; ASSERT( board ); /* there should always be a board info area */ /* copy part number */ strcpy( cur_dst, "Part:" ); cur_dst += strlen( cur_dst ); ASSERT( (board->part_num_tl & FIELD_FORMAT_MASK) == FIELD_FORMAT_ASCII ); field_len = board->part_num_tl & FIELD_LENGTH_MASK; copy_ascii_field( cur_dst, board->part_num, field_len, HYPHEN ); cur_dst += field_len; /* copy product name */ strcpy( cur_dst, ";Name:" ); cur_dst += strlen( cur_dst ); ASSERT( (board->product_tl & FIELD_FORMAT_MASK) == FIELD_FORMAT_ASCII ); field_len = board->product_tl & FIELD_LENGTH_MASK; copy_ascii_field( cur_dst, board->product, field_len, UNDERSCORE ); cur_dst += field_len; /* copy serial number */ strcpy( cur_dst, ";Serial:" ); cur_dst += strlen( cur_dst ); ASSERT( (board->serial_num_tl & FIELD_FORMAT_MASK) == FIELD_FORMAT_ASCII ); field_len = board->serial_num_tl & FIELD_LENGTH_MASK; copy_ascii_field( cur_dst, board->serial_num, field_len, HYPHEN); cur_dst += field_len; /* copy revision */ strcpy( cur_dst, ";Revision:"); cur_dst += strlen( cur_dst ); ASSERT( (board->board_rev_tl & FIELD_FORMAT_MASK) == FIELD_FORMAT_ASCII ); field_len = board->board_rev_tl & FIELD_LENGTH_MASK; copy_ascii_field( cur_dst, board->board_rev, field_len, HYPHEN ); cur_dst += field_len; /* EEPROMs don't have equivalents for the Group, Capability and * Variety fields, so we pad these with 0's */ strcpy( cur_dst, ";Group:ff;Capability:ffffffff;Variety:ff" ); cur_dst += strlen( cur_dst ); /* use the board serial number to "fake" a laser id */ strcpy( cur_dst, ";Laser:" ); cur_dst += strlen( cur_dst ); unique_id = generate_unique_id( board->serial_num, board->serial_num_tl & FIELD_LENGTH_MASK ); int64_to_hex_string( cur_dst, unique_id ); strcat( dst, ";" ); return 1; } /* These functions borrow heavily from chars2* in nic.c */ void copy_ascii_field( char *to, char *from, int length, int change_underscore ) { int i; for( i = 0; i < length; i++ ) { /* change underscores to hyphens if requested */ if( from[i] == '_' && change_underscore == HYPHEN ) to[i] = '-'; /* ; and ; are separators, so mustn't appear within * a field */ else if( from[i] == ':' || from[i] == ';' ) to[i] = '?'; /* I'm not sure why or if ASCII character 0xff would * show up in an EEPROM field, but the NIC parsing * routines wouldn't like it if it did... so we * get rid of it, just in case. */ else if( (unsigned char)from[i] == (unsigned char)0xff ) to[i] = ' '; /* unprintable characters are replaced with . */ else if( from[i] < ' ' || from[i] >= 0x7f ) to[i] = '.'; /* otherwise, just copy the character */ else to[i] = from[i]; } if( i == 0 ) { to[i] = ' '; /* return at least a space... */ i++; } to[i] = 0; /* terminating null */ } /* Note that int64_to_hex_string currently only has a big-endian * implementation. */ #ifdef _MIPSEB static void int64_to_hex_string( char *out, uint64_t val ) { int i; uchar_t table[] = "0123456789abcdef"; uchar_t *byte_ptr = (uchar_t *)&val; for( i = 0; i < sizeof(uint64_t); i++ ) { out[i*2] = table[ ((*byte_ptr) >> 4) & 0x0f ]; out[i*2+1] = table[ (*byte_ptr) & 0x0f ]; byte_ptr++; } out[i*2] = '\0'; } #else /* little endian */ static void int64_to_hex_string( char *out, uint64_t val ) { printk("int64_to_hex_string needs a little-endian implementation.\n"); } #endif /* _MIPSEB */ /* Convert a standard ASCII serial number to a unique integer * id number by treating the serial number string as though * it were a base 36 number */ uint64_t generate_unique_id( char *sn, int sn_len ) { int uid = 0; int i; #define VALID_BASE36(c) ((c >= '0' && c <='9') \ || (c >= 'A' && c <='Z') \ || (c >= 'a' && c <='z')) for( i = 0; i < sn_len; i++ ) { if( !VALID_BASE36(sn[i]) ) continue; uid *= 36; uid += char_to_base36( sn[i] ); } if( uid == 0 ) return rtc_time(); return uid; } uchar_t char_to_base36( char c ) { uchar_t val; if( c >= '0' && c <= '9' ) val = (c - '0'); else if( c >= 'A' && c <= 'Z' ) val = (c - 'A' + 10); else if( c >= 'a' && c <= 'z' ) val = (c - 'a' + 10); else val = 0; return val; } /* given a pointer to the three-byte little-endian EEPROM representation * of date-of-manufacture, this function translates to a big-endian * integer format */ int eeprom_xlate_board_mfr_date( uchar_t *src ) { int rval = 0; rval += *src; src++; rval += ((int)(*src) << 8); src ++; rval += ((int)(*src) << 16); return rval; } int eeprom_str( char *nic_str, nasid_t nasid, int component ) { eeprom_brd_record_t eep; eeprom_board_ia_t board; eeprom_chassis_ia_t chassis; int r; if( (component & C_DIMM) == C_DIMM ) { /* this function isn't applicable to DIMMs */ return EEP_PARAM; } else { eep.board_ia = &board; eep.spd = NULL; if( !(component & SUBORD_MASK) ) eep.chassis_ia = &chassis; /* only main boards have a chassis * info area */ else eep.chassis_ia = NULL; } switch( component & BRICK_MASK ) { case C_BRICK: r = cbrick_eeprom_read( &eep, nasid, component ); break; case IO_BRICK: r = iobrick_eeprom_read( &eep, nasid, component ); break; default: return EEP_PARAM; /* must be an invalid component */ } if( r ) return r; if( !nicify( nic_str, &eep ) ) return EEP_NICIFY; return EEP_OK; } int vector_eeprom_str( char *nic_str, nasid_t nasid, int component, net_vec_t path ) { eeprom_brd_record_t eep; eeprom_board_ia_t board; eeprom_chassis_ia_t chassis; int r; eep.board_ia = &board; if( !(component & SUBORD_MASK) ) eep.chassis_ia = &chassis; /* only main boards have a chassis * info area */ else eep.chassis_ia = NULL; if( !(component & VECTOR) ) return EEP_PARAM; if( (r = vector_eeprom_read( &eep, nasid, path, component )) ) return r; if( !nicify( nic_str, &eep ) ) return EEP_NICIFY; return EEP_OK; } int is_iobrick( int nasid, int widget_num ) { uint32_t wid_reg; int part_num, mfg_num; /* Read the widget's WIDGET_ID register to get * its part number and mfg number */ wid_reg = *(volatile int32_t *) (NODE_SWIN_BASE( nasid, widget_num ) + WIDGET_ID); part_num = (wid_reg & WIDGET_PART_NUM) >> WIDGET_PART_NUM_SHFT; mfg_num = (wid_reg & WIDGET_MFG_NUM) >> WIDGET_MFG_NUM_SHFT; /* Is this the "xbow part" of an XBridge? If so, this * widget is definitely part of an I/O brick. */ if( part_num == XXBOW_WIDGET_PART_NUM && mfg_num == XXBOW_WIDGET_MFGR_NUM ) return 1; /* Is this a "bridge part" of an XBridge? If so, once * again, we know this widget is part of an I/O brick. */ if( part_num == XBRIDGE_WIDGET_PART_NUM && mfg_num == XBRIDGE_WIDGET_MFGR_NUM ) return 1; return 0; } int cbrick_uid_get( nasid_t nasid, uint64_t *uid ) { #if !defined(CONFIG_SERIAL_SGI_L1_PROTOCOL) return EEP_L1; #else char uid_str[32]; char msg[BRL1_QSIZE]; int subch, len; l1sc_t sc; l1sc_t *scp; int local = (nasid == get_nasid()); if ( IS_RUNNING_ON_SIMULATOR() ) return EEP_L1; /* If the promlog variable pointed to by IP27LOG_OVNIC is set, * use that value for the cbrick UID rather than the EEPROM * serial number. */ #ifdef LOG_GETENV if( ip27log_getenv( nasid, IP27LOG_OVNIC, uid_str, NULL, 0 ) >= 0 ) { /* We successfully read IP27LOG_OVNIC, so return it as the UID. */ db_printf(( "cbrick_uid_get:" "Overriding UID with environment variable %s\n", IP27LOG_OVNIC )); *uid = strtoull( uid_str, NULL, 0 ); return EEP_OK; } #endif /* If this brick is retrieving its own uid, use the local l1sc_t to * arbitrate access to the l1; otherwise, set up a new one. */ if( local ) { scp = get_l1sc(); } else { scp = ≻ sc_init( &sc, nasid, BRL1_LOCALUART ); } /* fill in msg with the opcode & params */ BZERO( msg, BRL1_QSIZE ); if( (subch = sc_open( scp, L1_ADDR_LOCAL )) < 0 ) return EEP_L1; if( (len = sc_construct_msg( scp, subch, msg, BRL1_QSIZE, L1_ADDR_TASK_GENERAL, L1_REQ_SER_NUM, 0 )) < 0 ) { sc_close( scp, subch ); return( EEP_L1 ); } /* send the request to the L1 */ if( sc_command( scp, subch, msg, msg, &len ) ) { sc_close( scp, subch ); return( EEP_L1 ); } /* free up subchannel */ sc_close(scp, subch); /* check response */ if( sc_interpret_resp( msg, 2, L1_ARG_ASCII, uid_str ) < 0 ) { return( EEP_L1 ); } *uid = generate_unique_id( uid_str, strlen( uid_str ) ); return EEP_OK; #endif /* CONFIG_SERIAL_SGI_L1_PROTOCOL */ } int rbrick_uid_get( nasid_t nasid, net_vec_t path, uint64_t *uid ) { #if !defined(CONFIG_SERIAL_SGI_L1_PROTOCOL) return EEP_L1; #else char uid_str[32]; char msg[BRL1_QSIZE]; int subch, len; l1sc_t sc; if ( IS_RUNNING_ON_SIMULATOR() ) return EEP_L1; #ifdef BRINGUP #define FAIL \ { \ *uid = rtc_time(); \ printk( "rbrick_uid_get failed; using current time as uid\n" ); \ return EEP_OK; \ } #endif /* BRINGUP */ ROUTER_LOCK(path); sc_init( &sc, nasid, path ); /* fill in msg with the opcode & params */ BZERO( msg, BRL1_QSIZE ); if( (subch = sc_open( &sc, L1_ADDR_LOCAL )) < 0 ) { ROUTER_UNLOCK(path); FAIL; } if( (len = sc_construct_msg( &sc, subch, msg, BRL1_QSIZE, L1_ADDR_TASK_GENERAL, L1_REQ_SER_NUM, 0 )) < 0 ) { ROUTER_UNLOCK(path); sc_close( &sc, subch ); FAIL; } /* send the request to the L1 */ if( sc_command( &sc, subch, msg, msg, &len ) ) { ROUTER_UNLOCK(path); sc_close( &sc, subch ); FAIL; } /* free up subchannel */ ROUTER_UNLOCK(path); sc_close(&sc, subch); /* check response */ if( sc_interpret_resp( msg, 2, L1_ARG_ASCII, uid_str ) < 0 ) { FAIL; } *uid = generate_unique_id( uid_str, strlen( uid_str ) ); return EEP_OK; #endif /* CONFIG_SERIAL_SGI_L1_PROTOCOL */ } int iobrick_uid_get( nasid_t nasid, uint64_t *uid ) { eeprom_brd_record_t eep; eeprom_board_ia_t board; eeprom_chassis_ia_t chassis; int r; eep.board_ia = &board; eep.chassis_ia = &chassis; eep.spd = NULL; r = iobrick_eeprom_read( &eep, nasid, IO_BRICK ); if( r != EEP_OK ) { *uid = rtc_time(); return r; } *uid = generate_unique_id( board.serial_num, board.serial_num_tl & FIELD_LENGTH_MASK ); return EEP_OK; } int ibrick_mac_addr_get( nasid_t nasid, char *eaddr ) { eeprom_brd_record_t eep; eeprom_board_ia_t board; eeprom_chassis_ia_t chassis; int r; char *tmp; eep.board_ia = &board; eep.chassis_ia = &chassis; eep.spd = NULL; r = iobrick_eeprom_read( &eep, nasid, IO_BRICK ); if( (r != EEP_OK) || (board.mac_addr[0] == '\0') ) { db_printf(( "ibrick_mac_addr_get: " "Couldn't read MAC address from EEPROM\n" )); return EEP_L1; } else { /* successfully read info area */ int ix; tmp = board.mac_addr; for( ix = 0; ix < (board.mac_addr_tl & FIELD_LENGTH_MASK); ix++ ) { *eaddr++ = *tmp++; } *eaddr = '\0'; } return EEP_OK; } /* * eeprom_vertex_info_set * * Given a vertex handle, a component designation, a starting nasid * and (in the case of a router) a vector path to the component, this * function will read the EEPROM and attach the resulting information * to the vertex in the same string format as that provided by the * Dallas Semiconductor NIC drivers. If the vertex already has the * string, this function just returns the string. */ extern char *nic_vertex_info_get( devfs_handle_t ); extern void nic_vmc_check( devfs_handle_t, char * ); #ifdef BRINGUP /* the following were lifted from nic.c - change later? */ #define MAX_INFO 2048 #define NEWSZ(ptr,sz) ((ptr) = kern_malloc((sz))) #define DEL(ptr) (kern_free((ptr))) #endif /* BRINGUP */ char *eeprom_vertex_info_set( int component, int nasid, devfs_handle_t v, net_vec_t path ) { char *info_tmp; int info_len; char *info; /* see if this vertex is already marked */ info_tmp = nic_vertex_info_get(v); if (info_tmp) return info_tmp; /* get a temporary place for the data */ NEWSZ(info_tmp, MAX_INFO); if (!info_tmp) return NULL; /* read the EEPROM */ if( component & R_BRICK ) { if( RBRICK_EEPROM_STR( info_tmp, nasid, path ) != EEP_OK ) return NULL; } else { if( eeprom_str( info_tmp, nasid, component ) != EEP_OK ) return NULL; } /* allocate a smaller final place */ info_len = strlen(info_tmp)+1; NEWSZ(info, info_len); if (info) { strcpy(info, info_tmp); DEL(info_tmp); } else { info = info_tmp; } /* add info to the vertex */ hwgraph_info_add_LBL(v, INFO_LBL_NIC, (arbitrary_info_t) info); /* see if someone else got there first */ info_tmp = nic_vertex_info_get(v); if (info != info_tmp) { DEL(info); return info_tmp; } /* export the data */ hwgraph_info_export_LBL(v, INFO_LBL_NIC, info_len); /* trigger all matching callbacks */ nic_vmc_check(v, info); return info; } /********************************************************************* * * stubs for use until the Bedrock/L1 link is available * */ #include /* #define EEPROM_TEST */ /* fake eeprom reading functions (replace when the BR/L1 communication * channel is in working order) */ /* generate a charater in [0-9A-Z]; if an "extra" character is * specified (such as '_'), include it as one of the possibilities. */ char random_eeprom_ch( char extra ) { char ch; int modval = 36; if( extra ) modval++; ch = rtc_time() % modval; if( ch < 10 ) ch += '0'; else if( ch >= 10 && ch < 36 ) ch += ('A' - 10); else ch = extra; return ch; } /* create a part number of the form xxx-xxxx-xxx. * It may be important later to generate different * part numbers depending on the component we're * supposed to be "reading" from, so the component * paramter is provided. */ void fake_a_part_number( char *buf, int component ) { int i; switch( component ) { /* insert component-specific routines here */ case C_BRICK: strcpy( buf, "030-1266-001" ); break; default: for( i = 0; i < 12; i++ ) { if( i == 3 || i == 8 ) buf[i] = '-'; else buf[i] = random_eeprom_ch(0); } } } /* create a six-character serial number */ void fake_a_serial_number( char *buf, uint64_t ser ) { int i; static const char hexchars[] = "0123456789ABCDEF"; if (ser) { for( i = 5; i >=0; i-- ) { buf[i] = hexchars[ser & 0xf]; ser >>= 4; } } else { for( i = 0; i < 6; i++ ) buf[i] = random_eeprom_ch(0); } } void fake_a_product_name( uchar_t *format, char* buf, int component ) { switch( component & BRICK_MASK ) { case C_BRICK: if( component & SUBORD_MASK ) { strcpy( buf, "C_BRICK_SUB" ); *format = 0xCB; } else { strcpy( buf, "IP35" ); *format = 0xC4; } break; case R_BRICK: if( component & SUBORD_MASK ) { strcpy( buf, "R_BRICK_SUB" ); *format = 0xCB; } else { strcpy( buf, "R_BRICK" ); *format = 0xC7; } break; case IO_BRICK: if( component & SUBORD_MASK ) { strcpy( buf, "IO_BRICK_SUB" ); *format = 0xCC; } else { strcpy( buf, "IO_BRICK" ); *format = 0xC8; } break; default: strcpy( buf, "UNK_DEVICE" ); *format = 0xCA; } } int fake_an_eeprom_record( eeprom_brd_record_t *buf, int component, uint64_t ser ) { eeprom_board_ia_t *board; eeprom_chassis_ia_t *chassis; int i, cs; board = buf->board_ia; chassis = buf->chassis_ia; if( !(component & SUBORD_MASK) ) { if( !chassis ) return EEP_PARAM; chassis->format = 0; chassis->length = 5; chassis->type = 0x17; chassis->part_num_tl = 0xCC; fake_a_part_number( chassis->part_num, component ); chassis->serial_num_tl = 0xC6; fake_a_serial_number( chassis->serial_num, ser ); cs = chassis->format + chassis->length + chassis->type + chassis->part_num_tl + chassis->serial_num_tl; for( i = 0; i < (chassis->part_num_tl & FIELD_LENGTH_MASK); i++ ) cs += chassis->part_num[i]; for( i = 0; i < (chassis->serial_num_tl & FIELD_LENGTH_MASK); i++ ) cs += chassis->serial_num[i]; chassis->checksum = 256 - (cs % 256); } if( !board ) return EEP_PARAM; board->format = 0; board->length = 10; board->language = 0; board->mfg_date = 1789200; /* noon, 5/26/99 */ board->manuf_tl = 0xC3; strcpy( board->manuf, "SGI" ); fake_a_product_name( &(board->product_tl), board->product, component ); board->serial_num_tl = 0xC6; fake_a_serial_number( board->serial_num, ser ); board->part_num_tl = 0xCC; fake_a_part_number( board->part_num, component ); board->board_rev_tl = 0xC2; board->board_rev[0] = '0'; board->board_rev[1] = '1'; board->eeprom_size_tl = 0x01; board->eeprom_size = 1; board->temp_waiver_tl = 0xC2; board->temp_waiver[0] = '0'; board->temp_waiver[1] = '1'; cs = board->format + board->length + board->language + (board->mfg_date & 0xFF) + (board->mfg_date & 0xFF00) + (board->mfg_date & 0xFF0000) + board->manuf_tl + board->product_tl + board->serial_num_tl + board->part_num_tl + board->board_rev_tl + board->board_rev[0] + board->board_rev[1] + board->eeprom_size_tl + board->eeprom_size + board->temp_waiver_tl + board->temp_waiver[0] + board->temp_waiver[1]; for( i = 0; i < (board->manuf_tl & FIELD_LENGTH_MASK); i++ ) cs += board->manuf[i]; for( i = 0; i < (board->product_tl & FIELD_LENGTH_MASK); i++ ) cs += board->product[i]; for( i = 0; i < (board->serial_num_tl & FIELD_LENGTH_MASK); i++ ) cs += board->serial_num[i]; for( i = 0; i < (board->part_num_tl & FIELD_LENGTH_MASK); i++ ) cs += board->part_num[i]; board->checksum = 256 - (cs % 256); return EEP_OK; } #define EEPROM_CHUNKSIZE 64 #if defined(EEPROM_DEBUG) #define RETURN_ERROR \ { \ printk( "read_ia error return, component 0x%x, line %d" \ ", address 0x%x, ia code 0x%x\n", \ l1_compt, __LINE__, sc->subch[subch].target, ia_code ); \ return EEP_L1; \ } #else #define RETURN_ERROR return(EEP_L1) #endif int read_ia( l1sc_t *sc, int subch, int l1_compt, int ia_code, char *eep_record ) { #if !defined(CONFIG_SERIAL_SGI_L1_PROTOCOL) return EEP_L1; #else char msg[BRL1_QSIZE]; /* message buffer */ int len; /* number of bytes used in message buffer */ int ia_len = EEPROM_CHUNKSIZE; /* remaining bytes in info area */ int offset = 0; /* current offset into info area */ if ( IS_RUNNING_ON_SIMULATOR() ) return EEP_L1; BZERO( msg, BRL1_QSIZE ); /* retrieve EEPROM data in 64-byte chunks */ while( ia_len ) { /* fill in msg with opcode & params */ if( (len = sc_construct_msg( sc, subch, msg, BRL1_QSIZE, L1_ADDR_TASK_GENERAL, L1_REQ_EEPROM, 8, L1_ARG_INT, l1_compt, L1_ARG_INT, ia_code, L1_ARG_INT, offset, L1_ARG_INT, ia_len )) < 0 ) { RETURN_ERROR; } /* send the request to the L1 */ if( sc_command( sc, subch, msg, msg, &len ) ) { RETURN_ERROR; } /* check response */ if( sc_interpret_resp( msg, 5, L1_ARG_INT, &ia_len, L1_ARG_UNKNOWN, &len, eep_record ) < 0 ) { RETURN_ERROR; } if( ia_len > EEPROM_CHUNKSIZE ) ia_len = EEPROM_CHUNKSIZE; eep_record += EEPROM_CHUNKSIZE; offset += EEPROM_CHUNKSIZE; } return EEP_OK; #endif /* CONFIG_SERIAL_SGI_L1_PROTOCOL */ } int read_spd( l1sc_t *sc, int subch, int l1_compt, eeprom_spd_u *spd ) { #if !defined(CONFIG_SERIAL_SGI_L1_PROTOCOL) return EEP_L1; #else char msg[BRL1_QSIZE]; /* message buffer */ int len; /* number of bytes used in message buffer */ int resp; /* l1 response code */ int spd_len = EEPROM_CHUNKSIZE; /* remaining bytes in spd record */ int offset = 0; /* current offset into spd record */ char *spd_p = spd->bytes; /* "thumb" for writing to spd */ if ( IS_RUNNING_ON_SIMULATOR() ) return EEP_L1; BZERO( msg, BRL1_QSIZE ); /* retrieve EEPROM data in 64-byte chunks */ while( spd_len ) { /* fill in msg with opcode & params */ if( (len = sc_construct_msg( sc, subch, msg, BRL1_QSIZE, L1_ADDR_TASK_GENERAL, L1_REQ_EEPROM, 8, L1_ARG_INT, l1_compt, L1_ARG_INT, L1_EEP_SPD, L1_ARG_INT, offset, L1_ARG_INT, spd_len )) < 0 ) { return( EEP_L1 ); } /* send the request to the L1 */ if( sc_command( sc, subch, msg, msg, &len ) ) { return( EEP_L1 ); } /* check response */ if( (resp = sc_interpret_resp( msg, 5, L1_ARG_INT, &spd_len, L1_ARG_UNKNOWN, &len, spd_p )) < 0 ) { /* * translate l1 response code to eeprom.c error codes: * The L1 response will be L1_RESP_NAVAIL if the spd * can't be read (i.e. the spd isn't physically there). It will * return L1_RESP_INVAL if the spd exists, but fails the checksum * test because the eeprom wasn't programmed, programmed incorrectly, * or corrupted. L1_RESP_NAVAIL indicates the eeprom is likely not present, * whereas L1_RESP_INVAL indicates the eeprom is present, but the data is * invalid. */ if(resp == L1_RESP_INVAL) { resp = EEP_BAD_CHECKSUM; } else { resp = EEP_L1; } return( resp ); } if( spd_len > EEPROM_CHUNKSIZE ) spd_len = EEPROM_CHUNKSIZE; spd_p += EEPROM_CHUNKSIZE; offset += EEPROM_CHUNKSIZE; } return EEP_OK; #endif /* CONFIG_SERIAL_SGI_L1_PROTOCOL */ } int read_chassis_ia( l1sc_t *sc, int subch, int l1_compt, eeprom_chassis_ia_t *ia ) { char eep_record[512]; /* scratch area for building up info area */ char *eep_rec_p = eep_record; /* thumb for moving through eep_record */ int checksum = 0; /* use to verify eeprom record checksum */ int i; /* Read in info area record from the L1. */ if( read_ia( sc, subch, l1_compt, L1_EEP_CHASSIS, eep_record ) != EEP_OK ) { return EEP_L1; } /* Now we've got the whole info area. Transfer it to the data structure. */ eep_rec_p = eep_record; ia->format = *eep_rec_p++; ia->length = *eep_rec_p++; if( ia->length == 0 ) { /* since we're using 8*ia->length-1 as an array index later, make * sure it's sane. */ db_printf(( "read_chassis_ia: eeprom length byte of ZERO\n" )); return EEP_L1; } ia->type = *eep_rec_p++; ia->part_num_tl = *eep_rec_p++; (void)BCOPY( eep_rec_p, ia->part_num, (ia->part_num_tl & FIELD_LENGTH_MASK) ); eep_rec_p += (ia->part_num_tl & FIELD_LENGTH_MASK); ia->serial_num_tl = *eep_rec_p++; BCOPY( eep_rec_p, ia->serial_num, (ia->serial_num_tl & FIELD_LENGTH_MASK) ); eep_rec_p += (ia->serial_num_tl & FIELD_LENGTH_MASK); ia->checksum = eep_record[(8 * ia->length) - 1]; /* verify checksum */ eep_rec_p = eep_record; checksum = 0; for( i = 0; i < (8 * ia->length); i++ ) { checksum += *eep_rec_p++; } if( (checksum & 0xff) != 0 ) { db_printf(( "read_chassis_ia: bad checksum\n" )); db_printf(( "read_chassis_ia: target 0x%x uart 0x%x\n", sc->subch[subch].target, sc->uart )); return EEP_BAD_CHECKSUM; } return EEP_OK; } int read_board_ia( l1sc_t *sc, int subch, int l1_compt, eeprom_board_ia_t *ia ) { char eep_record[512]; /* scratch area for building up info area */ char *eep_rec_p = eep_record; /* thumb for moving through eep_record */ int checksum = 0; /* running checksum total */ int i; BZERO( ia, sizeof( eeprom_board_ia_t ) ); /* Read in info area record from the L1. */ if( read_ia( sc, subch, l1_compt, L1_EEP_BOARD, eep_record ) != EEP_OK ) { db_printf(( "read_board_ia: error reading info area from L1\n" )); return EEP_L1; } /* Now we've got the whole info area. Transfer it to the data structure. */ eep_rec_p = eep_record; ia->format = *eep_rec_p++; ia->length = *eep_rec_p++; if( ia->length == 0 ) { /* since we're using 8*ia->length-1 as an array index later, make * sure it's sane. */ db_printf(( "read_board_ia: eeprom length byte of ZERO\n" )); return EEP_L1; } ia->language = *eep_rec_p++; ia->mfg_date = eeprom_xlate_board_mfr_date( (uchar_t *)eep_rec_p ); eep_rec_p += 3; ia->manuf_tl = *eep_rec_p++; BCOPY( eep_rec_p, ia->manuf, (ia->manuf_tl & FIELD_LENGTH_MASK) ); eep_rec_p += (ia->manuf_tl & FIELD_LENGTH_MASK); ia->product_tl = *eep_rec_p++; BCOPY( eep_rec_p, ia->product, (ia->product_tl & FIELD_LENGTH_MASK) ); eep_rec_p += (ia->product_tl & FIELD_LENGTH_MASK); ia->serial_num_tl = *eep_rec_p++; BCOPY(eep_rec_p, ia->serial_num, (ia->serial_num_tl & FIELD_LENGTH_MASK)); eep_rec_p += (ia->serial_num_tl & FIELD_LENGTH_MASK); ia->part_num_tl = *eep_rec_p++; BCOPY( eep_rec_p, ia->part_num, (ia->part_num_tl & FIELD_LENGTH_MASK) ); eep_rec_p += (ia->part_num_tl & FIELD_LENGTH_MASK); eep_rec_p++; /* we do not use the FRU file id */ ia->board_rev_tl = *eep_rec_p++; BCOPY( eep_rec_p, ia->board_rev, (ia->board_rev_tl & FIELD_LENGTH_MASK) ); eep_rec_p += (ia->board_rev_tl & FIELD_LENGTH_MASK); ia->eeprom_size_tl = *eep_rec_p++; ia->eeprom_size = *eep_rec_p++; ia->temp_waiver_tl = *eep_rec_p++; BCOPY( eep_rec_p, ia->temp_waiver, (ia->temp_waiver_tl & FIELD_LENGTH_MASK) ); eep_rec_p += (ia->temp_waiver_tl & FIELD_LENGTH_MASK); /* if there's more, we must be reading a main board; get * additional fields */ if( ((unsigned char)*eep_rec_p != (unsigned char)EEPROM_EOF) ) { ia->ekey_G_tl = *eep_rec_p++; BCOPY( eep_rec_p, (char *)&ia->ekey_G, ia->ekey_G_tl & FIELD_LENGTH_MASK ); eep_rec_p += (ia->ekey_G_tl & FIELD_LENGTH_MASK); ia->ekey_P_tl = *eep_rec_p++; BCOPY( eep_rec_p, (char *)&ia->ekey_P, ia->ekey_P_tl & FIELD_LENGTH_MASK ); eep_rec_p += (ia->ekey_P_tl & FIELD_LENGTH_MASK); ia->ekey_Y_tl = *eep_rec_p++; BCOPY( eep_rec_p, (char *)&ia->ekey_Y, ia->ekey_Y_tl & FIELD_LENGTH_MASK ); eep_rec_p += (ia->ekey_Y_tl & FIELD_LENGTH_MASK); /* * need to get a couple more fields if this is an I brick */ if( ((unsigned char)*eep_rec_p != (unsigned char)EEPROM_EOF) ) { ia->mac_addr_tl = *eep_rec_p++; BCOPY( eep_rec_p, ia->mac_addr, ia->mac_addr_tl & FIELD_LENGTH_MASK ); eep_rec_p += (ia->mac_addr_tl & FIELD_LENGTH_MASK); ia->ieee1394_cfg_tl = *eep_rec_p++; BCOPY( eep_rec_p, ia->ieee1394_cfg, ia->ieee1394_cfg_tl & FIELD_LENGTH_MASK ); } } ia->checksum = eep_record[(ia->length * 8) - 1]; /* verify checksum */ eep_rec_p = eep_record; checksum = 0; for( i = 0; i < (8 * ia->length); i++ ) { checksum += *eep_rec_p++; } if( (checksum & 0xff) != 0 ) { db_printf(( "read_board_ia: bad checksum\n" )); db_printf(( "read_board_ia: target 0x%x uart 0x%x\n", sc->subch[subch].target, sc->uart )); return EEP_BAD_CHECKSUM; } return EEP_OK; } int _cbrick_eeprom_read( eeprom_brd_record_t *buf, l1sc_t *scp, int component ) { #if !defined(CONFIG_SERIAL_SGI_L1_PROTOCOL) return EEP_L1; #else int r; uint64_t uid = 0; #ifdef LOG_GETENV char uid_str[32]; #endif int l1_compt, subch; if ( IS_RUNNING_ON_SIMULATOR() ) return EEP_L1; /* make sure we're targeting a cbrick */ if( !(component & C_BRICK) ) return EEP_PARAM; /* If the promlog variable pointed to by IP27LOG_OVNIC is set, * use that value for the cbrick UID rather than the EEPROM * serial number. */ #ifdef LOG_GETENV if( ip27log_getenv( scp->nasid, IP27LOG_OVNIC, uid_str, "0", 0 ) >= 0 ) { db_printf(( "_cbrick_eeprom_read: " "Overriding UID with environment variable %s\n", IP27LOG_OVNIC )); uid = strtoull( uid_str, NULL, 0 ); } #endif if( (subch = sc_open( scp, L1_ADDR_LOCAL )) < 0 ) return EEP_L1; if((component & C_DIMM) == C_DIMM) { l1_compt = L1_EEP_DIMM(component & COMPT_MASK); r = read_spd(scp,subch,l1_compt, buf->spd); sc_close(scp,subch); return(r); } switch( component ) { case C_BRICK: /* c-brick motherboard */ l1_compt = L1_EEP_NODE; r = read_chassis_ia( scp, subch, l1_compt, buf->chassis_ia ); if( r != EEP_OK ) { sc_close( scp, subch ); db_printf(( "_cbrick_eeprom_read: using a fake eeprom record\n" )); return fake_an_eeprom_record( buf, component, uid ); } if( uid ) { /* If IP27LOG_OVNIC is set, we want to put that value * in as our UID. */ fake_a_serial_number( buf->chassis_ia->serial_num, uid ); buf->chassis_ia->serial_num_tl = 6; } break; case C_PIMM: /* one of the PIMM boards */ l1_compt = L1_EEP_PIMM( component & COMPT_MASK ); break; default: /* unsupported board type */ sc_close( scp, subch ); return EEP_PARAM; } r = read_board_ia( scp, subch, l1_compt, buf->board_ia ); sc_close( scp, subch ); if( r != EEP_OK ) { db_printf(( "_cbrick_eeprom_read: using a fake eeprom record\n" )); return fake_an_eeprom_record( buf, component, uid ); } return EEP_OK; #endif /* CONFIG_SERIAL_SGI_L1_PROTOCOL */ } int cbrick_eeprom_read( eeprom_brd_record_t *buf, nasid_t nasid, int component ) { #if !defined(CONFIG_SERIAL_SGI_L1_PROTOCOL) return EEP_L1; #else l1sc_t *scp; int local = (nasid == get_nasid()); if ( IS_RUNNING_ON_SIMULATOR() ) return EEP_L1; /* If this brick is retrieving its own uid, use the local l1sc_t to * arbitrate access to the l1; otherwise, set up a new one (prom) or * use an existing remote l1sc_t (kernel) */ if( local ) { scp = get_l1sc(); } else { scp = &NODEPDA( NASID_TO_COMPACT_NODEID(nasid) )->module->elsc; } return _cbrick_eeprom_read( buf, scp, component ); #endif /* CONFIG_SERIAL_SGI_L1_PROTOCOL */ } int iobrick_eeprom_read( eeprom_brd_record_t *buf, nasid_t nasid, int component ) { #if !defined(CONFIG_SERIAL_SGI_L1_PROTOCOL) return EEP_L1; #else int r; int l1_compt, subch; l1sc_t *scp; int local = (nasid == get_nasid()); if ( IS_RUNNING_ON_SIMULATOR() ) return EEP_L1; /* make sure we're talking to an applicable brick */ if( !(component & IO_BRICK) ) { return EEP_PARAM; } /* If we're talking to this c-brick's attached io brick, use * the local l1sc_t; otherwise, set up a new one (prom) or * use an existing remote l1sc_t (kernel) */ if( local ) { scp = get_l1sc(); } else { scp = &NODEPDA( NASID_TO_COMPACT_NODEID(nasid) )->module->elsc; } if( (subch = sc_open( scp, L1_ADDR_LOCALIO )) < 0 ) return EEP_L1; switch( component ) { case IO_BRICK: /* IO brick motherboard */ l1_compt = L1_EEP_LOGIC; r = read_chassis_ia( scp, subch, l1_compt, buf->chassis_ia ); if( r != EEP_OK ) { sc_close( scp, subch ); /* * Whenever we no longer need to test on hardware * that does not have EEPROMS, then this can be removed. */ r = fake_an_eeprom_record( buf, component, rtc_time() ); return r; } break; case IO_POWER: /* IO brick power board */ l1_compt = L1_EEP_POWER; break; default: /* unsupported board type */ sc_close( scp, subch ); return EEP_PARAM; } r = read_board_ia( scp, subch, l1_compt, buf->board_ia ); sc_close( scp, subch ); if( r != EEP_OK ) { return r; } return EEP_OK; #endif /* CONFIG_SERIAL_SGI_L1_PROTOCOL */ } int vector_eeprom_read( eeprom_brd_record_t *buf, nasid_t nasid, net_vec_t path, int component ) { #if !defined(CONFIG_SERIAL_SGI_L1_PROTOCOL) return EEP_L1; #else int r; uint64_t uid = 0; int l1_compt, subch; l1sc_t sc; if ( IS_RUNNING_ON_SIMULATOR() ) return EEP_L1; /* make sure we're targeting an applicable brick */ if( !(component & VECTOR) ) return EEP_PARAM; switch( component & BRICK_MASK ) { case R_BRICK: ROUTER_LOCK( path ); sc_init( &sc, nasid, path ); if( (subch = sc_open( &sc, L1_ADDR_LOCAL )) < 0 ) { db_printf(( "vector_eeprom_read: couldn't open subch\n" )); ROUTER_UNLOCK(path); return EEP_L1; } switch( component ) { case R_BRICK: /* r-brick motherboard */ l1_compt = L1_EEP_LOGIC; r = read_chassis_ia( &sc, subch, l1_compt, buf->chassis_ia ); if( r != EEP_OK ) { sc_close( &sc, subch ); ROUTER_UNLOCK( path ); printk( "vector_eeprom_read: couldn't get rbrick eeprom info;" " using current time as uid\n" ); uid = rtc_time(); db_printf(("vector_eeprom_read: using a fake eeprom record\n")); return fake_an_eeprom_record( buf, component, uid ); } break; case R_POWER: /* r-brick power board */ l1_compt = L1_EEP_POWER; break; default: /* unsupported board type */ sc_close( &sc, subch ); ROUTER_UNLOCK( path ); return EEP_PARAM; } r = read_board_ia( &sc, subch, l1_compt, buf->board_ia ); sc_close( &sc, subch ); ROUTER_UNLOCK( path ); if( r != EEP_OK ) { db_printf(( "vector_eeprom_read: using a fake eeprom record\n" )); return fake_an_eeprom_record( buf, component, uid ); } return EEP_OK; case C_BRICK: sc_init( &sc, nasid, path ); return _cbrick_eeprom_read( buf, &sc, component ); default: /* unsupported brick type */ return EEP_PARAM; } #endif /* CONFIG_SERIAL_SGI_L1_PROTOCOL */ }