Subversion Repositories Vertical

/*

 * $Header: C:/cvsroot/Vert03/vertlib/database.h,v 1.2 2004/06/22 21:44:14 mjames Exp $

 *

 * $Log: database.h,v $

 * Revision 1.2  2004/06/22 21:44:14  mjames

 * Firrst build most files

 *

 * Revision 1.1.1.1  2003/11/04 23:34:56  mjames

 * Imported into local repositrory

 *

 * Revision 1.14  2003/01/02 21:37:15  mjames

 * Experiment on creating NOT_ROUTABLE_H and NOT_ROUTABLE_L

 * properties on the nets so that pin jumpers can be made without a problem.

 *

 * Still need to sort out pin assignments made to these not_routable nets

 * which will become legal in some cases so that pullups and pulldown

 * pins can be used on the FPGA.

 *

 * Revision 1.13  2002/09/30 13:26:01  MJAMES

 * Upgraded nets to include 'lhs_expression' being the range on the

 * left hand side of a signal connection to a port

 *

 * std_logic_vector (0) <= std_logic , on a port of a chip

 *

 * Revision 1.12  2002/09/09 10:14:14  mjames

 * Moved pin remapping function to pin ident editing function from

 * sorting pin name routine.

 *

 * Revision 1.11  2002/08/06 12:52:49  mjames

 * Merge in from latest version

 *

 * Revision 1.11  2002/03/21 17:12:58  mjames

 * Added search path to vertical file opening for read

 *

 * Revision 1.10  2002/01/16 11:22:42  mjames

 * database.h header file is read in first as it undefined DLL stuff irrelevant

 * to HPUX

 *

 * Revision 1.9  2001/12/20 13:53:09  mjames

 * Added a bundle width field to the chip declaration

 *

 * Revision 1.8  2001/10/31 22:20:02  mjames

 * Tidying up problematical comments caused by CVS

 * 'intelligent' comment guessing

 *

 * Revision 1.7  2001/10/23 21:12:43  mjames

 * Created preliminary 'disconnect_node' function

 *

 * Revision 1.6  2001/09/16 20:36:03  mjames

 * Second attempt to modify wire bundles to be connector rather than net

 * centric. Allows more than one connector to carry the same net,

 *

 * Revision 1.5  2001/09/16 19:49:54  mjames

 * Second attempt at bundling the pins on sockets

 *

 * Revision 1.4  2001/09/13 21:08:21  mjames

 * Added simple wire bundling data structures.

 *

 * Revision 1.3  2001/06/06 12:10:24  mjames

 * Move from HPUX

 *

 * Revision 1.2  2000/10/19 22:06:36  mjames

 * Removed spurious RCS log lines from new CVS stuff

 *

 * Revision 1.1.1.1  2000/10/19 21:58:35  mjames

 * Mike put it here

 *

 *

 *

 */

 #pragma once

#include "expression.h"

#include "generic.h"

#if !defined _DATABASE

#define _DATABASE

#define MAXIDLEN 1024

#define BUFPREFIX "XX_"

#if defined PC

#define VERTICAL_INI_PATH "vertical.ini"

#define VERTICAL_PATH ".;c:/cygwin/usr/local/vert_files"

#else

#define VERTICAL_INI_PATH "vertical.ini"

#define VERTICAL_PATH ".;$(HOME)/.caddata/vert_files"

/* DLL creation declaration mode. not used on HP */

#if !defined __declspec

#define __declspec(x)

#endif

#endif

/* incomplete declarations to placate 'c' */

struct connector;

struct net;

struct netref;

struct equivalent_node_set;

/* the direction list */

typedef enum

{

        NONE,

        INPUT,

        OUTPUT,

        BUFFER,

        BIDIR,

        CONFIG,

        POWER

} pindir_t;

#define Create 0

#define Search 1

#define ISNULLSTR(x) ((x == NULL) || (x && (x[0] == 0)))

/* operations to manipulate the data structure */

/* from the ACF reader */

/* typedef enum { Ident,Type,Name,Value,Datatype,How_Routed } property_t; */

typedef enum

{

        Ident,

        Type,

        Name,

        Value,

        How_Routed

} property_t;

/* used in seting the routing_status attribute of a net */

typedef enum

{

        Free,           /* name given may be reassigned */

        By_Name,        /* Routed by Name */

        By_Net,         /* Routed by already existing net */

        By_Fixed_Net,   /* Routed through fixed existing net */

        By_Exact_Net,   /* Routed using identical already existing net */

        By_Creating,    /* Routed by creating a new net */

        By_Jumpering,   /* Routed by connecting an existing net */

        By_FixPins,     /* can only go here as pins are fixed */

        Not_Routable,   /* not allowed to participate in any routing */

        Not_Routable_H, /* pullup/VCC */

        Not_Routable_L  /* pulldown/GND */

} HowRouted_t;

/* these macros are reliant on sorted ordinal values */

#define IS_NOT_ROUTABLE(x) ((x) >= Not_Routable)

#define IS_ROUTABLE(x) ((x) < Not_Routable)

/* a type to hold a VHDL data type */

typedef struct vhdl

{

        char *basetype;

        expression_t *decl_expr; /* the range given in its declaration */

        expression_t *expr;         /* the expression that is used to */

                                    /* define the values of high/low etc */

        expression_t *default_expr; /* default value assigned in declaration */

        /*  char * text; */         /* this is the original declaration */

                                    /*  int low;

                                      int high; */

        unsigned int valid : 1;     /* is the expression valid ? */

        unsigned int is_vector : 1; /* is this port a vector */

        unsigned int is_downto : 1; /* is the vector X TO Y or X DOWNTO Y  */

} vhdl_t;

/* object node : point in a circuit connected a socket and a net */

typedef struct node

{

        struct node *sktnext; /* linked to a socket */

        char *identifier;     /* e.g 102, A22 */

        char *name;           /* internal signal name (actually same as netname )  */

        vhdl_t *vhdltype;       /* the subset of the net that the node is connected to */

        vhdl_t *orig_vhdltype;  /* how this node was originally declared */

        expression_t *lhs_expr; /* if the net is sliced on socket pin assignment LHS */

        pindir_t pindir;        /* final pin type input? output? bidir? unknown? */

        int pin_group;          /* can say 'any pin in group(n) only  is interchangeable' */

        struct net *net;        /* refer to net this node is on (if known) */

        struct net *routed_net; /* which routed net connects to this node */

        int refcount;          /* how many nets refer to this node */

        struct socket *socket; /* refer to socket this node is part of */

        struct equivalent_node_set *equivalent_nodes; /* member of set of equivalent nodes */

        /* sorting data structure */

        char *id_numeric_chars; /* the numeric part of the identifier */

        int id_numeric_cnt; /* the number of numeric chars in this part of the identifier */

        char *id_alpha_chars; /* the alphabetic part of the identifier */

        int id_alpha_cnt;     /* the number of alpha chars in this part of the ident */

        int pin_row;

        int pin_col;

        int pin_index;    /*  the ordinal pin number : which would be used in a bundle */

        int bundle_index; /* if >=0 then this pin is in a bundle */

        unsigned int fixed_pin : 1;     /* if fixed_pin = 1 then this pin can only be used

                                           to connect to the net in a particular

                                           direction */

        unsigned int in_use : 1;        /* if '1' the node is used by a pin

                                           if '0' the node has had a dummy name assigned*/

        unsigned int template_flag : 1; /* used in template processing */

        unsigned int net_assigned : 1;  /* if '1' the node (name) has a net assigned

                                           to it by routing */

        unsigned int fix_location : 1;  /* if set then nets referring to this pin

                                           have to be connected to it and nowhere else */

        unsigned int reservation : 1;   /* mark this as a reserved pin when it is given rsvXXXX

                                           ident */

} node_t;

/* different nets may refer to the same nodes

   but dependent on whether net is desired or already routed, different rules

   apply */

typedef struct noderef

{

        struct noderef *next;

        pindir_t pindir; /* proposed pin type input ? output ? bidir ? unknown ? */

        node_t *node;

        struct net *join_parent; /* Which net this node reference is joined to (used in

                                    alias/jumpering */

        struct net *net;

        /* the net that owns this node reference */

        unsigned int r_flag : 1; /* a routing flag to indicate this node has been

                                    found already at this phase of routing  */

        /*  char * datatype; */  /* pointer to the data type of this node */

        vhdl_t *vhdltype;       /* what this now has been aliased to in VHDL */

        vhdl_t *orig_vhdltype;  /* what this now has been aliased to in VHDL */

        expression_t *lhs_expr; /* the expression will be copied over when routing . Bus slice

                                   on LHS of pin assignment */

        char *orig_name; /* if this pointer is not null then the name of this reference will be

                          used in place of the net name when listing the nets  */

        struct noderef *base_noderef; /* used in jumpering to define original node reference

                                         that will be renamed: in the original node reference

                                         this pointer is to itself */

} noderef_t;

/* the aliased net join means that each sub_net keeps its own

   signal name while its identiier is common. The Jumpered

   net join means that the new signal is to be treated

   as a new net entity */

typedef enum

{

        NotJoined = 0,

        Aliased,  /* names are aliased onto same physical piece of wire */

        Jumpered, /* separate wires can be joined together */

} JoinMode_t;

/* object net : a piece of wire connected to a set of nodes */

typedef struct net

{

        struct net *next;

        struct net *prev;                  /* demand that previous net be referred to */

        struct net **list_ref;             /* the membership of which list:

                                              routed_list unrouted_list named_list*/

        char *identifier;                  /* e.g N1, N2 */

        char *name;                        /* signal names */

        HowRouted_t how_routed;            /* in fact this indicates how it was routed */

        int nodecount;                     /* how many nodes does this net have ? */

        noderef_t *nodes;                  /* and all the other nodes on this net */

        struct net *join_parent;           /* Which net this net is joined to (used in

                                              alias/jumpering */

        struct net *subnets;               /* if this net has subnets , refer to them */

        struct net *joined_nets;           /* other nets at this level of join */

        struct net *unrouted_fix_net;      /* is there an unrouted net fixed to this one ? */

        struct net *vhdl_connect_net;      /* pointer to a net connected by VHDL connection */

        JoinMode_t how_joined;             /* if subnets, is this an alias join or a

                                              jumpered join */

        struct net *unrouted_reference;    /* points at the net that is the unrouted

                                              original , if this is a routed net. */

        node_t *external_node;             /* if not null and there is a jumper then print

                                              the external node name rather than the net name*/

        unsigned int nodes_reserved : 1;   /* This net has been processed by the

                                              ensure_reservation function in routing.c */

        unsigned int has_external : 1;     /* one of the net nodes (at least)

                                              is an external connection */

        unsigned int has_fix_location : 1; /* one of the net nodes (at least)

                                              is a FIX_LOCATION pin */

                                           /* expanded information for partitioning */

        unsigned int leaves_partition : 1; /* '1' : crosses boundary of partition*/

        unsigned int inside_partition : 1; /* '1' : in use as internal signal

                                              in partition */

        unsigned int needs_buff_sig : 1;   /* if '1' then the external connection needs a local

                                              signal */

        unsigned int force_port : 1;   /* if '1' then the net will be forced to be a port on

                                          partition  */

        unsigned int type_defined : 1; /* the signal type has been defined so does not need to

                                          be patched up by guesswork in the partition

                                          calculation Oct 2000*/

        /* bundle structures : cause signal renaming when sockets

           are converted to a wire bundle leaving the

           partition */

        unsigned int bundle_member; /* set if the net is a bundle member */

        int bundle_index;           /* the ordinal number of the pin of the bundle */

        pindir_t ext_dir;          /* basic boundary crossing direction*/

        /*  char *   datatype;  */ /* the string description of the data type */

        vhdl_t *vhdltype;          /* what this looks like in VHDL */

} net_t;

/* net reference list, attched to a node */

typedef struct netref

{

        struct netref *next;

        net_t *net;

} netref_t;

/* unrouted node reference, which permits node by node pin  renaming */

typedef struct unrouted_ref

{

        struct unrouted_ref *next;

        net_t **listref;  /* the root pointer of which list this unrouted reference has been

                             added to */

        char *identifier; /* used to point to the pin identifier before creating unrouted net

                           */

        char *name;       /* this is the name by which this pin shall be known */

        char *orig_name; /* if this pointer is not null then the name of this reference will be

                            used in place of the net name when creating the nets !! */

        pindir_t pindir; /* proposed pin type input ? output ? bidir ? unknown ? */

        int pin_group;

        vhdl_t *vhdltype;       /* what this looks like in VHDL */

        vhdl_t *orig_vhdltype;  /* place holder for the signal type as originally declared */

        expression_t *lhs_expr; /* expression is sliced on the LHS */

} unrouted_ref_t;

/* member of list of pins  that carry the same signal on a device */

typedef struct equivalent_node

{

        struct equivalent_node *next;

        node_t *node;

} equivalent_node_t;

/* pointer to list of lists of pins  that carry the same signal on a device */

typedef struct equivalent_node_set

{

        struct equivalent_node_set *next;

        equivalent_node_t *nodes;

} equivalent_node_set_t;

/* a chip socket is a socket, as are all the board connectors */

/* A lastnode pointer is provided so that new nodes can be added to the     */

/* end rather than the beginning of the list */

/* reason: so that priority of assigning nodes is kept */

/* this will be altered by the sorting of the nodes by identifier */

typedef struct socket

{

        struct socket *next;

        struct socket *template_socket; /* the VHDL component for this entity if present */

        char *identifier;               /* e.g U1, U2 */

        char *type;

        char *name;

        char *value;

        node_t *nodes; /* the nodes attached to this chip */

        node_t *lastnode;

        unrouted_ref_t *unrouted_refs; /* when an unrouted node is read in the node is added

                                          here */

        generic_info_t *generics;      /* look in generic.c for more info */

        generic_info_t *unrouted_generics;          /* before elaboration */

        equivalent_node_set_t *equivalent_node_set; /* these pins carry equivalent signals

                                         FPGA context : represent inner through signals

                                         component context : represent external jumpers

                                         around pins of component. */

        int max_pin_col; /* determine pin identifier limits for later (see sorting.c, */

        int min_pin_col; /* sorting device pin IDs for more info.)                    */

        int max_pin_row;

        int min_pin_row;

        unsigned int is_FPGA : 1; /*  alters interpretation of equivalent nodes */

        unsigned int selected : 1;    /* a '1' here is used in the VHDL printout */

        unsigned int is_external : 1; /* a '1' here changes the rules about external ports*/

                                      /* If it is external then all nets attached give their

                                         names to the pins of the socket rather than calling

                                         them 'rsvXXXXXz' */

        unsigned int is_template : 1; /*   this chip is a template if it is '1' */

        unsigned int socket_type_seen : 1;  /* used in verilog printout to force

                                             * printout of only one instance

                                             * of a particular type */

        struct socket *parent_template_ref; /*   this chip is an alias template if this pointer

                                               is non-null  */

        int route_flags;      /* any device can have its fasttrack flags set independently */

        int named_in_use_cnt; /* counters used by the statistics module */

        int named_cnt;

        int routed_cnt;

        int unrouted_cnt;

        int lowest_bundle; /* base for bundle indices */

        int highest_bundle; /* non-zero will create an external net declaration using a bus

                               with highest_bundle -1 pins on it in the top level of a

                               partition */

        int bundle_width;   /* number of valid pins in the bundle */

} socket_t;

/* case insensitive strcmp */

extern int strcmp2 (char *s, char *t);

/* this is equvalent to 'strdup' but checks null pointer */

/* extern char *  allocstr(char * s); */

#define allocstr(s) ((s) == NULL ? NULL : strdup (s))

extern vhdl_t *get_vhdl_buswidth (noderef_t *ref);

extern void define_pin (

    net_t **listref,

    socket_t *chip,

    char *name,

    int pin_type,

    int pin_group,

    char *identifier,

    vhdl_t *vhdl,

    expression_t *lhs_expr);

/* this is a check on a socket ident : if it doesnt have one */

extern void ensure_socket_ident (socket_t *chip);

/* a string that is suffixed to names and identifiers

   when read in from the database */

extern void set_board_suffix (char *s);

/* set the socket type for further information */

extern void set_socket (socket_t *socket, property_t prop, char *str);

/* Tell the system about a new socket */

/* locate a socket by a property */

extern socket_t *find_socket (property_t prop, char *str, int srchonly, socket_t **head_ref);

extern void set_net (net_t *net, property_t prop, char *str);

extern net_t *find_net (net_t **listref, property_t prop, char *str, int srchonly);

/* set a node property */

extern void set_node (node_t *node, property_t prop, char *str);

/* locate a node on a chip by a property */

extern node_t *find_node (socket_t *socket, property_t prop, char *str, int srchonly);

/* joins a node to a net */

extern void connect_node_net (

    char *orig_name, /* added to allow name aliasing (this will be the OLD name ) */

    node_t *cnode,

    net_t *cnet,

    pindir_t pindir,

    vhdl_t *vhdl,

    vhdl_t *orig_vhdl,

    expression_t *lhs_expr);

/* remove net name attributes from the routed list */

extern void del_net_names (char *template);

/* disconnect a node from the netlist */

extern void disconnect_node (socket_t *chip, node_t *node);

/* global variables */

/* used in setting the routing status attribute of a net */

/* these are constant strings  */

/*extern char   Routed[]  ;     */ /* "Routed"    */

/*extern char   AssignedName[] ;*/ /* "Named"     */

/*extern char   Unrouted[] ;    */ /* "Unrouted"  */

extern socket_t *socket_head;

extern socket_t *template_head;

extern net_t *routed_list;

extern net_t *named_list;

extern net_t *named_tail;

extern net_t *unrouted_list;

extern char nullstr[];

extern char *decode_how_routed[];

extern char *decode_which_list (net_t **list_head);

/* this points at std_logic, std_ulogic etc */

extern vhdl_t *default_vhdl_datatype;

extern vhdl_t *default_vhdl_bustype;

extern void InitialiseData (void);

#endif