1 /* The remote-virtual-component simulator framework
2 for GDB, the GNU Debugger.
4 Copyright 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
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.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
48 #ifdef HAVE_SYS_TYPES_H
49 #include <sys/types.h>
52 #ifdef HAVE_SYS_TIME_H
56 #ifdef HAVE_SYS_SELECT_H
57 #include <sys/select.h>
60 /* Not guarded in dv-sockser.c, so why here. */
61 #include <netinet/in.h>
62 #include <arpa/inet.h>
64 #include <sys/socket.h>
70 rv - Remote Virtual component
76 Socket connection to a remote simulator component, for example one
77 for testing a verilog construction. Protocol defined below.
79 There is a set of 32-bit I/O ports, with a mapping from local to
80 remote addresses. There is a set of interrupts expressed as a
81 bit-mask, with a mapping from remote to local. There is a set of
82 memory ranges (actual memory defined elsewhere), also with a
83 mapping from remote to local addresses, that is expected to be
84 accessible to the remote simulator in 32-byte chunks (simulating
85 DMA). There is a mapping from remote cycles (or an appropriate
86 elsewhere defined time-slice) to local cycles.
90 reg = <address> <size>
91 The address (within the parent bus) that this device is to
94 remote-reg = <remote-address>
95 The address of reg on the remote side. Defaults to 0.
97 mem = <address> <size>
98 Specify an address-range (within the parent bus) that the remote
99 device can access. The memory is assumed to be already defined.
100 If there's no memory defined but the remote side asks for a memory
101 access, the simulation is aborted.
103 remote-mem = <remote-address>
104 The address of mem on the remote side. Defaults to 0.
107 Address of the mailbox interface. Writes to this address with the
108 local address of a mailbox command, a complete packet with length
109 and command; (4 or 6)) invokes the mailbox interface. Reads are
110 invalid. Replies are written to the same address. Address space
111 from <address> up-to-and-including <address>+3 is allocated.
113 max-poll-ticks = <local-count>
114 Sets the maximum interval between polling the external component,
115 expressed in internal cycles. Defaults to 10000.
117 watchdog-interval = <seconds>
118 Sets the wallclock seconds between watchdog packets sent to the
119 remote side (may be larger if there's no rv activity in that time).
120 Defaults to 30. If set to 0, no watchdog packets are sent.
122 intnum = <local-int-0> <local-int-1> ... <local-int-31>
123 Defines a map from remote bit numbers to local values to be emitted
124 on the "int" port, with the external bit number as the ordinal - 1
125 of the local translation. E.g. 43 121 would mean map external
126 (1<<0) to internal 43 and external (1<<1) to internal 121. The
127 default is unity; no translation. If more than one bit is set in
128 the remote interrupt word, the intmultiple property can be used to
129 control the translation.
131 intmultiple = <intvalue>
132 When more than one bit is set in the remote interrupt word, you may
133 want to map this situation to a separate interrupt value. If this
134 property is non-zero, it is used as that value. If it is zero, the
135 local value for the "int" port is the bitwise-or of the translated
139 The hostname or address where the simulator to be used listens.
140 Defaults to "127.0.0.1"
143 The hostname or address where the simulator to be used listens.
149 Don't connect to a remote side; use initial dummy contents from
150 <filename> (which has to be at least as big as the <size> argument
151 of reg above) or filled with byte-value <value>. Mailboxes are not
152 supported (can be defined but can not be used) and remote-memory
153 accesses don't apply. The main purpose for this property is to
154 simplify use of configuration and simulated hardware that is
155 e.g. only trivially initialized but not actually used.
161 Driven as a result of a remote interrupt request. The value is a
162 32-bit bitset of active interrupts.
172 This is version 1.0 of this protocol, defining packet format and
173 actions in a supposedly upward-compatible manner where client and
174 servers of different versions are expected to interoperate; the
175 format and the definitions below are hopefully generic enough to
178 Each connection has a server and a client (this code); the roles
179 are known beforehand. The client usually corresponds to a CPU and
180 memory system and the server corresponds to a memory-mapped
181 register hardware interface and/or a DMA controller. They
182 communicate using packets with specific commands, of which some
183 require replies from the other side; most are intiated by the
184 client with one exception. A reply uses the same format as the
187 Packets are at least three bytes long, where the first two bytes
188 form a header, a 16-bit little-endian number that is the total
189 length of the packet including the header. There is also a
190 one-byte command. The payload is optional, depending on the
193 [[16-bit-low-byte-of-length] [16-bit-high-byte-of-length]
194 [command/reply] [payload byte 0] [payload byte 1]
195 ... [payload byte (length-of-packet - 3)]]
199 A client or server that reads an undocumented command may exit with
200 a hard error. Payload not defined or disallowed below is ignored.
202 It is expected that future client versions find out the version of
203 the server side by polling with base commands, assuming earlier
204 versions if a certain reply isn't seen, with newly defined payload
205 parts where earlier versions left it undefined. New commands and
206 formats are sent only to the other side after the client and server
207 has found out each others version. Not all servers support all
208 commands; the type of server and supported set of commands is
209 expected to be known beforehand.
212 Initiated by the client, requires a reply from the server. The
213 payload from the client is at least 4 bytes, forming a 4-byte
214 little-endian address, the rest being undefined. The reply from
215 the server is at least 8 bytes, forming the same address data as in
216 the request and the second 4-byte data being the little-endian
220 Initiated by the client, requires a reply from the server. Payload
221 from the client is at least 8 bytes, forming a 4-byte little-endian
222 word being the address, the rest being the little-endian contents
223 to write. The reply from the server is 8 bytes unless elsewhere
224 agreed otherwise, forming the same address and data as in the
225 request. The data sent back may have been altered to correspond to
226 defined parts but can safely be discarded.
229 Initiated by the server, no reply. The payload is 4 bytes, forming
230 a little-endian word with bits numbers corresponding to currently
231 active interrupt sources; value (1<<N) indicating interrupt source
235 Initiated by the server, requires a reply. A client must know
236 beforehand when (in command sequence or constant) the server can
237 send this command and if so must then not send any commands of its
238 own (including watchdog commands); the server is allowed to assume
239 that incoming data is only replies to this command. The format is
240 8 bytes of data; 4 bytes of little-endian address followed by a
241 32-bit little endian word with the number of bytes to read. The
242 reply is the same address and number of bytes, followed by the data
246 Initiated by the server, no reply. The format is the same as a
247 reply to RV_MEM_RD_CMD; a 32-bit little-endian address, followed by
248 the 32-bit little-endian number of bytes to write (redundant
249 information but must be consistent with the packet header).
251 RV_MBOX_HANDLE_CMD = 5
252 Initiated by the client, requires a reply. The payload is 4
253 undefined bytes followed by an binary blob, the size of the
254 blob given by the packet header. The reply is a 32-bit little
255 endian number at the same index as the undefined bytes. Actual
256 semantics are application-specific.
259 Initiated by the client, requires a reply, with the reply using the
260 RV_MBOX_HANDLE_CMD reply format (i.e. *both* that command and
261 32-bit little-endian number). The payload is a 32-bit little
262 endian number followed by an undefined payload, at most 20 bytes
263 long. The reply is a 32-bit little endian number. Actual
264 semantics are application-specific.
267 Initiated by the client, no reply. A version 1.0 client sends no
268 payload; a version 1.0 server should ignore any such payload. A
269 version 1.0 server must not send a reply.
272 Possible future enhancements:
274 Synchronization; server and client reports the number of elapsed
275 cycles (unit to-be-defined) at each request or notification.
276 Pretty much the top-of-the-todo-list item.
278 Large addresses; 1.0 being restricted to 32-bit addresses.
280 Variable-size data; currently restricted to 32-bit register
283 Specified data endianness (not the packet header) perhaps as part
284 of an initial format request; currently little-endian only.
288 When used with servers sending RV_MEM_RD_CMD but being
289 narrow-minded about indata, set watchdog-interval to 0. Use
290 multiple rv instances when there are e.g. separate register and
291 memory servers. Alway log, setting "/rv/trace? true", at the
292 development phase. Borrow from the test-suite.
295 #define RV_FAMILY_NAME "rv"
303 RV_MBOX_HANDLE_CMD = 5,
309 typedef struct _hw_rv_device
311 /* Mapping of remote interrupt bit-numbers to local ones. */
312 unsigned32 remote_to_local_int[32];
314 /* When multiple bits are set, a non-zero value here indicates that
315 this value should be used instead. */
316 unsigned32 intmultiple;
318 /* Local address of registers. */
319 unsigned32 reg_address;
321 /* Size of register bank in bytes. */
324 /* Remote address of registers. */
325 unsigned32 remote_reg_address;
327 /* Local address of DMA:able memory. */
328 unsigned32 mem_address;
330 /* Size of DMA:able memory in bytes. */
333 /* Bitmask for valid DMA request size. */
334 unsigned32 mem_burst_mask;
336 /* Remote address of DMA:able memory. */
337 unsigned32 remote_mem_address;
339 /* (Local) address of mbox; where to put a pointer to the mbox to be
341 unsigned32 mbox_address;
343 /* Probably not 127.0.0.1:10000. */
347 /* If non-NULL, points to memory to use instead of connection. */
350 /* File descriptor for the socket. Set to -1 when error. Only one
351 of dummy and this is active. */
354 /* Stashed errno, as we don't emit an error right away. */
357 /* This, plus latency because the CPU might not be checking until a
358 CTI insn (usually a branch or a jump) is the interval in cycles
359 between the rv is polled for e.g. DMA requests. */
360 unsigned32 max_tick_poll_interval;
362 /* Running counter for exponential backoff up to
363 max_tick_poll_interval to avoid polling the connection
364 unnecessarily often. Set to 1 when rv activity (read/write
365 register, DMA request) is detected. */
366 unsigned32 next_period;
368 /* This is the interval in wall-clock seconds between watchdog
369 packets are sent to the remote side. Zero means no watchdog
371 unsigned32 watchdog_interval;
373 /* Last time we sent a watchdog packet. */
374 struct timeval last_wdog_time;
376 /* Mostly used as a kludge for knowing which rv:s have poll events
378 struct hw_event *poll_callback;
382 /* We might add ports in the future, so keep this an enumeration. */
389 static const struct hw_port_descriptor hw_rv_ports[] = {
390 { "int", INT_PORT, 0, output_port },
394 /* Send LEN bytes of data from BUF to the socket. Abort on
398 hw_rv_write (struct hw *me,
402 hw_rv_device *rv = (hw_rv_device *) hw_data (me);
403 unsigned8 *bufp = buf;
405 /* If we don't have a valid fd here, it's because we got an error
406 initially, and we suppressed that error. */
408 hw_abort (me, "couldn't open a connection to %s:%d because: %s",
409 rv->host, rv->port, strerror (rv->saved_errno));
413 ssize_t ret = write (rv->fd, bufp, len);
415 /* FIXME: More graceful exit. */
416 hw_abort (me, "write to %s:%d failed: %s\n", rv->host, rv->port,
424 /* Read LEN bytes of data into BUF from the socket. Set the file
425 descriptor to -1 if there's an error. */
428 hw_rv_read (struct hw *me,
432 hw_rv_device *rv = (hw_rv_device *) hw_data (me);
433 unsigned8 *bufp = buf;
437 ssize_t ret = read (rv->fd, bufp, len);
439 /* We get all zero if the remote end quits, but no error
440 indication; even select says there's data active. */
443 if (close (rv->fd) != 0)
444 /* FIXME: More graceful exit. */
445 hw_abort (me, "read from %s:%d failed: %d\n", rv->host, rv->port, errno);
455 /* Construct and send a packet of data of type CMD and len
456 LEN_NOHEADER (not counting the header...). */
459 hw_rv_send (struct hw *me,
462 unsigned int len_noheader)
464 hw_rv_device *rv = (hw_rv_device *) hw_data (me);
467 unsigned int len = len_noheader + 3;
471 buf[1] = (len >> 8) & 255;
474 if (len > sizeof (buf))
476 hw_rv_write (me, buf, 3);
482 memcpy (buf + 3, msg, len_noheader);
486 hw_rv_write (me, bufp, len);
489 /* Handle incoming DMA requests as per the RV_MEM_RD_CMD packet.
493 hw_rv_read_mem (struct hw *me, unsigned int len)
495 hw_rv_device *rv = (hw_rv_device *) hw_data (me);
496 /* If you change this size, please adjust the mem2 testcase. */
498 unsigned8 *bufp = buf;
505 hw_abort (me, "expected DMA read request len 8+3, got %d+3", len);
507 hw_rv_read (me, &leaddr, 4);
508 hw_rv_read (me, &lelen, 4);
509 len = LE2H_4 (lelen);
510 addr = LE2H_4 (leaddr);
512 if (addr < rv->remote_mem_address
513 || addr >= rv->remote_mem_address + rv->mem_size)
514 hw_abort (me, "DMA read at remote 0x%x; outside [0x%x..0x%x-1]",
515 (unsigned) addr, (unsigned) rv->remote_mem_address,
516 (unsigned) (rv->remote_mem_address + rv->mem_size));
517 addr = addr - rv->remote_mem_address + rv->mem_address;
520 hw_abort (me, "DMA read request for 0 bytes isn't supported");
522 if (len & ~rv->mem_burst_mask)
523 hw_abort (me, "DMA trying to read %d bytes; not matching mask of 0x%x",
524 len, rv->mem_burst_mask);
525 if (len + 8 > sizeof (buf))
526 bufp = hw_malloc (me, len + 8);
528 HW_TRACE ((me, "DMA R 0x%x..0x%x", addr, addr + len -1));
529 hw_dma_read_buffer (me, bufp + 8, 0, addr, len);
531 for (i = 0; i < len; i += 4)
532 HW_TRACE ((me, "0x%x: %02x %02x %02x %02x",
534 bufp[i+8], bufp[i+9], bufp[i+10], bufp[i+11]));
536 memcpy (bufp, &leaddr, 4);
537 memcpy (bufp + 4, &lelen, 4);
538 hw_rv_send (me, RV_MEM_RD_CMD, bufp, len + 8);
543 /* Handle incoming DMA requests as per the RV_MEM_WR_CMD packet.
547 hw_rv_write_mem (struct hw *me, unsigned int plen)
549 hw_rv_device *rv = (hw_rv_device *) hw_data (me);
550 /* If you change this size, please adjust the mem2 testcase. */
552 unsigned8 *bufp = buf;
559 hw_rv_read (me, &leaddr, 4);
560 hw_rv_read (me, &lelen, 4);
561 len = LE2H_4 (lelen);
562 addr = LE2H_4 (leaddr);
566 "inconsistency in DMA write request packet: "
567 "envelope %d+3, inner %d bytes", plen, len);
569 if (addr < rv->remote_mem_address
570 || addr >= rv->remote_mem_address + rv->mem_size)
571 hw_abort (me, "DMA write at remote 0x%x; outside [0x%x..0x%x-1]",
572 (unsigned) addr, (unsigned) rv->remote_mem_address,
573 (unsigned) (rv->remote_mem_address + rv->mem_size));
575 addr = addr - rv->remote_mem_address + rv->mem_address;
577 hw_abort (me, "DMA write request for 0 bytes isn't supported");
579 if (len & ~rv->mem_burst_mask)
580 hw_abort (me, "DMA trying to write %d bytes; not matching mask of 0x%x",
581 len, rv->mem_burst_mask);
582 if (len + 8 > sizeof (buf))
583 bufp = hw_malloc (me, len + 8);
585 hw_rv_read (me, bufp + 8, len);
586 HW_TRACE ((me, "DMA W 0x%x..0x%x", addr, addr + len - 1));
587 hw_dma_write_buffer (me, bufp + 8, 0, addr, len, 0);
589 for (i = 0; i < len; i += 4)
590 HW_TRACE ((me, "0x%x: %02x %02x %02x %02x",
592 bufp[i+8], bufp[i+9], bufp[i+10], bufp[i+11]));
598 hw_rv_irq (struct hw *me, unsigned int len)
600 hw_rv_device *rv = (hw_rv_device *) hw_data (me);
601 unsigned32 intbitsle;
602 unsigned32 intbits_ext;
603 unsigned32 intval = 0;
607 hw_abort (me, "IRQ with %d data not supported", len);
609 hw_rv_read (me, &intbitsle, 4);
610 intbits_ext = LE2H_4 (intbitsle);
611 for (i = 0; i < 32; i++)
612 if ((intbits_ext & (1 << i)) != 0)
613 intval |= rv->remote_to_local_int[i];
614 if ((intbits_ext & ~(intbits_ext - 1)) != intbits_ext
615 && rv->intmultiple != 0)
616 intval = rv->intmultiple;
618 HW_TRACE ((me, "IRQ 0x%x", intval));
619 hw_port_event (me, INT_PORT, intval);
622 /* Handle incoming interrupt notifications as per the RV_IRQ_CMD
623 packet. Abort on errors. */
626 hw_rv_handle_incoming (struct hw *me,
629 unsigned int *return_len)
631 hw_rv_device *rv = (hw_rv_device *) hw_data (me);
638 hw_rv_read (me, cbuf, 3);
643 len = cbuf[0] + cbuf[1] * 256 - 3;
646 /* These come in "asynchronously"; not as a reply. */
654 hw_rv_read_mem (me, len);
658 hw_rv_write_mem (me, len);
662 /* Something is incoming from the other side, so tighten up all
663 slack at the next wait. */
671 /* Don't try to handle more than one of these if we were'nt
672 expecting a reply. */
673 if (expected_type == -1)
678 /* Require a match between this supposed-reply and the command
680 if (cmd != expected_type)
681 hw_abort (me, "unexpected reply, expected command %d, got %d",
686 case RV_MBOX_PUT_CMD:
687 case RV_MBOX_HANDLE_CMD:
690 hw_rv_read (me, buf, len <= *return_len ? len : *return_len);
698 /* Send a watchdog packet. Make a note of wallclock time. */
701 hw_rv_send_wdog (struct hw *me)
703 hw_rv_device *rv = (hw_rv_device *) hw_data (me);
704 HW_TRACE ((me, "WD"));
705 gettimeofday (&rv->last_wdog_time, NULL);
706 hw_rv_send (me, RV_WATCHDOG_CMD, "", 0);
709 /* Poll the remote side: see if there's any incoming traffic; handle a
710 packet if so. Send a watchdog packet if it's time to do so.
711 Beware that the Linux select call indicates traffic for a socket
712 that the remote side has closed (which may be because it was
713 finished; don't hork until we need to write something just because
717 hw_rv_poll_once (struct hw *me)
719 hw_rv_device *rv = (hw_rv_device *) hw_data (me);
727 /* Connection has died or was never initiated. */
731 FD_SET (rv->fd, &rfds);
733 FD_SET (rv->fd, &efds);
737 ret = select (rv->fd + 1, &rfds, NULL, &efds, &tv);
738 gettimeofday (&now, NULL);
741 hw_abort (me, "select failed: %d\n", errno);
743 if (rv->watchdog_interval != 0
744 && now.tv_sec - rv->last_wdog_time.tv_sec >= rv->watchdog_interval)
745 hw_rv_send_wdog (me);
747 if (FD_ISSET (rv->fd, &rfds))
748 hw_rv_handle_incoming (me, -1, NULL, NULL);
751 /* Initialize mapping of remote-to-local interrupt data. */
754 hw_rv_map_ints (struct hw *me)
756 hw_rv_device *rv = (hw_rv_device *) hw_data (me);
759 for (i = 0; i < 32; i++)
760 rv->remote_to_local_int[i] = 1 << i;
762 if (hw_find_property (me, "intnum") != NULL)
763 for (i = 0; i < 32; i++)
765 signed_cell val = -1;
766 if (hw_find_integer_array_property (me, "intnum", i, &val) > 0)
769 rv->remote_to_local_int[i] = val;
771 hw_abort (me, "property \"intnum@%d\" must be > 0; is %d",
777 /* Handle the after-N-ticks "poll event", calling the poll-the-fd
778 method. Update the period. */
781 do_poll_event (struct hw *me, void *data)
783 hw_rv_device *rv = (hw_rv_device *) hw_data (me);
784 unsigned32 new_period;
786 if (rv->dummy != NULL)
789 hw_rv_poll_once (me);
792 = hw_event_queue_schedule (me, rv->next_period, do_poll_event, NULL);
794 new_period = rv->next_period * 2;
795 if (new_period <= rv->max_tick_poll_interval)
796 rv->next_period = new_period;
799 /* HW tree traverse function for hw_rv_add_init. */
802 hw_rv_add_poller (struct hw *me, void *data)
806 if (hw_family (me) == NULL
807 || strcmp (hw_family (me), RV_FAMILY_NAME) != 0)
810 rv = (hw_rv_device *) hw_data (me);
811 if (rv->poll_callback != NULL)
815 = hw_event_queue_schedule (me, 1, do_poll_event, NULL);
818 /* Simulator module init function for hw_rv_add_init. */
820 /* FIXME: For the call so hw_tree_traverse, we need to know that the
821 first member of struct sim_hw is the struct hw *root, but there's
822 no accessor method and struct sim_hw is defined in sim-hw.c only.
823 Hence this hack, until an accessor is added, or there's a traverse
824 function that takes a SIM_DESC argument. */
825 struct sim_hw { struct hw *tree; };
828 hw_rv_add_rv_pollers (SIM_DESC sd)
830 hw_tree_traverse (STATE_HW (sd)->tree, hw_rv_add_poller, NULL, NULL);
834 /* We need to add events for polling, but we can't add one from the
835 finish-function, and there are no other call points, at least for
836 instances without "reg" (when there are just DMA requests from the
837 remote end; no locally initiated activity). Therefore we add a
838 simulator module init function, but those don't have private
839 payload arguments; just a SD argument. We cope by parsing the HW
840 root and making sure *all* "rv":s have poll callbacks installed.
841 Luckily, this is just an initialization step, and not many
842 simultaneous instances of rv are expected: we get a N**2 complexity
843 for visits to each rv node by this method. */
846 hw_rv_add_init (struct hw *me)
848 sim_module_add_init_fn (hw_system (me), hw_rv_add_rv_pollers);
851 /* Open up a connection to the other side. Abort on errors. */
854 hw_rv_init_socket (struct hw *me)
856 hw_rv_device *rv = (hw_rv_device *) hw_data (me);
858 struct sockaddr_in server;
862 if (rv->dummy != NULL)
865 memset (&server, 0, sizeof (server));
866 server.sin_family = AF_INET;
867 server.sin_addr.s_addr = inet_addr (rv->host);
869 /* Solaris 2.7 lacks this macro. */
871 #define INADDR_NONE -1
874 if (server.sin_addr.s_addr == INADDR_NONE)
877 h = gethostbyname (rv->host);
880 memcpy (&server.sin_addr, h->h_addr, h->h_length);
881 server.sin_family = h->h_addrtype;
884 hw_abort (me, "can't resolve host %s", rv->host);
887 server.sin_port = htons (rv->port);
888 sock = socket (AF_INET, SOCK_STREAM, 0);
891 hw_abort (me, "can't get a socket for %s:%d connection",
894 if (connect (sock, (struct sockaddr *) &server, sizeof server) >= 0)
898 /* FIXME: init packet here. Maybe start packet too. */
899 if (rv->watchdog_interval != 0)
900 hw_rv_send_wdog (me);
903 /* Stash the errno for later display, if some connection activity
904 is requested. Don't emit an error here; we might have been
905 called just for test purposes. */
906 rv->saved_errno = errno;
909 /* Local rv register reads end up here. */
912 hw_rv_reg_read (struct hw *me,
916 unsigned int nr_bytes)
918 hw_rv_device *rv = (hw_rv_device *) hw_data (me);
919 unsigned8 addr_data[8] = "";
920 unsigned32 a_l = H2LE_4 (addr - rv->reg_address + rv->remote_reg_address);
921 unsigned int len = 8;
924 hw_abort (me, "must be four byte read");
926 if (addr == rv->mbox_address)
927 hw_abort (me, "invalid read of mbox address 0x%x",
928 (unsigned) rv->mbox_address);
930 memcpy (addr_data, &a_l, 4);
931 HW_TRACE ((me, "REG R 0x%x", addr));
932 if (rv->dummy != NULL)
935 memcpy (addr_data + 4, rv->dummy + addr - rv->reg_address, 4);
939 hw_rv_send (me, RV_READ_CMD, addr_data, len);
940 hw_rv_handle_incoming (me, RV_READ_CMD, addr_data, &len);
944 hw_abort (me, "read %d != 8 bytes returned", len);
945 HW_TRACE ((me, ":= 0x%02x%02x%02x%02x",
946 addr_data[7], addr_data[6], addr_data[5], addr_data[4]));
947 memcpy (dest, addr_data + 4, 4);
951 /* Local rv mbox requests (handle or put) end up here. */
954 hw_rv_mbox (struct hw *me, unsigned_word address)
956 unsigned8 buf[256+3];
961 = hw_dma_read_buffer (me, buf, 0, address, 3);
964 hw_abort (me, "mbox read %d != 3 bytes returned", len);
967 if (cmd != RV_MBOX_HANDLE_CMD && cmd != RV_MBOX_PUT_CMD)
968 hw_abort (me, "unsupported mbox command %d", cmd);
970 len = buf[0] + buf[1]*256;
972 if (len > sizeof (buf))
973 hw_abort (me, "mbox cmd %d send size %d unsupported", cmd, len);
975 rlen = hw_dma_read_buffer (me, buf + 3, 0, address + 3, len - 3);
977 hw_abort (me, "mbox read %d != %d bytes returned", rlen, len - 3);
979 HW_TRACE ((me, "MBOX %s 0x%x..0x%x",
980 cmd == RV_MBOX_HANDLE_CMD ? "H" : "P",
981 address, address + len - 1));
982 for (i = 0; i < rlen; i += 8)
983 HW_TRACE ((me, "0x%x: %02x %02x %02x %02x %02x %02x %02x %02x",
985 buf[3+i], buf[4+i], buf[5+i], buf[6+i], buf[7+i], buf[8+i],
986 buf[9+i], buf[10+i]));
989 hw_rv_send (me, cmd, buf + 3, len);
991 /* Note: both ..._PUT and ..._HANDLE get the ..._HANDLE reply. */
992 hw_rv_handle_incoming (me, RV_MBOX_HANDLE_CMD, buf + 3, &len);
993 if (len > sizeof (buf))
994 hw_abort (me, "mbox cmd %d receive size %d unsupported", cmd, len);
995 HW_TRACE ((me, "-> 0x%x..0x%x", address, address + len + 3 - 1));
996 for (i = 0; i < len; i += 8)
997 HW_TRACE ((me, "0x%x: %02x %02x %02x %02x %02x %02x %02x %02x",
999 buf[3+i], buf[4+i], buf[5+i], buf[6+i], buf[7+i], buf[8+i],
1000 buf[9+i], buf[10+i]));
1005 rlen = hw_dma_write_buffer (me, buf, 0, address, len, 0);
1007 hw_abort (me, "mbox write %d != %d bytes", rlen, len);
1010 /* Local rv register writes end up here. */
1013 hw_rv_reg_write (struct hw *me,
1017 unsigned int nr_bytes)
1019 hw_rv_device *rv = (hw_rv_device *) hw_data (me);
1021 unsigned8 addr_data[8] = "";
1022 unsigned32 a_l = H2LE_4 (addr - rv->reg_address + rv->remote_reg_address);
1023 unsigned int len = 8;
1026 hw_abort (me, "must be four byte write");
1028 memcpy (addr_data, &a_l, 4);
1029 memcpy (addr_data + 4, source, 4);
1031 if (addr == rv->mbox_address)
1033 unsigned32 mbox_addr_le;
1034 if (rv->dummy != NULL)
1035 hw_abort (me, "mbox not supported for a dummy instance");
1036 memcpy (&mbox_addr_le, source, 4);
1037 hw_rv_mbox (me, LE2H_4 (mbox_addr_le));
1041 HW_TRACE ((me, "REG W 0x%x := 0x%02x%02x%02x%02x", addr,
1042 addr_data[7], addr_data[6], addr_data[5], addr_data[4]));
1043 if (rv->dummy != NULL)
1046 memcpy (rv->dummy + addr - rv->reg_address, addr_data + 4, 4);
1050 hw_rv_send (me, RV_WRITE_CMD, addr_data, len);
1051 hw_rv_handle_incoming (me, RV_WRITE_CMD, addr_data, &len);
1055 hw_abort (me, "read %d != 8 bytes returned", len);
1057 /* We had an access: tighten up all slack. */
1058 rv->next_period = 1;
1063 /* Instance initializer function. */
1066 hw_rv_finish (struct hw *me)
1068 hw_rv_device *rv = HW_ZALLOC (me, hw_rv_device);
1070 const struct hw_property *mem_prop;
1071 const struct hw_property *dummy_prop;
1072 const struct hw_property *mbox_prop;
1074 set_hw_data (me, rv);
1078 #define RV_GET_PROP(T, N, M, D) \
1081 if (hw_find_property (me, N) != NULL) \
1082 rv->M = hw_find_ ## T ## _property (me, N); \
1087 #define RV_GET_IPROP(N, M, D) RV_GET_PROP (integer, N, M, D)
1089 RV_GET_PROP (string, "host", host, "127.0.0.1");
1090 RV_GET_IPROP ("port", port, 10000);
1091 RV_GET_IPROP ("remote-reg", remote_reg_address, 0);
1092 RV_GET_IPROP ("max-poll-ticks", max_tick_poll_interval, 10000);
1093 RV_GET_IPROP ("watchdog-interval", watchdog_interval, 30);
1094 RV_GET_IPROP ("remote-mem", remote_mem_address, 0);
1095 RV_GET_IPROP ("mem-burst-mask", mem_burst_mask, 0xffff);
1096 RV_GET_IPROP ("intmultiple", intmultiple, 0);
1098 set_hw_io_read_buffer (me, hw_rv_reg_read);
1099 set_hw_io_write_buffer (me, hw_rv_reg_write);
1100 set_hw_ports (me, hw_rv_ports);
1101 rv->next_period = 1;
1103 /* FIXME: We only support zero or one reg and zero or one mem area. */
1104 if (hw_find_property (me, "reg") != NULL)
1106 reg_property_spec reg;
1107 if (hw_find_reg_array_property (me, "reg", 0, ®))
1109 unsigned_word attach_address;
1111 unsigned int attach_size;
1113 hw_unit_address_to_attach_address (hw_parent (me),
1118 rv->reg_address = attach_address;
1119 hw_unit_size_to_attach_size (hw_parent (me),
1122 rv->reg_size = attach_size;
1123 if ((attach_address & 3) != 0)
1124 hw_abort (me, "register block must be 4 byte aligned");
1125 hw_attach_address (hw_parent (me),
1127 attach_space, attach_address, attach_size,
1131 hw_abort (me, "property \"reg\" has the wrong type");
1134 dummy_prop = hw_find_property (me, "dummy");
1135 if (dummy_prop != NULL)
1137 if (rv->reg_size == 0)
1138 hw_abort (me, "dummy argument requires a \"reg\" property");
1140 if (hw_property_type (dummy_prop) == integer_property)
1142 unsigned32 dummyfill = hw_find_integer_property (me, "dummy");
1143 unsigned8 *dummymem = hw_malloc (me, rv->reg_size);
1144 memset (dummymem, dummyfill, rv->reg_size);
1145 rv->dummy = dummymem;
1149 const char *dummyarg = hw_find_string_property (me, "dummy");
1150 unsigned8 *dummymem = hw_malloc (me, rv->reg_size);
1151 FILE *f = fopen (dummyarg, "rb");
1154 hw_abort (me, "opening dummy-file \"%s\": %s",
1155 dummyarg, strerror (errno));
1156 if (fread (dummymem, 1, rv->reg_size, f) != rv->reg_size)
1157 hw_abort (me, "reading dummy-file \"%s\": %s",
1158 dummyarg, strerror (errno));
1160 rv->dummy = dummymem;
1164 mbox_prop = hw_find_property (me, "mbox");
1165 if (mbox_prop != NULL)
1167 if (hw_property_type (mbox_prop) == integer_property)
1169 signed_cell attach_address_sc
1170 = hw_find_integer_property (me, "mbox");
1172 rv->mbox_address = (unsigned32) attach_address_sc;
1173 hw_attach_address (hw_parent (me),
1175 0, (unsigned32) attach_address_sc, 4, me);
1178 hw_abort (me, "property \"mbox\" has the wrong type");
1181 mem_prop = hw_find_property (me, "mem");
1182 if (mem_prop != NULL)
1184 signed_cell attach_address_sc;
1185 signed_cell attach_size_sc;
1187 /* Only specific names are reg_array_properties, the rest are
1188 array_properties. */
1189 if (hw_property_type (mem_prop) == array_property
1190 && hw_property_sizeof_array (mem_prop) == 2 * sizeof (attach_address_sc)
1191 && hw_find_integer_array_property (me, "mem", 0, &attach_address_sc)
1192 && hw_find_integer_array_property (me, "mem", 1, &attach_size_sc))
1194 /* Unfortunate choice of types forces us to dance around a bit. */
1195 rv->mem_address = (unsigned32) attach_address_sc;
1196 rv->mem_size = (unsigned32) attach_size_sc;
1197 if ((attach_address_sc & 3) != 0)
1198 hw_abort (me, "memory block must be 4 byte aligned");
1201 hw_abort (me, "property \"mem\" has the wrong type");
1204 hw_rv_map_ints (me);
1206 hw_rv_init_socket (me);
1208 /* We need an extra initialization pass, after all others currently
1209 scheduled (mostly, after the simulation events machinery has been
1210 initialized so the events we want don't get thrown out). */
1211 hw_rv_add_init (me);
1214 /* Our root structure; see dv-* build machinery for usage. */
1216 const struct hw_descriptor dv_rv_descriptor[] = {
1217 { RV_FAMILY_NAME, hw_rv_finish },