1 /* The remote-virtual-component simulator framework
2 for GDB, the GNU Debugger.
4 Copyright 2006-2021 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/>. */
34 #ifdef HAVE_SYS_TYPES_H
35 #include <sys/types.h>
38 #ifdef HAVE_SYS_TIME_H
42 #ifdef HAVE_SYS_SELECT_H
43 #include <sys/select.h>
46 /* Not guarded in dv-sockser.c, so why here. */
47 #include <netinet/in.h>
48 #include <arpa/inet.h>
50 #include <sys/socket.h>
56 rv - Remote Virtual component
62 Socket connection to a remote simulator component, for example one
63 for testing a verilog construction. Protocol defined below.
65 There is a set of 32-bit I/O ports, with a mapping from local to
66 remote addresses. There is a set of interrupts expressed as a
67 bit-mask, with a mapping from remote to local. There is a set of
68 memory ranges (actual memory defined elsewhere), also with a
69 mapping from remote to local addresses, that is expected to be
70 accessible to the remote simulator in 32-byte chunks (simulating
71 DMA). There is a mapping from remote cycles (or an appropriate
72 elsewhere defined time-slice) to local cycles.
76 reg = <address> <size>
77 The address (within the parent bus) that this device is to
80 remote-reg = <remote-address>
81 The address of reg on the remote side. Defaults to 0.
83 mem = <address> <size>
84 Specify an address-range (within the parent bus) that the remote
85 device can access. The memory is assumed to be already defined.
86 If there's no memory defined but the remote side asks for a memory
87 access, the simulation is aborted.
89 remote-mem = <remote-address>
90 The address of mem on the remote side. Defaults to 0.
93 Address of the mailbox interface. Writes to this address with the
94 local address of a mailbox command, a complete packet with length
95 and command; (4 or 6)) invokes the mailbox interface. Reads are
96 invalid. Replies are written to the same address. Address space
97 from <address> up-to-and-including <address>+3 is allocated.
99 max-poll-ticks = <local-count>
100 Sets the maximum interval between polling the external component,
101 expressed in internal cycles. Defaults to 10000.
103 watchdog-interval = <seconds>
104 Sets the wallclock seconds between watchdog packets sent to the
105 remote side (may be larger if there's no rv activity in that time).
106 Defaults to 30. If set to 0, no watchdog packets are sent.
108 intnum = <local-int-0> <local-int-1> ... <local-int-31>
109 Defines a map from remote bit numbers to local values to be emitted
110 on the "int" port, with the external bit number as the ordinal - 1
111 of the local translation. E.g. 43 121 would mean map external
112 (1<<0) to internal 43 and external (1<<1) to internal 121. The
113 default is unity; no translation. If more than one bit is set in
114 the remote interrupt word, the intmultiple property can be used to
115 control the translation.
117 intmultiple = <intvalue>
118 When more than one bit is set in the remote interrupt word, you may
119 want to map this situation to a separate interrupt value. If this
120 property is non-zero, it is used as that value. If it is zero, the
121 local value for the "int" port is the bitwise-or of the translated
125 The hostname or address where the simulator to be used listens.
126 Defaults to "127.0.0.1"
129 The hostname or address where the simulator to be used listens.
135 Don't connect to a remote side; use initial dummy contents from
136 <filename> (which has to be at least as big as the <size> argument
137 of reg above) or filled with byte-value <value>. Mailboxes are not
138 supported (can be defined but can not be used) and remote-memory
139 accesses don't apply. The main purpose for this property is to
140 simplify use of configuration and simulated hardware that is
141 e.g. only trivially initialized but not actually used.
147 Driven as a result of a remote interrupt request. The value is a
148 32-bit bitset of active interrupts.
158 This is version 1.0 of this protocol, defining packet format and
159 actions in a supposedly upward-compatible manner where client and
160 servers of different versions are expected to interoperate; the
161 format and the definitions below are hopefully generic enough to
164 Each connection has a server and a client (this code); the roles
165 are known beforehand. The client usually corresponds to a CPU and
166 memory system and the server corresponds to a memory-mapped
167 register hardware interface and/or a DMA controller. They
168 communicate using packets with specific commands, of which some
169 require replies from the other side; most are intiated by the
170 client with one exception. A reply uses the same format as the
173 Packets are at least three bytes long, where the first two bytes
174 form a header, a 16-bit little-endian number that is the total
175 length of the packet including the header. There is also a
176 one-byte command. The payload is optional, depending on the
179 [[16-bit-low-byte-of-length] [16-bit-high-byte-of-length]
180 [command/reply] [payload byte 0] [payload byte 1]
181 ... [payload byte (length-of-packet - 3)]]
185 A client or server that reads an undocumented command may exit with
186 a hard error. Payload not defined or disallowed below is ignored.
188 It is expected that future client versions find out the version of
189 the server side by polling with base commands, assuming earlier
190 versions if a certain reply isn't seen, with newly defined payload
191 parts where earlier versions left it undefined. New commands and
192 formats are sent only to the other side after the client and server
193 has found out each others version. Not all servers support all
194 commands; the type of server and supported set of commands is
195 expected to be known beforehand.
198 Initiated by the client, requires a reply from the server. The
199 payload from the client is at least 4 bytes, forming a 4-byte
200 little-endian address, the rest being undefined. The reply from
201 the server is at least 8 bytes, forming the same address data as in
202 the request and the second 4-byte data being the little-endian
206 Initiated by the client, requires a reply from the server. Payload
207 from the client is at least 8 bytes, forming a 4-byte little-endian
208 word being the address, the rest being the little-endian contents
209 to write. The reply from the server is 8 bytes unless elsewhere
210 agreed otherwise, forming the same address and data as in the
211 request. The data sent back may have been altered to correspond to
212 defined parts but can safely be discarded.
215 Initiated by the server, no reply. The payload is 4 bytes, forming
216 a little-endian word with bits numbers corresponding to currently
217 active interrupt sources; value (1<<N) indicating interrupt source
221 Initiated by the server, requires a reply. A client must know
222 beforehand when (in command sequence or constant) the server can
223 send this command and if so must then not send any commands of its
224 own (including watchdog commands); the server is allowed to assume
225 that incoming data is only replies to this command. The format is
226 8 bytes of data; 4 bytes of little-endian address followed by a
227 32-bit little endian word with the number of bytes to read. The
228 reply is the same address and number of bytes, followed by the data
232 Initiated by the server, no reply. The format is the same as a
233 reply to RV_MEM_RD_CMD; a 32-bit little-endian address, followed by
234 the 32-bit little-endian number of bytes to write (redundant
235 information but must be consistent with the packet header).
237 RV_MBOX_HANDLE_CMD = 5
238 Initiated by the client, requires a reply. The payload is 4
239 undefined bytes followed by an binary blob, the size of the
240 blob given by the packet header. The reply is a 32-bit little
241 endian number at the same index as the undefined bytes. Actual
242 semantics are application-specific.
245 Initiated by the client, requires a reply, with the reply using the
246 RV_MBOX_HANDLE_CMD reply format (i.e. *both* that command and
247 32-bit little-endian number). The payload is a 32-bit little
248 endian number followed by an undefined payload, at most 20 bytes
249 long. The reply is a 32-bit little endian number. Actual
250 semantics are application-specific.
253 Initiated by the client, no reply. A version 1.0 client sends no
254 payload; a version 1.0 server should ignore any such payload. A
255 version 1.0 server must not send a reply.
258 Possible future enhancements:
260 Synchronization; server and client reports the number of elapsed
261 cycles (unit to-be-defined) at each request or notification.
262 Pretty much the top-of-the-todo-list item.
264 Large addresses; 1.0 being restricted to 32-bit addresses.
266 Variable-size data; currently restricted to 32-bit register
269 Specified data endianness (not the packet header) perhaps as part
270 of an initial format request; currently little-endian only.
274 When used with servers sending RV_MEM_RD_CMD but being
275 narrow-minded about indata, set watchdog-interval to 0. Use
276 multiple rv instances when there are e.g. separate register and
277 memory servers. Alway log, setting "/rv/trace? true", at the
278 development phase. Borrow from the test-suite.
281 #define RV_FAMILY_NAME "rv"
289 RV_MBOX_HANDLE_CMD
= 5,
295 typedef struct _hw_rv_device
297 /* Mapping of remote interrupt bit-numbers to local ones. */
298 unsigned32 remote_to_local_int
[32];
300 /* When multiple bits are set, a non-zero value here indicates that
301 this value should be used instead. */
302 unsigned32 intmultiple
;
304 /* Local address of registers. */
305 unsigned32 reg_address
;
307 /* Size of register bank in bytes. */
310 /* Remote address of registers. */
311 unsigned32 remote_reg_address
;
313 /* Local address of DMA:able memory. */
314 unsigned32 mem_address
;
316 /* Size of DMA:able memory in bytes. */
319 /* Bitmask for valid DMA request size. */
320 unsigned32 mem_burst_mask
;
322 /* Remote address of DMA:able memory. */
323 unsigned32 remote_mem_address
;
325 /* (Local) address of mbox; where to put a pointer to the mbox to be
327 unsigned32 mbox_address
;
329 /* Probably not 127.0.0.1:10000. */
333 /* If non-NULL, points to memory to use instead of connection. */
336 /* File descriptor for the socket. Set to -1 when error. Only one
337 of dummy and this is active. */
340 /* Stashed errno, as we don't emit an error right away. */
343 /* This, plus latency because the CPU might not be checking until a
344 CTI insn (usually a branch or a jump) is the interval in cycles
345 between the rv is polled for e.g. DMA requests. */
346 unsigned32 max_tick_poll_interval
;
348 /* Running counter for exponential backoff up to
349 max_tick_poll_interval to avoid polling the connection
350 unnecessarily often. Set to 1 when rv activity (read/write
351 register, DMA request) is detected. */
352 unsigned32 next_period
;
354 /* This is the interval in wall-clock seconds between watchdog
355 packets are sent to the remote side. Zero means no watchdog
357 unsigned32 watchdog_interval
;
359 /* Last time we sent a watchdog packet. */
360 struct timeval last_wdog_time
;
362 /* Mostly used as a kludge for knowing which rv:s have poll events
364 struct hw_event
*poll_callback
;
368 /* We might add ports in the future, so keep this an enumeration. */
375 static const struct hw_port_descriptor hw_rv_ports
[] = {
376 { "int", INT_PORT
, 0, output_port
},
380 /* Send LEN bytes of data from BUF to the socket. Abort on
384 hw_rv_write (struct hw
*me
,
388 hw_rv_device
*rv
= (hw_rv_device
*) hw_data (me
);
389 unsigned8
*bufp
= buf
;
391 /* If we don't have a valid fd here, it's because we got an error
392 initially, and we suppressed that error. */
394 hw_abort (me
, "couldn't open a connection to %s:%d because: %s",
395 rv
->host
, rv
->port
, strerror (rv
->saved_errno
));
399 ssize_t ret
= write (rv
->fd
, bufp
, len
);
401 /* FIXME: More graceful exit. */
402 hw_abort (me
, "write to %s:%d failed: %s\n", rv
->host
, rv
->port
,
410 /* Read LEN bytes of data into BUF from the socket. Set the file
411 descriptor to -1 if there's an error. */
414 hw_rv_read (struct hw
*me
,
418 hw_rv_device
*rv
= (hw_rv_device
*) hw_data (me
);
419 unsigned8
*bufp
= buf
;
423 ssize_t ret
= read (rv
->fd
, bufp
, len
);
425 /* We get all zero if the remote end quits, but no error
426 indication; even select says there's data active. */
429 if (close (rv
->fd
) != 0)
430 /* FIXME: More graceful exit. */
431 hw_abort (me
, "read from %s:%d failed: %d\n", rv
->host
, rv
->port
, errno
);
441 /* Construct and send a packet of data of type CMD and len
442 LEN_NOHEADER (not counting the header...). */
445 hw_rv_send (struct hw
*me
,
448 unsigned int len_noheader
)
450 hw_rv_device
*rv
= (hw_rv_device
*) hw_data (me
);
453 unsigned int len
= len_noheader
+ 3;
457 buf
[1] = (len
>> 8) & 255;
460 if (len
> sizeof (buf
))
462 hw_rv_write (me
, buf
, 3);
468 memcpy (buf
+ 3, msg
, len_noheader
);
472 hw_rv_write (me
, bufp
, len
);
475 /* Handle incoming DMA requests as per the RV_MEM_RD_CMD packet.
479 hw_rv_read_mem (struct hw
*me
, unsigned int len
)
481 hw_rv_device
*rv
= (hw_rv_device
*) hw_data (me
);
482 /* If you change this size, please adjust the mem2 testcase. */
484 unsigned8
*bufp
= buf
;
491 hw_abort (me
, "expected DMA read request len 8+3, got %d+3", len
);
493 hw_rv_read (me
, &leaddr
, 4);
494 hw_rv_read (me
, &lelen
, 4);
495 len
= LE2H_4 (lelen
);
496 addr
= LE2H_4 (leaddr
);
498 if (addr
< rv
->remote_mem_address
499 || addr
>= rv
->remote_mem_address
+ rv
->mem_size
)
500 hw_abort (me
, "DMA read at remote 0x%x; outside [0x%x..0x%x-1]",
501 (unsigned) addr
, (unsigned) rv
->remote_mem_address
,
502 (unsigned) (rv
->remote_mem_address
+ rv
->mem_size
));
503 addr
= addr
- rv
->remote_mem_address
+ rv
->mem_address
;
506 hw_abort (me
, "DMA read request for 0 bytes isn't supported");
508 if (len
& ~rv
->mem_burst_mask
)
509 hw_abort (me
, "DMA trying to read %d bytes; not matching mask of 0x%x",
510 len
, rv
->mem_burst_mask
);
511 if (len
+ 8 > sizeof (buf
))
512 bufp
= hw_malloc (me
, len
+ 8);
514 HW_TRACE ((me
, "DMA R 0x%x..0x%x", addr
, addr
+ len
-1));
515 hw_dma_read_buffer (me
, bufp
+ 8, 0, addr
, len
);
517 for (i
= 0; i
< len
; i
+= 4)
518 HW_TRACE ((me
, "0x%x: %02x %02x %02x %02x",
520 bufp
[i
+8], bufp
[i
+9], bufp
[i
+10], bufp
[i
+11]));
522 memcpy (bufp
, &leaddr
, 4);
523 memcpy (bufp
+ 4, &lelen
, 4);
524 hw_rv_send (me
, RV_MEM_RD_CMD
, bufp
, len
+ 8);
529 /* Handle incoming DMA requests as per the RV_MEM_WR_CMD packet.
533 hw_rv_write_mem (struct hw
*me
, unsigned int plen
)
535 hw_rv_device
*rv
= (hw_rv_device
*) hw_data (me
);
536 /* If you change this size, please adjust the mem2 testcase. */
538 unsigned8
*bufp
= buf
;
545 hw_rv_read (me
, &leaddr
, 4);
546 hw_rv_read (me
, &lelen
, 4);
547 len
= LE2H_4 (lelen
);
548 addr
= LE2H_4 (leaddr
);
552 "inconsistency in DMA write request packet: "
553 "envelope %d+3, inner %d bytes", plen
, len
);
555 if (addr
< rv
->remote_mem_address
556 || addr
>= rv
->remote_mem_address
+ rv
->mem_size
)
557 hw_abort (me
, "DMA write at remote 0x%x; outside [0x%x..0x%x-1]",
558 (unsigned) addr
, (unsigned) rv
->remote_mem_address
,
559 (unsigned) (rv
->remote_mem_address
+ rv
->mem_size
));
561 addr
= addr
- rv
->remote_mem_address
+ rv
->mem_address
;
563 hw_abort (me
, "DMA write request for 0 bytes isn't supported");
565 if (len
& ~rv
->mem_burst_mask
)
566 hw_abort (me
, "DMA trying to write %d bytes; not matching mask of 0x%x",
567 len
, rv
->mem_burst_mask
);
568 if (len
+ 8 > sizeof (buf
))
569 bufp
= hw_malloc (me
, len
+ 8);
571 hw_rv_read (me
, bufp
+ 8, len
);
572 HW_TRACE ((me
, "DMA W 0x%x..0x%x", addr
, addr
+ len
- 1));
573 hw_dma_write_buffer (me
, bufp
+ 8, 0, addr
, len
, 0);
575 for (i
= 0; i
< len
; i
+= 4)
576 HW_TRACE ((me
, "0x%x: %02x %02x %02x %02x",
578 bufp
[i
+8], bufp
[i
+9], bufp
[i
+10], bufp
[i
+11]));
584 hw_rv_irq (struct hw
*me
, unsigned int len
)
586 hw_rv_device
*rv
= (hw_rv_device
*) hw_data (me
);
587 unsigned32 intbitsle
;
588 unsigned32 intbits_ext
;
589 unsigned32 intval
= 0;
593 hw_abort (me
, "IRQ with %d data not supported", len
);
595 hw_rv_read (me
, &intbitsle
, 4);
596 intbits_ext
= LE2H_4 (intbitsle
);
597 for (i
= 0; i
< 32; i
++)
598 if ((intbits_ext
& (1 << i
)) != 0)
599 intval
|= rv
->remote_to_local_int
[i
];
600 if ((intbits_ext
& ~(intbits_ext
- 1)) != intbits_ext
601 && rv
->intmultiple
!= 0)
602 intval
= rv
->intmultiple
;
604 HW_TRACE ((me
, "IRQ 0x%x", intval
));
605 hw_port_event (me
, INT_PORT
, intval
);
608 /* Handle incoming interrupt notifications as per the RV_IRQ_CMD
609 packet. Abort on errors. */
612 hw_rv_handle_incoming (struct hw
*me
,
615 unsigned int *return_len
)
617 hw_rv_device
*rv
= (hw_rv_device
*) hw_data (me
);
624 hw_rv_read (me
, cbuf
, 3);
629 len
= cbuf
[0] + cbuf
[1] * 256 - 3;
632 /* These come in "asynchronously"; not as a reply. */
640 hw_rv_read_mem (me
, len
);
644 hw_rv_write_mem (me
, len
);
648 /* Something is incoming from the other side, so tighten up all
649 slack at the next wait. */
657 /* Don't try to handle more than one of these if we were'nt
658 expecting a reply. */
659 if (expected_type
== -1)
664 /* Require a match between this supposed-reply and the command
666 if (cmd
!= expected_type
)
667 hw_abort (me
, "unexpected reply, expected command %d, got %d",
672 case RV_MBOX_PUT_CMD
:
673 case RV_MBOX_HANDLE_CMD
:
676 hw_rv_read (me
, buf
, len
<= *return_len
? len
: *return_len
);
684 /* Send a watchdog packet. Make a note of wallclock time. */
687 hw_rv_send_wdog (struct hw
*me
)
689 hw_rv_device
*rv
= (hw_rv_device
*) hw_data (me
);
690 HW_TRACE ((me
, "WD"));
691 gettimeofday (&rv
->last_wdog_time
, NULL
);
692 hw_rv_send (me
, RV_WATCHDOG_CMD
, "", 0);
695 /* Poll the remote side: see if there's any incoming traffic; handle a
696 packet if so. Send a watchdog packet if it's time to do so.
697 Beware that the Linux select call indicates traffic for a socket
698 that the remote side has closed (which may be because it was
699 finished; don't hork until we need to write something just because
703 hw_rv_poll_once (struct hw
*me
)
705 hw_rv_device
*rv
= (hw_rv_device
*) hw_data (me
);
713 /* Connection has died or was never initiated. */
717 FD_SET (rv
->fd
, &rfds
);
719 FD_SET (rv
->fd
, &efds
);
723 ret
= select (rv
->fd
+ 1, &rfds
, NULL
, &efds
, &tv
);
724 gettimeofday (&now
, NULL
);
727 hw_abort (me
, "select failed: %d\n", errno
);
729 if (rv
->watchdog_interval
!= 0
730 && now
.tv_sec
- rv
->last_wdog_time
.tv_sec
>= rv
->watchdog_interval
)
731 hw_rv_send_wdog (me
);
733 if (FD_ISSET (rv
->fd
, &rfds
))
734 hw_rv_handle_incoming (me
, -1, NULL
, NULL
);
737 /* Initialize mapping of remote-to-local interrupt data. */
740 hw_rv_map_ints (struct hw
*me
)
742 hw_rv_device
*rv
= (hw_rv_device
*) hw_data (me
);
745 for (i
= 0; i
< 32; i
++)
746 rv
->remote_to_local_int
[i
] = 1 << i
;
748 if (hw_find_property (me
, "intnum") != NULL
)
749 for (i
= 0; i
< 32; i
++)
751 signed_cell val
= -1;
752 if (hw_find_integer_array_property (me
, "intnum", i
, &val
) > 0)
755 rv
->remote_to_local_int
[i
] = val
;
757 hw_abort (me
, "property \"intnum@%d\" must be > 0; is %d",
763 /* Handle the after-N-ticks "poll event", calling the poll-the-fd
764 method. Update the period. */
767 do_poll_event (struct hw
*me
, void *data
)
769 hw_rv_device
*rv
= (hw_rv_device
*) hw_data (me
);
770 unsigned32 new_period
;
772 if (rv
->dummy
!= NULL
)
775 hw_rv_poll_once (me
);
778 = hw_event_queue_schedule (me
, rv
->next_period
, do_poll_event
, NULL
);
780 new_period
= rv
->next_period
* 2;
781 if (new_period
<= rv
->max_tick_poll_interval
)
782 rv
->next_period
= new_period
;
785 /* HW tree traverse function for hw_rv_add_init. */
788 hw_rv_add_poller (struct hw
*me
, void *data
)
792 if (hw_family (me
) == NULL
793 || strcmp (hw_family (me
), RV_FAMILY_NAME
) != 0)
796 rv
= (hw_rv_device
*) hw_data (me
);
797 if (rv
->poll_callback
!= NULL
)
801 = hw_event_queue_schedule (me
, 1, do_poll_event
, NULL
);
804 /* Simulator module init function for hw_rv_add_init. */
806 /* FIXME: For the call so hw_tree_traverse, we need to know that the
807 first member of struct sim_hw is the struct hw *root, but there's
808 no accessor method and struct sim_hw is defined in sim-hw.c only.
809 Hence this hack, until an accessor is added, or there's a traverse
810 function that takes a SIM_DESC argument. */
811 struct sim_hw
{ struct hw
*tree
; };
814 hw_rv_add_rv_pollers (SIM_DESC sd
)
816 hw_tree_traverse (STATE_HW (sd
)->tree
, hw_rv_add_poller
, NULL
, NULL
);
820 /* We need to add events for polling, but we can't add one from the
821 finish-function, and there are no other call points, at least for
822 instances without "reg" (when there are just DMA requests from the
823 remote end; no locally initiated activity). Therefore we add a
824 simulator module init function, but those don't have private
825 payload arguments; just a SD argument. We cope by parsing the HW
826 root and making sure *all* "rv":s have poll callbacks installed.
827 Luckily, this is just an initialization step, and not many
828 simultaneous instances of rv are expected: we get a N**2 complexity
829 for visits to each rv node by this method. */
832 hw_rv_add_init (struct hw
*me
)
834 sim_module_add_init_fn (hw_system (me
), hw_rv_add_rv_pollers
);
837 /* Open up a connection to the other side. Abort on errors. */
840 hw_rv_init_socket (struct hw
*me
)
842 hw_rv_device
*rv
= (hw_rv_device
*) hw_data (me
);
844 struct sockaddr_in server
;
848 if (rv
->dummy
!= NULL
)
851 memset (&server
, 0, sizeof (server
));
852 server
.sin_family
= AF_INET
;
853 server
.sin_addr
.s_addr
= inet_addr (rv
->host
);
855 /* Solaris 2.7 lacks this macro. */
857 #define INADDR_NONE -1
860 if (server
.sin_addr
.s_addr
== INADDR_NONE
)
863 h
= gethostbyname (rv
->host
);
866 memcpy (&server
.sin_addr
, h
->h_addr
, h
->h_length
);
867 server
.sin_family
= h
->h_addrtype
;
870 hw_abort (me
, "can't resolve host %s", rv
->host
);
873 server
.sin_port
= htons (rv
->port
);
874 sock
= socket (AF_INET
, SOCK_STREAM
, 0);
877 hw_abort (me
, "can't get a socket for %s:%d connection",
880 if (connect (sock
, (struct sockaddr
*) &server
, sizeof server
) >= 0)
884 /* FIXME: init packet here. Maybe start packet too. */
885 if (rv
->watchdog_interval
!= 0)
886 hw_rv_send_wdog (me
);
889 /* Stash the errno for later display, if some connection activity
890 is requested. Don't emit an error here; we might have been
891 called just for test purposes. */
892 rv
->saved_errno
= errno
;
895 /* Local rv register reads end up here. */
898 hw_rv_reg_read (struct hw
*me
,
902 unsigned int nr_bytes
)
904 hw_rv_device
*rv
= (hw_rv_device
*) hw_data (me
);
905 unsigned8 addr_data
[8] = "";
906 unsigned32 a_l
= H2LE_4 (addr
- rv
->reg_address
+ rv
->remote_reg_address
);
907 unsigned int len
= 8;
910 hw_abort (me
, "must be four byte read");
912 if (addr
== rv
->mbox_address
)
913 hw_abort (me
, "invalid read of mbox address 0x%x",
914 (unsigned) rv
->mbox_address
);
916 memcpy (addr_data
, &a_l
, 4);
917 HW_TRACE ((me
, "REG R 0x%x", addr
));
918 if (rv
->dummy
!= NULL
)
921 memcpy (addr_data
+ 4, rv
->dummy
+ addr
- rv
->reg_address
, 4);
925 hw_rv_send (me
, RV_READ_CMD
, addr_data
, len
);
926 hw_rv_handle_incoming (me
, RV_READ_CMD
, addr_data
, &len
);
930 hw_abort (me
, "read %d != 8 bytes returned", len
);
931 HW_TRACE ((me
, ":= 0x%02x%02x%02x%02x",
932 addr_data
[7], addr_data
[6], addr_data
[5], addr_data
[4]));
933 memcpy (dest
, addr_data
+ 4, 4);
937 /* Local rv mbox requests (handle or put) end up here. */
940 hw_rv_mbox (struct hw
*me
, unsigned_word address
)
942 unsigned8 buf
[256+3];
947 = hw_dma_read_buffer (me
, buf
, 0, address
, 3);
950 hw_abort (me
, "mbox read %d != 3 bytes returned", len
);
953 if (cmd
!= RV_MBOX_HANDLE_CMD
&& cmd
!= RV_MBOX_PUT_CMD
)
954 hw_abort (me
, "unsupported mbox command %d", cmd
);
956 len
= buf
[0] + buf
[1]*256;
958 if (len
> sizeof (buf
))
959 hw_abort (me
, "mbox cmd %d send size %d unsupported", cmd
, len
);
961 rlen
= hw_dma_read_buffer (me
, buf
+ 3, 0, address
+ 3, len
- 3);
963 hw_abort (me
, "mbox read %d != %d bytes returned", rlen
, len
- 3);
965 HW_TRACE ((me
, "MBOX %s 0x%x..0x%x",
966 cmd
== RV_MBOX_HANDLE_CMD
? "H" : "P",
967 address
, address
+ len
- 1));
968 for (i
= 0; i
< rlen
; i
+= 8)
969 HW_TRACE ((me
, "0x%x: %02x %02x %02x %02x %02x %02x %02x %02x",
971 buf
[3+i
], buf
[4+i
], buf
[5+i
], buf
[6+i
], buf
[7+i
], buf
[8+i
],
972 buf
[9+i
], buf
[10+i
]));
975 hw_rv_send (me
, cmd
, buf
+ 3, len
);
977 /* Note: both ..._PUT and ..._HANDLE get the ..._HANDLE reply. */
978 hw_rv_handle_incoming (me
, RV_MBOX_HANDLE_CMD
, buf
+ 3, &len
);
979 if (len
> sizeof (buf
))
980 hw_abort (me
, "mbox cmd %d receive size %d unsupported", cmd
, len
);
981 HW_TRACE ((me
, "-> 0x%x..0x%x", address
, address
+ len
+ 3 - 1));
982 for (i
= 0; i
< len
; 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
]));
991 rlen
= hw_dma_write_buffer (me
, buf
, 0, address
, len
, 0);
993 hw_abort (me
, "mbox write %d != %d bytes", rlen
, len
);
996 /* Local rv register writes end up here. */
999 hw_rv_reg_write (struct hw
*me
,
1003 unsigned int nr_bytes
)
1005 hw_rv_device
*rv
= (hw_rv_device
*) hw_data (me
);
1007 unsigned8 addr_data
[8] = "";
1008 unsigned32 a_l
= H2LE_4 (addr
- rv
->reg_address
+ rv
->remote_reg_address
);
1009 unsigned int len
= 8;
1012 hw_abort (me
, "must be four byte write");
1014 memcpy (addr_data
, &a_l
, 4);
1015 memcpy (addr_data
+ 4, source
, 4);
1017 if (addr
== rv
->mbox_address
)
1019 unsigned32 mbox_addr_le
;
1020 if (rv
->dummy
!= NULL
)
1021 hw_abort (me
, "mbox not supported for a dummy instance");
1022 memcpy (&mbox_addr_le
, source
, 4);
1023 hw_rv_mbox (me
, LE2H_4 (mbox_addr_le
));
1027 HW_TRACE ((me
, "REG W 0x%x := 0x%02x%02x%02x%02x", addr
,
1028 addr_data
[7], addr_data
[6], addr_data
[5], addr_data
[4]));
1029 if (rv
->dummy
!= NULL
)
1032 memcpy (rv
->dummy
+ addr
- rv
->reg_address
, addr_data
+ 4, 4);
1036 hw_rv_send (me
, RV_WRITE_CMD
, addr_data
, len
);
1037 hw_rv_handle_incoming (me
, RV_WRITE_CMD
, addr_data
, &len
);
1041 hw_abort (me
, "read %d != 8 bytes returned", len
);
1043 /* We had an access: tighten up all slack. */
1044 rv
->next_period
= 1;
1049 /* Instance initializer function. */
1052 hw_rv_finish (struct hw
*me
)
1054 hw_rv_device
*rv
= HW_ZALLOC (me
, hw_rv_device
);
1056 const struct hw_property
*mem_prop
;
1057 const struct hw_property
*dummy_prop
;
1058 const struct hw_property
*mbox_prop
;
1060 set_hw_data (me
, rv
);
1064 #define RV_GET_PROP(T, N, M, D) \
1067 if (hw_find_property (me, N) != NULL) \
1068 rv->M = hw_find_ ## T ## _property (me, N); \
1073 #define RV_GET_IPROP(N, M, D) RV_GET_PROP (integer, N, M, D)
1075 RV_GET_PROP (string
, "host", host
, "127.0.0.1");
1076 RV_GET_IPROP ("port", port
, 10000);
1077 RV_GET_IPROP ("remote-reg", remote_reg_address
, 0);
1078 RV_GET_IPROP ("max-poll-ticks", max_tick_poll_interval
, 10000);
1079 RV_GET_IPROP ("watchdog-interval", watchdog_interval
, 30);
1080 RV_GET_IPROP ("remote-mem", remote_mem_address
, 0);
1081 RV_GET_IPROP ("mem-burst-mask", mem_burst_mask
, 0xffff);
1082 RV_GET_IPROP ("intmultiple", intmultiple
, 0);
1084 set_hw_io_read_buffer (me
, hw_rv_reg_read
);
1085 set_hw_io_write_buffer (me
, hw_rv_reg_write
);
1086 set_hw_ports (me
, hw_rv_ports
);
1087 rv
->next_period
= 1;
1089 /* FIXME: We only support zero or one reg and zero or one mem area. */
1090 if (hw_find_property (me
, "reg") != NULL
)
1092 reg_property_spec reg
;
1093 if (hw_find_reg_array_property (me
, "reg", 0, ®
))
1095 unsigned_word attach_address
;
1097 unsigned int attach_size
;
1099 hw_unit_address_to_attach_address (hw_parent (me
),
1104 rv
->reg_address
= attach_address
;
1105 hw_unit_size_to_attach_size (hw_parent (me
),
1108 rv
->reg_size
= attach_size
;
1109 if ((attach_address
& 3) != 0)
1110 hw_abort (me
, "register block must be 4 byte aligned");
1111 hw_attach_address (hw_parent (me
),
1113 attach_space
, attach_address
, attach_size
,
1117 hw_abort (me
, "property \"reg\" has the wrong type");
1120 dummy_prop
= hw_find_property (me
, "dummy");
1121 if (dummy_prop
!= NULL
)
1123 if (rv
->reg_size
== 0)
1124 hw_abort (me
, "dummy argument requires a \"reg\" property");
1126 if (hw_property_type (dummy_prop
) == integer_property
)
1128 unsigned32 dummyfill
= hw_find_integer_property (me
, "dummy");
1129 unsigned8
*dummymem
= hw_malloc (me
, rv
->reg_size
);
1130 memset (dummymem
, dummyfill
, rv
->reg_size
);
1131 rv
->dummy
= dummymem
;
1135 const char *dummyarg
= hw_find_string_property (me
, "dummy");
1136 unsigned8
*dummymem
= hw_malloc (me
, rv
->reg_size
);
1137 FILE *f
= fopen (dummyarg
, "rb");
1140 hw_abort (me
, "opening dummy-file \"%s\": %s",
1141 dummyarg
, strerror (errno
));
1142 if (fread (dummymem
, 1, rv
->reg_size
, f
) != rv
->reg_size
)
1143 hw_abort (me
, "reading dummy-file \"%s\": %s",
1144 dummyarg
, strerror (errno
));
1146 rv
->dummy
= dummymem
;
1150 mbox_prop
= hw_find_property (me
, "mbox");
1151 if (mbox_prop
!= NULL
)
1153 if (hw_property_type (mbox_prop
) == integer_property
)
1155 signed_cell attach_address_sc
1156 = hw_find_integer_property (me
, "mbox");
1158 rv
->mbox_address
= (unsigned32
) attach_address_sc
;
1159 hw_attach_address (hw_parent (me
),
1161 0, (unsigned32
) attach_address_sc
, 4, me
);
1164 hw_abort (me
, "property \"mbox\" has the wrong type");
1167 mem_prop
= hw_find_property (me
, "mem");
1168 if (mem_prop
!= NULL
)
1170 signed_cell attach_address_sc
;
1171 signed_cell attach_size_sc
;
1173 /* Only specific names are reg_array_properties, the rest are
1174 array_properties. */
1175 if (hw_property_type (mem_prop
) == array_property
1176 && hw_property_sizeof_array (mem_prop
) == 2 * sizeof (attach_address_sc
)
1177 && hw_find_integer_array_property (me
, "mem", 0, &attach_address_sc
)
1178 && hw_find_integer_array_property (me
, "mem", 1, &attach_size_sc
))
1180 /* Unfortunate choice of types forces us to dance around a bit. */
1181 rv
->mem_address
= (unsigned32
) attach_address_sc
;
1182 rv
->mem_size
= (unsigned32
) attach_size_sc
;
1183 if ((attach_address_sc
& 3) != 0)
1184 hw_abort (me
, "memory block must be 4 byte aligned");
1187 hw_abort (me
, "property \"mem\" has the wrong type");
1190 hw_rv_map_ints (me
);
1192 hw_rv_init_socket (me
);
1194 /* We need an extra initialization pass, after all others currently
1195 scheduled (mostly, after the simulation events machinery has been
1196 initialized so the events we want don't get thrown out). */
1197 hw_rv_add_init (me
);
1200 /* Our root structure; see dv-* build machinery for usage. */
1202 const struct hw_descriptor dv_rv_descriptor
[] = {
1203 { RV_FAMILY_NAME
, hw_rv_finish
},