src/devices/dev_dreamcast_gdrom.c

/*
 *  Copyright (C) 2006-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_dreamcast_gdrom.c,v 1.4 2007/02/03 20:14:23 debug Exp $
 *  
 *  Dreamcast GD-ROM.
 *
 *  TODO: This is just a dummy so far.
 */

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

#include "cpu.h"
#include "device.h"
#include "diskimage.h"
#include "machine.h"
#include "memory.h"
#include "misc.h"

#include "dreamcast_sysasicvar.h"


/*  #define debug fatal  */

struct dreamcast_gdrom_data {
        uint8_t         busy;           /*  Busy status  */
        uint8_t         stat;           /*  Status  */
        int             cnt;            /*  Data length  */
        uint8_t         cond;

        int             cmd_count;
        uint8_t         cmd[12];

        uint8_t         *data;
        int             data_len;
        int             cur_data_offset;
        int             cur_cnt;
};

/*  Register offsets:  */
#define GDROM_BUSY              0x18
#define GDROM_DATA              0x80
#define GDROM_REGX              0x84
#define GDROM_STAT              0x8c
#define GDROM_CNTLO             0x90
#define GDROM_CNTHI             0x94
#define GDROM_COND              0x9c

#define COND_DATA_AVAIL         0x08


static void alloc_data(struct dreamcast_gdrom_data *d)
{
        d->data_len = d->cnt;
        d->data = malloc(d->data_len);
        if (d->data == NULL) {
                fprintf(stderr, "GDROM alloc_data: out of memory\n");
                exit(1);
        }
        memset(d->data, 0, d->data_len);
}


static void handle_command(struct cpu *cpu, struct dreamcast_gdrom_data *d)
{
        int64_t sector_nr, sector_count;
        int i, res;

        debug("[ GDROM cmd: ");
        for (i=0; i<12; i++)
                debug("%02x ", d->cmd[i]);
        debug("(cnt=%i) ]\n", d->cnt);

        if (d->data != NULL)
                free(d->data);
        d->data = NULL;
        d->cur_data_offset = 0;
        d->cur_cnt = 0;

        switch (d->cmd[0]) {

        case 0x14:
                /*  Read Table-Of-Contents:  */
                if (d->cnt != 408) {
                        fatal("GDROM Read TOC not 408 bytes?\n");
                        exit(1);
                }
                alloc_data(d);

                /*  TODO: Fill TOC in a better way  */
                d->data[99*4] = 1;      /*  First track  */
                d->data[100*4] = 2;     /*  Last track  */

                d->data[0*4] = 0x10;    /*  Track 1  */
                d->data[1*4] = 0x10;    /*  Track 2  */
                break;

        case 0x30:
                /*  Read sectors:  */
                if (d->cmd[1] != 0x20) {
                        fatal("GDROM unimplemented data format 0x%02x\n",
                            d->cmd[1]);
                        exit(1);
                }
                sector_nr = d->cmd[2] * 65536 + d->cmd[3] * 256 + d->cmd[4];
                sector_count = d->cmd[8] * 65536 + d->cmd[9] * 256 + d->cmd[10];
                if (d->cnt == 0)
                        d->cnt = 65536;
                alloc_data(d);
                if (sector_count * 2048 != d->data_len) {
                        fatal("Huh? GDROM data_len=0x%x, but sector_count"
                            "=0x%x\n", (int)d->data_len, (int)sector_count);
                        exit(1);
                }

{
if (sector_nr >= 1376810)
        sector_nr -= 1376810;
sector_nr -= 150;
if (sector_nr > 1048576)
        sector_nr -= 1048576;
/*  printf("sector nr = %i\n", (int)sector_nr);  */

if (sector_nr < 1000)
        sector_nr += (diskimage_get_baseoffset(cpu->machine, 0, DISKIMAGE_IDE)
         / 2048);
}

                res = diskimage_access(cpu->machine, 0, DISKIMAGE_IDE,
                    0, sector_nr * 2048, d->data, d->data_len);
                if (!res) {
                        fatal("GDROM: diskimage_access failed? TODO\n");
//                      exit(1);
                }
                break;

        case 0x70:
                /*  Mount: (?)  */
                break;

        default:fatal("GDROM handle_command: unimplemented command 0x%02x"
                    "\n", d->cmd[0]);
                exit(1);
        }

        if (d->data != NULL)
                d->cond |= COND_DATA_AVAIL;

        if (d->cnt == 65536)
                d->cnt = 32768;

        SYSASIC_TRIGGER_EVENT(SYSASIC_EVENT_GDROM);
}


DEVICE_ACCESS(dreamcast_gdrom)
{
        struct dreamcast_gdrom_data *d = (struct dreamcast_gdrom_data *) extra;
        uint64_t idata = 0, odata = 0;

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

        switch (relative_addr) {

        case GDROM_BUSY:
                if (writeflag == MEM_READ) {
                        odata = d->busy;
                } else {
                        fatal("Write to GDROM_BUSY?\n");
                        exit(1);
                }
                break;

        case GDROM_DATA:
                if (len != sizeof(uint16_t)) {
                        fatal("Non-16bit GDROM data access? TODO\n");
                        exit(1);
                }

                if (writeflag == MEM_READ) {
                        if (!(d->cond & COND_DATA_AVAIL)) {
                                fatal("Read from GDROM_DATA when no data"
                                    " is available? TODO\n");
                                exit(1);
                        }
                        if (d->cur_data_offset < d->data_len) {
                                odata = d->data[d->cur_data_offset ++];
                                odata |= (d->data[d->cur_data_offset ++] << 8);
                                d->cur_cnt += 2;
                                if (d->cur_cnt >= d->cnt) {
                                        if (d->cur_data_offset >= d->data_len) {
                                                d->cond &= ~COND_DATA_AVAIL;
                                        } else {
                                                d->cnt = d->data_len -
                                                    d->cur_data_offset;
                                                d->cur_cnt = 0;
                                        }
                                        SYSASIC_TRIGGER_EVENT(
                                            SYSASIC_EVENT_GDROM);
                                }
                        } else {
                                fatal("Read too much from GDROM_DATA\n");
                                exit(1);
                        }
                } else {
                        if (d->busy & 0x08) {
                                if (d->cmd_count >= 12) {
                                        fatal("Too much GDROM_DATA?\n");
                                        exit(1);
                                }
                                /*  Add data to cmd:  */
                                d->cmd[d->cmd_count++] = idata;
                                d->cmd[d->cmd_count++] = idata >> 8;
                                if (d->cmd_count == 12) {
                                        d->busy &= ~0x08;
                                        handle_command(cpu, d);
                                }
                        } else {
                                fatal("Write to GDROM_DATA, but not waiting"
                                    " for data?\n");
                                exit(1);
                        }
                }
                break;

        case GDROM_REGX:
                if (writeflag == MEM_READ) {
                        fatal("Read from GDROM_REGX?\n");
                        exit(1);
                } else {
                        /*  NetBSD/dreamcast writes 0 here.  */
                        if (idata != 0) {
                                fatal("Write to GDROM_REGX?\n");
                                exit(1);
                        }
                }
                break;

        case GDROM_STAT:
                if (writeflag == MEM_READ) {
                        odata = d->stat;
                } else {
                        fatal("Write to GDROM_STAT?\n");
                        exit(1);
                }
                break;

        case GDROM_CNTLO:
                if (writeflag == MEM_READ) {
                        odata = d->cnt & 0xff;
                } else {
                        d->cnt = (d->cnt & 0xff00) | (idata & 0xff);
                }
                break;

        case GDROM_CNTHI:
                if (writeflag == MEM_READ) {
                        odata = (d->cnt >> 8) & 0xff;
                } else {
                        d->cnt = (d->cnt & 0x00ff) | ((idata & 0xff) << 8);
                }
                break;

        case GDROM_COND:
                if (writeflag == MEM_READ) {
                        odata = d->cond;
                } else {
                        d->cond = idata;

                        /*
                         *  NetBSD/dreamcast writes 0xa0 to GDROM_COND to
                         *  start a command. It expects (BUSY & 0x88) to
                         *  be 0x08 after writing to GDROM_COND, and STAT
                         *  to be not equal to 6. NetBSD then sends 6
                         *  16-bit data words to GDROM_DATA.
                         */
                        if (idata == 0xa0) {
                                d->stat = 0;    /*  TODO  */
                                d->busy |= 0x08;
                                d->cmd_count = 0;
                        } else {
                                fatal("dreamcast_gdrom: unimplemented "
                                    "GDROM_COND = 0x%02x\n", (int)idata);
                                exit(1);
                        }
                }
                break;

        default:if (writeflag == MEM_READ) {
                        fatal("[ dreamcast_gdrom: read from addr 0x%x ]\n",
                            (int)relative_addr);
                } else {
                        fatal("[ dreamcast_gdrom: write to addr 0x%x: 0x%x ]\n",
                            (int)relative_addr, (int)idata);
                }
                exit(1);
        }

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

        return 1;
}


DEVINIT(dreamcast_gdrom)
{
        struct machine *machine = devinit->machine;
        struct dreamcast_gdrom_data *d =
            malloc(sizeof(struct dreamcast_gdrom_data));
        if (d == NULL) {
                fprintf(stderr, "out of memory\n");
                exit(1);
        }
        memset(d, 0, sizeof(struct dreamcast_gdrom_data));

        memory_device_register(machine->memory, devinit->name,
            0x005f7000, 0x100, dev_dreamcast_gdrom_access, d,
            DM_DEFAULT, NULL);

        return 1;
}

1	dpavlin	34	/*
2			* Copyright (C) 2006-2007 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_dreamcast_gdrom.c,v 1.4 2007/02/03 20:14:23 debug Exp $
29			*
30			* Dreamcast GD-ROM.
31			*
32			* TODO: This is just a dummy so far.
33			*/
34
35			#include <stdio.h>
36			#include <stdlib.h>
37			#include <string.h>
38
39			#include "cpu.h"
40			#include "device.h"
41			#include "diskimage.h"
42			#include "machine.h"
43			#include "memory.h"
44			#include "misc.h"
45
46			#include "dreamcast_sysasicvar.h"
47
48
49			/* #define debug fatal */
50
51			struct dreamcast_gdrom_data {
52			uint8_t busy; /* Busy status */
53			uint8_t stat; /* Status */
54			int cnt; /* Data length */
55			uint8_t cond;
56
57			int cmd_count;
58			uint8_t cmd[12];
59
60			uint8_t *data;
61			int data_len;
62			int cur_data_offset;
63			int cur_cnt;
64			};
65
66			/* Register offsets: */
67			#define GDROM_BUSY 0x18
68			#define GDROM_DATA 0x80
69			#define GDROM_REGX 0x84
70			#define GDROM_STAT 0x8c
71			#define GDROM_CNTLO 0x90
72			#define GDROM_CNTHI 0x94
73			#define GDROM_COND 0x9c
74
75			#define COND_DATA_AVAIL 0x08
76
77
78			static void alloc_data(struct dreamcast_gdrom_data *d)
79			{
80			d->data_len = d->cnt;
81			d->data = malloc(d->data_len);
82			if (d->data == NULL) {
83			fprintf(stderr, "GDROM alloc_data: out of memory\n");
84			exit(1);
85			}
86			memset(d->data, 0, d->data_len);
87			}
88
89
90			static void handle_command(struct cpu cpu, struct dreamcast_gdrom_data d)
91			{
92			int64_t sector_nr, sector_count;
93			int i, res;
94
95			debug("[ GDROM cmd: ");
96			for (i=0; i<12; i++)
97			debug("%02x ", d->cmd[i]);
98			debug("(cnt=%i) ]\n", d->cnt);
99
100			if (d->data != NULL)
101			free(d->data);
102			d->data = NULL;
103			d->cur_data_offset = 0;
104			d->cur_cnt = 0;
105
106			switch (d->cmd[0]) {
107
108			case 0x14:
109			/* Read Table-Of-Contents: */
110			if (d->cnt != 408) {
111			fatal("GDROM Read TOC not 408 bytes?\n");
112			exit(1);
113			}
114			alloc_data(d);
115
116			/* TODO: Fill TOC in a better way */
117			d->data[994] = 1; / First track */
118			d->data[1004] = 2; / Last track */
119
120			d->data[04] = 0x10; / Track 1 */
121			d->data[14] = 0x10; / Track 2 */
122			break;
123
124			case 0x30:
125			/* Read sectors: */
126			if (d->cmd[1] != 0x20) {
127			fatal("GDROM unimplemented data format 0x%02x\n",
128			d->cmd[1]);
129			exit(1);
130			}
131			sector_nr = d->cmd[2] * 65536 + d->cmd[3] * 256 + d->cmd[4];
132			sector_count = d->cmd[8] * 65536 + d->cmd[9] * 256 + d->cmd[10];
133			if (d->cnt == 0)
134			d->cnt = 65536;
135			alloc_data(d);
136			if (sector_count * 2048 != d->data_len) {
137			fatal("Huh? GDROM data_len=0x%x, but sector_count"
138			"=0x%x\n", (int)d->data_len, (int)sector_count);
139			exit(1);
140			}
141
142			{
143			if (sector_nr >= 1376810)
144			sector_nr -= 1376810;
145			sector_nr -= 150;
146			if (sector_nr > 1048576)
147			sector_nr -= 1048576;
148			/* printf("sector nr = %i\n", (int)sector_nr); */
149
150			if (sector_nr < 1000)
151			sector_nr += (diskimage_get_baseoffset(cpu->machine, 0, DISKIMAGE_IDE)
152			/ 2048);
153			}
154
155			res = diskimage_access(cpu->machine, 0, DISKIMAGE_IDE,
156			0, sector_nr * 2048, d->data, d->data_len);
157			if (!res) {
158			fatal("GDROM: diskimage_access failed? TODO\n");
159			// exit(1);
160			}
161			break;
162
163			case 0x70:
164			/* Mount: (?) */
165			break;
166
167			default:fatal("GDROM handle_command: unimplemented command 0x%02x"
168			"\n", d->cmd[0]);
169			exit(1);
170			}
171
172			if (d->data != NULL)
173			d->cond \|= COND_DATA_AVAIL;
174
175			if (d->cnt == 65536)
176			d->cnt = 32768;
177
178			SYSASIC_TRIGGER_EVENT(SYSASIC_EVENT_GDROM);
179			}
180
181
182			DEVICE_ACCESS(dreamcast_gdrom)
183			{
184			struct dreamcast_gdrom_data d = (struct dreamcast_gdrom_data ) extra;
185			uint64_t idata = 0, odata = 0;
186
187			if (writeflag == MEM_WRITE)
188			idata = memory_readmax64(cpu, data, len);
189
190			switch (relative_addr) {
191
192			case GDROM_BUSY:
193			if (writeflag == MEM_READ) {
194			odata = d->busy;
195			} else {
196			fatal("Write to GDROM_BUSY?\n");
197			exit(1);
198			}
199			break;
200
201			case GDROM_DATA:
202			if (len != sizeof(uint16_t)) {
203			fatal("Non-16bit GDROM data access? TODO\n");
204			exit(1);
205			}
206
207			if (writeflag == MEM_READ) {
208			if (!(d->cond & COND_DATA_AVAIL)) {
209			fatal("Read from GDROM_DATA when no data"
210			" is available? TODO\n");
211			exit(1);
212			}
213			if (d->cur_data_offset < d->data_len) {
214			odata = d->data[d->cur_data_offset ++];
215			odata \|= (d->data[d->cur_data_offset ++] << 8);
216			d->cur_cnt += 2;
217			if (d->cur_cnt >= d->cnt) {
218			if (d->cur_data_offset >= d->data_len) {
219			d->cond &= ~COND_DATA_AVAIL;
220			} else {
221			d->cnt = d->data_len -
222			d->cur_data_offset;
223			d->cur_cnt = 0;
224			}
225			SYSASIC_TRIGGER_EVENT(
226			SYSASIC_EVENT_GDROM);
227			}
228			} else {
229			fatal("Read too much from GDROM_DATA\n");
230			exit(1);
231			}
232			} else {
233			if (d->busy & 0x08) {
234			if (d->cmd_count >= 12) {
235			fatal("Too much GDROM_DATA?\n");
236			exit(1);
237			}
238			/* Add data to cmd: */
239			d->cmd[d->cmd_count++] = idata;
240			d->cmd[d->cmd_count++] = idata >> 8;
241			if (d->cmd_count == 12) {
242			d->busy &= ~0x08;
243			handle_command(cpu, d);
244			}
245			} else {
246			fatal("Write to GDROM_DATA, but not waiting"
247			" for data?\n");
248			exit(1);
249			}
250			}
251			break;
252
253			case GDROM_REGX:
254			if (writeflag == MEM_READ) {
255			fatal("Read from GDROM_REGX?\n");
256			exit(1);
257			} else {
258			/* NetBSD/dreamcast writes 0 here. */
259			if (idata != 0) {
260			fatal("Write to GDROM_REGX?\n");
261			exit(1);
262			}
263			}
264			break;
265
266			case GDROM_STAT:
267			if (writeflag == MEM_READ) {
268			odata = d->stat;
269			} else {
270			fatal("Write to GDROM_STAT?\n");
271			exit(1);
272			}
273			break;
274
275			case GDROM_CNTLO:
276			if (writeflag == MEM_READ) {
277			odata = d->cnt & 0xff;
278			} else {
279			d->cnt = (d->cnt & 0xff00) \| (idata & 0xff);
280			}
281			break;
282
283			case GDROM_CNTHI:
284			if (writeflag == MEM_READ) {
285			odata = (d->cnt >> 8) & 0xff;
286			} else {
287			d->cnt = (d->cnt & 0x00ff) \| ((idata & 0xff) << 8);
288			}
289			break;
290
291			case GDROM_COND:
292			if (writeflag == MEM_READ) {
293			odata = d->cond;
294			} else {
295			d->cond = idata;
296
297			/*
298			* NetBSD/dreamcast writes 0xa0 to GDROM_COND to
299			* start a command. It expects (BUSY & 0x88) to
300			* be 0x08 after writing to GDROM_COND, and STAT
301			* to be not equal to 6. NetBSD then sends 6
302			* 16-bit data words to GDROM_DATA.
303			*/
304			if (idata == 0xa0) {
305			d->stat = 0; /* TODO */
306			d->busy \|= 0x08;
307			d->cmd_count = 0;
308			} else {
309			fatal("dreamcast_gdrom: unimplemented "
310			"GDROM_COND = 0x%02x\n", (int)idata);
311			exit(1);
312			}
313			}
314			break;
315
316			default:if (writeflag == MEM_READ) {
317			fatal("[ dreamcast_gdrom: read from addr 0x%x ]\n",
318			(int)relative_addr);
319			} else {
320			fatal("[ dreamcast_gdrom: write to addr 0x%x: 0x%x ]\n",
321			(int)relative_addr, (int)idata);
322			}
323			exit(1);
324			}
325
326			if (writeflag == MEM_READ)
327			memory_writemax64(cpu, data, len, odata);
328
329			return 1;
330			}
331
332
333			DEVINIT(dreamcast_gdrom)
334			{
335			struct machine *machine = devinit->machine;
336			struct dreamcast_gdrom_data *d =
337			malloc(sizeof(struct dreamcast_gdrom_data));
338			if (d == NULL) {
339			fprintf(stderr, "out of memory\n");
340			exit(1);
341			}
342			memset(d, 0, sizeof(struct dreamcast_gdrom_data));
343
344			memory_device_register(machine->memory, devinit->name,
345			0x005f7000, 0x100, dev_dreamcast_gdrom_access, d,
346			DM_DEFAULT, NULL);
347
348			return 1;
349			}
350