src/devices/dev_pmagja.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_pmagja.c,v 1.16 2005/10/26 14:37:04 debug Exp $
 *  
 *  TURBOchannel PMAG-JA graphics device.
 *
 *  TODO
 */

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

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


#define XSIZE           1280
#define YSIZE           1024

#define PMAGJA_FIRSTOFFSET      0x40030

/*  #define JA_DEBUG  */

struct pmagja_data {
        int             irq_nr;
        struct memory   *fb_mem;
        struct vfb_data *vfb_data;

        unsigned char   pixeldata[XSIZE * YSIZE];

        int             current_r;
        int             current_g;
        int             current_b;

        int             pip_offset;
};


/*
 *  dev_pmagja_access():
 */
int dev_pmagja_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;
        struct pmagja_data *d = extra;
        int i, res = 1;

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

        relative_addr += PMAGJA_FIRSTOFFSET;

#ifdef JA_DEBUG
{
int i;
for (i=0; i<len; i++)
  if (data[i] != 0 && data[i] != 1 && data[i]!=0xff)
        if (writeflag)
                fatal("[ pmagja: write to addr 0x%08llx: 0x%08llx ]\n",
                    (long long)relative_addr, (long long)idata);
}
#endif

        switch (relative_addr) {
        case 0x0800c4:          /*  pip offset  */
                if (writeflag==MEM_READ) {
                        odata = d->pip_offset;
                        debug("[ pmagja: read from pip offset: 0x%08llx ]\n",
                            (long long)odata);
                } else {
                        d->pip_offset = idata;
                        debug("[ px: write to pip offset: 0x%08llx ]\n",
                            (long long)idata);
                }
                break;
        default:
                if (relative_addr >= 0x200000) {
                        /*  8-bit access:  */
                        for (i=0; i<len; i++) {
                                int ofs = relative_addr - 0x200000 + i;
                                int x, y;
                                unsigned char newdata[3];
                                y = ofs / XSIZE;
                                x = ofs - y*XSIZE;

                                if (writeflag) {
                                        d->pixeldata[x + y*XSIZE] = data[i];
                                        newdata[0] = d->vfb_data->rgb_palette[
                                            data[i] * 3 + 0];
                                        newdata[1] = d->vfb_data->rgb_palette[
                                            data[i] * 3 + 1];
                                        newdata[2] = d->vfb_data->rgb_palette[
                                            data[i] * 3 + 2];
                                        dev_fb_access(cpu, d->fb_mem, (x +
                                            y * XSIZE) * 3, newdata, 3,
                                            writeflag, d->vfb_data);
                                } else {
                                        data[i] = d->pixeldata[x + y*XSIZE];
                                }
                        }
                        /*  Return success.  */
                        return 1;
                } else if (relative_addr >= 0x100000 &&
                    relative_addr < 0x200000) {
                        /*  24-bit access:  */
#if 0
{
        if (writeflag)
            if (idata != 0)
                fatal("[ pmagja: write to addr 0x%08llx: 0x%08llx ]\n",
                    (long long)relative_addr, (long long)idata);
}
#endif
                        int x, y, ofs;

                        ofs = (relative_addr - 0x100000) * 2;
                        y = ofs / XSIZE;
                        x = ofs - y * XSIZE;

#if 0
                        if (writeflag == MEM_WRITE) {
                                int ix;
                                for (ix=0; ix<len*2; ix++) {
                                        unsigned char data[3];
                                        int ctype;

                                        data[0] = data[1] = data[2] = 0;
                                        ctype = (idata >> (ix*4)) & 0xf;
                                        if (ctype == 0)
                                                data[0] = 255;
                                        if (ctype == 3)
                                                data[1] = 255;
                                        if (ctype == 0xf)
                                                data[2] = 255;

                                        res = dev_fb_access(cpu, d->fb_mem,
                                            ofs * 3, data, 3, MEM_WRITE,
                                            d->vfb_data);
                                        ofs ++;
                                }
                        }
#endif
                        return 1;
                } else {
                        /*  Unknown:  */
                        if (writeflag==MEM_READ) {
                                fatal("[ pmagja: read from addr 0x%x: "
                                    "0x%llx ]\n", (int)relative_addr,
                                    (long long)odata);
                        } else {
                                fatal("[ pmagja: write to addr 0x%x: "
                                    "0x%llx ]\n", (int)relative_addr,
                                    (long long)idata);
                        }
                }
        }

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

#ifdef JA_DEBUG
/*
        if (!writeflag)
                fatal("[ pmagja: read from addr 0x%08llx: 0x%08llx ]\n",
                    (long long)relative_addr, (long long)odata);
*/
#endif

        return res;
}


/*
 *  dev_pmagja_init():
 */
void dev_pmagja_init(struct machine *machine, struct memory *mem,
        uint64_t baseaddr, int irq_nr)
{
        struct pmagja_data *d;

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

        d->irq_nr = irq_nr;

        d->fb_mem = memory_new(XSIZE * YSIZE * 3, machine->arch);
        if (d->fb_mem == NULL) {
                fprintf(stderr, "dev_pmagja_init(): out of memory (1)\n");
                exit(1);
        }
        d->vfb_data = dev_fb_init(machine, d->fb_mem, 0, VFB_GENERIC,
            XSIZE, YSIZE, XSIZE, YSIZE, 24, "PMAG-JA");
        if (d->vfb_data == NULL) {
                fprintf(stderr, "dev_pmagja_init(): out of memory (2)\n");
                exit(2);
        }

        /*  TODO: not bt459, but a bt463:  */
        dev_bt459_init(machine, mem, baseaddr + 0x40000, 0, d->vfb_data, 8,
            irq_nr, 0); /*  palette  (TODO: type)  */
        dev_bt431_init(mem, baseaddr + 0x40010, d->vfb_data, 8);  /*  cursor  */

        memory_device_register(mem, "pmagja", baseaddr + PMAGJA_FIRSTOFFSET,
            DEV_PMAGJA_LENGTH - PMAGJA_FIRSTOFFSET, dev_pmagja_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_pmagja.c,v 1.16 2005/10/26 14:37:04 debug Exp $
29	*
30	* TURBOchannel PMAG-JA graphics device.
31	*
32	* TODO
33	*/
34
35	#include <stdio.h>
36	#include <stdlib.h>
37	#include <string.h>
38
39	#include "devices.h"
40	#include "machine.h"
41	#include "memory.h"
42	#include "misc.h"
43
44
45	#define XSIZE 1280
46	#define YSIZE 1024
47
48	#define PMAGJA_FIRSTOFFSET 0x40030
49
50	/* #define JA_DEBUG */
51
52	struct pmagja_data {
53	int irq_nr;
54	struct memory *fb_mem;
55	struct vfb_data *vfb_data;
56
57	unsigned char pixeldata[XSIZE * YSIZE];
58
59	int current_r;
60	int current_g;
61	int current_b;
62
63	int pip_offset;
64	};
65
66
67	/*
68	* dev_pmagja_access():
69	*/
70	int dev_pmagja_access(struct cpu cpu, struct memory mem,
71	uint64_t relative_addr, unsigned char *data, size_t len,
72	int writeflag, void *extra)
73	{
74	uint64_t idata = 0, odata = 0;
75	struct pmagja_data *d = extra;
76	int i, res = 1;
77
78	if (writeflag == MEM_WRITE)
79	idata = memory_readmax64(cpu, data, len);
80
81	relative_addr += PMAGJA_FIRSTOFFSET;
82
83	#ifdef JA_DEBUG
84	{
85	int i;
86	for (i=0; i<len; i++)
87	if (data[i] != 0 && data[i] != 1 && data[i]!=0xff)
88	if (writeflag)
89	fatal("[ pmagja: write to addr 0x%08llx: 0x%08llx ]\n",
90	(long long)relative_addr, (long long)idata);
91	}
92	#endif
93
94	switch (relative_addr) {
95	case 0x0800c4: /* pip offset */
96	if (writeflag==MEM_READ) {
97	odata = d->pip_offset;
98	debug("[ pmagja: read from pip offset: 0x%08llx ]\n",
99	(long long)odata);
100	} else {
101	d->pip_offset = idata;
102	debug("[ px: write to pip offset: 0x%08llx ]\n",
103	(long long)idata);
104	}
105	break;
106	default:
107	if (relative_addr >= 0x200000) {
108	/* 8-bit access: */
109	for (i=0; i<len; i++) {
110	int ofs = relative_addr - 0x200000 + i;
111	int x, y;
112	unsigned char newdata[3];
113	y = ofs / XSIZE;
114	x = ofs - y*XSIZE;
115
116	if (writeflag) {
117	d->pixeldata[x + y*XSIZE] = data[i];
118	newdata[0] = d->vfb_data->rgb_palette[
119	data[i] * 3 + 0];
120	newdata[1] = d->vfb_data->rgb_palette[
121	data[i] * 3 + 1];
122	newdata[2] = d->vfb_data->rgb_palette[
123	data[i] * 3 + 2];
124	dev_fb_access(cpu, d->fb_mem, (x +
125	y * XSIZE) * 3, newdata, 3,
126	writeflag, d->vfb_data);
127	} else {
128	data[i] = d->pixeldata[x + y*XSIZE];
129	}
130	}
131	/* Return success. */
132	return 1;
133	} else if (relative_addr >= 0x100000 &&
134	relative_addr < 0x200000) {
135	/* 24-bit access: */
136	#if 0
137	{
138	if (writeflag)
139	if (idata != 0)
140	fatal("[ pmagja: write to addr 0x%08llx: 0x%08llx ]\n",
141	(long long)relative_addr, (long long)idata);
142	}
143	#endif
144	int x, y, ofs;
145
146	ofs = (relative_addr - 0x100000) * 2;
147	y = ofs / XSIZE;
148	x = ofs - y * XSIZE;
149
150	#if 0
151	if (writeflag == MEM_WRITE) {
152	int ix;
153	for (ix=0; ix<len*2; ix++) {
154	unsigned char data[3];
155	int ctype;
156
157	data[0] = data[1] = data[2] = 0;
158	ctype = (idata >> (ix*4)) & 0xf;
159	if (ctype == 0)
160	data[0] = 255;
161	if (ctype == 3)
162	data[1] = 255;
163	if (ctype == 0xf)
164	data[2] = 255;
165
166	res = dev_fb_access(cpu, d->fb_mem,
167	ofs * 3, data, 3, MEM_WRITE,
168	d->vfb_data);
169	ofs ++;
170	}
171	}
172	#endif
173	return 1;
174	} else {
175	/* Unknown: */
176	if (writeflag==MEM_READ) {
177	fatal("[ pmagja: read from addr 0x%x: "
178	"0x%llx ]\n", (int)relative_addr,
179	(long long)odata);
180	} else {
181	fatal("[ pmagja: write to addr 0x%x: "
182	"0x%llx ]\n", (int)relative_addr,
183	(long long)idata);
184	}
185	}
186	}
187
188	if (writeflag == MEM_READ)
189	memory_writemax64(cpu, data, len, odata);
190
191	#ifdef JA_DEBUG
192	/*
193	if (!writeflag)
194	fatal("[ pmagja: read from addr 0x%08llx: 0x%08llx ]\n",
195	(long long)relative_addr, (long long)odata);
196	*/
197	#endif
198
199	return res;
200	}
201
202
203	/*
204	* dev_pmagja_init():
205	*/
206	void dev_pmagja_init(struct machine machine, struct memory mem,
207	uint64_t baseaddr, int irq_nr)
208	{
209	struct pmagja_data *d;
210
211	d = malloc(sizeof(struct pmagja_data));
212	if (d == NULL) {
213	fprintf(stderr, "out of memory\n");
214	exit(1);
215	}
216	memset(d, 0, sizeof(struct pmagja_data));
217
218	d->irq_nr = irq_nr;
219
220	d->fb_mem = memory_new(XSIZE * YSIZE * 3, machine->arch);
221	if (d->fb_mem == NULL) {
222	fprintf(stderr, "dev_pmagja_init(): out of memory (1)\n");
223	exit(1);
224	}
225	d->vfb_data = dev_fb_init(machine, d->fb_mem, 0, VFB_GENERIC,
226	XSIZE, YSIZE, XSIZE, YSIZE, 24, "PMAG-JA");
227	if (d->vfb_data == NULL) {
228	fprintf(stderr, "dev_pmagja_init(): out of memory (2)\n");
229	exit(2);
230	}
231
232	/* TODO: not bt459, but a bt463: */
233	dev_bt459_init(machine, mem, baseaddr + 0x40000, 0, d->vfb_data, 8,
234	irq_nr, 0); /* palette (TODO: type) */
235	dev_bt431_init(mem, baseaddr + 0x40010, d->vfb_data, 8); /* cursor */
236
237	memory_device_register(mem, "pmagja", baseaddr + PMAGJA_FIRSTOFFSET,
238	DEV_PMAGJA_LENGTH - PMAGJA_FIRSTOFFSET, dev_pmagja_access, d,
239	MEM_DEFAULT, NULL);
240	}
241