src/devices/dev_kn01.c

/*
 *  Copyright (C) 2003-2006  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.8 2006/01/01 13:17:16 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_csr_data {
        int             color_fb;
        int             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)  */
};


/*
 *  dev_kn01_csr_access():
 */
DEVICE_ACCESS(kn01_csr)
{
        struct kn01_csr_data *k = extra;
        int csr;

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

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

        csr = k->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_csr_init():
 */
void dev_kn01_csr_init(struct memory *mem, uint64_t baseaddr, int color_fb)
{
        struct kn01_csr_data *k = malloc(sizeof(struct kn01_csr_data));
        if (k == NULL) {
                fprintf(stderr, "out of memory\n");
                exit(1);
        }

        memset(k, 0, sizeof(struct kn01_csr_data));
        k->color_fb = color_fb;

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

        memory_device_register(mem, "kn01_csr", baseaddr,
            DEV_KN01_CSR_LENGTH, dev_kn01_csr_access, k, DM_DEFAULT, NULL);
}

1	/*
2	* Copyright (C) 2003-2006 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_kn01.c,v 1.8 2006/01/01 13:17:16 debug Exp $
29	*
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	struct kn01_csr_data {
53	int color_fb;
54	int csr;
55	};
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	/*
82	* dev_kn01_csr_access():
83	*/
84	DEVICE_ACCESS(kn01_csr)
85	{
86	struct kn01_csr_data *k = extra;
87	int csr;
88
89	if (writeflag == MEM_WRITE) {
90	/* TODO */
91	return 1;
92	}
93
94	/* Read: */
95	if (len != 2 \|\| relative_addr != 0) {
96	fatal("[ kn01_csr: trying to read something which is not "
97	"the first half-word of the csr ]");
98	}
99
100	csr = k->csr;
101
102	if (cpu->byte_order == EMUL_LITTLE_ENDIAN) {
103	data[0] = csr & 0xff;
104	data[1] = (csr >> 8) & 0xff;
105	} else {
106	data[1] = csr & 0xff;
107	data[0] = (csr >> 8) & 0xff;
108	}
109
110	return 1;
111	}
112
113
114	/*
115	* dev_vdac_access():
116	*/
117	DEVICE_ACCESS(vdac)
118	{
119	struct vdac_data d = (struct vdac_data ) extra;
120
121	/* Read from/write to the vdac: */
122	switch (relative_addr) {
123	case DEV_VDAC_MAPWA:
124	if (writeflag == MEM_WRITE) {
125	d->cur_write_addr = data[0];
126	d->sub_color = 0;
127	} else {
128	debug("[ vdac: read from MAPWA ]\n");
129	data[0] = d->vdac_reg[relative_addr];
130	}
131	break;
132	case DEV_VDAC_MAP:
133	if (writeflag == MEM_WRITE) {
134	d->cur_rgb[d->sub_color] = data[0];
135	d->sub_color++;
136
137	if (d->sub_color > 2) {
138	/* (Only update for color, not mono mode) */
139	if (d->color_fb_flag)
140	memcpy(d->rgb_palette +
141	3*d->cur_write_addr, d->cur_rgb, 3);
142
143	d->sub_color = 0;
144	d->cur_write_addr ++;
145	}
146	} else {
147	if (d->sub_color == 0) {
148	memcpy(d->cur_rgb, d->rgb_palette +
149	3 * d->cur_read_addr, 3);
150	}
151	data[0] = d->cur_rgb[d->sub_color];
152	d->sub_color++;
153	if (d->sub_color > 2) {
154	d->sub_color = 0;
155	d->cur_read_addr ++;
156	}
157	}
158	break;
159	case DEV_VDAC_MAPRA:
160	if (writeflag == MEM_WRITE) {
161	d->cur_read_addr = data[0];
162	d->sub_color = 0;
163	} else {
164	debug("[ vdac: read from MAPRA ]\n");
165	data[0] = d->vdac_reg[relative_addr];
166	}
167	break;
168	case DEV_VDAC_OVERWA:
169	if (writeflag == MEM_WRITE) {
170	d->cur_write_addr_overlay = data[0];
171	d->sub_color_overlay = 0;
172	} else {
173	debug("[ vdac: read from OVERWA ]\n");
174	data[0] = d->vdac_reg[relative_addr];
175	}
176	break;
177	case DEV_VDAC_OVER:
178	if (writeflag == MEM_WRITE) {
179	d->cur_rgb_overlay[d->sub_color_overlay] = data[0];
180	d->sub_color_overlay++;
181
182	if (d->sub_color_overlay > 2) {
183	/* (Only update for color, not mono mode) */
184	if (d->color_fb_flag)
185	memcpy(d->rgb_palette_overlay +
186	3 * d->cur_write_addr_overlay,
187	d->cur_rgb_overlay, 3);
188
189	d->sub_color_overlay = 0;
190	d->cur_write_addr_overlay ++;
191	if (d->cur_write_addr_overlay > 15)
192	d->cur_write_addr_overlay = 0;
193	}
194	} else {
195	if (d->sub_color_overlay == 0) {
196	memcpy(d->cur_rgb_overlay,
197	d->rgb_palette_overlay +
198	3 * d->cur_read_addr_overlay, 3);
199	}
200	data[0] = d->cur_rgb_overlay[d->sub_color_overlay];
201	d->sub_color_overlay++;
202	if (d->sub_color_overlay > 2) {
203	d->sub_color_overlay = 0;
204	d->cur_read_addr_overlay ++;
205	if (d->cur_read_addr_overlay > 15)
206	d->cur_read_addr_overlay = 0;
207	}
208	}
209	break;
210	case DEV_VDAC_OVERRA:
211	if (writeflag == MEM_WRITE) {
212	d->cur_read_addr_overlay = data[0];
213	d->sub_color_overlay = 0;
214	} else {
215	debug("[ vdac: read from OVERRA ]\n");
216	data[0] = d->vdac_reg[relative_addr];
217	}
218	break;
219	default:
220	if (writeflag == MEM_WRITE) {
221	debug("[ vdac: unimplemented write to address 0x%x,"
222	" data=0x%02x ]\n", (int)relative_addr, data[0]);
223	d->vdac_reg[relative_addr] = data[0];
224	} else {
225	debug("[ vdac: unimplemented read from address 0x%x"
226	" ]\n", (int)relative_addr);
227	data[0] = d->vdac_reg[relative_addr];
228	}
229	}
230
231	/* Pretend it was ok: */
232	return 1;
233	}
234
235
236	/*
237	* dev_vdac_init():
238	*/
239	void dev_vdac_init(struct memory *mem, uint64_t baseaddr,
240	unsigned char *rgb_palette, int color_fb_flag)
241	{
242	struct vdac_data *d = malloc(sizeof(struct vdac_data));
243	if (d == NULL) {
244	fprintf(stderr, "out of memory\n");
245	exit(1);
246	}
247	memset(d, 0, sizeof(struct vdac_data));
248	d->rgb_palette = rgb_palette;
249	d->color_fb_flag = color_fb_flag;
250
251	memory_device_register(mem, "vdac", baseaddr, DEV_VDAC_LENGTH,
252	dev_vdac_access, (void *)d, DM_DEFAULT, NULL);
253	}
254
255
256	/*
257	* dev_kn01_csr_init():
258	*/
259	void dev_kn01_csr_init(struct memory *mem, uint64_t baseaddr, int color_fb)
260	{
261	struct kn01_csr_data *k = malloc(sizeof(struct kn01_csr_data));
262	if (k == NULL) {
263	fprintf(stderr, "out of memory\n");
264	exit(1);
265	}
266
267	memset(k, 0, sizeof(struct kn01_csr_data));
268	k->color_fb = color_fb;
269
270	k->csr = 0;
271	k->csr \|= (color_fb? 0 : KN01_CSR_MONO);
272
273	memory_device_register(mem, "kn01_csr", baseaddr,
274	DEV_KN01_CSR_LENGTH, dev_kn01_csr_access, k, DM_DEFAULT, NULL);
275	}
276