src/devices/dev_kn01.c

/*
 *  Copyright (C) 2003-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_kn01.c,v 1.10 2007/01/05 15:20:06 debug Exp $
 *  
 *  KN01 stuff ("PMAX", DECstation type 1); CSR (System Control Register)
 *  and VDAC.
 *
 *  TODO: The CSR isn't really complete.
 *
 *  One of the few usable bits in the csr would be KN01_CSR_MONO.
 *  If that bit is set, the framebuffer is treated as a monochrome
 *  one.
 */

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

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

#include "dec_kn01.h"


struct kn01_data {
        int                     color_fb;
        uint32_t                csr;
};


struct vdac_data {
        unsigned char   vdac_reg[DEV_VDAC_LENGTH];

        int             color_fb_flag;

        unsigned char   cur_read_addr;
        unsigned char   cur_write_addr;

        int             sub_color;      /*  subcolor. 0, 1, or 2  */
        unsigned char   cur_rgb[3];

        unsigned char   *rgb_palette;           /*  ptr to 256 * 3 (r,g,b)  */

        unsigned char   cur_read_addr_overlay;
        unsigned char   cur_write_addr_overlay;

        int             sub_color_overlay;      /*  subcolor: 0, 1, or 2  */
        unsigned char   cur_rgb_overlay[3];

        unsigned char   rgb_palette_overlay[16 * 3];    /*  16 * 3 (r,g,b)  */
};


DEVICE_ACCESS(kn01)
{
        struct kn01_data *d = extra;
        int csr;

        if (writeflag == MEM_WRITE) {
                /*  TODO  */
                return 1;
        }

        /*  Read:  */
        if (len != 2 || relative_addr != 0) {
                fatal("[ kn01: trying to read something which is not "
                    "the first half-word of the csr ]");
        }

        csr = d->csr;

        if (cpu->byte_order == EMUL_LITTLE_ENDIAN) {
                data[0] = csr & 0xff;
                data[1] = (csr >> 8) & 0xff;
        } else {
                data[1] = csr & 0xff;
                data[0] = (csr >> 8) & 0xff;
        }

        return 1;
}


/*
 *  dev_vdac_access():
 */
DEVICE_ACCESS(vdac)
{
        struct vdac_data *d = (struct vdac_data *) extra;

        /*  Read from/write to the vdac:  */
        switch (relative_addr) {
        case DEV_VDAC_MAPWA:
                if (writeflag == MEM_WRITE) {
                        d->cur_write_addr = data[0];
                        d->sub_color = 0;
                } else {
                        debug("[ vdac: read from MAPWA ]\n");
                        data[0] = d->vdac_reg[relative_addr];
                }
                break;
        case DEV_VDAC_MAP:
                if (writeflag == MEM_WRITE) {
                        d->cur_rgb[d->sub_color] = data[0];
                        d->sub_color++;

                        if (d->sub_color > 2) {
                                /*  (Only update for color, not mono mode)  */
                                if (d->color_fb_flag)
                                        memcpy(d->rgb_palette +
                                            3*d->cur_write_addr, d->cur_rgb, 3);

                                d->sub_color = 0;
                                d->cur_write_addr ++;
                        }
                } else {
                        if (d->sub_color == 0) {
                                memcpy(d->cur_rgb, d->rgb_palette +
                                    3 * d->cur_read_addr, 3);
                        }
                        data[0] = d->cur_rgb[d->sub_color];
                        d->sub_color++;
                        if (d->sub_color > 2) {
                                d->sub_color = 0;
                                d->cur_read_addr ++;
                        }
                }
                break;
        case DEV_VDAC_MAPRA:
                if (writeflag == MEM_WRITE) {
                        d->cur_read_addr = data[0];
                        d->sub_color = 0;
                } else {
                        debug("[ vdac: read from MAPRA ]\n");
                        data[0] = d->vdac_reg[relative_addr];
                }
                break;
        case DEV_VDAC_OVERWA:
                if (writeflag == MEM_WRITE) {
                        d->cur_write_addr_overlay = data[0];
                        d->sub_color_overlay = 0;
                } else {
                        debug("[ vdac: read from OVERWA ]\n");
                        data[0] = d->vdac_reg[relative_addr];
                }
                break;
        case DEV_VDAC_OVER:
                if (writeflag == MEM_WRITE) {
                        d->cur_rgb_overlay[d->sub_color_overlay] = data[0];
                        d->sub_color_overlay++;

                        if (d->sub_color_overlay > 2) {
                                /*  (Only update for color, not mono mode)  */
                                if (d->color_fb_flag)
                                        memcpy(d->rgb_palette_overlay +
                                            3 * d->cur_write_addr_overlay,
                                            d->cur_rgb_overlay, 3);

                                d->sub_color_overlay = 0;
                                d->cur_write_addr_overlay ++;
                                if (d->cur_write_addr_overlay > 15)
                                        d->cur_write_addr_overlay = 0;
                        }
                } else {
                        if (d->sub_color_overlay == 0) {
                                memcpy(d->cur_rgb_overlay,
                                    d->rgb_palette_overlay +
                                    3 * d->cur_read_addr_overlay, 3);
                        }
                        data[0] = d->cur_rgb_overlay[d->sub_color_overlay];
                        d->sub_color_overlay++;
                        if (d->sub_color_overlay > 2) {
                                d->sub_color_overlay = 0;
                                d->cur_read_addr_overlay ++;
                                if (d->cur_read_addr_overlay > 15)
                                        d->cur_read_addr_overlay = 0;
                        }
                }
                break;
        case DEV_VDAC_OVERRA:
                if (writeflag == MEM_WRITE) {
                        d->cur_read_addr_overlay = data[0];
                        d->sub_color_overlay = 0;
                } else {
                        debug("[ vdac: read from OVERRA ]\n");
                        data[0] = d->vdac_reg[relative_addr];
                }
                break;
        default:
                if (writeflag == MEM_WRITE) {
                        debug("[ vdac: unimplemented write to address 0x%x,"
                            " data=0x%02x ]\n", (int)relative_addr, data[0]);
                        d->vdac_reg[relative_addr] = data[0];
                } else {
                        debug("[ vdac: unimplemented read from address 0x%x"
                            " ]\n", (int)relative_addr);
                        data[0] = d->vdac_reg[relative_addr];
                }
        }

        /*  Pretend it was ok:  */
        return 1;
}


/*
 *  dev_vdac_init():
 */
void dev_vdac_init(struct memory *mem, uint64_t baseaddr,
        unsigned char *rgb_palette, int color_fb_flag)
{
        struct vdac_data *d = malloc(sizeof(struct vdac_data));
        if (d == NULL) {
                fprintf(stderr, "out of memory\n");
                exit(1);
        }
        memset(d, 0, sizeof(struct vdac_data));
        d->rgb_palette   = rgb_palette;
        d->color_fb_flag = color_fb_flag;

        memory_device_register(mem, "vdac", baseaddr, DEV_VDAC_LENGTH,
            dev_vdac_access, (void *)d, DM_DEFAULT, NULL);
}


/*
 *  dev_kn01_init():
 */
void dev_kn01_init(struct memory *mem, uint64_t baseaddr, int color_fb)
{
        struct kn01_data *d = malloc(sizeof(struct kn01_data));
        if (d == NULL) {
                fprintf(stderr, "out of memory\n");
                exit(1);
        }

        memset(d, 0, sizeof(struct kn01_data));
        d->color_fb = color_fb;

        d->csr = 0;
        d->csr |= (color_fb? 0 : KN01_CSR_MONO);

        memory_device_register(mem, "kn01", baseaddr,
            DEV_KN01_LENGTH, dev_kn01_access, d, DM_DEFAULT, NULL);
}

1	dpavlin	4	/*
2	dpavlin	34	* Copyright (C) 2003-2007 Anders Gavare. All rights reserved.
3	dpavlin	4	*
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	34	* $Id: dev_kn01.c,v 1.10 2007/01/05 15:20:06 debug Exp $
29	dpavlin	4	*
30			* KN01 stuff ("PMAX", DECstation type 1); CSR (System Control Register)
31			* and VDAC.
32			*
33			* TODO: The CSR isn't really complete.
34			*
35			* One of the few usable bits in the csr would be KN01_CSR_MONO.
36			* If that bit is set, the framebuffer is treated as a monochrome
37			* one.
38			*/
39
40			#include <stdio.h>
41			#include <stdlib.h>
42			#include <string.h>
43
44			#include "cpu.h"
45			#include "devices.h"
46			#include "memory.h"
47			#include "misc.h"
48
49			#include "dec_kn01.h"
50
51
52	dpavlin	34	struct kn01_data {
53			int color_fb;
54			uint32_t csr;
55	dpavlin	4	};
56
57
58			struct vdac_data {
59			unsigned char vdac_reg[DEV_VDAC_LENGTH];
60
61			int color_fb_flag;
62
63			unsigned char cur_read_addr;
64			unsigned char cur_write_addr;
65
66			int sub_color; /* subcolor. 0, 1, or 2 */
67			unsigned char cur_rgb[3];
68
69			unsigned char rgb_palette; / ptr to 256 * 3 (r,g,b) */
70
71			unsigned char cur_read_addr_overlay;
72			unsigned char cur_write_addr_overlay;
73
74			int sub_color_overlay; /* subcolor: 0, 1, or 2 */
75			unsigned char cur_rgb_overlay[3];
76
77			unsigned char rgb_palette_overlay[16 * 3]; /* 16 * 3 (r,g,b) */
78			};
79
80
81	dpavlin	34	DEVICE_ACCESS(kn01)
82	dpavlin	4	{
83	dpavlin	34	struct kn01_data *d = extra;
84	dpavlin	4	int csr;
85
86			if (writeflag == MEM_WRITE) {
87			/* TODO */
88			return 1;
89			}
90
91			/* Read: */
92			if (len != 2 \|\| relative_addr != 0) {
93	dpavlin	34	fatal("[ kn01: trying to read something which is not "
94	dpavlin	4	"the first half-word of the csr ]");
95			}
96
97	dpavlin	34	csr = d->csr;
98	dpavlin	4
99			if (cpu->byte_order == EMUL_LITTLE_ENDIAN) {
100			data[0] = csr & 0xff;
101			data[1] = (csr >> 8) & 0xff;
102			} else {
103			data[1] = csr & 0xff;
104			data[0] = (csr >> 8) & 0xff;
105			}
106
107			return 1;
108			}
109
110
111			/*
112			* dev_vdac_access():
113			*/
114	dpavlin	22	DEVICE_ACCESS(vdac)
115	dpavlin	4	{
116			struct vdac_data d = (struct vdac_data ) extra;
117
118			/* Read from/write to the vdac: */
119			switch (relative_addr) {
120			case DEV_VDAC_MAPWA:
121			if (writeflag == MEM_WRITE) {
122			d->cur_write_addr = data[0];
123			d->sub_color = 0;
124			} else {
125			debug("[ vdac: read from MAPWA ]\n");
126			data[0] = d->vdac_reg[relative_addr];
127			}
128			break;
129			case DEV_VDAC_MAP:
130			if (writeflag == MEM_WRITE) {
131			d->cur_rgb[d->sub_color] = data[0];
132			d->sub_color++;
133
134			if (d->sub_color > 2) {
135			/* (Only update for color, not mono mode) */
136			if (d->color_fb_flag)
137			memcpy(d->rgb_palette +
138			3*d->cur_write_addr, d->cur_rgb, 3);
139
140			d->sub_color = 0;
141			d->cur_write_addr ++;
142			}
143			} else {
144			if (d->sub_color == 0) {
145			memcpy(d->cur_rgb, d->rgb_palette +
146			3 * d->cur_read_addr, 3);
147			}
148			data[0] = d->cur_rgb[d->sub_color];
149			d->sub_color++;
150			if (d->sub_color > 2) {
151			d->sub_color = 0;
152			d->cur_read_addr ++;
153			}
154			}
155			break;
156			case DEV_VDAC_MAPRA:
157			if (writeflag == MEM_WRITE) {
158			d->cur_read_addr = data[0];
159			d->sub_color = 0;
160			} else {
161			debug("[ vdac: read from MAPRA ]\n");
162			data[0] = d->vdac_reg[relative_addr];
163			}
164			break;
165			case DEV_VDAC_OVERWA:
166			if (writeflag == MEM_WRITE) {
167			d->cur_write_addr_overlay = data[0];
168			d->sub_color_overlay = 0;
169			} else {
170			debug("[ vdac: read from OVERWA ]\n");
171			data[0] = d->vdac_reg[relative_addr];
172			}
173			break;
174			case DEV_VDAC_OVER:
175			if (writeflag == MEM_WRITE) {
176			d->cur_rgb_overlay[d->sub_color_overlay] = data[0];
177			d->sub_color_overlay++;
178
179			if (d->sub_color_overlay > 2) {
180			/* (Only update for color, not mono mode) */
181			if (d->color_fb_flag)
182			memcpy(d->rgb_palette_overlay +
183			3 * d->cur_write_addr_overlay,
184			d->cur_rgb_overlay, 3);
185
186			d->sub_color_overlay = 0;
187			d->cur_write_addr_overlay ++;
188			if (d->cur_write_addr_overlay > 15)
189			d->cur_write_addr_overlay = 0;
190			}
191			} else {
192			if (d->sub_color_overlay == 0) {
193			memcpy(d->cur_rgb_overlay,
194			d->rgb_palette_overlay +
195			3 * d->cur_read_addr_overlay, 3);
196			}
197			data[0] = d->cur_rgb_overlay[d->sub_color_overlay];
198			d->sub_color_overlay++;
199			if (d->sub_color_overlay > 2) {
200			d->sub_color_overlay = 0;
201			d->cur_read_addr_overlay ++;
202			if (d->cur_read_addr_overlay > 15)
203			d->cur_read_addr_overlay = 0;
204			}
205			}
206			break;
207			case DEV_VDAC_OVERRA:
208			if (writeflag == MEM_WRITE) {
209			d->cur_read_addr_overlay = data[0];
210			d->sub_color_overlay = 0;
211			} else {
212			debug("[ vdac: read from OVERRA ]\n");
213			data[0] = d->vdac_reg[relative_addr];
214			}
215			break;
216			default:
217			if (writeflag == MEM_WRITE) {
218			debug("[ vdac: unimplemented write to address 0x%x,"
219			" data=0x%02x ]\n", (int)relative_addr, data[0]);
220			d->vdac_reg[relative_addr] = data[0];
221			} else {
222			debug("[ vdac: unimplemented read from address 0x%x"
223			" ]\n", (int)relative_addr);
224			data[0] = d->vdac_reg[relative_addr];
225			}
226			}
227
228			/* Pretend it was ok: */
229			return 1;
230			}
231
232
233			/*
234			* dev_vdac_init():
235			*/
236			void dev_vdac_init(struct memory *mem, uint64_t baseaddr,
237			unsigned char *rgb_palette, int color_fb_flag)
238			{
239			struct vdac_data *d = malloc(sizeof(struct vdac_data));
240			if (d == NULL) {
241			fprintf(stderr, "out of memory\n");
242			exit(1);
243			}
244			memset(d, 0, sizeof(struct vdac_data));
245			d->rgb_palette = rgb_palette;
246			d->color_fb_flag = color_fb_flag;
247
248			memory_device_register(mem, "vdac", baseaddr, DEV_VDAC_LENGTH,
249	dpavlin	20	dev_vdac_access, (void *)d, DM_DEFAULT, NULL);
250	dpavlin	4	}
251
252
253			/*
254	dpavlin	34	* dev_kn01_init():
255	dpavlin	4	*/
256	dpavlin	34	void dev_kn01_init(struct memory *mem, uint64_t baseaddr, int color_fb)
257	dpavlin	4	{
258	dpavlin	34	struct kn01_data *d = malloc(sizeof(struct kn01_data));
259			if (d == NULL) {
260	dpavlin	4	fprintf(stderr, "out of memory\n");
261			exit(1);
262			}
263
264	dpavlin	34	memset(d, 0, sizeof(struct kn01_data));
265			d->color_fb = color_fb;
266	dpavlin	4
267	dpavlin	34	d->csr = 0;
268			d->csr \|= (color_fb? 0 : KN01_CSR_MONO);
269	dpavlin	4
270	dpavlin	34	memory_device_register(mem, "kn01", baseaddr,
271			DEV_KN01_LENGTH, dev_kn01_access, d, DM_DEFAULT, NULL);
272	dpavlin	4	}
273