src/devices/dev_ether.c

/*
 *  Copyright (C) 2005-2007  Anders Gavare.  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright  
 *     notice, this list of conditions and the following disclaimer in the 
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE   
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 *   
 *
 *  $Id: dev_ether.c,v 1.17 2006/12/30 13:30:57 debug Exp $
 *
 *  Basic "ethernet" network device. This is a simple test device which can
 *  be used to send and receive packets to/from a simulated ethernet network.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "cpu.h"
#include "device.h"
#include "emul.h"
#include "machine.h"
#include "memory.h"
#include "misc.h"
#include "net.h"

#include "testmachine/dev_ether.h"


#define DEV_ETHER_TICK_SHIFT    14

struct ether_data {
        unsigned char           buf[DEV_ETHER_BUFFER_SIZE];
        unsigned char           mac[6];

        int                     status;
        int                     packet_len;

        struct interrupt        irq;
};


DEVICE_TICK(ether)
{  
        struct ether_data *d = (struct ether_data *) extra;
        int r = 0;

        d->status &= ~DEV_ETHER_STATUS_MORE_PACKETS_AVAILABLE;
        if (cpu->machine->emul->net != NULL)
                r = net_ethernet_rx_avail(cpu->machine->emul->net, d);
        if (r)
                d->status |= DEV_ETHER_STATUS_MORE_PACKETS_AVAILABLE;

        if (d->status)
                INTERRUPT_ASSERT(d->irq);
        else
                INTERRUPT_DEASSERT(d->irq);
}


DEVICE_ACCESS(ether_buf)
{
        struct ether_data *d = (struct ether_data *) extra;

        if (writeflag == MEM_WRITE)
                memcpy(d->buf + relative_addr, data, len);
        else
                memcpy(data, d->buf + relative_addr, len);
        return 1;
}


DEVICE_ACCESS(ether)
{
        struct ether_data *d = (struct ether_data *) extra;
        uint64_t idata = 0, odata = 0;
        unsigned char *incoming_ptr;
        int incoming_len;

        if (writeflag == MEM_WRITE)
                idata = memory_readmax64(cpu, data, len);

        /*  Note: relative_addr + DEV_ETHER_BUFFER_SIZE to get the same
            offsets as in the header file:  */

        switch (relative_addr + DEV_ETHER_BUFFER_SIZE) {

        case DEV_ETHER_STATUS:
                if (writeflag == MEM_READ) {
                        odata = d->status;
                        d->status = 0;
                        INTERRUPT_DEASSERT(d->irq);
                } else
                        fatal("[ ether: WARNING: write to status ]\n");
                break;

        case DEV_ETHER_PACKETLENGTH:
                if (writeflag == MEM_READ)
                        odata = d->packet_len;
                else {
                        if ((int64_t)idata < 0) {
                                fatal("[ ether: ERROR: packet len too"
                                    " short (%i bytes) ]\n", (int)idata);
                                idata = -1;
                        }
                        if (idata > DEV_ETHER_BUFFER_SIZE) {
                                fatal("[ ether: ERROR: packet len too"
                                    " large (%i bytes) ]\n", (int)idata);
                                idata = DEV_ETHER_BUFFER_SIZE;
                        }
                        d->packet_len = idata;
                }
                break;

        case DEV_ETHER_COMMAND:
                if (writeflag == MEM_READ) {
                        fatal("[ ether: WARNING: read from command ]\n");
                        break;
                }

                /*  Write:  */
                switch (idata) {

                case DEV_ETHER_COMMAND_RX:      /*  Receive:  */
                        if (cpu->machine->emul->net == NULL)
                                fatal("[ ether: RECEIVE but no net? ]\n");
                        else {
                                d->status &= ~DEV_ETHER_STATUS_PACKET_RECEIVED;
                                net_ethernet_rx(cpu->machine->emul->net,
                                    d, &incoming_ptr, &incoming_len);
                                if (incoming_ptr != NULL) {
                                        d->status |=
                                            DEV_ETHER_STATUS_PACKET_RECEIVED;
                                        if (incoming_len>DEV_ETHER_BUFFER_SIZE)
                                                incoming_len =
                                                    DEV_ETHER_BUFFER_SIZE;
                                        memcpy(d->buf, incoming_ptr,
                                            incoming_len);
                                        free(incoming_ptr);
                                        d->packet_len = incoming_len;
                                }
                        }
                        dev_ether_tick(cpu, d);
                        break;

                case DEV_ETHER_COMMAND_TX:      /*  Send  */
                        if (cpu->machine->emul->net == NULL)
                                fatal("[ ether: SEND but no net? ]\n");
                        else
                                net_ethernet_tx(cpu->machine->emul->net,
                                    d, d->buf, d->packet_len);
                        d->status &= ~DEV_ETHER_STATUS_PACKET_RECEIVED;
                        dev_ether_tick(cpu, d);
                        break;

                default:fatal("[ ether: UNIMPLEMENTED command 0x"
                            "%02x ]\n", idata);
                        cpu->running = 0;
                }
                break;

        default:if (writeflag == MEM_WRITE) {
                        fatal("[ ether: unimplemented write to "
                            "offset 0x%x: data=0x%x ]\n", (int)
                            relative_addr, (int)idata);
                } else {
                        fatal("[ ether: unimplemented read from "
                            "offset 0x%x ]\n", (int)relative_addr);
                }
        }

        if (writeflag == MEM_READ)
                memory_writemax64(cpu, data, len, odata);

        return 1;
}


DEVINIT(ether)
{
        struct ether_data *d = malloc(sizeof(struct ether_data));
        size_t nlen;
        char *n1, *n2;
        char tmp[50];

        nlen = strlen(devinit->name) + 80;
        n1 = malloc(nlen);
        n2 = malloc(nlen);

        if (d == NULL || n1 == NULL || n2 == NULL) {
                fprintf(stderr, "out of memory\n");
                exit(1);
        }
        memset(d, 0, sizeof(struct ether_data));

        INTERRUPT_CONNECT(devinit->interrupt_path, d->irq);

        net_generate_unique_mac(devinit->machine, d->mac);
        snprintf(tmp, sizeof(tmp), "%02x:%02x:%02x:%02x:%02x:%02x",
            d->mac[0], d->mac[1], d->mac[2], d->mac[3], d->mac[4], d->mac[5]);

        snprintf(n1, nlen, "%s [%s]", devinit->name, tmp);
        snprintf(n2, nlen, "%s [%s, control]", devinit->name, tmp);

        memory_device_register(devinit->machine->memory, n1, devinit->addr,
            DEV_ETHER_BUFFER_SIZE, dev_ether_buf_access, (void *)d,
            DM_DYNTRANS_OK | DM_DYNTRANS_WRITE_OK |
            DM_READS_HAVE_NO_SIDE_EFFECTS, d->buf);
        memory_device_register(devinit->machine->memory, n2,
            devinit->addr + DEV_ETHER_BUFFER_SIZE,
            DEV_ETHER_LENGTH-DEV_ETHER_BUFFER_SIZE, dev_ether_access, (void *)d,
            DM_DEFAULT, NULL);

        net_add_nic(devinit->machine->emul->net, d, d->mac);

        machine_add_tickfunction(devinit->machine,
            dev_ether_tick, d, DEV_ETHER_TICK_SHIFT, 0.0);

        return 1;
}

1	dpavlin	12	/*
2	dpavlin	34	* Copyright (C) 2005-2007 Anders Gavare. All rights reserved.
3	dpavlin	12	*
4			* Redistribution and use in source and binary forms, with or without
5			* modification, are permitted provided that the following conditions are met:
6			*
7			* 1. Redistributions of source code must retain the above copyright
8			* notice, this list of conditions and the following disclaimer.
9			* 2. Redistributions in binary form must reproduce the above copyright
10			* notice, this list of conditions and the following disclaimer in the
11			* documentation and/or other materials provided with the distribution.
12			* 3. The name of the author may not be used to endorse or promote products
13			* derived from this software without specific prior written permission.
14			*
15			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25			* SUCH DAMAGE.
26			*
27			*
28	dpavlin	34	* $Id: dev_ether.c,v 1.17 2006/12/30 13:30:57 debug Exp $
29	dpavlin	12	*
30			* Basic "ethernet" network device. This is a simple test device which can
31			* be used to send and receive packets to/from a simulated ethernet network.
32			*/
33
34			#include <stdio.h>
35			#include <stdlib.h>
36			#include <string.h>
37
38			#include "cpu.h"
39			#include "device.h"
40			#include "emul.h"
41			#include "machine.h"
42			#include "memory.h"
43			#include "misc.h"
44			#include "net.h"
45
46	dpavlin	24	#include "testmachine/dev_ether.h"
47	dpavlin	12
48	dpavlin	24
49	dpavlin	12	#define DEV_ETHER_TICK_SHIFT 14
50
51			struct ether_data {
52	dpavlin	34	unsigned char buf[DEV_ETHER_BUFFER_SIZE];
53			unsigned char mac[6];
54	dpavlin	12
55	dpavlin	34	int status;
56			int packet_len;
57	dpavlin	12
58	dpavlin	34	struct interrupt irq;
59	dpavlin	12	};
60
61
62	dpavlin	32	DEVICE_TICK(ether)
63	dpavlin	12	{
64			struct ether_data d = (struct ether_data ) extra;
65			int r = 0;
66
67	dpavlin	24	d->status &= ~DEV_ETHER_STATUS_MORE_PACKETS_AVAILABLE;
68	dpavlin	12	if (cpu->machine->emul->net != NULL)
69			r = net_ethernet_rx_avail(cpu->machine->emul->net, d);
70			if (r)
71	dpavlin	24	d->status \|= DEV_ETHER_STATUS_MORE_PACKETS_AVAILABLE;
72	dpavlin	12
73			if (d->status)
74	dpavlin	34	INTERRUPT_ASSERT(d->irq);
75	dpavlin	12	else
76	dpavlin	34	INTERRUPT_DEASSERT(d->irq);
77	dpavlin	12	}
78
79
80	dpavlin	22	DEVICE_ACCESS(ether_buf)
81	dpavlin	12	{
82			struct ether_data d = (struct ether_data ) extra;
83
84			if (writeflag == MEM_WRITE)
85			memcpy(d->buf + relative_addr, data, len);
86			else
87			memcpy(data, d->buf + relative_addr, len);
88			return 1;
89			}
90
91
92	dpavlin	22	DEVICE_ACCESS(ether)
93	dpavlin	12	{
94			struct ether_data d = (struct ether_data ) extra;
95			uint64_t idata = 0, odata = 0;
96			unsigned char *incoming_ptr;
97			int incoming_len;
98
99	dpavlin	18	if (writeflag == MEM_WRITE)
100			idata = memory_readmax64(cpu, data, len);
101	dpavlin	12
102	dpavlin	24	/* Note: relative_addr + DEV_ETHER_BUFFER_SIZE to get the same
103			offsets as in the header file: */
104
105			switch (relative_addr + DEV_ETHER_BUFFER_SIZE) {
106
107			case DEV_ETHER_STATUS:
108	dpavlin	12	if (writeflag == MEM_READ) {
109			odata = d->status;
110			d->status = 0;
111	dpavlin	34	INTERRUPT_DEASSERT(d->irq);
112	dpavlin	12	} else
113			fatal("[ ether: WARNING: write to status ]\n");
114			break;
115	dpavlin	24
116			case DEV_ETHER_PACKETLENGTH:
117	dpavlin	12	if (writeflag == MEM_READ)
118			odata = d->packet_len;
119			else {
120			if ((int64_t)idata < 0) {
121			fatal("[ ether: ERROR: packet len too"
122			" short (%i bytes) ]\n", (int)idata);
123			idata = -1;
124			}
125	dpavlin	24	if (idata > DEV_ETHER_BUFFER_SIZE) {
126	dpavlin	12	fatal("[ ether: ERROR: packet len too"
127			" large (%i bytes) ]\n", (int)idata);
128	dpavlin	24	idata = DEV_ETHER_BUFFER_SIZE;
129	dpavlin	12	}
130			d->packet_len = idata;
131			}
132			break;
133	dpavlin	24
134			case DEV_ETHER_COMMAND:
135			if (writeflag == MEM_READ) {
136	dpavlin	12	fatal("[ ether: WARNING: read from command ]\n");
137	dpavlin	24	break;
138			}
139
140			/* Write: */
141			switch (idata) {
142
143			case DEV_ETHER_COMMAND_RX: /* Receive: */
144			if (cpu->machine->emul->net == NULL)
145			fatal("[ ether: RECEIVE but no net? ]\n");
146			else {
147			d->status &= ~DEV_ETHER_STATUS_PACKET_RECEIVED;
148			net_ethernet_rx(cpu->machine->emul->net,
149			d, &incoming_ptr, &incoming_len);
150			if (incoming_ptr != NULL) {
151			d->status \|=
152			DEV_ETHER_STATUS_PACKET_RECEIVED;
153			if (incoming_len>DEV_ETHER_BUFFER_SIZE)
154			incoming_len =
155			DEV_ETHER_BUFFER_SIZE;
156			memcpy(d->buf, incoming_ptr,
157			incoming_len);
158			free(incoming_ptr);
159			d->packet_len = incoming_len;
160	dpavlin	12	}
161			}
162	dpavlin	24	dev_ether_tick(cpu, d);
163			break;
164
165			case DEV_ETHER_COMMAND_TX: /* Send */
166			if (cpu->machine->emul->net == NULL)
167			fatal("[ ether: SEND but no net? ]\n");
168			else
169			net_ethernet_tx(cpu->machine->emul->net,
170			d, d->buf, d->packet_len);
171			d->status &= ~DEV_ETHER_STATUS_PACKET_RECEIVED;
172			dev_ether_tick(cpu, d);
173			break;
174
175			default:fatal("[ ether: UNIMPLEMENTED command 0x"
176			"%02x ]\n", idata);
177			cpu->running = 0;
178	dpavlin	12	}
179			break;
180	dpavlin	24
181	dpavlin	12	default:if (writeflag == MEM_WRITE) {
182			fatal("[ ether: unimplemented write to "
183			"offset 0x%x: data=0x%x ]\n", (int)
184			relative_addr, (int)idata);
185			} else {
186			fatal("[ ether: unimplemented read from "
187			"offset 0x%x ]\n", (int)relative_addr);
188			}
189			}
190
191			if (writeflag == MEM_READ)
192			memory_writemax64(cpu, data, len, odata);
193
194			return 1;
195			}
196
197
198	dpavlin	22	DEVINIT(ether)
199	dpavlin	12	{
200			struct ether_data *d = malloc(sizeof(struct ether_data));
201			size_t nlen;
202			char n1, n2;
203			char tmp[50];
204
205			nlen = strlen(devinit->name) + 80;
206			n1 = malloc(nlen);
207			n2 = malloc(nlen);
208
209			if (d == NULL \|\| n1 == NULL \|\| n2 == NULL) {
210			fprintf(stderr, "out of memory\n");
211			exit(1);
212			}
213			memset(d, 0, sizeof(struct ether_data));
214
215	dpavlin	34	INTERRUPT_CONNECT(devinit->interrupt_path, d->irq);
216
217	dpavlin	12	net_generate_unique_mac(devinit->machine, d->mac);
218			snprintf(tmp, sizeof(tmp), "%02x:%02x:%02x:%02x:%02x:%02x",
219			d->mac[0], d->mac[1], d->mac[2], d->mac[3], d->mac[4], d->mac[5]);
220
221			snprintf(n1, nlen, "%s [%s]", devinit->name, tmp);
222			snprintf(n2, nlen, "%s [%s, control]", devinit->name, tmp);
223
224	dpavlin	24	memory_device_register(devinit->machine->memory, n1, devinit->addr,
225			DEV_ETHER_BUFFER_SIZE, dev_ether_buf_access, (void *)d,
226	dpavlin	20	DM_DYNTRANS_OK \| DM_DYNTRANS_WRITE_OK \|
227			DM_READS_HAVE_NO_SIDE_EFFECTS, d->buf);
228	dpavlin	12	memory_device_register(devinit->machine->memory, n2,
229	dpavlin	24	devinit->addr + DEV_ETHER_BUFFER_SIZE,
230			DEV_ETHER_LENGTH-DEV_ETHER_BUFFER_SIZE, dev_ether_access, (void *)d,
231	dpavlin	20	DM_DEFAULT, NULL);
232	dpavlin	12
233			net_add_nic(devinit->machine->emul->net, d, d->mac);
234
235			machine_add_tickfunction(devinit->machine,
236	dpavlin	24	dev_ether_tick, d, DEV_ETHER_TICK_SHIFT, 0.0);
237	dpavlin	12
238			return 1;
239			}
240