vvp/memory.h

   1 #ifndef __memory_H                                      // -*- c++ -*-
   2 #define __memory_H
   3 /*
   4  * Copyright (c) 2001 Stephen Williams (steve@icarus.com)
   5  * Copyright (c) 2001 Stephan Boettcher <stephan@nevis.columbia.edu>
   6  *
   7  *    This source code is free software; you can redistribute it
   8  *    and/or modify it in source code form under the terms of the GNU
   9  *    General Public License as published by the Free Software
  10  *    Foundation; either version 2 of the License, or (at your option)
  11  *    any later version.
  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 #ifdef HAVE_CVS_IDENT
  23 #ident "$Id: memory.h,v 1.13 2007/03/22 16:08:19 steve Exp $"
  24 #endif
  25
  26 #include "vvp_net.h"
  27 #include "vpi_user.h"
  28
  29 /*
  30 **  vvp_memory_t         is a memory
  31 **  vvp_memory_index_t   is a memory index range definition
  32 */
  33 typedef struct vvp_memory_s *vvp_memory_t;
  34
  35 struct memory_address_range {
  36       int msb;
  37       int lsb;
  38 };
  39
  40 /*
  41  * Given a memory device, the memory_configure function configures it
  42  * by defining the dimensions of the device. It is an error to
  43  * redefine the dimensions of a device already configured.
  44  *
  45  * The lsb and msb define the dimensions of a word. They are in
  46  * Verilog form. The actual word contents are vvp_vector4_t values.
  47  *
  48  * The idx array is an array of address ranges that describe the
  49  * complete multi-dimensional array. In a normal Verilog array, idxs
  50  * is 1, and idx is a pointer to a single memory_address_range. The
  51  * table does not need to be persistent.
  52  */
  53 extern void memory_configure(vvp_memory_t mem, int msb, int lsb,
  54                              unsigned idxs,
  55                              const struct memory_address_range *idx);
  56 extern void memory_attach_self(vvp_memory_t mem, vpiHandle self);
  57
  58 /*
  59  * init_word and set_word functions take the memory to be manipulated
  60  * and write a word value at the given word address. The idx is the
  61  * canonical (0-based, 1-dimensional) address of the word to be
  62  * written. The caller needs to have converted any multi-dimensional
  63  * address into a canonical address first.
  64  *
  65  * The difference between init_word and set_word are that the set_word
  66  * function causes values to be propagated through structural ports,
  67  * but the init_word does not.
  68  */
  69 extern void memory_init_word(vvp_memory_t mem,
  70                              unsigned idx,
  71                              vvp_vector4_t val);
  72 extern void memory_set_word(vvp_memory_t mem,
  73                             unsigned idx,
  74                             unsigned off,
  75                             vvp_vector4_t val);
  76
  77 /*
  78  * this doesn't actually write the value to the memory word, but
  79  * scedules for the write to happen some time in the future. The delay
  80  * is in simulation clock units
  81  */
  82 void schedule_memory(vvp_memory_t mem, unsigned addr,
  83                      vvp_vector4_t val, unsigned long delay);
  84
  85 /*
  86  * Get the word value at the given index into the memory.
  87  */
  88 extern vvp_vector4_t memory_get_word(vvp_memory_t mem, unsigned idx);
  89
  90
  91   /* Number of words in the memory. */
  92 unsigned memory_word_count(vvp_memory_t mem);
  93   /* Width of a word */
  94 unsigned memory_word_width(vvp_memory_t mem);
  95   /* Get the user declared geometry of the memory address. This is the
  96      msb and lsb values for each pair in the multi-dimensional array. */
  97 long memory_left_range(vvp_memory_t mem, unsigned ix);
  98 long memory_right_range(vvp_memory_t mem, unsigned ix);
  99   /* Get the user defined geometry for the memory *word*. */
 100 long memory_word_left_range(vvp_memory_t mem);
 101 long memory_word_right_range(vvp_memory_t mem);
 102
 103
 104 /* vvp_fun_memport
 105  * The vvp_fum_memport is a structural port into a vvp_memory_t
 106  * object. The output is the word that is read from the addressed
 107  * memory, and the inputs are the address and optional write controls.
 108  *
 109  * 0  -- Address
 110  * This addresses the word in the memory. The output follows this
 111  * address as it changes, and also follows the value of the addressed
 112  * word.
 113  *
 114  * 1  -- Write event
 115  *
 116  * 2  -- Write enable
 117  *
 118  * 3  -- Write data
 119  *
 120  * NOTE: This functor is unique in that it needs to store the
 121  * vvp_net_t pointer associated with it. It needs this because it can
 122  * received input from other than its ports. Notably, the memory
 123  * itself reports word changes.
 124  */
 125 class vvp_fun_memport  : public vvp_net_fun_t {
 126
 127     public:
 128       explicit vvp_fun_memport(vvp_memory_t mem, vvp_net_t*net);
 129       ~vvp_fun_memport();
 130
 131       void recv_vec4(vvp_net_ptr_t port, const vvp_vector4_t&bit);
 132
 133     private:
 134       vvp_memory_t mem_;
 135
 136       friend void memory_set_word(vvp_memory_t, unsigned,
 137                                   unsigned, vvp_vector4_t);
 138       void check_word_change(unsigned long address);
 139       class vvp_fun_memport*next_;
 140
 141       unsigned long addr_;
 142
 143       vvp_net_t*net_;
 144 };
 145
 146 /*
 147 **  Access to the memory symbol table.
 148 **
 149 ** The memory_find function locates the memory device by name. If the
 150 ** device does not exist, a nil is returned.
 151 **
 152 ** The memory_create functio create a new memory device with the given
 153 ** name. It is a fatal error to try to create a device that already exists.
 154 */
 155 vvp_memory_t memory_find(char *label);
 156 vvp_memory_t memory_create(char *label);
 157
 158 /*
 159  * $Log: memory.h,v $
 160  * Revision 1.13  2007/03/22 16:08:19  steve
 161  *  Spelling fixes from Larry
 162  *
 163  * Revision 1.12  2006/03/05 05:45:58  steve
 164  *  Add support for memory value change callbacks.
 165  *
 166  * Revision 1.11  2006/02/02 02:44:00  steve
 167  *  Allow part selects of memory words in l-values.
 168  *
 169  * Revision 1.10  2005/06/22 00:04:49  steve
 170  *  Reduce vvp_vector4 copies by using const references.
 171  *
 172  * Revision 1.9  2005/03/09 04:52:40  steve
 173  *  reimplement memory ports.
 174  *
 175  * Revision 1.8  2005/03/03 04:33:10  steve
 176  *  Rearrange how memories are supported as vvp_vector4 arrays.
 177  *
 178  */
 179
 180 #endif