cfg_tree.h

Go to the documentation of this file.

/*** MODULE CFG_TREE ***/
/******************************************************************************/
/******************************************************************************/
/*
* Author: Fred Kleinsorge (GCT_TREE)
* Conversion to CFG_TREE: Burns Fisher
*
*   Modified by:
*
*       X-2     WBF         Burns Fisher                    27-Jul-1999
*               Change include cfgdef to <> rather than ""
*
*       X-1     WBF         Burns Fisher                    23-Jul-1999
*               Initial checkin
*/
#ifndef _CFG_TREE_H_
#define _CFG_TREE_H_

#include <cfgdef.h>

/*
 *  This is the internal max fragments supported
 */
#define MAX_FRAGMENTS 64

typedef struct _cfg_mem_frag_defs {
  uint64        type;
  uint64        id;
  uint64        flags;
  uint64        pa;
  uint64        size;
} CFG_MEM_FRAG_DEFS;

/*
 *   DEBUG flags
 */
#define CFG__DEBUG_ALLOCATE_NODE                0x001
#define CFG__DEBUG_INIT                         0x002
#define CFG__DEBUG_LOOKUP_NODE                  0x004
#define CFG__DEBUG_CREATE_GALAXY                0x008
#define CFG__DEBUG_ASSIGN_HW_COMMUNITY          0x010
#define CFG__DEBUG_ASSIGN_HW_PARTITION          0x020
#define CFG__DEBUG_INSERT_NODE                  0x040
#define CFG__DEBUG_CREATE_PARTITION_ID          0x080
#define CFG__DEBUG_CREATE_COMMUNITY_ID          0x100
#define CFG__DEBUG_BIND_NODE                    0x200
#define CFG__DEBUG_INIT_FRAGS                   0x400
#define CFG__DEBUG_DEASSIGN_HW                  0x800
#define CFG__DEBUG_ASSIGN_MEM_FRAG              0x1000
#define CFG__DEBUG_DEASSIGN_MEM_FRAG            0x2000
#define CFG__DEBUG_GET_MAX_PARTITIONS           0x4000
#define CFG__DEBUG_VALIDATE_PARTITIONS          0x8000

#ifndef CFG__DEBUG_FLAGS
#define CFG__DEBUG_FLAGS 0
#endif

#ifdef VMS$GLX
#define CFG_POINTER_TO_ROOT glx$gpq_config_tree
#pragma __required_pointer_size save
#pragma __required_pointer_size long
extern CFG_NODE *glx$gpq_config_tree;
#define CFG__EXTERNAL_ROOT
#pragma __required_pointer_size restore
#endif

/*
 *   Extern data
 */
#ifndef CFG_POINTER_TO_ROOT
#define CFG_POINTER_TO_ROOT cfg_root
extern CFG_NODE *cfg_root;
#endif

#ifdef CFG__DEBUG
extern int32 cfg_debug;
#endif

/*
 *  Node creation routines
 */
CFG_HANDLE cfg__alloc_node(char nodeType, char nodeSubType, uint64 flags, int32 extra_size, void *type_specific);
#ifdef V5_MEMORY
CFG_HANDLE cfg__create_mem_desc(char nodeType, char nodeSubType, uint64 flags, int32 extra_size, void *type_specific);
#endif
CFG_HANDLE cfg__create_mem_sub(char nodeType, char nodeSubType, uint64 flags, int32 extra_size, void *type_specific);

/*
 *  Node deletion routines
 */
void       cfg__delete_node(CFG_HANDLE node);

/*
 *  Node initialization routines
 */
#ifdef V5_MEMORY
int32      cfg__mem_frag_init(CFG_HANDLE node, CFG_HANDLE community, CFG_HANDLE partition, void *type_specific);
#endif
int32      cfg__partition_init(CFG_HANDLE node, CFG_HANDLE community, CFG_HANDLE partition, void *type_specific);
int32      cfg__cpu_init(CFG_HANDLE node, CFG_HANDLE community, CFG_HANDLE partition, void *type_specific);

extern void       cfg__insert_node(CFG_HANDLE current, CFG_HANDLE newNode, int ins_type);

typedef struct _cfg_node_info {
  int32         size;
  CFG_HANDLE    (*create_node)(char nodeType, char nodeSubType, uint64 flags, int32 extra_size, void *type_specific);
  void          (*delete_node)(CFG_HANDLE handle);
  int32         (*galaxy_init)(CFG_HANDLE node, CFG_HANDLE community, CFG_HANDLE partition, void *type_specific);
} CFG_NODE_INFO;

/*
 *  This array is used to create, init, and delete nodes, it is indexed by
 *  the node type.  The first entry is the base size of the node.  The next
 *  is the routine used to create the node.  Then the routine to delete the
 *  node, and finally a Galaxy initialization routine.
 *
 *  The normal node creation is cfg__alloc_node, but if there is special
 *  processing - like some initialization data from the HW definition, or
 *  the size needs to be dynamically set - then a private creation routine
 *  can be implemented (they will typically call cfg__alloc_node to do the
 *  actual creation).  Deletion is the same.  If special things need to be
 *  done as part of the deletion, this is where to hook it.
 *
 *  The galaxy initialization routine is a type specific initialization that
 *  will be done when the galaxy software configuration is completed.
 *
 */
static CFG_NODE_INFO cfg_node_info[CFG$K_NODE_LAST+1] = {
  {0,                              0,               0,                 0},      /* N/A  */
  {sizeof(CFG_ROOT_NODE),          0,               0,                 0},      /* Galaxy Root  */
  {sizeof(CFG_HW_ROOT_NODE),       cfg__alloc_node, cfg__delete_node,  0},      /* Hardware Root  */
  {sizeof(CFG_SW_ROOT_NODE),       cfg__alloc_node, cfg__delete_node,  0},      /* Software Root  */
  {sizeof(CFG_TEMPLATE_ROOT_NODE), cfg__alloc_node, cfg__delete_node,  0},      /* Temlplate Root  */
  {sizeof(CFG_COMMUNITY_NODE),     cfg__alloc_node, cfg__delete_node,  0},      /* Community  */
  {sizeof(CFG_PARTITION_NODE),     cfg__alloc_node, cfg__delete_node,  cfg__partition_init}, /* Partition  */
  {sizeof(CFG_SBB_NODE),           cfg__alloc_node, cfg__delete_node,  0},      /* System Building Block  */
  {sizeof(CFG_PSEUDO_NODE),        cfg__alloc_node, cfg__delete_node,  0},      /* Pseudo  */
  {sizeof(CFG_CPU_NODE),           cfg__alloc_node, cfg__delete_node,  cfg__cpu_init}, /* CPU  */
  {sizeof(CFG_MEMORY_SUB_NODE),    cfg__create_mem_sub, cfg__delete_node, 0},   /* Memory Subsystem  */
#ifdef V5_MEMORY
  {sizeof(CFG_MEM_DESC_NODE),      cfg__create_mem_desc,cfg__delete_node, cfg__mem_frag_init}, /* Memory Description  */
#else
  {0,                              0,               0,                 0},      /* N/A  */
#endif
  {sizeof(CFG_MEMORY_CTRL_NODE),   cfg__alloc_node, cfg__delete_node,  0},      /* Memory Control  */
  {sizeof(CFG_IOP_NODE),           cfg__alloc_node, cfg__delete_node,  0},      /* IO Processor  */
  {sizeof(CFG_HOSE_NODE),          cfg__alloc_node, cfg__delete_node,  0},      /* Hose  */
  {sizeof(CFG_BUS_NODE),           cfg__alloc_node, cfg__delete_node,  0},      /* Bus  */
  {sizeof(CFG_IO_CTRL_NODE),       cfg__alloc_node, cfg__delete_node,  0},      /* IO Controller  */
  {sizeof(CFG_SLOT_NODE),          cfg__alloc_node, cfg__delete_node,  0},      /* Slot  */
  {sizeof(CFG_CPU_MODULE_NODE),    cfg__alloc_node, cfg__delete_node,  0},      /* CPU Module Card  */
  {0,                              cfg__alloc_node, cfg__delete_node,  0},      /* NODE_LAST  */
};

/*
 *   The actual config buffer has a two quadword header.  The first quadword
 *   is the total size in bytes of the buffer, and the second is architected
 *   as the checksum.
 */
#define CFG__BUFFER_HEADER_SIZE 64

/*
 *   The node insertion can be sibling (next) or child
 */
#define CFG__INSERT_NEXT_SIBLING    1
#define CFG__INSERT_CHILD           2
#define CFG__INSERT_CHILD_LAST_SIB  3
#define CFG__INSERT_LAST_SIBLING    4

#endif  /* _CFG_TREE_H_ */

Project space on SourceForge.net