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	dpavlin	4	/*
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	dpavlin	18	* $Id: dev_pmagja.c,v 1.16 2005/10/26 14:37:04 debug Exp $
29	dpavlin	4	*
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	dpavlin	18	if (writeflag == MEM_WRITE)
79			idata = memory_readmax64(cpu, data, len);
80
81	dpavlin	4	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	dpavlin	12	d->fb_mem = memory_new(XSIZE * YSIZE * 3, machine->arch);
221	dpavlin	4	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	dpavlin	12	XSIZE, YSIZE, XSIZE, YSIZE, 24, "PMAG-JA");
227	dpavlin	4	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