sim/common/dv-glue.c

   1 /* The common simulator framework for GDB, the GNU Debugger.
   2
   3    Copyright 2002-2023 Free Software Foundation, Inc.
   4
   5    Contributed by Andrew Cagney and Red Hat.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 /* This must come before any other includes.  */
  23 #include "defs.h"
  24
  25 #include <string.h>
  26
  27 #include "hw-main.h"
  28
  29 /* DEVICE
  30
  31
  32    glue - glue to interconnect and test hardware ports
  33
  34
  35    DESCRIPTION
  36
  37
  38    The glue device provides two functions.  Firstly, it provides a
  39    mechanism for inspecting and driving the port network.  Secondly,
  40    it provides a set of boolean primitives that can be used to apply
  41    combinatorial operations to the port network.
  42
  43    Glue devices have a variable number of big endian <<output>>
  44    registers.  Each register is target-word sized.  The registers can
  45    be read and written.
  46
  47    Writing to an output register results in an event being driven
  48    (level determined by the value written) on the devices
  49    corresponding output port.
  50
  51    Reading an <<output>> register returns either the last value
  52    written or the most recently computed value (for that register) as
  53    a result of an event ariving on that port (which ever was computed
  54    last).
  55
  56    At present the following sub device types are available:
  57
  58    <<glue>>: In addition to driving its output interrupt port with any
  59    value written to an interrupt input port is stored in the
  60    corresponding <<output>> register.  Such input interrupts, however,
  61    are not propogated to an output interrupt port.
  62
  63    <<glue-and>>: The bit-wise AND of the interrupt inputs is computed
  64    and then both stored in <<output>> register zero and propogated to
  65    output interrupt output port zero.
  66
  67
  68    PROPERTIES
  69
  70
  71    reg = <address> <size> (required)
  72
  73    Specify the address (within the parent bus) that this device is to
  74    live.  The address must be 2048 * sizeof (word) (8k in a 32bit
  75    simulation) aligned.
  76
  77
  78    interrupt-ranges = <int-number> <range> (optional)
  79
  80    If present, this specifies the number of valid interrupt inputs (up
  81    to the maximum of 2048).  By default, <<int-number>> is zero and
  82    range is determined by the <<reg>> size.
  83
  84
  85    PORTS
  86
  87
  88    int[0..] (input, output)
  89
  90    Both an input and an output port.
  91
  92
  93    EXAMPLES
  94
  95
  96    Enable tracing of the device:
  97
  98    | -t glue-device \
  99
 100
 101    Create source, bitwize-and, and sink glue devices.  Since the
 102    device at address <<0x10000>> is of size <<8>> it will have two
 103    output interrupt ports.
 104
 105    | -o '/iobus@0xf0000000/glue@0x10000/reg 0x10000 8' \
 106    | -o '/iobus@0xf0000000/glue-and@0x20000/reg 0x20000 4' \
 107    | -o '/iobus@0xf0000000/glue-and/interrupt-ranges 0 2' \
 108    | -o '/iobus@0xf0000000/glue@0x30000/reg 0x30000 4' \
 109
 110
 111    Wire the two source interrupts to the AND device:
 112
 113    | -o '/iobus@0xf0000000/glue@0x10000 > 0 0 /iobus/glue-and' \
 114    | -o '/iobus@0xf0000000/glue@0x10000 > 1 1 /iobus/glue-and' \
 115
 116
 117    Wire the AND device up to the sink so that the and's output is not
 118    left open.
 119
 120    | -o '/iobus@0xf0000000/glue-and > 0 0 /iobus/glue@0x30000' \
 121
 122
 123    With the above configuration.  The client program is able to
 124    compute a two bit AND.  For instance the <<C>> stub below prints 1
 125    AND 0.
 126
 127    |  unsigned *input = (void*)0xf0010000;
 128    |  unsigned *output = (void*)0xf0030000;
 129    |  unsigned ans;
 130    |  input[0] = htonl(1);
 131    |  input[1] = htonl(0);
 132    |  ans = ntohl(*output);
 133    |  write_string("AND is ");
 134    |  write_int(ans);
 135    |  write_line();
 136
 137
 138    BUGS
 139
 140
 141    A future implementation of this device may support multiple
 142    interrupt ranges.
 143
 144    Some of the devices listed may not yet be fully implemented.
 145
 146    Additional devices such as a D flip-flop (DFF), an inverter (INV)
 147    or a latch (LAT) may prove useful.
 148
 149    */
 150
 151
 152 enum
 153 {
 154   max_nr_ports = 2048,
 155 };
 156
 157 enum hw_glue_type
 158 {
 159   glue_undefined = 0,
 160   glue_io,
 161   glue_and,
 162   glue_nand,
 163   glue_or,
 164   glue_xor,
 165   glue_nor,
 166   glue_not,
 167 };
 168
 169 struct hw_glue
 170 {
 171   enum hw_glue_type type;
 172   int int_number;
 173   int *input;
 174   int nr_inputs;
 175   unsigned sizeof_input;
 176   /* our output registers */
 177   int space;
 178   unsigned_word address;
 179   unsigned sizeof_output;
 180   int *output;
 181   int nr_outputs;
 182 };
 183
 184
 185 static hw_io_read_buffer_method hw_glue_io_read_buffer;
 186 static hw_io_write_buffer_method hw_glue_io_write_buffer;
 187 static hw_port_event_method hw_glue_port_event;
 188 static const struct hw_port_descriptor hw_glue_ports[];
 189
 190 static void
 191 hw_glue_finish (struct hw *me)
 192 {
 193   struct hw_glue *glue = HW_ZALLOC (me, struct hw_glue);
 194   const char *name = hw_name (me);
 195
 196   /* establish our own methods */
 197   set_hw_data (me, glue);
 198   set_hw_io_read_buffer (me, hw_glue_io_read_buffer);
 199   set_hw_io_write_buffer (me, hw_glue_io_write_buffer);
 200   set_hw_ports (me, hw_glue_ports);
 201   set_hw_port_event (me, hw_glue_port_event);
 202
 203   /* attach to our parent bus */
 204   do_hw_attach_regs (me);
 205
 206   /* establish the output registers */
 207   if (hw_find_property (me, "reg"))
 208     {
 209       reg_property_spec unit;
 210       int reg_nr;
 211
 212       /* Find a relevant reg entry.  */
 213       reg_nr = 0;
 214       while (hw_find_reg_array_property (me, "reg", reg_nr, &unit)
 215              && !hw_unit_size_to_attach_size (hw_parent (me),
 216                                               &unit.size,
 217                                               &glue->sizeof_output,
 218                                               me))
 219         reg_nr++;
 220
 221       /* Check out the size ...  */
 222       if (glue->sizeof_output == 0)
 223         hw_abort (me, "at least one reg property size must be nonzero");
 224       if (glue->sizeof_output % sizeof (unsigned_word) != 0)
 225         hw_abort (me, "reg property size must be %ld aligned",
 226                   (long) sizeof (unsigned_word));
 227
 228       /* ... and the address.  */
 229       hw_unit_address_to_attach_address (hw_parent (me),
 230                                          &unit.address,
 231                                          &glue->space,
 232                                          &glue->address,
 233                                          me);
 234       if (glue->address % (sizeof (unsigned_word) * max_nr_ports) != 0)
 235         hw_abort (me, "reg property address must be %ld aligned",
 236                   (long) (sizeof (unsigned_word) * max_nr_ports));
 237
 238       glue->nr_outputs = glue->sizeof_output / sizeof (unsigned_word);
 239     }
 240   else
 241     {
 242       /* Allow bitwise glue devices to declare only ports.  */
 243       if (!strcmp (name, "glue"))
 244         hw_abort (me, "Missing \"reg\" property");
 245
 246       glue->nr_outputs = 1;
 247       glue->sizeof_output = sizeof (unsigned_word);
 248     }
 249   glue->output = hw_zalloc (me, glue->sizeof_output);
 250
 251   /* establish the input ports */
 252   {
 253     const struct hw_property *ranges;
 254
 255     ranges = hw_find_property (me, "interrupt-ranges");
 256     if (ranges == NULL)
 257       {
 258         glue->int_number = 0;
 259         glue->nr_inputs = glue->nr_outputs;
 260       }
 261     else if (ranges->sizeof_array != sizeof (unsigned_cell) * 2)
 262       {
 263         hw_abort (me, "invalid interrupt-ranges property (incorrect size)");
 264       }
 265     else
 266       {
 267         const unsigned_cell *int_range = ranges->array;
 268
 269         glue->int_number = BE2H_cell (int_range[0]);
 270         glue->nr_inputs = BE2H_cell (int_range[1]);
 271       }
 272     glue->sizeof_input = glue->nr_inputs * sizeof (unsigned);
 273     glue->input = hw_zalloc (me, glue->sizeof_input);
 274   }
 275
 276   /* determine our type */
 277   if (strcmp (name, "glue") == 0)
 278     glue->type = glue_io;
 279   else if (strcmp (name, "glue-and") == 0)
 280     glue->type = glue_and;
 281   else if (strcmp (name, "glue-or") == 0)
 282     glue->type = glue_or;
 283   else if (strcmp (name, "glue-xor") == 0)
 284     glue->type = glue_xor;
 285   else
 286     hw_abort (me, "unimplemented glue type");
 287
 288   HW_TRACE ((me, "int-number %d, nr_inputs %d, nr_outputs %d",
 289              glue->int_number, glue->nr_inputs, glue->nr_outputs));
 290 }
 291
 292 static unsigned
 293 hw_glue_io_read_buffer (struct hw *me,
 294                         void *dest,
 295                         int space,
 296                         unsigned_word addr,
 297                         unsigned nr_bytes)
 298 {
 299   struct hw_glue *glue = (struct hw_glue *) hw_data (me);
 300   int reg = ((addr - glue->address) / sizeof (unsigned_word)) % glue->nr_outputs;
 301
 302   if (nr_bytes != sizeof (unsigned_word)
 303       || (addr % sizeof (unsigned_word)) != 0)
 304     hw_abort (me, "missaligned read access (%d:0x%lx:%d) not supported",
 305               space, (unsigned long)addr, nr_bytes);
 306
 307   *(unsigned_word *)dest = H2BE_4 (glue->output[reg]);
 308
 309   HW_TRACE ((me, "read - port %d (0x%lx), level %d",
 310              reg, (unsigned long) addr, glue->output[reg]));
 311
 312   return nr_bytes;
 313 }
 314
 315
 316 static unsigned
 317 hw_glue_io_write_buffer (struct hw *me,
 318                          const void *source,
 319                          int space,
 320                          unsigned_word addr,
 321                          unsigned nr_bytes)
 322 {
 323   struct hw_glue *glue = (struct hw_glue *) hw_data (me);
 324   int reg = ((addr - glue->address) / sizeof (unsigned_word)) % max_nr_ports;
 325
 326   if (nr_bytes != sizeof (unsigned_word)
 327       || (addr % sizeof (unsigned_word)) != 0)
 328     hw_abort (me, "missaligned write access (%d:0x%lx:%d) not supported",
 329               space, (unsigned long) addr, nr_bytes);
 330
 331   glue->output[reg] = H2BE_4 (*(unsigned_word *)source);
 332
 333   HW_TRACE ((me, "write - port %d (0x%lx), level %d",
 334              reg, (unsigned long) addr, glue->output[reg]));
 335
 336   hw_port_event (me, reg, glue->output[reg]);
 337
 338   return nr_bytes;
 339 }
 340
 341 static void
 342 hw_glue_port_event (struct hw *me,
 343                     int my_port,
 344                     struct hw *source,
 345                     int source_port,
 346                     int level)
 347 {
 348   struct hw_glue *glue = (struct hw_glue *) hw_data (me);
 349   int i;
 350
 351   if (my_port < glue->int_number
 352       || my_port >= glue->int_number + glue->nr_inputs)
 353     hw_abort (me, "port %d outside of valid range", my_port);
 354
 355   glue->input[my_port - glue->int_number] = level;
 356   switch (glue->type)
 357     {
 358     case glue_io:
 359       {
 360         int port = my_port % glue->nr_outputs;
 361
 362         glue->output[port] = level;
 363
 364         HW_TRACE ((me, "input - port %d (0x%lx), level %d",
 365                    my_port,
 366                    (unsigned long) glue->address + port * sizeof (unsigned_word),
 367                    level));
 368         return;
 369       }
 370     case glue_and:
 371       {
 372         glue->output[0] = glue->input[0];
 373         for (i = 1; i < glue->nr_inputs; i++)
 374           glue->output[0] &= glue->input[i];
 375         break;
 376       }
 377     case glue_or:
 378       {
 379         glue->output[0] = glue->input[0];
 380         for (i = 1; i < glue->nr_inputs; i++)
 381           glue->output[0] |= glue->input[i];
 382         break;
 383       }
 384     case glue_xor:
 385       {
 386         glue->output[0] = glue->input[0];
 387         for (i = 1; i < glue->nr_inputs; i++)
 388           glue->output[0] ^= glue->input[i];
 389         break;
 390       }
 391     default:
 392       {
 393         hw_abort (me, "operator not implemented");
 394         return;
 395       }
 396     }
 397
 398   /* If we fell through, we want to generate a port event.  */
 399   HW_TRACE ((me, "port %d, level %d arrived - output %d",
 400              my_port, level, glue->output[0]));
 401
 402   hw_port_event (me, 0, glue->output[0]);
 403 }
 404
 405
 406 static const struct hw_port_descriptor hw_glue_ports[] =
 407 {
 408   { "int", 0, max_nr_ports, 0 },
 409   { NULL, 0, 0, 0 }
 410 };
 411
 412
 413 const struct hw_descriptor dv_glue_descriptor[] =
 414 {
 415   { "glue", hw_glue_finish, },
 416   { "glue-and", hw_glue_finish, },
 417   { "glue-nand", hw_glue_finish, },
 418   { "glue-or", hw_glue_finish, },
 419   { "glue-xor", hw_glue_finish, },
 420   { "glue-nor", hw_glue_finish, },
 421   { "glue-not", hw_glue_finish, },
 422   { NULL, NULL },
 423 };