开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
eeprom.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：36k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

eeprom.c：源码内容
  1. /*
  2.  * This file is subject to the terms and conditions of the GNU General Public
  3.  * License.  See the file "COPYING" in the main directory of this archive
  4.  * for more details.
  5.  *
  6.  * Copyright (C) 1999-2002 Silicon Graphics, Inc. All rights reserved.
  7.  */
  9. /*
  10.  * WARNING:     There is more than one copy of this file in different isms.
  11.  *              All copies must be kept exactly in sync.
  12.  *              Do not modify this file without also updating the following:
  13.  *
  14.  *              irix/kern/io/eeprom.c
  15.  *              stand/arcs/lib/libsk/ml/eeprom.c
  16.  * stand/arcs/lib/libkl/io/eeprom.c
  17.  *
  18.  *      (from time to time they might not be in sync but that's due to bringup
  19.  *       activity - this comment is to remind us that they eventually have to
  20.  *       get back together)
  21.  *
  22.  * eeprom.c
  23.  *
  24.  * access to board-mounted EEPROMs via the L1 system controllers
  25.  *
  26.  */
  28. #include <linux/types.h>
  29. #include <linux/config.h>
  30. #include <linux/slab.h>
  31. #include <asm/sn/sgi.h>
  32. #include <asm/sn/io.h>
  33. #include <asm/sn/iograph.h>
  34. #include <asm/sn/invent.h>
  35. #include <asm/sn/hcl.h>
  36. #include <asm/sn/hcl_util.h>
  37. #include <asm/sn/labelcl.h>
  38. #include <asm/sn/eeprom.h>
  39. #include <asm/sn/router.h>
  40. #include <asm/sn/module.h>
  41. #include <asm/sn/ksys/l1.h>
  42. #include <asm/sn/nodepda.h>
  43. #include <asm/sn/clksupport.h>
  44. #include <asm/sn/sn_cpuid.h>
  45. #include <asm/sn/simulator.h>
  47. #if defined(EEPROM_DEBUG)
  48. #define db_printf(x) printk x
  49. #else
  50. #define db_printf(x) printk x
  51. #endif
  53. #define BCOPY(x,y,z) memcpy(y,x,z)
  55. #define UNDERSCORE 0 /* don't convert underscores to hyphens */
  56. #define HYPHEN 1 /* convert underscores to hyphens */
  58. void copy_ascii_field( char *to, char *from, int length,
  59.           int change_underscore );
  60. uint64_t generate_unique_id( char *sn, int sn_len );
  61. uchar_t char_to_base36( char c );
  62. int nicify( char *dst, eeprom_brd_record_t *src );
  63. static void int64_to_hex_string( char *out, uint64_t val );
  65. // extern int router_lock( net_vec_t, int, int );
  66. // extern int router_unlock( net_vec_t );
  67. #define ROUTER_LOCK(p)  // router_lock(p, 10000, 3000000)
  68. #define ROUTER_UNLOCK(p)  // router_unlock(p)
  70. #define IP27LOG_OVNIC           "OverrideNIC"
  73. /* the following function converts an EEPROM record to a close facsimile
  74.  * of the string returned by reading a Dallas Semiconductor NIC (see
  75.  * one of the many incarnations of nic.c for details on that driver)
  76.  */
  77. int nicify( char *dst, eeprom_brd_record_t *src )
  78. {
  79.     int field_len;
  80.     uint64_t unique_id;
  81.     char *cur_dst = dst;
  82.     eeprom_board_ia_t   *board;
  84.     board   = src->board_ia;
  85.     ASSERT( board );  /* there should always be a board info area */
  87.     /* copy part number */
  88.     strcpy( cur_dst, "Part:" );
  89.     cur_dst += strlen( cur_dst );
  90.     ASSERT( (board->part_num_tl & FIELD_FORMAT_MASK)
  91.     == FIELD_FORMAT_ASCII );
  92.     field_len = board->part_num_tl & FIELD_LENGTH_MASK;
  93.     copy_ascii_field( cur_dst, board->part_num, field_len, HYPHEN );
  94.     cur_dst += field_len;
  96.     /* copy product name */
  97.     strcpy( cur_dst, ";Name:" );
  98.     cur_dst += strlen( cur_dst );
  99.     ASSERT( (board->product_tl & FIELD_FORMAT_MASK) == FIELD_FORMAT_ASCII );
  100.     field_len = board->product_tl & FIELD_LENGTH_MASK;
  101.     copy_ascii_field( cur_dst, board->product, field_len, UNDERSCORE );
  102.     cur_dst += field_len;
  104.     /* copy serial number */
  105.     strcpy( cur_dst, ";Serial:" );
  106.     cur_dst += strlen( cur_dst );
  107.     ASSERT( (board->serial_num_tl & FIELD_FORMAT_MASK)
  108.     == FIELD_FORMAT_ASCII );
  109.     field_len = board->serial_num_tl & FIELD_LENGTH_MASK;
  110.     copy_ascii_field( cur_dst, board->serial_num, field_len,
  111.       HYPHEN);
  113.     cur_dst += field_len;
  115.     /* copy revision */
  116.     strcpy( cur_dst, ";Revision:");
  117.     cur_dst += strlen( cur_dst );
  118.     ASSERT( (board->board_rev_tl & FIELD_FORMAT_MASK)
  119.     == FIELD_FORMAT_ASCII );
  120.     field_len = board->board_rev_tl & FIELD_LENGTH_MASK;
  121.     copy_ascii_field( cur_dst, board->board_rev, field_len, HYPHEN );
  122.     cur_dst += field_len;
  124.     /* EEPROMs don't have equivalents for the Group, Capability and
  125.      * Variety fields, so we pad these with 0's
  126.      */
  127.     strcpy( cur_dst, ";Group:ff;Capability:ffffffff;Variety:ff" );
  128.     cur_dst += strlen( cur_dst );
  130.     /* use the board serial number to "fake" a laser id */
  131.     strcpy( cur_dst, ";Laser:" );
  132.     cur_dst += strlen( cur_dst );
  133.     unique_id = generate_unique_id( board->serial_num,
  134.     board->serial_num_tl & FIELD_LENGTH_MASK );
  135.     int64_to_hex_string( cur_dst, unique_id );
  136.     strcat( dst, ";" );
  138.     return 1;
  139. }
  142. /* These functions borrow heavily from chars2* in nic.c
  143.  */
  144. void copy_ascii_field( char *to, char *from, int length,
  145.        int change_underscore )
  146. {
  147.     int i;
  148.     for( i = 0; i < length; i++ ) {
  150. /* change underscores to hyphens if requested */
  151. if( from[i] == '_' && change_underscore == HYPHEN )
  152.     to[i] = '-';
  154. /* ; and ; are separators, so mustn't appear within
  155.  * a field */
  156. else if( from[i] == ':' || from[i] == ';' )
  157.     to[i] = '?';
  159. /* I'm not sure why or if ASCII character 0xff would
  160.  * show up in an EEPROM field, but the NIC parsing
  161.  * routines wouldn't like it if it did... so we
  162.  * get rid of it, just in case. */
  163. else if( (unsigned char)from[i] == (unsigned char)0xff )
  164.     to[i] = ' ';
  166. /* unprintable characters are replaced with . */
  167. else if( from[i] < ' ' || from[i] >= 0x7f )
  168.     to[i] = '.';
  170. /* otherwise, just copy the character */
  171. else
  172.     to[i] = from[i];
  173.     }
  175.     if( i == 0 ) {
  176. to[i] = ' '; /* return at least a space... */
  177. i++;
  178.     }
  179.     to[i] = 0;      /* terminating null */
  180. }
  182. /* Note that int64_to_hex_string currently only has a big-endian
  183.  * implementation.
  184.  */
  185. #ifdef _MIPSEB
  186. static void int64_to_hex_string( char *out, uint64_t val )
  187. {
  188.     int i;
  189.     uchar_t table[] = "0123456789abcdef";
  190.     uchar_t *byte_ptr = (uchar_t *)&val;
  191.     for( i = 0; i < sizeof(uint64_t); i++ ) {
  192. out[i*2] = table[ ((*byte_ptr) >> 4) & 0x0f ];
  193. out[i*2+1] = table[ (*byte_ptr) & 0x0f ];
  194. byte_ptr++;
  195.     }
  196.     out[i*2] = '';
  197. }
  199. #else /* little endian */
  201. static void int64_to_hex_string( char *out, uint64_t val )
  202. {
  205. printk("int64_to_hex_string needs a little-endian implementation.n");
  206. }
  207. #endif /* _MIPSEB */
  209. /* Convert a standard ASCII serial number to a unique integer
  210.  * id number by treating the serial number string as though
  211.  * it were a base 36 number
  212.  */
  213. uint64_t generate_unique_id( char *sn, int sn_len )
  214. {
  215.     int uid = 0;
  216.     int i;
  218.     #define VALID_BASE36(c) ((c >= '0' && c <='9') 
  219.     ||   (c >= 'A' && c <='Z') 
  220.     ||   (c >= 'a' && c <='z'))
  222.     for( i = 0; i < sn_len; i++ ) {
  223. if( !VALID_BASE36(sn[i]) )
  224.     continue;
  225. uid *= 36;
  226. uid += char_to_base36( sn[i] );
  227.     }
  229.     if( uid == 0 )
  230. return rtc_time();
  232.     return uid;
  233. }
  235. uchar_t char_to_base36( char c )
  236. {
  237.     uchar_t val;
  239.     if( c >= '0' && c <= '9' )
  240. val = (c - '0');
  242.     else if( c >= 'A' && c <= 'Z' )
  243. val = (c - 'A' + 10);
  245.     else if( c >= 'a' && c <= 'z' )
  246. val = (c - 'a' + 10);
  248.     else val = 0;
  250.     return val;
  251. }
  254. /* given a pointer to the three-byte little-endian EEPROM representation
  255.  * of date-of-manufacture, this function translates to a big-endian
  256.  * integer format
  257.  */
  258. int eeprom_xlate_board_mfr_date( uchar_t *src )
  259. {
  260.     int rval = 0;
  261.     rval += *src; src++;
  262.     rval += ((int)(*src) << 8); src ++;
  263.     rval += ((int)(*src) << 16);
  264.     return rval;
  265. }
  268. int eeprom_str( char *nic_str, nasid_t nasid, int component )
  269. {
  270.     eeprom_brd_record_t eep;
  271.     eeprom_board_ia_t board;
  272.     eeprom_chassis_ia_t chassis;
  273.     int r;
  275.     if( (component & C_DIMM) == C_DIMM ) {
  276. /* this function isn't applicable to DIMMs */
  277. return EEP_PARAM;
  278.     }
  279.     else {
  280. eep.board_ia = &board;
  281. eep.spd = NULL;
  282. if( !(component & SUBORD_MASK) )
  283.     eep.chassis_ia = &chassis;  /* only main boards have a chassis
  284.  * info area */
  285. else
  286.     eep.chassis_ia = NULL;
  287.     }
  288.     
  289.     switch( component & BRICK_MASK ) {
  290.       case C_BRICK:
  291. r = cbrick_eeprom_read( &eep, nasid, component );
  292. break;
  293.       case IO_BRICK:
  294. r = iobrick_eeprom_read( &eep, nasid, component );
  295. break;
  296.       default:
  297. return EEP_PARAM;  /* must be an invalid component */
  298.     }
  299.     if( r )
  300. return r;
  301.     if( !nicify( nic_str, &eep ) )
  302. return EEP_NICIFY;
  304.     return EEP_OK;
  305. }
  307. int vector_eeprom_str( char *nic_str, nasid_t nasid,
  308.        int component, net_vec_t path )
  309. {
  310.     eeprom_brd_record_t eep;
  311.     eeprom_board_ia_t board;
  312.     eeprom_chassis_ia_t chassis;
  313.     int r;
  315.     eep.board_ia = &board;
  316.     if( !(component & SUBORD_MASK) )
  317.         eep.chassis_ia = &chassis;  /* only main boards have a chassis
  318.                                      * info area */
  319.     else
  320.         eep.chassis_ia = NULL;
  322.     if( !(component & VECTOR) )
  323. return EEP_PARAM;
  325.     if( (r = vector_eeprom_read( &eep, nasid, path, component )) )
  326. return r;
  328.     if( !nicify( nic_str, &eep ) )
  329.         return EEP_NICIFY;
  331.     return EEP_OK;
  332. }
  335. int is_iobrick( int nasid, int widget_num )
  336. {
  337.     uint32_t wid_reg;
  338.     int part_num, mfg_num;
  340.     /* Read the widget's WIDGET_ID register to get
  341.      * its part number and mfg number
  342.      */
  343.     wid_reg = *(volatile int32_t *)
  344.         (NODE_SWIN_BASE( nasid, widget_num ) + WIDGET_ID);
  346.     part_num = (wid_reg & WIDGET_PART_NUM) >> WIDGET_PART_NUM_SHFT;
  347.     mfg_num = (wid_reg & WIDGET_MFG_NUM) >> WIDGET_MFG_NUM_SHFT;
  349.     /* Is this the "xbow part" of an XBridge?  If so, this
  350.      * widget is definitely part of an I/O brick.
  351.      */
  352.     if( part_num == XXBOW_WIDGET_PART_NUM &&
  353. mfg_num == XXBOW_WIDGET_MFGR_NUM )
  355. return 1;
  357.     /* Is this a "bridge part" of an XBridge?  If so, once
  358.      * again, we know this widget is part of an I/O brick.
  359.      */
  360.     if( part_num == XBRIDGE_WIDGET_PART_NUM &&
  361. mfg_num == XBRIDGE_WIDGET_MFGR_NUM )
  363. return 1;
  365.     return 0;
  366. }
  369. int cbrick_uid_get( nasid_t nasid, uint64_t *uid )
  370. {
  371.     char uid_str[32];
  372.     char msg[BRL1_QSIZE];
  373.     int subch, len;
  374.     l1sc_t sc;
  375.     l1sc_t *scp;
  376.     int local = (nasid == get_nasid());
  378.     if ( IS_RUNNING_ON_SIMULATOR() )
  379. return EEP_L1;
  381.     /* If the promlog variable pointed to by IP27LOG_OVNIC is set,
  382.      * use that value for the cbrick UID rather than the EEPROM
  383.      * serial number.
  384.      */
  385. #ifdef LOG_GETENV
  386.     if( ip27log_getenv( nasid, IP27LOG_OVNIC, uid_str, NULL, 0 ) >= 0 )
  387.     {
  388. /* We successfully read IP27LOG_OVNIC, so return it as the UID. */
  389. db_printf(( "cbrick_uid_get:"
  390.     "Overriding UID with environment variable %sn", 
  391.     IP27LOG_OVNIC ));
  392. *uid = strtoull( uid_str, NULL, 0 );
  393. return EEP_OK;
  394.     }
  395. #endif
  397.     /* If this brick is retrieving its own uid, use the local l1sc_t to
  398.      * arbitrate access to the l1; otherwise, set up a new one.
  399.      */
  400.     if( local ) {
  401. scp = get_l1sc();
  402.     }
  403.     else {
  404. scp = &sc;
  405. sc_init( &sc, nasid, BRL1_LOCALHUB_UART );
  406.     }
  408.     /* fill in msg with the opcode & params */
  409.     BZERO( msg, BRL1_QSIZE );
  410.     if( (subch = sc_open( scp, L1_ADDR_LOCAL )) < 0 )
  411. return EEP_L1;
  413.     if( (len = sc_construct_msg( scp, subch, msg, BRL1_QSIZE,
  414.  L1_ADDR_TASK_GENERAL,
  415.  L1_REQ_SER_NUM, 0 )) < 0 )
  416.     {
  417. sc_close( scp, subch );
  418. return( EEP_L1 );
  419.     }
  421.     /* send the request to the L1 */
  422.     if( sc_command( scp, subch, msg, msg, &len ) ) {
  423. sc_close( scp, subch );
  424. return( EEP_L1 );
  425.     }
  427.     /* free up subchannel */
  428.     sc_close(scp, subch);
  430.     /* check response */
  431.     if( sc_interpret_resp( msg, 2, L1_ARG_ASCII, uid_str ) < 0 )
  432.     {
  433. return( EEP_L1 );
  434.     }
  436.     *uid = generate_unique_id( uid_str, strlen( uid_str ) );
  438.     return EEP_OK;
  439. }
  442. int rbrick_uid_get( nasid_t nasid, net_vec_t path, uint64_t *uid )
  443. {
  444.     char uid_str[32];
  445.     char msg[BRL1_QSIZE];
  446.     int subch, len;
  447.     l1sc_t sc;
  449.     if ( IS_RUNNING_ON_SIMULATOR() )
  450. return EEP_L1;
  452. #define FAIL
  453.     {
  454. *uid = rtc_time();
  455. printk( "rbrick_uid_get failed; using current time as uidn" );
  456. return EEP_OK;
  457.     }
  459.     ROUTER_LOCK(path);
  460.     sc_init( &sc, nasid, path );
  462.     /* fill in msg with the opcode & params */
  463.     BZERO( msg, BRL1_QSIZE );
  464.     if( (subch = sc_open( &sc, L1_ADDR_LOCAL )) < 0 ) {
  465. ROUTER_UNLOCK(path);
  466. FAIL;
  467.     }
  469.     if( (len = sc_construct_msg( &sc, subch, msg, BRL1_QSIZE,
  470.  L1_ADDR_TASK_GENERAL,
  471.  L1_REQ_SER_NUM, 0 )) < 0 )
  472.     {
  473. ROUTER_UNLOCK(path);
  474. sc_close( &sc, subch );
  475. FAIL;
  476.     }
  478.     /* send the request to the L1 */
  479.     if( sc_command( &sc, subch, msg, msg, &len ) ) {
  480. ROUTER_UNLOCK(path);
  481. sc_close( &sc, subch );
  482. FAIL;
  483.     }
  485.     /* free up subchannel */
  486.     ROUTER_UNLOCK(path);
  487.     sc_close(&sc, subch);
  489.     /* check response */
  490.     if( sc_interpret_resp( msg, 2, L1_ARG_ASCII, uid_str ) < 0 )
  491.     {
  492. FAIL;
  493.     }
  495.     *uid = generate_unique_id( uid_str, strlen( uid_str ) );
  497.     return EEP_OK;
  498. }
  500. int iobrick_uid_get( nasid_t nasid, uint64_t *uid )
  501. {
  502.     eeprom_brd_record_t eep;
  503.     eeprom_board_ia_t board;
  504.     eeprom_chassis_ia_t chassis;
  505.     int r;
  507.     eep.board_ia = &board;
  508.     eep.chassis_ia = &chassis;
  509.     eep.spd = NULL;
  511.     r = iobrick_eeprom_read( &eep, nasid, IO_BRICK );
  512.     if( r != EEP_OK ) {
  513.         *uid = rtc_time();
  514.         return r;
  515.     }
  517.     *uid = generate_unique_id( board.serial_num,
  518.                                board.serial_num_tl & FIELD_LENGTH_MASK );
  520.     return EEP_OK;
  521. }
  524. int ibrick_mac_addr_get( nasid_t nasid, char *eaddr )
  525. {
  526.     eeprom_brd_record_t eep;
  527.     eeprom_board_ia_t board;
  528.     eeprom_chassis_ia_t chassis;
  529.     int r;
  530.     char *tmp;
  532.     eep.board_ia = &board;
  533.     eep.chassis_ia = &chassis;
  534.     eep.spd = NULL;
  536.     r = iobrick_eeprom_read( &eep, nasid, IO_BRICK );
  537.     if( (r != EEP_OK) || (board.mac_addr[0] == '') ) {
  538. db_printf(( "ibrick_mac_addr_get: "
  539.     "Couldn't read MAC address from EEPROMn" ));
  540. return EEP_L1;
  541.     }
  542.     else {
  543. /* successfully read info area */
  544. int ix;
  545. tmp = board.mac_addr;
  546. for( ix = 0; ix < (board.mac_addr_tl & FIELD_LENGTH_MASK); ix++ )
  547. {
  548.     *eaddr++ = *tmp++;
  549. }
  550. *eaddr = '';
  551.     }
  553.     return EEP_OK;
  554. }
  557. /* 
  558.  * eeprom_vertex_info_set
  559.  *
  560.  * Given a vertex handle, a component designation, a starting nasid
  561.  * and (in the case of a router) a vector path to the component, this
  562.  * function will read the EEPROM and attach the resulting information
  563.  * to the vertex in the same string format as that provided by the
  564.  * Dallas Semiconductor NIC drivers.  If the vertex already has the
  565.  * string, this function just returns the string.
  566.  */
  568. extern char *nic_vertex_info_get( devfs_handle_t );
  569. extern void nic_vmc_check( devfs_handle_t, char * );
  570. /* the following were lifted from nic.c - change later? */
  571. #define MAX_INFO 2048
  572. #define NEWSZ(ptr,sz)   ((ptr) = kern_malloc((sz)))
  573. #define DEL(ptr) (kern_free((ptr)))
  575. char *eeprom_vertex_info_set( int component, int nasid, devfs_handle_t v,
  576.                               net_vec_t path )
  577. {
  578.         char *info_tmp;
  579.         int info_len;
  580.         char *info;
  582.         /* see if this vertex is already marked */
  583.         info_tmp = nic_vertex_info_get(v);
  584.         if (info_tmp) return info_tmp;
  586.         /* get a temporary place for the data */
  587.         NEWSZ(info_tmp, MAX_INFO);
  588.         if (!info_tmp) return NULL;
  590.         /* read the EEPROM */
  591. if( component & R_BRICK ) {
  592.     if( RBRICK_EEPROM_STR( info_tmp, nasid, path ) != EEP_OK )
  593. return NULL;
  594. }
  595. else {
  596.             if( eeprom_str( info_tmp, nasid, component ) != EEP_OK )
  597.         return NULL;
  598. }
  600.         /* allocate a smaller final place */
  601.         info_len = strlen(info_tmp)+1;
  602.         NEWSZ(info, info_len);
  603.         if (info) {
  604.                 strcpy(info, info_tmp);
  605.                 DEL(info_tmp);
  606.         } else {
  607.                 info = info_tmp;
  608.         }
  610.         /* add info to the vertex */
  611.         hwgraph_info_add_LBL(v, INFO_LBL_NIC,
  612.                              (arbitrary_info_t) info);
  614.         /* see if someone else got there first */
  615.         info_tmp = nic_vertex_info_get(v);
  616.         if (info != info_tmp) {
  617.             DEL(info);
  618.             return info_tmp;
  619.         }
  621.         /* export the data */
  622.         hwgraph_info_export_LBL(v, INFO_LBL_NIC, info_len);
  624.         /* trigger all matching callbacks */
  625.         nic_vmc_check(v, info);
  627.         return info;
  628. }
  631. /*********************************************************************
  632.  *
  633.  * stubs for use until the Bedrock/L1 link is available
  634.  *
  635.  */
  637. #include <asm/sn/nic.h>
  639. /* #define EEPROM_TEST */
  641. /* fake eeprom reading functions (replace when the BR/L1 communication
  642.  * channel is in working order)
  643.  */
  646. /* generate a charater in [0-9A-Z]; if an "extra" character is
  647.  * specified (such as '_'), include it as one of the possibilities.
  648.  */
  649. char random_eeprom_ch( char extra ) 
  650. {
  651.     char ch;
  652.     int modval = 36;
  653.     if( extra )
  654. modval++;
  655.     
  656.     ch = rtc_time() % modval;
  658.     if( ch < 10 )
  659.         ch += '0';
  660.     else if( ch >= 10 && ch < 36 )
  661. ch += ('A' - 10);
  662.     else
  663. ch = extra;
  665.     return ch;
  666. }
  668. /* create a part number of the form xxx-xxxx-xxx.
  669.  * It may be important later to generate different
  670.  * part numbers depending on the component we're
  671.  * supposed to be "reading" from, so the component
  672.  * paramter is provided.
  673.  */
  674. void fake_a_part_number( char *buf, int component )
  675. {
  676.     int i;
  677.     switch( component ) {
  679.     /* insert component-specific routines here */
  681.     case C_BRICK:
  682. strcpy( buf, "030-1266-001" );
  683. break;
  684.     default:
  685.         for( i = 0; i < 12; i++ ) {
  686.     if( i == 3 || i == 8 )
  687.         buf[i] = '-';
  688.     else
  689.         buf[i] = random_eeprom_ch(0);
  690.         }
  691.     }
  692. }
  695. /* create a six-character serial number */
  696. void fake_a_serial_number( char *buf, uint64_t ser )
  697. {
  698.     int i;
  699.     static const char hexchars[] = "0123456789ABCDEF";
  701.     if (ser) {
  702. for( i = 5; i >=0; i-- ) {
  703.     buf[i] = hexchars[ser & 0xf];
  704.     ser >>= 4;
  705. }
  706.     }
  707.     else {
  708. for( i = 0; i < 6; i++ )
  709.     buf[i] = random_eeprom_ch(0);
  710.     }
  711. }
  714. void fake_a_product_name( uchar_t *format, char* buf, int component )
  715. {
  716.     switch( component & BRICK_MASK ) {
  718.     case C_BRICK:
  719. if( component & SUBORD_MASK ) {
  720.     strcpy( buf, "C_BRICK_SUB" );
  721.     *format = 0xCB;
  722. }
  723. else {
  724.     strcpy( buf, "IP35" );
  725.     *format = 0xC4;
  726. }
  727. break;
  729.     case R_BRICK:
  730.         if( component & SUBORD_MASK ) {
  731.             strcpy( buf, "R_BRICK_SUB" );
  732.             *format = 0xCB;
  733.         }
  734.         else {
  735.             strcpy( buf, "R_BRICK" );
  736.             *format = 0xC7;
  737.         }
  738.         break;
  740.     case IO_BRICK:
  741.         if( component & SUBORD_MASK ) {
  742.             strcpy( buf, "IO_BRICK_SUB" );
  743.             *format = 0xCC;
  744.         }
  745.         else {
  746.             strcpy( buf, "IO_BRICK" );
  747.             *format = 0xC8;
  748.         }
  749.         break;
  751.     default:
  752. strcpy( buf, "UNK_DEVICE" );
  753. *format = 0xCA;
  754.     }
  755. }
  759. int fake_an_eeprom_record( eeprom_brd_record_t *buf, int component, 
  760.    uint64_t ser )
  761. {
  762.     eeprom_board_ia_t *board;
  763.     eeprom_chassis_ia_t *chassis;
  764.     int i, cs;
  766.     board = buf->board_ia;
  767.     chassis = buf->chassis_ia;
  769.     if( !(component & SUBORD_MASK) ) {
  770. if( !chassis )
  771.     return EEP_PARAM;
  772. chassis->format = 0;
  773. chassis->length = 5;
  774. chassis->type = 0x17;
  776. chassis->part_num_tl = 0xCC;
  777. fake_a_part_number( chassis->part_num, component );
  778. chassis->serial_num_tl = 0xC6;
  779. fake_a_serial_number( chassis->serial_num, ser );
  781. cs = chassis->format + chassis->length + chassis->type
  782.     + chassis->part_num_tl + chassis->serial_num_tl;
  783. for( i = 0; i < (chassis->part_num_tl & FIELD_LENGTH_MASK); i++ )
  784.     cs += chassis->part_num[i];
  785. for( i = 0; i < (chassis->serial_num_tl & FIELD_LENGTH_MASK); i++ )
  786.     cs += chassis->serial_num[i];
  787. chassis->checksum = 256 - (cs % 256);
  788.     }
  790.     if( !board )
  791. return EEP_PARAM;
  792.     board->format = 0;
  793.     board->length = 10;
  794.     board->language = 0;
  795.     board->mfg_date = 1789200; /* noon, 5/26/99 */
  796.     board->manuf_tl = 0xC3;
  797.     strcpy( board->manuf, "SGI" );
  799.     fake_a_product_name( &(board->product_tl), board->product, component );
  801.     board->serial_num_tl = 0xC6;
  802.     fake_a_serial_number( board->serial_num, ser );
  804.     board->part_num_tl = 0xCC;
  805.     fake_a_part_number( board->part_num, component );
  807.     board->board_rev_tl = 0xC2;
  808.     board->board_rev[0] = '0';
  809.     board->board_rev[1] = '1';
  811.     board->eeprom_size_tl = 0x01;
  812.     board->eeprom_size = 1;
  814.     board->temp_waiver_tl = 0xC2;
  815.     board->temp_waiver[0] = '0';
  816.     board->temp_waiver[1] = '1';
  818.     cs = board->format + board->length + board->language
  819. + (board->mfg_date & 0xFF)
  820. + (board->mfg_date & 0xFF00)
  821. + (board->mfg_date & 0xFF0000)
  822. + board->manuf_tl + board->product_tl + board->serial_num_tl
  823. + board->part_num_tl + board->board_rev_tl
  824. + board->board_rev[0] + board->board_rev[1]
  825. + board->eeprom_size_tl + board->eeprom_size + board->temp_waiver_tl
  826. + board->temp_waiver[0] + board->temp_waiver[1];
  827.     for( i = 0; i < (board->manuf_tl & FIELD_LENGTH_MASK); i++ )
  828. cs += board->manuf[i];
  829.     for( i = 0; i < (board->product_tl & FIELD_LENGTH_MASK); i++ )
  830. cs += board->product[i];
  831.     for( i = 0; i < (board->serial_num_tl & FIELD_LENGTH_MASK); i++ )
  832. cs += board->serial_num[i];
  833.     for( i = 0; i < (board->part_num_tl & FIELD_LENGTH_MASK); i++ )
  834. cs += board->part_num[i];
  835.     
  836.     board->checksum = 256 - (cs % 256);
  838.     return EEP_OK;
  839. }
  841. #define EEPROM_CHUNKSIZE 64
  843. #if defined(EEPROM_DEBUG)
  844. #define RETURN_ERROR
  845. {
  846.     printk( "read_ia error return, component 0x%x, line %d"
  847.     ", address 0x%x, ia code 0x%xn",
  848.     l1_compt, __LINE__, sc->subch[subch].target, ia_code );
  849.     return EEP_L1;
  850. }
  852. #else
  853. #define RETURN_ERROR return(EEP_L1)
  854. #endif
  856. int read_ia( l1sc_t *sc, int subch, int l1_compt, 
  857.      int ia_code, char *eep_record )
  858. {
  859.     char msg[BRL1_QSIZE];     /* message buffer */
  860.     int len;                  /* number of bytes used in message buffer */
  861.     int ia_len = EEPROM_CHUNKSIZE; /* remaining bytes in info area */
  862.     int offset = 0;                /* current offset into info area */
  864.     if ( IS_RUNNING_ON_SIMULATOR() )
  865. return EEP_L1;
  867.     BZERO( msg, BRL1_QSIZE );
  869.     /* retrieve EEPROM data in 64-byte chunks
  870.      */
  872.     while( ia_len )
  873.     {
  874. /* fill in msg with opcode & params */
  875. if( (len = sc_construct_msg( sc, subch, msg, BRL1_QSIZE,
  876.      L1_ADDR_TASK_GENERAL,
  877.      L1_REQ_EEPROM, 8,
  878.      L1_ARG_INT, l1_compt,
  879.      L1_ARG_INT, ia_code,
  880.      L1_ARG_INT, offset,
  881.      L1_ARG_INT, ia_len )) < 0 )
  882. {
  883.     RETURN_ERROR;
  884. }
  886. /* send the request to the L1 */
  888. if( sc_command( sc, subch, msg, msg, &len ) ) {
  889.     RETURN_ERROR;
  890. }
  892. /* check response */
  893. if( sc_interpret_resp( msg, 5, 
  894.        L1_ARG_INT, &ia_len,
  895.        L1_ARG_UNKNOWN, &len, eep_record ) < 0 )
  896. {
  897.     RETURN_ERROR;
  898. }
  900. if( ia_len > EEPROM_CHUNKSIZE )
  901.     ia_len = EEPROM_CHUNKSIZE;
  903. eep_record += EEPROM_CHUNKSIZE;
  904. offset += EEPROM_CHUNKSIZE;
  905.     }
  907.     return EEP_OK;
  908. }
  911. int read_spd( l1sc_t *sc, int subch, int l1_compt,
  912.       eeprom_spd_u *spd )
  913. {
  914.     char msg[BRL1_QSIZE];      /* message buffer */
  915.     int len;                   /* number of bytes used in message buffer */
  916.     int resp;                       /* l1 response code */
  917.     int spd_len = EEPROM_CHUNKSIZE; /* remaining bytes in spd record */
  918.     int offset = 0;     /* current offset into spd record */
  919.     char *spd_p = spd->bytes;     /* "thumb" for writing to spd */
  921.     if ( IS_RUNNING_ON_SIMULATOR() )
  922. return EEP_L1;
  924.     BZERO( msg, BRL1_QSIZE );
  926.     /* retrieve EEPROM data in 64-byte chunks
  927.      */
  929.     while( spd_len )
  930.     {
  931. /* fill in msg with opcode & params */
  932. if( (len = sc_construct_msg( sc, subch, msg, BRL1_QSIZE,
  933.      L1_ADDR_TASK_GENERAL,
  934.      L1_REQ_EEPROM, 8,
  935.      L1_ARG_INT, l1_compt,
  936.      L1_ARG_INT, L1_EEP_SPD,
  937.      L1_ARG_INT, offset,
  938.      L1_ARG_INT, spd_len )) < 0 )
  939. {
  940.     return( EEP_L1 );
  941. }
  943. /* send the request to the L1 */
  944. if( sc_command( sc, subch, msg, msg, &len ) ) {
  945.     return( EEP_L1 );
  946. }
  948. /* check response */
  949. if( (resp = sc_interpret_resp( msg, 5, 
  950.        L1_ARG_INT, &spd_len,
  951.        L1_ARG_UNKNOWN, &len, spd_p )) < 0 )
  952. {
  953.             /*
  954.              * translate l1 response code to eeprom.c error codes:
  955.              * The L1 response will be L1_RESP_NAVAIL if the spd
  956.              * can't be read (i.e. the spd isn't physically there). It will
  957.              * return L1_RESP_INVAL if the spd exists, but fails the checksum
  958.              * test because the eeprom wasn't programmed, programmed incorrectly,
  959.              * or corrupted. L1_RESP_NAVAIL indicates the eeprom is likely not present,
  960.              * whereas L1_RESP_INVAL indicates the eeprom is present, but the data is
  961.              * invalid.
  962.              */
  963.             if(resp == L1_RESP_INVAL) {
  964.                 resp = EEP_BAD_CHECKSUM;
  965.             } else {
  966.                 resp = EEP_L1;
  967.             }
  968.             return( resp );
  969. }
  971. if( spd_len > EEPROM_CHUNKSIZE )
  972.     spd_len = EEPROM_CHUNKSIZE;
  974. spd_p += EEPROM_CHUNKSIZE;
  975. offset += EEPROM_CHUNKSIZE;
  976.     }
  977.     return EEP_OK;
  978. }
  981. int read_chassis_ia( l1sc_t *sc, int subch, int l1_compt,
  982.      eeprom_chassis_ia_t *ia )
  983. {
  984.     char eep_record[512];          /* scratch area for building up info area */
  985.     char *eep_rec_p = eep_record;  /* thumb for moving through eep_record */
  986.     int checksum = 0;              /* use to verify eeprom record checksum */
  987.     int i;
  989.     /* Read in info area record from the L1.
  990.      */
  991.     if( read_ia( sc, subch, l1_compt, L1_EEP_CHASSIS, eep_record )
  992. != EEP_OK )
  993.     {
  994. return EEP_L1;
  995.     }
  997.     /* Now we've got the whole info area.  Transfer it to the data structure.
  998.      */
  1000.     eep_rec_p = eep_record;
  1001.     ia->format = *eep_rec_p++;
  1002.     ia->length = *eep_rec_p++;
  1003.     if( ia->length == 0 ) {
  1004. /* since we're using 8*ia->length-1 as an array index later, make
  1005.  * sure it's sane.
  1006.  */
  1007. db_printf(( "read_chassis_ia: eeprom length byte of ZEROn" ));
  1008. return EEP_L1;
  1009.     }
  1010.     ia->type = *eep_rec_p++;
  1011.    
  1012.     ia->part_num_tl = *eep_rec_p++;
  1014.     (void)BCOPY( eep_rec_p, ia->part_num, (ia->part_num_tl & FIELD_LENGTH_MASK) );
  1015.     eep_rec_p += (ia->part_num_tl & FIELD_LENGTH_MASK);
  1017.     ia->serial_num_tl = *eep_rec_p++;
  1019.     BCOPY( eep_rec_p, ia->serial_num, 
  1020.    (ia->serial_num_tl & FIELD_LENGTH_MASK) );
  1021.     eep_rec_p += (ia->serial_num_tl & FIELD_LENGTH_MASK);
  1023.     ia->checksum = eep_record[(8 * ia->length) - 1];
  1025.     /* verify checksum */
  1026.     eep_rec_p = eep_record;
  1027.     checksum = 0;
  1028.     for( i = 0; i < (8 * ia->length); i++ ) {
  1029. checksum += *eep_rec_p++;
  1030.     }
  1032.     if( (checksum & 0xff) != 0 )
  1033.     {
  1034. db_printf(( "read_chassis_ia: bad checksumn" ));
  1035. db_printf(( "read_chassis_ia: target 0x%x  uart 0x%lxn",
  1036.    sc->subch[subch].target, sc->uart ));
  1037. return EEP_BAD_CHECKSUM;
  1038.     }
  1040.     return EEP_OK;
  1041. }
  1044. int read_board_ia( l1sc_t *sc, int subch, int l1_compt,
  1045.    eeprom_board_ia_t *ia )
  1046. {
  1047.     char eep_record[512];          /* scratch area for building up info area */
  1048.     char *eep_rec_p = eep_record;  /* thumb for moving through eep_record */
  1049.     int checksum = 0;              /* running checksum total */
  1050.     int i;
  1052.     BZERO( ia, sizeof( eeprom_board_ia_t ) );
  1054.     /* Read in info area record from the L1.
  1055.      */
  1056.     if( read_ia( sc, subch, l1_compt, L1_EEP_BOARD, eep_record )
  1057. != EEP_OK )
  1058.     {
  1059. db_printf(( "read_board_ia: error reading info area from L1n" ));
  1060. return EEP_L1;
  1061.     }
  1063.      /* Now we've got the whole info area.  Transfer it to the data structure.
  1064.       */
  1066.     eep_rec_p = eep_record;
  1067.     ia->format = *eep_rec_p++;
  1068.     ia->length = *eep_rec_p++;
  1069.     if( ia->length == 0 ) {
  1070. /* since we're using 8*ia->length-1 as an array index later, make
  1071.  * sure it's sane.
  1072.  */
  1073. db_printf(( "read_board_ia: eeprom length byte of ZEROn" ));
  1074. return EEP_L1;
  1075.     }
  1076.     ia->language = *eep_rec_p++;
  1077.     
  1078.     ia->mfg_date = eeprom_xlate_board_mfr_date( (uchar_t *)eep_rec_p );
  1079.     eep_rec_p += 3;
  1081.     ia->manuf_tl = *eep_rec_p++;
  1082.     
  1083.     BCOPY( eep_rec_p, ia->manuf, (ia->manuf_tl & FIELD_LENGTH_MASK) );
  1084.     eep_rec_p += (ia->manuf_tl & FIELD_LENGTH_MASK);
  1086.     ia->product_tl = *eep_rec_p++;
  1087.     
  1088.     BCOPY( eep_rec_p, ia->product, (ia->product_tl & FIELD_LENGTH_MASK) );
  1089.     eep_rec_p += (ia->product_tl & FIELD_LENGTH_MASK);
  1091.     ia->serial_num_tl = *eep_rec_p++;
  1092.     
  1093.     BCOPY(eep_rec_p, ia->serial_num, (ia->serial_num_tl & FIELD_LENGTH_MASK));
  1094.     eep_rec_p += (ia->serial_num_tl & FIELD_LENGTH_MASK);
  1096.     ia->part_num_tl = *eep_rec_p++;
  1098.     BCOPY( eep_rec_p, ia->part_num, (ia->part_num_tl & FIELD_LENGTH_MASK) );
  1099.     eep_rec_p += (ia->part_num_tl & FIELD_LENGTH_MASK);
  1101.     eep_rec_p++; /* we do not use the FRU file id */
  1102.     
  1103.     ia->board_rev_tl = *eep_rec_p++;
  1104.     
  1105.     BCOPY( eep_rec_p, ia->board_rev, (ia->board_rev_tl & FIELD_LENGTH_MASK) );
  1106.     eep_rec_p += (ia->board_rev_tl & FIELD_LENGTH_MASK);
  1108.     ia->eeprom_size_tl = *eep_rec_p++;
  1109.     ia->eeprom_size = *eep_rec_p++;
  1111.     ia->temp_waiver_tl = *eep_rec_p++;
  1112.     
  1113.     BCOPY( eep_rec_p, ia->temp_waiver, 
  1114.    (ia->temp_waiver_tl & FIELD_LENGTH_MASK) );
  1115.     eep_rec_p += (ia->temp_waiver_tl & FIELD_LENGTH_MASK);
  1117.     /* if there's more, we must be reading a main board; get
  1118.      * additional fields
  1119.      */
  1120.     if( ((unsigned char)*eep_rec_p != (unsigned char)EEPROM_EOF) ) {
  1122. ia->ekey_G_tl = *eep_rec_p++;
  1123. BCOPY( eep_rec_p, (char *)&ia->ekey_G, 
  1124.        ia->ekey_G_tl & FIELD_LENGTH_MASK );
  1125. eep_rec_p += (ia->ekey_G_tl & FIELD_LENGTH_MASK);
  1127. ia->ekey_P_tl = *eep_rec_p++;
  1128. BCOPY( eep_rec_p, (char *)&ia->ekey_P, 
  1129.        ia->ekey_P_tl & FIELD_LENGTH_MASK );
  1130. eep_rec_p += (ia->ekey_P_tl & FIELD_LENGTH_MASK);
  1132. ia->ekey_Y_tl = *eep_rec_p++;
  1133. BCOPY( eep_rec_p, (char *)&ia->ekey_Y, 
  1134.        ia->ekey_Y_tl & FIELD_LENGTH_MASK );
  1135. eep_rec_p += (ia->ekey_Y_tl & FIELD_LENGTH_MASK);
  1137. /* 
  1138.  * need to get a couple more fields if this is an I brick 
  1139.  */
  1140. if( ((unsigned char)*eep_rec_p != (unsigned char)EEPROM_EOF) ) {
  1142.     ia->mac_addr_tl = *eep_rec_p++;
  1143.     BCOPY( eep_rec_p, ia->mac_addr, 
  1144.    ia->mac_addr_tl & FIELD_LENGTH_MASK );
  1145.     eep_rec_p += (ia->mac_addr_tl & FIELD_LENGTH_MASK);
  1146.     
  1147.     ia->ieee1394_cfg_tl = *eep_rec_p++;
  1148.     BCOPY( eep_rec_p, ia->ieee1394_cfg,
  1149.    ia->ieee1394_cfg_tl & FIELD_LENGTH_MASK );
  1150.     
  1151. }
  1152.     }
  1154.     ia->checksum = eep_record[(ia->length * 8) - 1];
  1156.     /* verify checksum */
  1157.     eep_rec_p = eep_record;
  1158.     checksum = 0;
  1159.     for( i = 0; i < (8 * ia->length); i++ ) {
  1160. checksum += *eep_rec_p++;
  1161.     }
  1163.     if( (checksum & 0xff) != 0 )
  1164.     {
  1165. db_printf(( "read_board_ia: bad checksumn" ));
  1166. db_printf(( "read_board_ia: target 0x%x  uart 0x%lxn",
  1167.     sc->subch[subch].target, sc->uart ));
  1168. return EEP_BAD_CHECKSUM;
  1169.     }
  1171.     return EEP_OK;
  1172. }
  1175. int _cbrick_eeprom_read( eeprom_brd_record_t *buf, l1sc_t *scp,
  1176.  int component )
  1177. {
  1178.     int r;
  1179.     uint64_t uid = 0;
  1180. #ifdef LOG_GETENV
  1181.     char uid_str[32];
  1182. #endif
  1183.     int l1_compt, subch;
  1185.     if ( IS_RUNNING_ON_SIMULATOR() )
  1186. return EEP_L1;
  1188.     /* make sure we're targeting a cbrick */
  1189.     if( !(component & C_BRICK) )
  1190. return EEP_PARAM;
  1192.     /* If the promlog variable pointed to by IP27LOG_OVNIC is set,
  1193.      * use that value for the cbrick UID rather than the EEPROM
  1194.      * serial number.
  1195.      */
  1196. #ifdef LOG_GETENV
  1197.     if( ip27log_getenv( scp->nasid, IP27LOG_OVNIC, uid_str, "0", 0 ) >= 0 )
  1198.     {
  1199. db_printf(( "_cbrick_eeprom_read: "
  1200.     "Overriding UID with environment variable %sn", 
  1201.     IP27LOG_OVNIC ));
  1202. uid = strtoull( uid_str, NULL, 0 );
  1203.     }
  1204. #endif
  1206.     if( (subch = sc_open( scp, L1_ADDR_LOCAL )) < 0 )
  1207. return EEP_L1;
  1209.     if((component & C_DIMM) == C_DIMM) {
  1210.         l1_compt = L1_EEP_DIMM(component & COMPT_MASK);
  1211.         r = read_spd(scp,subch,l1_compt, buf->spd);
  1212.         sc_close(scp,subch);
  1213.         return(r);
  1214.     }
  1216.     switch( component )
  1217.     {
  1218.       case C_BRICK:
  1219. /* c-brick motherboard */
  1220. l1_compt = L1_EEP_NODE;
  1221. r = read_chassis_ia( scp, subch, l1_compt, buf->chassis_ia );
  1222. if( r != EEP_OK ) {
  1223.     sc_close( scp, subch );
  1224.     db_printf(( "_cbrick_eeprom_read: using a fake eeprom recordn" ));
  1225.     return fake_an_eeprom_record( buf, component, uid );
  1226. }
  1227. if( uid ) {
  1228.     /* If IP27LOG_OVNIC is set, we want to put that value
  1229.      * in as our UID. */
  1230.     fake_a_serial_number( buf->chassis_ia->serial_num, uid );
  1231.     buf->chassis_ia->serial_num_tl = 6;
  1232. }
  1233. break;
  1235.       case C_PIMM:
  1236. /* one of the PIMM boards */
  1237. l1_compt = L1_EEP_PIMM( component & COMPT_MASK );
  1238. break;
  1240.       default:
  1241. /* unsupported board type */
  1242. sc_close( scp, subch );
  1243. return EEP_PARAM;
  1244.     }
  1245.       
  1246.     r = read_board_ia( scp, subch, l1_compt, buf->board_ia );
  1247.     sc_close( scp, subch );
  1248.     if( r != EEP_OK ) 
  1249.     {
  1250. db_printf(( "_cbrick_eeprom_read: using a fake eeprom recordn" ));
  1251. return fake_an_eeprom_record( buf, component, uid );
  1252.     }
  1253.     return EEP_OK;
  1254. }
  1257. int cbrick_eeprom_read( eeprom_brd_record_t *buf, nasid_t nasid,
  1258.              int component )
  1259. {
  1260.     l1sc_t *scp;
  1261.     int local = (nasid == get_nasid());
  1263.     if ( IS_RUNNING_ON_SIMULATOR() )
  1264. return EEP_L1;
  1266.     /* If this brick is retrieving its own uid, use the local l1sc_t to
  1267.      * arbitrate access to the l1; otherwise, set up a new one (prom) or
  1268.      * use an existing remote l1sc_t (kernel)
  1269.      */
  1270.     if( local ) {
  1271. scp = get_l1sc();
  1272.     }
  1273.     else {
  1274. scp = &NODEPDA( NASID_TO_COMPACT_NODEID(nasid) )->module->elsc;
  1275.     }
  1277.     return _cbrick_eeprom_read( buf, scp, component );
  1278. }
  1281. int iobrick_eeprom_read( eeprom_brd_record_t *buf, nasid_t nasid,
  1282.  int component )
  1283. {
  1284.     int r;
  1285.     int l1_compt, subch;
  1286.     l1sc_t *scp;
  1287.     int local = (nasid == get_nasid());
  1289.     if ( IS_RUNNING_ON_SIMULATOR() )
  1290. return EEP_L1;
  1292.     /* make sure we're talking to an applicable brick */
  1293.     if( !(component & IO_BRICK) ) {
  1294. return EEP_PARAM;
  1295.     }
  1297.     /* If we're talking to this c-brick's attached io brick, use
  1298.      * the local l1sc_t; otherwise, set up a new one (prom) or
  1299.      * use an existing remote l1sc_t (kernel)
  1300.      */
  1301.     if( local ) {
  1302. scp = get_l1sc();
  1303.     }
  1304.     else {
  1305. scp = &NODEPDA( NASID_TO_COMPACT_NODEID(nasid) )->module->elsc;
  1306.     }
  1308.     if( (subch = sc_open( scp, L1_ADDR_LOCALIO )) < 0 )
  1309. return EEP_L1;
  1312.     switch( component )
  1313.     {
  1314.       case IO_BRICK:
  1315. /* IO brick motherboard */
  1316. l1_compt = L1_EEP_LOGIC;
  1317. r = read_chassis_ia( scp, subch, l1_compt, buf->chassis_ia );
  1319. if( r != EEP_OK ) {
  1320.     sc_close( scp, subch );
  1321. /*
  1322.  * Whenever we no longer need to test on hardware
  1323.  * that does not have EEPROMS, then this can be removed.
  1324.  */
  1325.     r = fake_an_eeprom_record( buf, component, rtc_time() );
  1326.     return r;
  1327. }
  1328. break;
  1330.       case IO_POWER:
  1331. /* IO brick power board */
  1332. l1_compt = L1_EEP_POWER;
  1333. break;
  1335.       default:
  1336. /* unsupported board type */
  1337. sc_close( scp, subch );
  1338. return EEP_PARAM;
  1339.     }
  1341.     r = read_board_ia( scp, subch, l1_compt, buf->board_ia );
  1342.     sc_close( scp, subch );
  1343.     if( r != EEP_OK ) {
  1344. return r;
  1345.     }
  1346.     return EEP_OK;
  1347. }
  1350. int vector_eeprom_read( eeprom_brd_record_t *buf, nasid_t nasid,
  1351. net_vec_t path, int component )
  1352. {
  1353.     int r;
  1354.     uint64_t uid = 0;
  1355.     int l1_compt, subch;
  1356.     l1sc_t sc;
  1358.     if ( IS_RUNNING_ON_SIMULATOR() )
  1359. return EEP_L1;
  1361.     /* make sure we're targeting an applicable brick */
  1362.     if( !(component & VECTOR) )
  1363. return EEP_PARAM;
  1365.     switch( component & BRICK_MASK )
  1366.     {
  1367.       case R_BRICK:
  1368. ROUTER_LOCK( path );
  1369. sc_init( &sc, nasid, path );
  1371. if( (subch = sc_open( &sc, L1_ADDR_LOCAL )) < 0 )
  1372. {
  1373.     db_printf(( "vector_eeprom_read: couldn't open subchn" ));
  1374.     ROUTER_UNLOCK(path);
  1375.     return EEP_L1;
  1376. }
  1377. switch( component )
  1378. {
  1379.   case R_BRICK:
  1380.     /* r-brick motherboard */
  1381.     l1_compt = L1_EEP_LOGIC;
  1382.          r = read_chassis_ia( &sc, subch, l1_compt, buf->chassis_ia );
  1383.     if( r != EEP_OK ) {
  1384. sc_close( &sc, subch );
  1385. ROUTER_UNLOCK( path );
  1386. printk( "vector_eeprom_read: couldn't get rbrick eeprom info;"
  1387. " using current time as uidn" );
  1388. uid = rtc_time();
  1389. db_printf(("vector_eeprom_read: using a fake eeprom recordn"));
  1390. return fake_an_eeprom_record( buf, component, uid );
  1391.     }
  1392.     break;
  1394.   case R_POWER:
  1395.     /* r-brick power board */
  1396.     l1_compt = L1_EEP_POWER;
  1397.     break;
  1399.   default:
  1400.     /* unsupported board type */
  1401.     sc_close( &sc, subch );
  1402.     ROUTER_UNLOCK( path );
  1403.     return EEP_PARAM;
  1404. }
  1405. r = read_board_ia( &sc, subch, l1_compt, buf->board_ia );
  1406. sc_close( &sc, subch );
  1407. ROUTER_UNLOCK( path );
  1408. if( r != EEP_OK ) {
  1409.     db_printf(( "vector_eeprom_read: using a fake eeprom recordn" ));
  1410.     return fake_an_eeprom_record( buf, component, uid );
  1411. }
  1412. return EEP_OK;
  1414.       case C_BRICK:
  1415. sc_init( &sc, nasid, path );
  1416. return _cbrick_eeprom_read( buf, &sc, component );
  1418.       default:
  1419. /* unsupported brick type */
  1420. return EEP_PARAM;
  1421.     }
  1422. }