0.3.1/devices/dev_ps2_stuff.c

/*
 *  Copyright (C) 2003-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_ps2_stuff.c,v 1.18 2005/02/26 10:51:01 debug Exp $
 *  
 *  Playstation 2 misc. stuff:
 *
 *      offset 0x0000   timer control
 *      offset 0x8000   DMA controller
 *      offset 0xf000   Interrupt register
 */

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

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

#include "ee_timerreg.h"
#include "ps2_dmacreg.h"

#define TICK_STEPS_SHIFT        16

/*  NOTE/TODO: This should be the same as in ps2_gs:  */
#define DEV_PS2_GIF_FAKE_BASE           0x50000000


/*
 *  dev_ps2_stuff_tick():
 */
void dev_ps2_stuff_tick(struct cpu *cpu, void *extra)
{
        struct ps2_data *d = extra;

        /*  Count-up Enable:   TODO: by how much?  */
        if (d->timer_mode[0] & T_MODE_CUE)
                d->timer_count[0] ++;

        /*  TODO:  right now this interrupts every now and then, this should
                be 100 Hz in NetBSD, but isn't  */
        if (d->timer_mode[0] & (T_MODE_CMPE | T_MODE_OVFE)) {
                /*  Zero return:  */
                if (d->timer_mode[0] & T_MODE_ZRET)
                        d->timer_count[0] = 0;

                cpu_interrupt(cpu, 0x200 +8);           /*  0x200 is timer0  */
        }
}


/*
 *  dev_ps2_stuff_access():
 */
int dev_ps2_stuff_access(struct cpu *cpu, struct memory *mem,
        uint64_t relative_addr, unsigned char *data, size_t len,
        int writeflag, void *extra)
{
        uint64_t idata = 0, odata = 0;
        int regnr = 0;
        struct ps2_data *d = extra;
        int timer_nr = 0;

        idata = memory_readmax64(cpu, data, len);

        if (relative_addr >= 0x8000 && relative_addr < 0x8000 + DMAC_REGSIZE) {
                regnr = (relative_addr - 0x8000) / 16;
                if (writeflag == MEM_READ)
                        odata = d->dmac_reg[regnr];
                else
                        d->dmac_reg[regnr] = idata;
        }

        /*
         *  Timer control:
         *  The four timers are at offsets 0, 0x800, 0x1000, and 0x1800.
         */
        if (relative_addr < TIMER_REGSIZE) {
                /*  0, 1, 2, or 3  */
                timer_nr = (relative_addr & 0x1800) >> 11;
                relative_addr &= (TIMER_OFS-1);
        }

        switch (relative_addr) {
        case 0x0000:    /*  timer count  */
                if (writeflag == MEM_READ) {
                        odata = d->timer_count[timer_nr];
                        if (timer_nr == 0) {
                                /*  :-)  TODO: remove this?  */
                                d->timer_count[timer_nr] ++;
                        }
                        debug("[ ps2_stuff: read timer %i count: 0x%llx ]\n",
                            timer_nr, (long long)odata);
                } else {
                        d->timer_count[timer_nr] = idata;
                        debug("[ ps2_stuff: write timer %i count: 0x%llx ]\n",
                            timer_nr, (long long)idata);
                }
                break;
        case 0x0010:    /*  timer mode  */
                if (writeflag == MEM_READ) {
                        odata = d->timer_mode[timer_nr];
                        debug("[ ps2_stuff: read timer %i mode: 0x%llx ]\n",
                            timer_nr, (long long)odata);
                } else {
                        d->timer_mode[timer_nr] = idata;
                        debug("[ ps2_stuff: write timer %i mode: 0x%llx ]\n",
                            timer_nr, (long long)idata);
                }
                break;
        case 0x0020:    /*  timer comp  */
                if (writeflag == MEM_READ) {
                        odata = d->timer_comp[timer_nr];
                        debug("[ ps2_stuff: read timer %i comp: 0x%llx ]\n",
                            timer_nr, (long long)odata);
                } else {
                        d->timer_comp[timer_nr] = idata;
                        debug("[ ps2_stuff: write timer %i comp: 0x%llx ]\n",
                            timer_nr, (long long)idata);
                }
                break;
        case 0x0030:    /*  timer hold  */
                if (writeflag == MEM_READ) {
                        odata = d->timer_hold[timer_nr];
                        debug("[ ps2_stuff: read timer %i hold: 0x%llx ]\n",
                            timer_nr, (long long)odata);
                        if (timer_nr >= 2)
                                fatal("[ WARNING: ps2_stuff: read from non-"
                                    "existant timer %i hold register ]\n");
                } else {
                        d->timer_hold[timer_nr] = idata;
                        debug("[ ps2_stuff: write timer %i hold: 0x%llx ]\n",
                            timer_nr, (long long)idata);
                        if (timer_nr >= 2)
                                fatal("[ WARNING: ps2_stuff: write to "
                                    "non-existant timer %i hold register ]\n",
                                    timer_nr);
                }
                break;

        case 0x8000 + D2_CHCR_REG:
                if (writeflag==MEM_READ) {
                        odata = d->dmac_reg[regnr];
                        /*  debug("[ ps2_stuff: dmac read from D2_CHCR "
                            "(0x%llx) ]\n", (long long)d->dmac_reg[regnr]);  */
                } else {
                        /*  debug("[ ps2_stuff: dmac write to D2_CHCR, "
                            "data 0x%016llx ]\n", (long long) idata);  */
                        if (idata & D_CHCR_STR) {
                                int length = d->dmac_reg[D2_QWC_REG/0x10] * 16;
                                uint64_t from_addr = d->dmac_reg[
                                    D2_MADR_REG/0x10];
                                uint64_t to_addr   = d->dmac_reg[
                                    D2_TADR_REG/0x10];
                                unsigned char *copy_buf;

                                debug("[ ps2_stuff: dmac [ch2] transfer addr="
                                    "0x%016llx len=0x%lx ]\n", (long long)
                                    d->dmac_reg[D2_MADR_REG/0x10],
                                    (long)length);

                                copy_buf = malloc(length);
                                if (copy_buf == NULL) {
                                        fprintf(stderr, "out of memory in "
                                            "dev_ps2_stuff_access()\n");
                                        exit(1);
                                }
                                cpu->memory_rw(cpu, cpu->mem, from_addr,
                                    copy_buf, length, MEM_READ,
                                    CACHE_NONE | PHYSICAL);
                                cpu->memory_rw(cpu, cpu->mem,
                                    d->other_memory_base[DMA_CH_GIF] + to_addr,
                                    copy_buf, length, MEM_WRITE,
                                    CACHE_NONE | PHYSICAL);
                                free(copy_buf);

                                /*  Done with the transfer:  */
                                d->dmac_reg[D2_QWC_REG/0x10] = 0;
                                idata &= ~D_CHCR_STR;

                                cpu_interrupt(cpu, (1 << 18) +8);
                                    /*  1<<18 is dma2  */
                        } else
                                debug("[ ps2_stuff: dmac [ch2] stopping "
                                    "transfer ]\n");
                        d->dmac_reg[regnr] = idata;
                        return 1;
                }
                break;

        case 0x8000 + D2_QWC_REG:
        case 0x8000 + D2_MADR_REG:
        case 0x8000 + D2_TADR_REG:
                /*  no debug output  */
                break;

        case 0xe010:    /*  dmac interrupt status (and mask,  */
                        /*  the upper 16 bits)  */
                if (writeflag == MEM_WRITE) {
                        uint32_t oldmask = d->dmac_reg[regnr] & 0xffff0000;
                        /*  Clear out those bits that are set in idata:  */
                        d->dmac_reg[regnr] &= ~idata;
                        d->dmac_reg[regnr] &= 0xffff;
                        d->dmac_reg[regnr] |= oldmask;
                        if (((d->dmac_reg[regnr] & 0xffff) &
                            ((d->dmac_reg[regnr]>>16) & 0xffff)) == 0) {
                                /*  irq 3 is the DMAC  */
                                cpu_interrupt_ack(cpu, 3);
                        }
                } else {
                        /*  Hm... make it seem like the mask bits are (at
                            least as much as) the interrupt assertions:  */
                        odata = d->dmac_reg[regnr];
                        odata |= (odata << 16);
                }
                break;

        case 0xf000:    /*  interrupt register  */
                if (writeflag == MEM_READ) {
                        odata = d->intr;
                        debug("[ ps2_stuff: read from Interrupt Register:"
                            " 0x%llx ]\n", (long long)odata);

                        /*  TODO: these are possibly not correct,
                            but makes NetBSD run easier.  */
                        d->intr = 0;
                        cpu_interrupt_ack(cpu, 2);
                } else {
                        debug("[ ps2_stuff: write to Interrupt Register: "
                            "0x%llx ]\n", (long long)idata);
                        /*  Clear out those bits that are set in idata:  */
                        d->intr &= ~idata;
                        if (idata == 0)
                                d->intr = 0;
                        /*  TODO:  which of the above and below is best?  */
                        if (d->intr == 0) {
                                /*  Hm...  idata +8);  */
                                cpu_interrupt_ack(cpu, 2);
                        }
                }
                break;

        case 0xf010:    /*  interrupt mask  */
                if (writeflag == MEM_READ)
                        odata = d->imask;
                else {
                        d->imask = idata;
                }
                break;

        default:
                if (writeflag==MEM_READ) {
                        debug("[ ps2_stuff: read from addr 0x%x: 0x%llx ]\n",
                            (int)relative_addr, (long long)odata);
                } else {
                        debug("[ ps2_stuff: write to addr 0x%x: 0x%llx ]\n",
                            (int)relative_addr, (long long)idata);
                }
        }

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

        return 1;
}


/*
 *  dev_ps2_stuff_init():
 */
struct ps2_data *dev_ps2_stuff_init(struct machine *machine,
        struct memory *mem, uint64_t baseaddr)
{
        struct ps2_data *d;

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

        d->other_memory_base[DMA_CH_GIF] = DEV_PS2_GIF_FAKE_BASE;

        memory_device_register(mem, "ps2_stuff", baseaddr,
            DEV_PS2_STUFF_LENGTH, dev_ps2_stuff_access, d, MEM_DEFAULT, NULL);
        machine_add_tickfunction(machine,
            dev_ps2_stuff_tick, d, TICK_STEPS_SHIFT);

        return d;
}

1	dpavlin	2	/*
2			* Copyright (C) 2003-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_ps2_stuff.c,v 1.18 2005/02/26 10:51:01 debug Exp $
29			*
30			* Playstation 2 misc. stuff:
31			*
32			* offset 0x0000 timer control
33			* offset 0x8000 DMA controller
34			* offset 0xf000 Interrupt register
35			*/
36
37			#include <stdio.h>
38			#include <stdlib.h>
39			#include <string.h>
40
41			#include "cpu.h"
42			#include "devices.h"
43			#include "machine.h"
44			#include "memory.h"
45			#include "misc.h"
46
47			#include "ee_timerreg.h"
48			#include "ps2_dmacreg.h"
49
50			#define TICK_STEPS_SHIFT 16
51
52			/* NOTE/TODO: This should be the same as in ps2_gs: */
53			#define DEV_PS2_GIF_FAKE_BASE 0x50000000
54
55
56			/*
57			* dev_ps2_stuff_tick():
58			*/
59			void dev_ps2_stuff_tick(struct cpu cpu, void extra)
60			{
61			struct ps2_data *d = extra;
62
63			/* Count-up Enable: TODO: by how much? */
64			if (d->timer_mode[0] & T_MODE_CUE)
65			d->timer_count[0] ++;
66
67			/* TODO: right now this interrupts every now and then, this should
68			be 100 Hz in NetBSD, but isn't */
69			if (d->timer_mode[0] & (T_MODE_CMPE \| T_MODE_OVFE)) {
70			/* Zero return: */
71			if (d->timer_mode[0] & T_MODE_ZRET)
72			d->timer_count[0] = 0;
73
74			cpu_interrupt(cpu, 0x200 +8); /* 0x200 is timer0 */
75			}
76			}
77
78
79			/*
80			* dev_ps2_stuff_access():
81			*/
82			int dev_ps2_stuff_access(struct cpu cpu, struct memory mem,
83			uint64_t relative_addr, unsigned char *data, size_t len,
84			int writeflag, void *extra)
85			{
86			uint64_t idata = 0, odata = 0;
87			int regnr = 0;
88			struct ps2_data *d = extra;
89			int timer_nr = 0;
90
91			idata = memory_readmax64(cpu, data, len);
92
93			if (relative_addr >= 0x8000 && relative_addr < 0x8000 + DMAC_REGSIZE) {
94			regnr = (relative_addr - 0x8000) / 16;
95			if (writeflag == MEM_READ)
96			odata = d->dmac_reg[regnr];
97			else
98			d->dmac_reg[regnr] = idata;
99			}
100
101			/*
102			* Timer control:
103			* The four timers are at offsets 0, 0x800, 0x1000, and 0x1800.
104			*/
105			if (relative_addr < TIMER_REGSIZE) {
106			/* 0, 1, 2, or 3 */
107			timer_nr = (relative_addr & 0x1800) >> 11;
108			relative_addr &= (TIMER_OFS-1);
109			}
110
111			switch (relative_addr) {
112			case 0x0000: /* timer count */
113			if (writeflag == MEM_READ) {
114			odata = d->timer_count[timer_nr];
115			if (timer_nr == 0) {
116			/* :-) TODO: remove this? */
117			d->timer_count[timer_nr] ++;
118			}
119			debug("[ ps2_stuff: read timer %i count: 0x%llx ]\n",
120			timer_nr, (long long)odata);
121			} else {
122			d->timer_count[timer_nr] = idata;
123			debug("[ ps2_stuff: write timer %i count: 0x%llx ]\n",
124			timer_nr, (long long)idata);
125			}
126			break;
127			case 0x0010: /* timer mode */
128			if (writeflag == MEM_READ) {
129			odata = d->timer_mode[timer_nr];
130			debug("[ ps2_stuff: read timer %i mode: 0x%llx ]\n",
131			timer_nr, (long long)odata);
132			} else {
133			d->timer_mode[timer_nr] = idata;
134			debug("[ ps2_stuff: write timer %i mode: 0x%llx ]\n",
135			timer_nr, (long long)idata);
136			}
137			break;
138			case 0x0020: /* timer comp */
139			if (writeflag == MEM_READ) {
140			odata = d->timer_comp[timer_nr];
141			debug("[ ps2_stuff: read timer %i comp: 0x%llx ]\n",
142			timer_nr, (long long)odata);
143			} else {
144			d->timer_comp[timer_nr] = idata;
145			debug("[ ps2_stuff: write timer %i comp: 0x%llx ]\n",
146			timer_nr, (long long)idata);
147			}
148			break;
149			case 0x0030: /* timer hold */
150			if (writeflag == MEM_READ) {
151			odata = d->timer_hold[timer_nr];
152			debug("[ ps2_stuff: read timer %i hold: 0x%llx ]\n",
153			timer_nr, (long long)odata);
154			if (timer_nr >= 2)
155			fatal("[ WARNING: ps2_stuff: read from non-"
156			"existant timer %i hold register ]\n");
157			} else {
158			d->timer_hold[timer_nr] = idata;
159			debug("[ ps2_stuff: write timer %i hold: 0x%llx ]\n",
160			timer_nr, (long long)idata);
161			if (timer_nr >= 2)
162			fatal("[ WARNING: ps2_stuff: write to "
163			"non-existant timer %i hold register ]\n",
164			timer_nr);
165			}
166			break;
167
168			case 0x8000 + D2_CHCR_REG:
169			if (writeflag==MEM_READ) {
170			odata = d->dmac_reg[regnr];
171			/* debug("[ ps2_stuff: dmac read from D2_CHCR "
172			"(0x%llx) ]\n", (long long)d->dmac_reg[regnr]); */
173			} else {
174			/* debug("[ ps2_stuff: dmac write to D2_CHCR, "
175			"data 0x%016llx ]\n", (long long) idata); */
176			if (idata & D_CHCR_STR) {
177			int length = d->dmac_reg[D2_QWC_REG/0x10] * 16;
178			uint64_t from_addr = d->dmac_reg[
179			D2_MADR_REG/0x10];
180			uint64_t to_addr = d->dmac_reg[
181			D2_TADR_REG/0x10];
182			unsigned char *copy_buf;
183
184			debug("[ ps2_stuff: dmac [ch2] transfer addr="
185			"0x%016llx len=0x%lx ]\n", (long long)
186			d->dmac_reg[D2_MADR_REG/0x10],
187			(long)length);
188
189			copy_buf = malloc(length);
190			if (copy_buf == NULL) {
191			fprintf(stderr, "out of memory in "
192			"dev_ps2_stuff_access()\n");
193			exit(1);
194			}
195			cpu->memory_rw(cpu, cpu->mem, from_addr,
196			copy_buf, length, MEM_READ,
197			CACHE_NONE \| PHYSICAL);
198			cpu->memory_rw(cpu, cpu->mem,
199			d->other_memory_base[DMA_CH_GIF] + to_addr,
200			copy_buf, length, MEM_WRITE,
201			CACHE_NONE \| PHYSICAL);
202			free(copy_buf);
203
204			/* Done with the transfer: */
205			d->dmac_reg[D2_QWC_REG/0x10] = 0;
206			idata &= ~D_CHCR_STR;
207
208			cpu_interrupt(cpu, (1 << 18) +8);
209			/* 1<<18 is dma2 */
210			} else
211			debug("[ ps2_stuff: dmac [ch2] stopping "
212			"transfer ]\n");
213			d->dmac_reg[regnr] = idata;
214			return 1;
215			}
216			break;
217
218			case 0x8000 + D2_QWC_REG:
219			case 0x8000 + D2_MADR_REG:
220			case 0x8000 + D2_TADR_REG:
221			/* no debug output */
222			break;
223
224			case 0xe010: /* dmac interrupt status (and mask, */
225			/* the upper 16 bits) */
226			if (writeflag == MEM_WRITE) {
227			uint32_t oldmask = d->dmac_reg[regnr] & 0xffff0000;
228			/* Clear out those bits that are set in idata: */
229			d->dmac_reg[regnr] &= ~idata;
230			d->dmac_reg[regnr] &= 0xffff;
231			d->dmac_reg[regnr] \|= oldmask;
232			if (((d->dmac_reg[regnr] & 0xffff) &
233			((d->dmac_reg[regnr]>>16) & 0xffff)) == 0) {
234			/* irq 3 is the DMAC */
235			cpu_interrupt_ack(cpu, 3);
236			}
237			} else {
238			/* Hm... make it seem like the mask bits are (at
239			least as much as) the interrupt assertions: */
240			odata = d->dmac_reg[regnr];
241			odata \|= (odata << 16);
242			}
243			break;
244
245			case 0xf000: /* interrupt register */
246			if (writeflag == MEM_READ) {
247			odata = d->intr;
248			debug("[ ps2_stuff: read from Interrupt Register:"
249			" 0x%llx ]\n", (long long)odata);
250
251			/* TODO: these are possibly not correct,
252			but makes NetBSD run easier. */
253			d->intr = 0;
254			cpu_interrupt_ack(cpu, 2);
255			} else {
256			debug("[ ps2_stuff: write to Interrupt Register: "
257			"0x%llx ]\n", (long long)idata);
258			/* Clear out those bits that are set in idata: */
259			d->intr &= ~idata;
260			if (idata == 0)
261			d->intr = 0;
262			/* TODO: which of the above and below is best? */
263			if (d->intr == 0) {
264			/* Hm... idata +8); */
265			cpu_interrupt_ack(cpu, 2);
266			}
267			}
268			break;
269
270			case 0xf010: /* interrupt mask */
271			if (writeflag == MEM_READ)
272			odata = d->imask;
273			else {
274			d->imask = idata;
275			}
276			break;
277
278			default:
279			if (writeflag==MEM_READ) {
280			debug("[ ps2_stuff: read from addr 0x%x: 0x%llx ]\n",
281			(int)relative_addr, (long long)odata);
282			} else {
283			debug("[ ps2_stuff: write to addr 0x%x: 0x%llx ]\n",
284			(int)relative_addr, (long long)idata);
285			}
286			}
287
288			if (writeflag == MEM_READ)
289			memory_writemax64(cpu, data, len, odata);
290
291			return 1;
292			}
293
294
295			/*
296			* dev_ps2_stuff_init():
297			*/
298			struct ps2_data dev_ps2_stuff_init(struct machine machine,
299			struct memory *mem, uint64_t baseaddr)
300			{
301			struct ps2_data *d;
302
303			d = malloc(sizeof(struct ps2_data));
304			if (d == NULL) {
305			fprintf(stderr, "out of memory\n");
306			exit(1);
307			}
308			memset(d, 0, sizeof(struct ps2_data));
309
310			d->other_memory_base[DMA_CH_GIF] = DEV_PS2_GIF_FAKE_BASE;
311
312			memory_device_register(mem, "ps2_stuff", baseaddr,
313			DEV_PS2_STUFF_LENGTH, dev_ps2_stuff_access, d, MEM_DEFAULT, NULL);
314			machine_add_tickfunction(machine,
315			dev_ps2_stuff_tick, d, TICK_STEPS_SHIFT);
316
317			return d;
318			}
319