src/devices/dev_ether.c

/*
 *  Copyright (C) 2005  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.8 2005/10/26 14:37:03 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 "devices.h"
#include "emul.h"
#include "machine.h"
#include "memory.h"
#include "misc.h"
#include "net.h"


#define DEV_ETHER_MAXBUFLEN     16384
#define DEV_ETHER_TICK_SHIFT    14

#define STATUS_RECEIVED         0x01
#define STATUS_MORE_AVAIL       0x02

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

        int             status;
        int             packet_len;

        int             irq_nr;
};


/*
 *  dev_ether_tick():
 */
void dev_ether_tick(struct cpu *cpu, void *extra)
{  
        struct ether_data *d = (struct ether_data *) extra;
        int r = 0;

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

        if (d->status)
                cpu_interrupt(cpu, d->irq_nr);
        else
                cpu_interrupt_ack(cpu, d->irq_nr);
}


/*
 *  dev_ether_buf_access():
 */
int dev_ether_buf_access(struct cpu *cpu, struct memory *mem,
        uint64_t relative_addr, unsigned char *data, size_t len,
        int writeflag, void *extra)
{
        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;
}


/*
 *  dev_ether_access():
 */
int dev_ether_access(struct cpu *cpu, struct memory *mem,
        uint64_t relative_addr, unsigned char *data, size_t len,
        int writeflag, void *extra)
{
        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);

        switch (relative_addr) {
        case 0x0000:
                if (writeflag == MEM_READ) {
                        odata = d->status;
                        d->status = 0;
                        cpu_interrupt_ack(cpu, d->irq_nr);
                } else
                        fatal("[ ether: WARNING: write to status ]\n");
                break;
        case 0x0010:
                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_MAXBUFLEN) {
                                fatal("[ ether: ERROR: packet len too"
                                    " large (%i bytes) ]\n", (int)idata);
                                idata = DEV_ETHER_MAXBUFLEN;
                        }
                        d->packet_len = idata;
                }
                break;
        case 0x0020:
                if (writeflag == MEM_READ)
                        fatal("[ ether: WARNING: read from command ]\n");
                else {
                        switch (idata) {
                        case 0x00:              /*  Receive:  */
                                if (cpu->machine->emul->net == NULL)
                                        fatal("[ ether: RECEIVE but no "
                                            "net? ]\n");
                                else {
                                        d->status &= ~STATUS_RECEIVED;
                                        net_ethernet_rx(cpu->machine->emul->net,
                                            d, &incoming_ptr, &incoming_len);
                                        if (incoming_ptr != NULL) {
                                                d->status |= STATUS_RECEIVED;
                                                if (incoming_len >
                                                    DEV_ETHER_MAXBUFLEN)
                                                        incoming_len =
                                                            DEV_ETHER_MAXBUFLEN;
                                                memcpy(d->buf, incoming_ptr,
                                                    incoming_len);
                                                free(incoming_ptr);
                                                d->packet_len = incoming_len;
                                        }
                                }
                                dev_ether_tick(cpu, d);
                                break;
                        case 0x01:              /*  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 &= ~STATUS_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():
 */
int devinit_ether(struct devinit *devinit)
{
        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));
        d->irq_nr = devinit->irq_nr;

        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_MAXBUFLEN, dev_ether_buf_access, (void *)d,
            MEM_DYNTRANS_OK | MEM_DYNTRANS_WRITE_OK |
            MEM_READING_HAS_NO_SIDE_EFFECTS, d->buf);
        memory_device_register(devinit->machine->memory, n2,
            devinit->addr + DEV_ETHER_MAXBUFLEN,
            DEV_ETHER_LENGTH-DEV_ETHER_MAXBUFLEN, dev_ether_access, (void *)d,
            MEM_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);

        return 1;
}

1	dpavlin	12	/*
2			* Copyright (C) 2005 Anders Gavare. All rights reserved.
3			*
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	18	* $Id: dev_ether.c,v 1.8 2005/10/26 14:37:03 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 "devices.h"
41			#include "emul.h"
42			#include "machine.h"
43			#include "memory.h"
44			#include "misc.h"
45			#include "net.h"
46
47
48			#define DEV_ETHER_MAXBUFLEN 16384
49			#define DEV_ETHER_TICK_SHIFT 14
50
51			#define STATUS_RECEIVED 0x01
52			#define STATUS_MORE_AVAIL 0x02
53
54			struct ether_data {
55			unsigned char buf[DEV_ETHER_MAXBUFLEN];
56			unsigned char mac[6];
57
58			int status;
59			int packet_len;
60
61			int irq_nr;
62			};
63
64
65			/*
66			* dev_ether_tick():
67			*/
68			void dev_ether_tick(struct cpu cpu, void extra)
69			{
70			struct ether_data d = (struct ether_data ) extra;
71			int r = 0;
72
73			d->status &= ~STATUS_MORE_AVAIL;
74			if (cpu->machine->emul->net != NULL)
75			r = net_ethernet_rx_avail(cpu->machine->emul->net, d);
76			if (r)
77			d->status \|= STATUS_MORE_AVAIL;
78
79			if (d->status)
80			cpu_interrupt(cpu, d->irq_nr);
81			else
82			cpu_interrupt_ack(cpu, d->irq_nr);
83			}
84
85
86			/*
87			* dev_ether_buf_access():
88			*/
89			int dev_ether_buf_access(struct cpu cpu, struct memory mem,
90			uint64_t relative_addr, unsigned char *data, size_t len,
91			int writeflag, void *extra)
92			{
93			struct ether_data d = (struct ether_data ) extra;
94
95			if (writeflag == MEM_WRITE)
96			memcpy(d->buf + relative_addr, data, len);
97			else
98			memcpy(data, d->buf + relative_addr, len);
99			return 1;
100			}
101
102
103			/*
104			* dev_ether_access():
105			*/
106			int dev_ether_access(struct cpu cpu, struct memory mem,
107			uint64_t relative_addr, unsigned char *data, size_t len,
108			int writeflag, void *extra)
109			{
110			struct ether_data d = (struct ether_data ) extra;
111			uint64_t idata = 0, odata = 0;
112			unsigned char *incoming_ptr;
113			int incoming_len;
114
115	dpavlin	18	if (writeflag == MEM_WRITE)
116			idata = memory_readmax64(cpu, data, len);
117	dpavlin	12
118			switch (relative_addr) {
119			case 0x0000:
120			if (writeflag == MEM_READ) {
121			odata = d->status;
122			d->status = 0;
123			cpu_interrupt_ack(cpu, d->irq_nr);
124			} else
125			fatal("[ ether: WARNING: write to status ]\n");
126			break;
127			case 0x0010:
128			if (writeflag == MEM_READ)
129			odata = d->packet_len;
130			else {
131			if ((int64_t)idata < 0) {
132			fatal("[ ether: ERROR: packet len too"
133			" short (%i bytes) ]\n", (int)idata);
134			idata = -1;
135			}
136			if (idata > DEV_ETHER_MAXBUFLEN) {
137			fatal("[ ether: ERROR: packet len too"
138			" large (%i bytes) ]\n", (int)idata);
139			idata = DEV_ETHER_MAXBUFLEN;
140			}
141			d->packet_len = idata;
142			}
143			break;
144			case 0x0020:
145			if (writeflag == MEM_READ)
146			fatal("[ ether: WARNING: read from command ]\n");
147			else {
148			switch (idata) {
149			case 0x00: /* Receive: */
150			if (cpu->machine->emul->net == NULL)
151			fatal("[ ether: RECEIVE but no "
152			"net? ]\n");
153			else {
154			d->status &= ~STATUS_RECEIVED;
155			net_ethernet_rx(cpu->machine->emul->net,
156			d, &incoming_ptr, &incoming_len);
157			if (incoming_ptr != NULL) {
158			d->status \|= STATUS_RECEIVED;
159			if (incoming_len >
160			DEV_ETHER_MAXBUFLEN)
161			incoming_len =
162			DEV_ETHER_MAXBUFLEN;
163			memcpy(d->buf, incoming_ptr,
164			incoming_len);
165			free(incoming_ptr);
166			d->packet_len = incoming_len;
167			}
168			}
169			dev_ether_tick(cpu, d);
170			break;
171			case 0x01: /* Send */
172			if (cpu->machine->emul->net == NULL)
173			fatal("[ ether: SEND but no net? ]\n");
174			else
175			net_ethernet_tx(cpu->machine->emul->net,
176			d, d->buf, d->packet_len);
177			d->status &= ~STATUS_RECEIVED;
178			dev_ether_tick(cpu, d);
179			break;
180			default:fatal("[ ether: UNIMPLEMENTED command 0x"
181			"%02x ]\n", idata);
182			cpu->running = 0;
183			}
184			}
185			break;
186			default:if (writeflag == MEM_WRITE) {
187			fatal("[ ether: unimplemented write to "
188			"offset 0x%x: data=0x%x ]\n", (int)
189			relative_addr, (int)idata);
190			} else {
191			fatal("[ ether: unimplemented read from "
192			"offset 0x%x ]\n", (int)relative_addr);
193			}
194			}
195
196			if (writeflag == MEM_READ)
197			memory_writemax64(cpu, data, len, odata);
198
199			return 1;
200			}
201
202
203			/*
204			* devinit_ether():
205			*/
206			int devinit_ether(struct devinit *devinit)
207			{
208			struct ether_data *d = malloc(sizeof(struct ether_data));
209			size_t nlen;
210			char n1, n2;
211			char tmp[50];
212
213			nlen = strlen(devinit->name) + 80;
214			n1 = malloc(nlen);
215			n2 = malloc(nlen);
216
217			if (d == NULL \|\| n1 == NULL \|\| n2 == NULL) {
218			fprintf(stderr, "out of memory\n");
219			exit(1);
220			}
221			memset(d, 0, sizeof(struct ether_data));
222			d->irq_nr = devinit->irq_nr;
223
224			net_generate_unique_mac(devinit->machine, d->mac);
225			snprintf(tmp, sizeof(tmp), "%02x:%02x:%02x:%02x:%02x:%02x",
226			d->mac[0], d->mac[1], d->mac[2], d->mac[3], d->mac[4], d->mac[5]);
227
228			snprintf(n1, nlen, "%s [%s]", devinit->name, tmp);
229			snprintf(n2, nlen, "%s [%s, control]", devinit->name, tmp);
230
231			memory_device_register(devinit->machine->memory, n1,
232			devinit->addr, DEV_ETHER_MAXBUFLEN, dev_ether_buf_access, (void *)d,
233			MEM_DYNTRANS_OK \| MEM_DYNTRANS_WRITE_OK \|
234			MEM_READING_HAS_NO_SIDE_EFFECTS, d->buf);
235			memory_device_register(devinit->machine->memory, n2,
236			devinit->addr + DEV_ETHER_MAXBUFLEN,
237			DEV_ETHER_LENGTH-DEV_ETHER_MAXBUFLEN, dev_ether_access, (void *)d,
238			MEM_DEFAULT, NULL);
239
240			net_add_nic(devinit->machine->emul->net, d, d->mac);
241
242			machine_add_tickfunction(devinit->machine,
243			dev_ether_tick, d, DEV_ETHER_TICK_SHIFT);
244
245			return 1;
246			}
247