vpip/vpi_bit.c

   1 /*
   2  * Copyright (c) 2000 Stephen Williams (steve@icarus.com)
   3  *
   4  *    This source code is free software; you can redistribute it
   5  *    and/or modify it in source code form under the terms of the GNU
   6  *    General Public License as published by the Free Software
   7  *    Foundation; either version 2 of the License, or (at your option)
   8  *    any later version
   9  *
  10  *    This program is distributed in the hope that it will be useful,
  11  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *    GNU General Public License for more details.
  14  *
  15  *    You should have received a copy of the GNU General Public License
  16  *    along with this program; if not, write to the Free Software
  17  *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  18  */
  19 #ifdef HAVE_CVS_IDENT
  20 #ident "$Id: vpi_bit.c,v 1.2 2002/08/12 01:35:05 steve Exp $"
  21 #endif
  22
  23 # include  "vpi_priv.h"
  24 # include  <stdio.h>
  25
  26 /*
  27  * A signal value is unambiguous if the top 4 bits and the bottom 4
  28  * bits are identical. This means that the VSSSvsss bits of the 8bit
  29  * value have V==v and SSS==sss.
  30  */
  31 #define UNAMBIG(v) (! B_ISAMBIG(v))
  32
  33
  34 # define STREN1(v) ( ((v)&0x80)? ((v)&0xf0) : (0x70 - ((v)&0xf0)) )
  35 # define STREN0(v) ( ((v)&0x08)? ((v)&0x0f) : (0x07 - ((v)&0x0f)) )
  36
  37 vpip_bit_t vpip_pair_resolve(vpip_bit_t a, vpip_bit_t b)
  38 {
  39       vpip_bit_t res = a;
  40
  41       if (B_ISZ(b))
  42             return a;
  43
  44       if (UNAMBIG(a) && UNAMBIG(b)) {
  45
  46               /* If both signals are unambiguous, simply choose
  47                  the stronger. If they have the same strength
  48                  but different values, then this becomes
  49                  ambiguous. */
  50
  51             if (a == b) {
  52
  53                     /* values are equal. do nothing. */
  54
  55             } else if ((b&0x07) > (res&0x07)) {
  56
  57                     /* New value is stronger. Take it. */
  58                   res = b;
  59
  60             } else if ((b&0x77) == (res&0x77)) {
  61
  62                     /* Strengths are the same. Make value ambiguous. */
  63                   res = (res&0x70) | (b&0x07) | 0x80;
  64
  65             } else {
  66
  67                     /* Must be res is the stronger one. */
  68             }
  69
  70       } else if (UNAMBIG(res) || UNAMBIG(b)) {
  71
  72               /* If one of the signals is unambiguous, then it
  73                  will sweep up the weaker parts of the ambiguous
  74                  signal. The result may be ambiguous, or maybe not. */
  75
  76             vpip_bit_t tmp = 0;
  77
  78             if ((res&0x70) > (b&0x70))
  79                   tmp |= res&0xf0;
  80             else
  81                   tmp |= b&0xf0;
  82
  83             if ((res&0x07) > (b&0x07))
  84                   tmp |= res&0x0f;
  85             else
  86                   tmp |= b&0x0f;
  87
  88             res = tmp;
  89
  90       } else {
  91
  92               /* If both signals are ambiguous, then the result
  93                  has an even wider ambiguity. */
  94
  95             vpip_bit_t tmp = 0;
  96
  97             if (STREN1(b) > STREN1(res))
  98                   tmp |= b&0xf0;
  99             else
 100                   tmp |= res&0xf0;
 101
 102             if (STREN0(b) < STREN0(res))
 103                   tmp |= b&0x0f;
 104             else
 105                   tmp |= res&0x0f;
 106
 107             res = tmp;
 108       }
 109
 110         /* Cannonicalize the HiZ value. */
 111       if ((res&0x77) == 0)
 112             res = HiZ;
 113
 114       return res;
 115 }
 116
 117 vpip_bit_t vpip_bits_resolve(const vpip_bit_t*bits, unsigned nbits)
 118 {
 119       unsigned idx;
 120       vpip_bit_t res = bits[0];
 121
 122       idx = 1;
 123       while ((idx < nbits) && B_ISZ(res)) {
 124             res = bits[idx];
 125             idx += 1;
 126       }
 127
 128       for ( ;  idx < nbits ;  idx += 1)
 129             res = vpip_pair_resolve(res, bits[idx]);
 130
 131
 132       return res;
 133 }
 134
 135 /*
 136  * $Log: vpi_bit.c,v $
 137  * Revision 1.2  2002/08/12 01:35:05  steve
 138  *  conditional ident string using autoconfig.
 139  *
 140  * Revision 1.1  2001/03/14 19:27:44  steve
 141  *  Rearrange VPI support libraries.
 142  *
 143  * Revision 1.5  2000/05/11 01:37:33  steve
 144  *  Calculate the X output value from drive0 and drive1
 145  *
 146  * Revision 1.4  2000/05/09 21:16:35  steve
 147  *  Give strengths to logic and bufz devices.
 148  *
 149  * Revision 1.3  2000/05/07 04:37:56  steve
 150  *  Carry strength values from Verilog source to the
 151  *  pform and netlist for gates.
 152  *
 153  *  Change vvm constants to use the driver_t to drive
 154  *  a constant value. This works better if there are
 155  *  multiple drivers on a signal.
 156  *
 157  * Revision 1.2  2000/03/22 05:16:38  steve
 158  *  Integrate drive resolution function.
 159  *
 160  * Revision 1.1  2000/03/22 04:26:40  steve
 161  *  Replace the vpip_bit_t with a typedef and
 162  *  define values for all the different bit
 163  *  values, including strengths.
 164  *
 165  */
 166