src/devices/dev_pmagja.c

/*
 *  Copyright (C) 2004-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_pmagja.c,v 1.21 2006/12/30 13:30:58 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 {
        struct interrupt        irq;
        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():
 */
DEVICE_ACCESS(pmagja)
{
        uint64_t idata = 0, odata = 0;
        struct pmagja_data *d = extra;
        size_t i, res = 1;

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

        relative_addr += PMAGJA_FIRSTOFFSET;

#ifdef JA_DEBUG
{
size_t 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, char *irq_path)
{
        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));

        INTERRUPT_CONNECT(irq_path, d->irq);

        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_path, 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,
            DM_DEFAULT, NULL);
}

1	/*
2	* Copyright (C) 2004-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_pmagja.c,v 1.21 2006/12/30 13:30:58 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	struct interrupt irq;
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	DEVICE_ACCESS(pmagja)
71	{
72	uint64_t idata = 0, odata = 0;
73	struct pmagja_data *d = extra;
74	size_t i, res = 1;
75
76	if (writeflag == MEM_WRITE)
77	idata = memory_readmax64(cpu, data, len);
78
79	relative_addr += PMAGJA_FIRSTOFFSET;
80
81	#ifdef JA_DEBUG
82	{
83	size_t i;
84	for (i=0; i<len; i++)
85	if (data[i] != 0 && data[i] != 1 && data[i]!=0xff)
86	if (writeflag)
87	fatal("[ pmagja: write to addr 0x%08llx: 0x%08llx ]\n",
88	(long long)relative_addr, (long long)idata);
89	}
90	#endif
91
92	switch (relative_addr) {
93	case 0x0800c4: /* pip offset */
94	if (writeflag==MEM_READ) {
95	odata = d->pip_offset;
96	debug("[ pmagja: read from pip offset: 0x%08llx ]\n",
97	(long long)odata);
98	} else {
99	d->pip_offset = idata;
100	debug("[ px: write to pip offset: 0x%08llx ]\n",
101	(long long)idata);
102	}
103	break;
104	default:
105	if (relative_addr >= 0x200000) {
106	/* 8-bit access: */
107	for (i=0; i<len; i++) {
108	int ofs = relative_addr - 0x200000 + i;
109	int x, y;
110	unsigned char newdata[3];
111	y = ofs / XSIZE;
112	x = ofs - y*XSIZE;
113
114	if (writeflag) {
115	d->pixeldata[x + y*XSIZE] = data[i];
116	newdata[0] = d->vfb_data->rgb_palette[
117	data[i] * 3 + 0];
118	newdata[1] = d->vfb_data->rgb_palette[
119	data[i] * 3 + 1];
120	newdata[2] = d->vfb_data->rgb_palette[
121	data[i] * 3 + 2];
122	dev_fb_access(cpu, d->fb_mem, (x +
123	y * XSIZE) * 3, newdata, 3,
124	writeflag, d->vfb_data);
125	} else {
126	data[i] = d->pixeldata[x + y*XSIZE];
127	}
128	}
129	/* Return success. */
130	return 1;
131	} else if (relative_addr >= 0x100000 &&
132	relative_addr < 0x200000) {
133	/* 24-bit access: */
134	#if 0
135	{
136	if (writeflag)
137	if (idata != 0)
138	fatal("[ pmagja: write to addr 0x%08llx: 0x%08llx ]\n",
139	(long long)relative_addr, (long long)idata);
140	}
141	#endif
142	int x, y, ofs;
143
144	ofs = (relative_addr - 0x100000) * 2;
145	y = ofs / XSIZE;
146	x = ofs - y * XSIZE;
147
148	#if 0
149	if (writeflag == MEM_WRITE) {
150	int ix;
151	for (ix=0; ix<len*2; ix++) {
152	unsigned char data[3];
153	int ctype;
154
155	data[0] = data[1] = data[2] = 0;
156	ctype = (idata >> (ix*4)) & 0xf;
157	if (ctype == 0)
158	data[0] = 255;
159	if (ctype == 3)
160	data[1] = 255;
161	if (ctype == 0xf)
162	data[2] = 255;
163
164	res = dev_fb_access(cpu, d->fb_mem,
165	ofs * 3, data, 3, MEM_WRITE,
166	d->vfb_data);
167	ofs ++;
168	}
169	}
170	#endif
171	return 1;
172	} else {
173	/* Unknown: */
174	if (writeflag==MEM_READ) {
175	fatal("[ pmagja: read from addr 0x%x: "
176	"0x%llx ]\n", (int)relative_addr,
177	(long long)odata);
178	} else {
179	fatal("[ pmagja: write to addr 0x%x: "
180	"0x%llx ]\n", (int)relative_addr,
181	(long long)idata);
182	}
183	}
184	}
185
186	if (writeflag == MEM_READ)
187	memory_writemax64(cpu, data, len, odata);
188
189	#ifdef JA_DEBUG
190	/*
191	if (!writeflag)
192	fatal("[ pmagja: read from addr 0x%08llx: 0x%08llx ]\n",
193	(long long)relative_addr, (long long)odata);
194	*/
195	#endif
196
197	return res;
198	}
199
200
201	/*
202	* dev_pmagja_init():
203	*/
204	void dev_pmagja_init(struct machine machine, struct memory mem,
205	uint64_t baseaddr, char *irq_path)
206	{
207	struct pmagja_data *d;
208
209	d = malloc(sizeof(struct pmagja_data));
210	if (d == NULL) {
211	fprintf(stderr, "out of memory\n");
212	exit(1);
213	}
214	memset(d, 0, sizeof(struct pmagja_data));
215
216	INTERRUPT_CONNECT(irq_path, d->irq);
217
218	d->fb_mem = memory_new(XSIZE * YSIZE * 3, machine->arch);
219	if (d->fb_mem == NULL) {
220	fprintf(stderr, "dev_pmagja_init(): out of memory (1)\n");
221	exit(1);
222	}
223	d->vfb_data = dev_fb_init(machine, d->fb_mem, 0, VFB_GENERIC,
224	XSIZE, YSIZE, XSIZE, YSIZE, 24, "PMAG-JA");
225	if (d->vfb_data == NULL) {
226	fprintf(stderr, "dev_pmagja_init(): out of memory (2)\n");
227	exit(2);
228	}
229
230	/* TODO: not bt459, but a bt463: */
231	dev_bt459_init(machine, mem, baseaddr + 0x40000, 0, d->vfb_data, 8,
232	irq_path, 0); /* palette (TODO: type) */
233	dev_bt431_init(mem, baseaddr + 0x40010, d->vfb_data, 8); /* cursor */
234
235	memory_device_register(mem, "pmagja", baseaddr + PMAGJA_FIRSTOFFSET,
236	DEV_PMAGJA_LENGTH - PMAGJA_FIRSTOFFSET, dev_pmagja_access, d,
237	DM_DEFAULT, NULL);
238	}
239