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.5 2007/06/15 19:11:15 debug Exp $
 *  
 *  COMMENT: 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;

        CHECK_ALLOCATION(d->data = malloc(d->data_len));
        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 dreamcast_gdrom_data *d;

        CHECK_ALLOCATION(d = malloc(sizeof(struct dreamcast_gdrom_data)));
        memset(d, 0, sizeof(struct dreamcast_gdrom_data));

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