src/devices/dev_sgi_mardigras.c

/*
 *  Copyright (C) 2003-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_sgi_mardigras.c,v 1.20 2005/11/13 00:14:10 debug Exp $
 *  
 *  "MardiGras" graphics controller on SGI IP30 (Octane).
 *
 *  Most of this is just guesses based on the behaviour of Linux/Octane.
 *
 *  TODO
 */

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

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


#define debug fatal


#define DEV_SGI_MARDIGRAS_LENGTH        0x800000

#define MARDIGRAS_FAKE_OFFSET   0x500000000ULL  /*  hopefully available  */
#define MARDIGRAS_DEFAULT_XSIZE 1280
#define MARDIGRAS_DEFAULT_YSIZE 1024

#define MICROCODE_START         0x50000
#define MICROCODE_END           0x55000

static int mardigras_xsize = MARDIGRAS_DEFAULT_XSIZE;
static int mardigras_ysize = MARDIGRAS_DEFAULT_YSIZE;

struct sgi_mardigras_data {
        struct vfb_data         *fb;
        unsigned char           microcode_ram[MICROCODE_END - MICROCODE_START];
        uint64_t                palette_reg_select;
        int                     currentx;
        int                     currenty;
        int                     color;
        int                     startx;
        int                     starty;
        int                     stopx;
        int                     stopy;
        uint64_t                draw_mode;
};


/*
 *  mardigras_20400():
 */
void mardigras_20400(struct cpu *cpu, struct sgi_mardigras_data *d,
        uint64_t idata)
{
        int i, x, y, r,g,b, len, addr;
        unsigned char pixels[3 * 8000];

        /*  Get rgb from palette:  */
        r = d->fb->rgb_palette[d->color * 3 + 0];
        g = d->fb->rgb_palette[d->color * 3 + 1];
        b = d->fb->rgb_palette[d->color * 3 + 2];

        /*  Set color:  */
        if ((idata & 0x00ffffff00000000ULL) == 0x00185C0400000000ULL) {
                int color = (idata >> 12) & 0xff;
                d->color = color;
                return;
        }

        /*  Set start XY:  */
        if ((idata & 0x00ffffff00000000ULL) == 0x0018460400000000ULL) {
                d->startx = (idata >> 16) & 0xffff;
                d->starty = idata & 0xffff;
                if (d->startx >= mardigras_xsize)
                        d->startx = 0;
                if (d->starty >= mardigras_ysize)
                        d->starty = 0;
                d->currentx = d->startx;
                d->currenty = d->starty;
                return;
        }

        /*  Set stop XY:  */
        if ((idata & 0x00ffffff00000000ULL) == 0x0018470400000000ULL) {
                d->stopx = (idata >> 16) & 0xffff;
                d->stopy = idata & 0xffff;
                if (d->stopx >= mardigras_xsize)
                        d->stopx = 0;
                if (d->stopy >= mardigras_ysize)
                        d->stopy = 0;
                return;
        }

        /*  Draw modes: (Rectangle or Bitmap, respectively)  */
        if (idata == 0x0019100400018000ULL ||
            idata == 0x0019100400418008ULL) {
                d->draw_mode = idata;
                return;
        }

        /*  Send command:  */
        if (idata == 0x001C130400000018ULL) {
                switch (d->draw_mode) {
                /*  Rectangle:  */
                case 0x0019100400018000ULL:
                        /*  Fill pixels[] with pixels:  */
                        len = 0;
                        for (x=d->startx; x<=d->stopx; x++) {
                                pixels[len + 0] = r;
                                pixels[len + 1] = g;
                                pixels[len + 2] = b;
                                len += 3;
                        }
                        if (len == 0)
                                break;
                        for (y=d->starty; y<=d->stopy; y++) {
                                addr = (mardigras_xsize * (mardigras_ysize -
                                    1 - y) + d->startx) * 3;
                                /*  printf("addr = %i\n", addr);  */

                                /*  Write a line:  */
                                dev_fb_access(cpu, cpu->mem,
                                    addr, pixels, len, MEM_WRITE, d->fb);
                        }
                        break;
                /*  Bitmap:  */
                case 0x0019100400418008ULL:
                        break;
                default:
                        fatal("[ sgi_mardigras: unknown draw mode ]\n");
                }
                return;
        }

        /*  Send a line of bitmap data:  */
        if ((idata & 0x00ffffff00000000ULL) == 0x001C700400000000ULL) {
                addr = (mardigras_xsize * (mardigras_ysize - 1 - d->currenty)
                    + d->currentx) * 3;
/*
                printf("addr=%08x curx,y=%4i,%4i startx,y=%4i,%4i "
                    "stopx,y=%4i,%4i\n", addr, d->currentx, d->currenty,
                    d->startx, d->starty, d->stopx, d->stopy);
*/
                len = 8*3;

                if (addr > mardigras_xsize * mardigras_ysize * 3 || addr < 0)
                        return;

                /*  Read a line:  */
                dev_fb_access(cpu, cpu->mem,
                    addr, pixels, len, MEM_READ, d->fb);

                i = 0;
                while (i < 8) {
                        if ((idata >> (24 + (7-i))) & 1) {
                                pixels[i*3 + 0] = r;
                                pixels[i*3 + 1] = g;
                                pixels[i*3 + 2] = b;
                        }
                        i ++;

                        d->currentx ++;
                        if (d->currentx > d->stopx) {
                                d->currentx = d->startx;
                                d->currenty ++;
                                if (d->currenty > d->stopy)
                                        d->currenty = d->starty;
                        }
                }

                /*  Write a line:  */
                dev_fb_access(cpu, cpu->mem,
                    addr, pixels, len, MEM_WRITE, d->fb);

                return;
        }

        debug("mardigras_20400(): 0x%016llx\n", (long long)idata);
}


/*
 *  dev_sgi_mardigras_access():
 */
int dev_sgi_mardigras_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 sgi_mardigras_data *d = extra;
        int i;

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

        /*  Accessing the microcode_ram works like ordinary ram:  */
        if (relative_addr >= MICROCODE_START &&
            relative_addr <  MICROCODE_END) {
                relative_addr -= MICROCODE_START;
                if (writeflag == MEM_WRITE)
                        memcpy(d->microcode_ram + relative_addr, data, len);
                else
                        memcpy(data, d->microcode_ram + relative_addr, len);
                return 1;
        }

        switch (relative_addr) {
        case 0x00004:
                /*  xtalk data:  (according to Linux/IP30)  */
                /*  (mfgr & 0x7ff) << 1  */
                /*  (part & 0xffff) << 12  */
                /*  (rev  & 0xf) << 28  */
                odata = (2 << 28) | (0xc003 << 12) | (0x2aa << 1);
                break;
        case 0x20008:   /*  Fifo status  */
                break;
        case 0x20200:
                break;
        case 0x20400:
                if (writeflag == MEM_WRITE)
                        mardigras_20400(cpu, d, idata);
                else
                        debug("[ sgi_mardigras: read from 0x20400? ]\n");
                break;
        case 0x58040:
                /*  HQ4 microcode stuff  */
                break;
        case 0x70c30:
                /*  Palette register select?  */
                if (writeflag == MEM_WRITE)
                        d->palette_reg_select = idata;
                else
                        odata = d->palette_reg_select;
                break;
        case 0x70d18:
                /*  Palette register read/write?  */
                i = 3 * ((d->palette_reg_select >> 8) & 0xff);
                if (writeflag == MEM_WRITE) {
                        d->fb->rgb_palette[i + 0] = (idata >> 24) & 0xff;
                        d->fb->rgb_palette[i + 1] = (idata >> 16) & 0xff;
                        d->fb->rgb_palette[i + 2] = (idata >>  8) & 0xff;
                } else {
                        odata = (d->fb->rgb_palette[i+0] << 24) +
                                (d->fb->rgb_palette[i+1] << 16) +
                                (d->fb->rgb_palette[i+2] << 8);
                }
                break;
        case 0x71208:
                odata = 8;
                break;
        default:
                if (writeflag==MEM_READ) {
                        debug("[ sgi_mardigras: read from 0x%08lx ]\n",
                            (long)relative_addr);
                } else {
                        debug("[ sgi_mardigras: write to  0x%08lx: 0x%016llx"
                            " ]\n", (long)relative_addr, (long long)idata);
                }
        }

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

        return 1;
}


/*
 *  devinit_sgi_mardigras():
 */
int devinit_sgi_mardigras(struct devinit *devinit)
{
        struct sgi_mardigras_data *d;

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

        d->fb = dev_fb_init(devinit->machine, devinit->machine->memory,
            MARDIGRAS_FAKE_OFFSET, VFB_GENERIC,
            mardigras_xsize, mardigras_ysize,
            mardigras_xsize, mardigras_ysize, 24, "SGI MardiGras");
        if (d->fb == NULL) {
                fprintf(stderr, "dev_sgi_mardigras_init(): out of memory\n");
                exit(1);
        }

        memory_device_register(devinit->machine->memory, devinit->name,
            devinit->addr, DEV_SGI_MARDIGRAS_LENGTH, dev_sgi_mardigras_access,
            d, DM_DEFAULT, NULL);

        return 1;
}

1	/*
2	* Copyright (C) 2003-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_sgi_mardigras.c,v 1.20 2005/11/13 00:14:10 debug Exp $
29	*
30	* "MardiGras" graphics controller on SGI IP30 (Octane).
31	*
32	* Most of this is just guesses based on the behaviour of Linux/Octane.
33	*
34	* TODO
35	*/
36
37	#include <stdio.h>
38	#include <stdlib.h>
39	#include <string.h>
40
41	#include "cpu.h"
42	#include "device.h"
43	#include "devices.h"
44	#include "memory.h"
45	#include "machine.h"
46	#include "misc.h"
47
48
49	#define debug fatal
50
51
52	#define DEV_SGI_MARDIGRAS_LENGTH 0x800000
53
54	#define MARDIGRAS_FAKE_OFFSET 0x500000000ULL /* hopefully available */
55	#define MARDIGRAS_DEFAULT_XSIZE 1280
56	#define MARDIGRAS_DEFAULT_YSIZE 1024
57
58	#define MICROCODE_START 0x50000
59	#define MICROCODE_END 0x55000
60
61	static int mardigras_xsize = MARDIGRAS_DEFAULT_XSIZE;
62	static int mardigras_ysize = MARDIGRAS_DEFAULT_YSIZE;
63
64	struct sgi_mardigras_data {
65	struct vfb_data *fb;
66	unsigned char microcode_ram[MICROCODE_END - MICROCODE_START];
67	uint64_t palette_reg_select;
68	int currentx;
69	int currenty;
70	int color;
71	int startx;
72	int starty;
73	int stopx;
74	int stopy;
75	uint64_t draw_mode;
76	};
77
78
79	/*
80	* mardigras_20400():
81	*/
82	void mardigras_20400(struct cpu cpu, struct sgi_mardigras_data d,
83	uint64_t idata)
84	{
85	int i, x, y, r,g,b, len, addr;
86	unsigned char pixels[3 * 8000];
87
88	/* Get rgb from palette: */
89	r = d->fb->rgb_palette[d->color * 3 + 0];
90	g = d->fb->rgb_palette[d->color * 3 + 1];
91	b = d->fb->rgb_palette[d->color * 3 + 2];
92
93	/* Set color: */
94	if ((idata & 0x00ffffff00000000ULL) == 0x00185C0400000000ULL) {
95	int color = (idata >> 12) & 0xff;
96	d->color = color;
97	return;
98	}
99
100	/* Set start XY: */
101	if ((idata & 0x00ffffff00000000ULL) == 0x0018460400000000ULL) {
102	d->startx = (idata >> 16) & 0xffff;
103	d->starty = idata & 0xffff;
104	if (d->startx >= mardigras_xsize)
105	d->startx = 0;
106	if (d->starty >= mardigras_ysize)
107	d->starty = 0;
108	d->currentx = d->startx;
109	d->currenty = d->starty;
110	return;
111	}
112
113	/* Set stop XY: */
114	if ((idata & 0x00ffffff00000000ULL) == 0x0018470400000000ULL) {
115	d->stopx = (idata >> 16) & 0xffff;
116	d->stopy = idata & 0xffff;
117	if (d->stopx >= mardigras_xsize)
118	d->stopx = 0;
119	if (d->stopy >= mardigras_ysize)
120	d->stopy = 0;
121	return;
122	}
123
124	/* Draw modes: (Rectangle or Bitmap, respectively) */
125	if (idata == 0x0019100400018000ULL \|\|
126	idata == 0x0019100400418008ULL) {
127	d->draw_mode = idata;
128	return;
129	}
130
131	/* Send command: */
132	if (idata == 0x001C130400000018ULL) {
133	switch (d->draw_mode) {
134	/* Rectangle: */
135	case 0x0019100400018000ULL:
136	/* Fill pixels[] with pixels: */
137	len = 0;
138	for (x=d->startx; x<=d->stopx; x++) {
139	pixels[len + 0] = r;
140	pixels[len + 1] = g;
141	pixels[len + 2] = b;
142	len += 3;
143	}
144	if (len == 0)
145	break;
146	for (y=d->starty; y<=d->stopy; y++) {
147	addr = (mardigras_xsize * (mardigras_ysize -
148	1 - y) + d->startx) * 3;
149	/* printf("addr = %i\n", addr); */
150
151	/* Write a line: */
152	dev_fb_access(cpu, cpu->mem,
153	addr, pixels, len, MEM_WRITE, d->fb);
154	}
155	break;
156	/* Bitmap: */
157	case 0x0019100400418008ULL:
158	break;
159	default:
160	fatal("[ sgi_mardigras: unknown draw mode ]\n");
161	}
162	return;
163	}
164
165	/* Send a line of bitmap data: */
166	if ((idata & 0x00ffffff00000000ULL) == 0x001C700400000000ULL) {
167	addr = (mardigras_xsize * (mardigras_ysize - 1 - d->currenty)
168	+ d->currentx) * 3;
169	/*
170	printf("addr=%08x curx,y=%4i,%4i startx,y=%4i,%4i "
171	"stopx,y=%4i,%4i\n", addr, d->currentx, d->currenty,
172	d->startx, d->starty, d->stopx, d->stopy);
173	*/
174	len = 8*3;
175
176	if (addr > mardigras_xsize * mardigras_ysize * 3 \|\| addr < 0)
177	return;
178
179	/* Read a line: */
180	dev_fb_access(cpu, cpu->mem,
181	addr, pixels, len, MEM_READ, d->fb);
182
183	i = 0;
184	while (i < 8) {
185	if ((idata >> (24 + (7-i))) & 1) {
186	pixels[i*3 + 0] = r;
187	pixels[i*3 + 1] = g;
188	pixels[i*3 + 2] = b;
189	}
190	i ++;
191
192	d->currentx ++;
193	if (d->currentx > d->stopx) {
194	d->currentx = d->startx;
195	d->currenty ++;
196	if (d->currenty > d->stopy)
197	d->currenty = d->starty;
198	}
199	}
200
201	/* Write a line: */
202	dev_fb_access(cpu, cpu->mem,
203	addr, pixels, len, MEM_WRITE, d->fb);
204
205	return;
206	}
207
208	debug("mardigras_20400(): 0x%016llx\n", (long long)idata);
209	}
210
211
212	/*
213	* dev_sgi_mardigras_access():
214	*/
215	int dev_sgi_mardigras_access(struct cpu cpu, struct memory mem,
216	uint64_t relative_addr, unsigned char *data, size_t len,
217	int writeflag, void *extra)
218	{
219	uint64_t idata = 0, odata = 0;
220	struct sgi_mardigras_data *d = extra;
221	int i;
222
223	if (writeflag == MEM_WRITE)
224	idata = memory_readmax64(cpu, data, len);
225
226	/* Accessing the microcode_ram works like ordinary ram: */
227	if (relative_addr >= MICROCODE_START &&
228	relative_addr < MICROCODE_END) {
229	relative_addr -= MICROCODE_START;
230	if (writeflag == MEM_WRITE)
231	memcpy(d->microcode_ram + relative_addr, data, len);
232	else
233	memcpy(data, d->microcode_ram + relative_addr, len);
234	return 1;
235	}
236
237	switch (relative_addr) {
238	case 0x00004:
239	/* xtalk data: (according to Linux/IP30) */
240	/* (mfgr & 0x7ff) << 1 */
241	/* (part & 0xffff) << 12 */
242	/* (rev & 0xf) << 28 */
243	odata = (2 << 28) \| (0xc003 << 12) \| (0x2aa << 1);
244	break;
245	case 0x20008: /* Fifo status */
246	break;
247	case 0x20200:
248	break;
249	case 0x20400:
250	if (writeflag == MEM_WRITE)
251	mardigras_20400(cpu, d, idata);
252	else
253	debug("[ sgi_mardigras: read from 0x20400? ]\n");
254	break;
255	case 0x58040:
256	/* HQ4 microcode stuff */
257	break;
258	case 0x70c30:
259	/* Palette register select? */
260	if (writeflag == MEM_WRITE)
261	d->palette_reg_select = idata;
262	else
263	odata = d->palette_reg_select;
264	break;
265	case 0x70d18:
266	/* Palette register read/write? */
267	i = 3 * ((d->palette_reg_select >> 8) & 0xff);
268	if (writeflag == MEM_WRITE) {
269	d->fb->rgb_palette[i + 0] = (idata >> 24) & 0xff;
270	d->fb->rgb_palette[i + 1] = (idata >> 16) & 0xff;
271	d->fb->rgb_palette[i + 2] = (idata >> 8) & 0xff;
272	} else {
273	odata = (d->fb->rgb_palette[i+0] << 24) +
274	(d->fb->rgb_palette[i+1] << 16) +
275	(d->fb->rgb_palette[i+2] << 8);
276	}
277	break;
278	case 0x71208:
279	odata = 8;
280	break;
281	default:
282	if (writeflag==MEM_READ) {
283	debug("[ sgi_mardigras: read from 0x%08lx ]\n",
284	(long)relative_addr);
285	} else {
286	debug("[ sgi_mardigras: write to 0x%08lx: 0x%016llx"
287	" ]\n", (long)relative_addr, (long long)idata);
288	}
289	}
290
291	if (writeflag == MEM_READ)
292	memory_writemax64(cpu, data, len, odata);
293
294	return 1;
295	}
296
297
298	/*
299	* devinit_sgi_mardigras():
300	*/
301	int devinit_sgi_mardigras(struct devinit *devinit)
302	{
303	struct sgi_mardigras_data *d;
304
305	d = malloc(sizeof(struct sgi_mardigras_data));
306	if (d == NULL) {
307	fprintf(stderr, "out of memory\n");
308	exit(1);
309	}
310	memset(d, 0, sizeof(struct sgi_mardigras_data));
311
312	d->fb = dev_fb_init(devinit->machine, devinit->machine->memory,
313	MARDIGRAS_FAKE_OFFSET, VFB_GENERIC,
314	mardigras_xsize, mardigras_ysize,
315	mardigras_xsize, mardigras_ysize, 24, "SGI MardiGras");
316	if (d->fb == NULL) {
317	fprintf(stderr, "dev_sgi_mardigras_init(): out of memory\n");
318	exit(1);
319	}
320
321	memory_device_register(devinit->machine->memory, devinit->name,
322	devinit->addr, DEV_SGI_MARDIGRAS_LENGTH, dev_sgi_mardigras_access,
323	d, DM_DEFAULT, NULL);
324
325	return 1;
326	}
327