src/machines/machine_alpha.c

/*
 *  Copyright (C) 2005-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: machine_alpha.c,v 1.7 2006/06/24 10:19:19 debug Exp $
 */

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

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

#include "alpha_autoconf.h"
#include "alpha_rpb.h"


MACHINE_SETUP(alpha)
{
        struct rpb rpb;
        struct crb crb;
        struct ctb ctb;
        struct mddt mddt;

        switch (machine->machine_subtype) {

        case ST_ALPHABOOK1:
                machine->machine_name = "AlphaBook 1";
                device_add(machine, "lca");
                break;

        case ST_DEC_4100:
                machine->machine_name = "AlphaServer 4100";
                break;

        case ST_DEC_3000_300:
                machine->machine_name = "DEC 3000/300";
                machine->main_console_handle = (size_t)device_add(machine,
                    "z8530 addr=0x1b0200000 irq=0 addr_mult=4");
                break;

        case ST_EB164:
                machine->machine_name = "EB164";
                break;

        default:fatal("Unimplemented Alpha machine type %i\n",
                    machine->machine_subtype);
                exit(1);
        }

        if (!machine->prom_emulation)
                return;

        /*  These are used by NetBSD/alpha:  */
        /*  a0 = First free Page Frame Number  */
        /*  a1 = PFN of current Level 1 page table  */
        /*  a2 = Bootinfo magic  */
        /*  a3 = Bootinfo pointer  */
        /*  a4 = Bootinfo version  */
        cpu->cd.alpha.r[ALPHA_A0] = 16*1024*1024 / 8192;
        cpu->cd.alpha.r[ALPHA_A1] = 0;  /*  TODO  */
        cpu->cd.alpha.r[ALPHA_A2] = ALPHA_BOOTINFO_MAGIC;
        cpu->cd.alpha.r[ALPHA_A3] = 0;  /*  TODO  */
        cpu->cd.alpha.r[ALPHA_A4] = 1;

        /*
         *  HWRPB: Hardware Restart Parameter Block
         *
         *  TODO: Almost everything.
         */
        memset(&rpb, 0, sizeof(struct rpb));
        store_64bit_word_in_host(cpu, (unsigned char *)
            &(rpb.rpb_phys), HWRPB_ADDR);
        strlcpy((char *)&(rpb.rpb_magic), "HWRPB", 8);
        store_64bit_word_in_host(cpu, (unsigned char *)
            &(rpb.rpb_size), sizeof(struct rpb));
        store_64bit_word_in_host(cpu, (unsigned char *)
            &(rpb.rpb_page_size), 8192);
        store_64bit_word_in_host(cpu, (unsigned char *)
            &(rpb.rpb_type), machine->machine_subtype);
        store_64bit_word_in_host(cpu, (unsigned char *)
            &(rpb.rpb_cc_freq), 100000000);
        store_64bit_word_in_host(cpu, (unsigned char *)
            &(rpb.rpb_ctb_off), CTB_ADDR - HWRPB_ADDR);
        store_64bit_word_in_host(cpu, (unsigned char *)
            &(rpb.rpb_crb_off), CRB_ADDR - HWRPB_ADDR);
        store_64bit_word_in_host(cpu, (unsigned char *)
            &(rpb.rpb_memdat_off), MEMDAT_ADDR - HWRPB_ADDR);

        /*  CTB: Console Terminal Block  */
        memset(&ctb, 0, sizeof(struct ctb));
        store_64bit_word_in_host(cpu, (unsigned char *)
            &(ctb.ctb_term_type), machine->use_x11?
            CTB_GRAPHICS : CTB_PRINTERPORT);

        /*  CRB: Console Routine Block  */
        memset(&crb, 0, sizeof(struct crb));
        store_64bit_word_in_host(cpu, (unsigned char *)
            &(crb.crb_v_dispatch), CRB_ADDR - 0x100);
        store_64bit_word(cpu, CRB_ADDR - 0x100 + 8, 0x10000);
        store_64bit_word_in_host(cpu, (unsigned char *)
            &(crb.crb_v_fixup), CRB_ADDR - 0x80);
        store_64bit_word(cpu, CRB_ADDR - 0x80 + 8, 0x10800);

        /*
         *  MDDT: Memory Data Descriptor Table. For now, it is a simple
         *  two-entry table with half of the available RAM in each entry.
         *  (The values are in number of 8K pages.)
         *  The first 16 MB are not included (the kernel lives there).
         *  The last 1 MB is not included either, it is reserved for bootup
         *  and similar.
         */
        memset(&mddt, 0, sizeof(struct mddt));
        store_64bit_word_in_host(cpu, (unsigned char *)
            &(mddt.mddt_cluster_cnt), 2);
        store_64bit_word_in_host(cpu, (unsigned char *)
            &(mddt.mddt_clusters[0].mddt_pfn), 128 * 16);
        store_64bit_word_in_host(cpu, (unsigned char *)
            &(mddt.mddt_clusters[0].mddt_pg_cnt),
            (machine->physical_ram_in_mb - 16) * 128);
        store_64bit_word_in_host(cpu, (unsigned char *)
            &(mddt.mddt_clusters[1].mddt_pfn), machine->physical_ram_in_mb*128);
        store_64bit_word_in_host(cpu, (unsigned char *)
            &(mddt.mddt_clusters[1].mddt_pg_cnt), (machine->physical_ram_in_mb
            - 1) * 128);

        /*
         *  Place a special "hack" palcode call at 0x10000 and 0x10800:
         *  (Hopefully nothing else will be there.)
         */
        store_32bit_word(cpu, 0x10000, 0x3fffffe);
        store_32bit_word(cpu, 0x10800, 0x3fffffd);

        store_buf(cpu, HWRPB_ADDR, (char *)&rpb, sizeof(struct rpb));
        store_buf(cpu, CTB_ADDR, (char *)&ctb, sizeof(struct ctb));
        store_buf(cpu, CRB_ADDR, (char *)&crb, sizeof(struct crb));
        store_buf(cpu, MEMDAT_ADDR, (char *)&mddt, sizeof(struct mddt));
}


MACHINE_DEFAULT_CPU(alpha)
{
        switch (machine->machine_subtype) {

        case ST_ALPHABOOK1:
                machine->cpu_name = strdup("21066");
                break;

        case ST_DEC_4100:
                machine->cpu_name = strdup("21164A-2");
                break;

        case ST_DEC_3000_300:
                machine->cpu_name = strdup("21064");
                break;

        case ST_EB164:
                machine->cpu_name = strdup("21164PC");
                break;

        default:fatal("Unimplemented Alpha machine type %i\n",
                    machine->machine_subtype);
                exit(1);
        }
}


MACHINE_DEFAULT_RAM(alpha)
{
        machine->physical_ram_in_mb = 64;
}


MACHINE_REGISTER(alpha)
{
        MR_DEFAULT(alpha, "Alpha", ARCH_ALPHA, MACHINE_ALPHA);

        machine_entry_add_alias(me, "alpha");

        machine_entry_add_subtype(me, "AlphaBook 1", ST_ALPHABOOK1,
            "alphabook1", NULL);

        machine_entry_add_subtype(me, "AlphaServer 4100", ST_DEC_4100,
            "alphaserver4100", NULL);

        machine_entry_add_subtype(me, "DEC 3000/300", ST_DEC_3000_300,
            "3000/300", NULL);

        machine_entry_add_subtype(me, "EB164", ST_EB164,
            "eb164", NULL);

        me->set_default_ram = machine_default_ram_alpha;
}

1	/*
2	* Copyright (C) 2005-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: machine_alpha.c,v 1.7 2006/06/24 10:19:19 debug Exp $
29	*/
30
31	#include <stdio.h>
32	#include <string.h>
33	#include <stdlib.h>
34
35	#include "cpu.h"
36	#include "device.h"
37	#include "devices.h"
38	#include "machine.h"
39	#include "memory.h"
40	#include "misc.h"
41
42	#include "alpha_autoconf.h"
43	#include "alpha_rpb.h"
44
45
46	MACHINE_SETUP(alpha)
47	{
48	struct rpb rpb;
49	struct crb crb;
50	struct ctb ctb;
51	struct mddt mddt;
52
53	switch (machine->machine_subtype) {
54
55	case ST_ALPHABOOK1:
56	machine->machine_name = "AlphaBook 1";
57	device_add(machine, "lca");
58	break;
59
60	case ST_DEC_4100:
61	machine->machine_name = "AlphaServer 4100";
62	break;
63
64	case ST_DEC_3000_300:
65	machine->machine_name = "DEC 3000/300";
66	machine->main_console_handle = (size_t)device_add(machine,
67	"z8530 addr=0x1b0200000 irq=0 addr_mult=4");
68	break;
69
70	case ST_EB164:
71	machine->machine_name = "EB164";
72	break;
73
74	default:fatal("Unimplemented Alpha machine type %i\n",
75	machine->machine_subtype);
76	exit(1);
77	}
78
79	if (!machine->prom_emulation)
80	return;
81
82	/* These are used by NetBSD/alpha: */
83	/* a0 = First free Page Frame Number */
84	/* a1 = PFN of current Level 1 page table */
85	/* a2 = Bootinfo magic */
86	/* a3 = Bootinfo pointer */
87	/* a4 = Bootinfo version */
88	cpu->cd.alpha.r[ALPHA_A0] = 1610241024 / 8192;
89	cpu->cd.alpha.r[ALPHA_A1] = 0; /* TODO */
90	cpu->cd.alpha.r[ALPHA_A2] = ALPHA_BOOTINFO_MAGIC;
91	cpu->cd.alpha.r[ALPHA_A3] = 0; /* TODO */
92	cpu->cd.alpha.r[ALPHA_A4] = 1;
93
94	/*
95	* HWRPB: Hardware Restart Parameter Block
96	*
97	* TODO: Almost everything.
98	*/
99	memset(&rpb, 0, sizeof(struct rpb));
100	store_64bit_word_in_host(cpu, (unsigned char *)
101	&(rpb.rpb_phys), HWRPB_ADDR);
102	strlcpy((char *)&(rpb.rpb_magic), "HWRPB", 8);
103	store_64bit_word_in_host(cpu, (unsigned char *)
104	&(rpb.rpb_size), sizeof(struct rpb));
105	store_64bit_word_in_host(cpu, (unsigned char *)
106	&(rpb.rpb_page_size), 8192);
107	store_64bit_word_in_host(cpu, (unsigned char *)
108	&(rpb.rpb_type), machine->machine_subtype);
109	store_64bit_word_in_host(cpu, (unsigned char *)
110	&(rpb.rpb_cc_freq), 100000000);
111	store_64bit_word_in_host(cpu, (unsigned char *)
112	&(rpb.rpb_ctb_off), CTB_ADDR - HWRPB_ADDR);
113	store_64bit_word_in_host(cpu, (unsigned char *)
114	&(rpb.rpb_crb_off), CRB_ADDR - HWRPB_ADDR);
115	store_64bit_word_in_host(cpu, (unsigned char *)
116	&(rpb.rpb_memdat_off), MEMDAT_ADDR - HWRPB_ADDR);
117
118	/* CTB: Console Terminal Block */
119	memset(&ctb, 0, sizeof(struct ctb));
120	store_64bit_word_in_host(cpu, (unsigned char *)
121	&(ctb.ctb_term_type), machine->use_x11?
122	CTB_GRAPHICS : CTB_PRINTERPORT);
123
124	/* CRB: Console Routine Block */
125	memset(&crb, 0, sizeof(struct crb));
126	store_64bit_word_in_host(cpu, (unsigned char *)
127	&(crb.crb_v_dispatch), CRB_ADDR - 0x100);
128	store_64bit_word(cpu, CRB_ADDR - 0x100 + 8, 0x10000);
129	store_64bit_word_in_host(cpu, (unsigned char *)
130	&(crb.crb_v_fixup), CRB_ADDR - 0x80);
131	store_64bit_word(cpu, CRB_ADDR - 0x80 + 8, 0x10800);
132
133	/*
134	* MDDT: Memory Data Descriptor Table. For now, it is a simple
135	* two-entry table with half of the available RAM in each entry.
136	* (The values are in number of 8K pages.)
137	* The first 16 MB are not included (the kernel lives there).
138	* The last 1 MB is not included either, it is reserved for bootup
139	* and similar.
140	*/
141	memset(&mddt, 0, sizeof(struct mddt));
142	store_64bit_word_in_host(cpu, (unsigned char *)
143	&(mddt.mddt_cluster_cnt), 2);
144	store_64bit_word_in_host(cpu, (unsigned char *)
145	&(mddt.mddt_clusters[0].mddt_pfn), 128 * 16);
146	store_64bit_word_in_host(cpu, (unsigned char *)
147	&(mddt.mddt_clusters[0].mddt_pg_cnt),
148	(machine->physical_ram_in_mb - 16) * 128);
149	store_64bit_word_in_host(cpu, (unsigned char *)
150	&(mddt.mddt_clusters[1].mddt_pfn), machine->physical_ram_in_mb*128);
151	store_64bit_word_in_host(cpu, (unsigned char *)
152	&(mddt.mddt_clusters[1].mddt_pg_cnt), (machine->physical_ram_in_mb
153	- 1) * 128);
154
155	/*
156	* Place a special "hack" palcode call at 0x10000 and 0x10800:
157	* (Hopefully nothing else will be there.)
158	*/
159	store_32bit_word(cpu, 0x10000, 0x3fffffe);
160	store_32bit_word(cpu, 0x10800, 0x3fffffd);
161
162	store_buf(cpu, HWRPB_ADDR, (char *)&rpb, sizeof(struct rpb));
163	store_buf(cpu, CTB_ADDR, (char *)&ctb, sizeof(struct ctb));
164	store_buf(cpu, CRB_ADDR, (char *)&crb, sizeof(struct crb));
165	store_buf(cpu, MEMDAT_ADDR, (char *)&mddt, sizeof(struct mddt));
166	}
167
168
169	MACHINE_DEFAULT_CPU(alpha)
170	{
171	switch (machine->machine_subtype) {
172
173	case ST_ALPHABOOK1:
174	machine->cpu_name = strdup("21066");
175	break;
176
177	case ST_DEC_4100:
178	machine->cpu_name = strdup("21164A-2");
179	break;
180
181	case ST_DEC_3000_300:
182	machine->cpu_name = strdup("21064");
183	break;
184
185	case ST_EB164:
186	machine->cpu_name = strdup("21164PC");
187	break;
188
189	default:fatal("Unimplemented Alpha machine type %i\n",
190	machine->machine_subtype);
191	exit(1);
192	}
193	}
194
195
196	MACHINE_DEFAULT_RAM(alpha)
197	{
198	machine->physical_ram_in_mb = 64;
199	}
200
201
202	MACHINE_REGISTER(alpha)
203	{
204	MR_DEFAULT(alpha, "Alpha", ARCH_ALPHA, MACHINE_ALPHA);
205
206	machine_entry_add_alias(me, "alpha");
207
208	machine_entry_add_subtype(me, "AlphaBook 1", ST_ALPHABOOK1,
209	"alphabook1", NULL);
210
211	machine_entry_add_subtype(me, "AlphaServer 4100", ST_DEC_4100,
212	"alphaserver4100", NULL);
213
214	machine_entry_add_subtype(me, "DEC 3000/300", ST_DEC_3000_300,
215	"3000/300", NULL);
216
217	machine_entry_add_subtype(me, "EB164", ST_EB164,
218	"eb164", NULL);
219
220	me->set_default_ram = machine_default_ram_alpha;
221	}
222