0.3.1/devices/dev_ram.c

/*
 *  Copyright (C) 2004-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_ram.c,v 1.13 2005/02/11 09:53:48 debug Exp $
 *  
 *  A generic RAM (memory) device.  Can also be used to mirror/alias another
 *  part of RAM.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/mman.h>

#include "console.h"
#include "cpu.h"
#include "devices.h"
#include "memory.h"
#include "misc.h"


/*  #define RAM_DEBUG  */

struct ram_data {
        int             mode;
        uint64_t        otheraddress;

        /*  If mode = DEV_RAM_RAM:  */
        unsigned char   *data;
        uint64_t        length;
};


/*
 *  dev_ram_access():
 */
int dev_ram_access(struct cpu *cpu, struct memory *mem,
        uint64_t relative_addr, unsigned char *data, size_t len,
        int writeflag, void *extra)
{
        struct ram_data *d = extra;

#ifdef RAM_DEBUG
        if (writeflag==MEM_READ) {
                debug("[ ram: read from 0x%x, len=%i ]\n",
                    (int)relative_addr, (int)len);
        } else {
                int i;
                debug("[ ram: write to 0x%x:", (int)relative_addr);
                for (i=0; i<len; i++)
                        debug(" %02x", data[i]);
                debug(" (len=%i) ]\n", len);
        }
#endif

        switch (d->mode) {
        case DEV_RAM_MIRROR:
                /*  TODO:  how about caches?  */
                return cpu->memory_rw(cpu, mem,
                    d->otheraddress + relative_addr, data, len,
                    writeflag, PHYSICAL);
        case DEV_RAM_RAM:
                if (writeflag == MEM_WRITE)
                        memcpy(&d->data[relative_addr], data, len);
                else
                        memcpy(data, &d->data[relative_addr], len);
                break;
        default:
                fatal("dev_ram_access(): unknown mode %i\n", d->mode);
                exit(1);
        }

        return 1;
}


/*
 *  dev_ram_init():
 */
void dev_ram_init(struct memory *mem, uint64_t baseaddr, uint64_t length,
        int mode, uint64_t otheraddress)
{
        struct ram_data *d;

        d = malloc(sizeof(struct ram_data));
        if (d == NULL) {
                fprintf(stderr, "out of memory\n");
                exit(1);
        }

        memset(d, 0, sizeof(struct ram_data));

        d->mode         = mode;
        d->otheraddress = otheraddress;

        switch (d->mode) {
        case DEV_RAM_MIRROR:
                break;
        case DEV_RAM_RAM:
                /*
                 *  Allocate zero-filled RAM using mmap(). If mmap() failed,
                 *  try malloc(), but then we also have to memset(), which
                 *  can be slow for large chunks of memory.
                 */
                d->length = length;
                d->data = (unsigned char *) mmap(NULL, length,
                    PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
                if (d->data == NULL) {
                        d->data = malloc(length);
                        if (d->data == NULL) {
                                fprintf(stderr, "out of memory\n");
                                exit(1);
                        }
                        memset(d->data, 0, length);
                }
                break;
        default:
                fatal("dev_ram_access(): unknown mode %i\n", d->mode);
                exit(1);
        }

        memory_device_register(mem, "ram", baseaddr, length,
            dev_ram_access, d, MEM_DEFAULT, NULL);
}

1	/*
2	* Copyright (C) 2004-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	* $Id: dev_ram.c,v 1.13 2005/02/11 09:53:48 debug Exp $
29	*
30	* A generic RAM (memory) device. Can also be used to mirror/alias another
31	* part of RAM.
32	*/
33
34	#include <stdio.h>
35	#include <stdlib.h>
36	#include <string.h>
37	#include <sys/types.h>
38	#include <sys/mman.h>
39
40	#include "console.h"
41	#include "cpu.h"
42	#include "devices.h"
43	#include "memory.h"
44	#include "misc.h"
45
46
47	/* #define RAM_DEBUG */
48
49	struct ram_data {
50	int mode;
51	uint64_t otheraddress;
52
53	/* If mode = DEV_RAM_RAM: */
54	unsigned char *data;
55	uint64_t length;
56	};
57
58
59	/*
60	* dev_ram_access():
61	*/
62	int dev_ram_access(struct cpu cpu, struct memory mem,
63	uint64_t relative_addr, unsigned char *data, size_t len,
64	int writeflag, void *extra)
65	{
66	struct ram_data *d = extra;
67
68	#ifdef RAM_DEBUG
69	if (writeflag==MEM_READ) {
70	debug("[ ram: read from 0x%x, len=%i ]\n",
71	(int)relative_addr, (int)len);
72	} else {
73	int i;
74	debug("[ ram: write to 0x%x:", (int)relative_addr);
75	for (i=0; i<len; i++)
76	debug(" %02x", data[i]);
77	debug(" (len=%i) ]\n", len);
78	}
79	#endif
80
81	switch (d->mode) {
82	case DEV_RAM_MIRROR:
83	/* TODO: how about caches? */
84	return cpu->memory_rw(cpu, mem,
85	d->otheraddress + relative_addr, data, len,
86	writeflag, PHYSICAL);
87	case DEV_RAM_RAM:
88	if (writeflag == MEM_WRITE)
89	memcpy(&d->data[relative_addr], data, len);
90	else
91	memcpy(data, &d->data[relative_addr], len);
92	break;
93	default:
94	fatal("dev_ram_access(): unknown mode %i\n", d->mode);
95	exit(1);
96	}
97
98	return 1;
99	}
100
101
102	/*
103	* dev_ram_init():
104	*/
105	void dev_ram_init(struct memory *mem, uint64_t baseaddr, uint64_t length,
106	int mode, uint64_t otheraddress)
107	{
108	struct ram_data *d;
109
110	d = malloc(sizeof(struct ram_data));
111	if (d == NULL) {
112	fprintf(stderr, "out of memory\n");
113	exit(1);
114	}
115
116	memset(d, 0, sizeof(struct ram_data));
117
118	d->mode = mode;
119	d->otheraddress = otheraddress;
120
121	switch (d->mode) {
122	case DEV_RAM_MIRROR:
123	break;
124	case DEV_RAM_RAM:
125	/*
126	* Allocate zero-filled RAM using mmap(). If mmap() failed,
127	* try malloc(), but then we also have to memset(), which
128	* can be slow for large chunks of memory.
129	*/
130	d->length = length;
131	d->data = (unsigned char *) mmap(NULL, length,
132	PROT_READ \| PROT_WRITE, MAP_ANON \| MAP_PRIVATE, -1, 0);
133	if (d->data == NULL) {
134	d->data = malloc(length);
135	if (d->data == NULL) {
136	fprintf(stderr, "out of memory\n");
137	exit(1);
138	}
139	memset(d->data, 0, length);
140	}
141	break;
142	default:
143	fatal("dev_ram_access(): unknown mode %i\n", d->mode);
144	exit(1);
145	}
146
147	memory_device_register(mem, "ram", baseaddr, length,
148	dev_ram_access, d, MEM_DEFAULT, NULL);
149	}
150