vpip/vpi_memory.c

   1 /*
   2  * Copyright (c) 1999-2000 Picture Elements, Inc.
   3  *    Stephen Williams (steve@picturel.com)
   4  *
   5  *    This source code is free software; you can redistribute it
   6  *    and/or modify it in source code form under the terms of the GNU
   7  *    General Public License as published by the Free Software
   8  *    Foundation; either version 2 of the License, or (at your option)
   9  *    any later version. In order to redistribute the software in
  10  *    binary form, you will need a Picture Elements Binary Software
  11  *    License.
  12  *
  13  *    This program is distributed in the hope that it will be useful,
  14  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *    GNU General Public License for more details.
  17  *
  18  *    You should have received a copy of the GNU General Public License
  19  *    along with this program; if not, write to the Free Software
  20  *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  21  *  ---
  22  *    You should also have received a copy of the Picture Elements
  23  *    Binary Software License offer along with the source. This offer
  24  *    allows you to obtain the right to redistribute the software in
  25  *    binary (compiled) form. If you have not received it, contact
  26  *    Picture Elements, Inc., 777 Panoramic Way, Berkeley, CA 94704.
  27  */
  28 #ifdef HAVE_CVS_IDENT
  29 #ident "$Id: vpi_memory.c,v 1.4 2007/02/26 19:49:51 steve Exp $"
  30 #endif
  31
  32 # include  "vpi_priv.h"
  33 # include  <stdlib.h>
  34 # include  <assert.h>
  35
  36 static int memory_get(int code, vpiHandle ref)
  37 {
  38       struct __vpiMemory*rfp = (struct __vpiMemory*)ref;
  39
  40       assert(ref->vpi_type->type_code==vpiMemory);
  41
  42       switch (code) {
  43           case vpiSize:
  44             return rfp->size;
  45
  46           default:
  47             return 0;
  48       }
  49 }
  50
  51 static const char* memory_get_str(int code, vpiHandle ref)
  52 {
  53       struct __vpiMemory*rfp = (struct __vpiMemory*)ref;
  54       assert(ref->vpi_type->type_code==vpiMemory);
  55
  56       switch (code) {
  57
  58           case vpiFullName:
  59             return (char*)rfp->name;
  60       }
  61
  62       return 0;
  63 }
  64
  65 static vpiHandle memory_iterate(int code, vpiHandle ref)
  66 {
  67       unsigned idx;
  68       struct __vpiMemory*rfp = (struct __vpiMemory*)ref;
  69       assert(ref->vpi_type->type_code==vpiMemory);
  70
  71       switch (code) {
  72           case vpiMemoryWord:
  73             if (rfp->args == 0) {
  74                   rfp->args = calloc(rfp->size, sizeof(vpiHandle));
  75                   for (idx = 0 ;  idx < rfp->size ;  idx += 1)
  76                         rfp->args[idx] = &rfp->words[idx].base;
  77             }
  78             return vpip_make_iterator(rfp->size, rfp->args);
  79
  80           default:
  81             return 0;
  82       }
  83 }
  84
  85 static vpiHandle memory_index(vpiHandle ref, int index)
  86 {
  87       struct __vpiMemory*rfp = (struct __vpiMemory*)ref;
  88       assert(ref->vpi_type->type_code==vpiMemory);
  89
  90       if (rfp->args == 0) {
  91             unsigned idx;
  92             rfp->args = calloc(rfp->size, sizeof(vpiHandle));
  93             for (idx = 0 ;  idx < rfp->size ;  idx += 1)
  94                   rfp->args[idx] = &rfp->words[idx].base;
  95       }
  96
  97       if (index > rfp->size) return 0;
  98       if (index < 0) return 0;
  99       return &(rfp->words[index].base);
 100 }
 101
 102 static int memory_word_get(int code, vpiHandle ref)
 103 {
 104       struct __vpiMemoryWord*rfp = (struct __vpiMemoryWord*)ref;
 105       assert(ref->vpi_type->type_code==vpiMemoryWord);
 106
 107       switch (code) {
 108           case vpiSize:
 109             return rfp->mem->width;
 110
 111           default:
 112             return 0;
 113       }
 114 }
 115
 116 static vpiHandle memory_word_put(vpiHandle ref, p_vpi_value val,
 117                                  p_vpi_time tim, int flags)
 118 {
 119       unsigned idx;
 120       vpip_bit_t*base;
 121       struct __vpiMemoryWord*rfp = (struct __vpiMemoryWord*)ref;
 122       assert(ref->vpi_type->type_code==vpiMemoryWord);
 123
 124       base = rfp->mem->bits + rfp->index*rfp->mem->width;
 125
 126       assert(val->format == vpiVectorVal);
 127       for (idx = 0 ;  idx < rfp->mem->width ;  idx += 1) {
 128             p_vpi_vecval cur = val->value.vector + (idx/32);
 129             int aval = cur->aval >> (idx%32);
 130             int bval = cur->bval >> (idx%32);
 131
 132             if (bval & 1) {
 133                   if (aval & 1)
 134                         *base = StX;
 135                   else
 136                         *base = HiZ;
 137             } else {
 138                   if (aval & 1)
 139                         *base = St1;
 140                   else
 141                         *base = St0;
 142             }
 143             base += 1;
 144       }
 145       return 0;
 146 }
 147
 148 static void memory_word_get_value(vpiHandle ref, s_vpi_value*vp)
 149 {
 150       struct __vpiMemoryWord*rfp = (struct __vpiMemoryWord*)ref;
 151       assert(ref->vpi_type->type_code==vpiMemoryWord);
 152
 153       vpip_bits_get_value(rfp->mem->bits+rfp->index*rfp->mem->width,
 154                           rfp->mem->width, vp, 0);
 155 }
 156
 157 static const struct __vpirt vpip_memory_rt = {
 158       vpiMemory,
 159       memory_get,
 160       memory_get_str,
 161       0,
 162       0,
 163       0,
 164       memory_iterate,
 165       memory_index
 166 };
 167
 168 static const struct __vpirt vpip_memory_word_rt = {
 169       vpiMemoryWord,
 170       memory_word_get,
 171       0,
 172       memory_word_get_value,
 173       memory_word_put,
 174       0,
 175       0,
 176       0
 177 };
 178
 179 vpiHandle vpip_make_memory(struct __vpiMemory*ref, const char*name,
 180                            unsigned wid, unsigned siz)
 181 {
 182       unsigned idx;
 183
 184       ref->base.vpi_type = &vpip_memory_rt;
 185       ref->name = name;
 186       ref->bits = calloc(wid*siz, sizeof(vpip_bit_t));
 187       for (idx = 0 ;  idx < wid*siz ;  idx += 1)
 188             ref->bits[idx] = StX;
 189       ref->words = calloc(siz, sizeof(struct __vpiMemoryWord));
 190       ref->args = 0;
 191       ref->width = wid;
 192       ref->size  = siz;
 193
 194       for (idx = 0 ;  idx < siz ;  idx += 1) {
 195             ref->words[idx].base.vpi_type = &vpip_memory_word_rt;
 196             ref->words[idx].mem = ref;
 197             ref->words[idx].index = idx;
 198       }
 199
 200       return &(ref->base);
 201 }
 202 /*
 203  * $Log: vpi_memory.c,v $
 204  * Revision 1.4  2007/02/26 19:49:51  steve
 205  *  Spelling fixes (larry doolittle)
 206  *
 207  * Revision 1.3  2002/08/12 01:35:05  steve
 208  *  conditional ident string using autoconfig.
 209  *
 210  * Revision 1.2  2001/10/26 02:29:10  steve
 211  *  const/non-const warnings. (Stephan Boettcher)
 212  *
 213  * Revision 1.1  2001/03/14 19:27:44  steve
 214  *  Rearrange VPI support libraries.
 215  *
 216  * Revision 1.9  2001/01/06 22:22:17  steve
 217  *  Support signed decimal display of variables.
 218  *
 219  * Revision 1.8  2000/06/28 18:38:00  steve
 220  *  Initialize memories as they are create.
 221  *
 222  * Revision 1.7  2000/03/22 04:26:41  steve
 223  *  Replace the vpip_bit_t with a typedef and
 224  *  define values for all the different bit
 225  *  values, including strengths.
 226  *
 227  * Revision 1.6  2000/02/29 01:41:32  steve
 228  *  Fix warning and typo.
 229  *
 230  * Revision 1.5  2000/02/23 02:56:56  steve
 231  *  Macintosh compilers do not support ident.
 232  *
 233  * Revision 1.4  2000/02/13 19:18:28  steve
 234  *  Accept memory words as parameter to $display.
 235  *
 236  * Revision 1.3  1999/12/15 04:15:17  steve
 237  *  Implement vpi_put_value for memory words.
 238  *
 239  * Revision 1.2  1999/12/15 04:01:14  steve
 240  *  Add the VPI implementation of $readmemh.
 241  *
 242  * Revision 1.1  1999/11/10 02:52:24  steve
 243  *  Create the vpiMemory handle type.
 244  *
 245  */
 246