ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/cebix/SheepShaver/src/name_registry.cpp

Comparing SheepShaver/src/name_registry.cpp (file contents):
Revision 1.1 by cebix, 2002-02-04T16:58:13Z vs.
Revision 1.10 by gbeauche, 2004-06-29T20:25:54Z

#	Line 1 | Line 1
1		/*
2		*  name_registry.cpp - Name Registry handling
3		*
4	<	*  SheepShaver (C) 1997-2002 Christian Bauer and Marc Hellwig
4	>	*  SheepShaver (C) 1997-2004 Christian Bauer and Marc Hellwig
5		*
6		*  This program is free software; you can redistribute it and/or modify
7		*  it under the terms of the GNU General Public License as published by
#	Line 25 | Line 25
25		#include "main.h"
26		#include "macos_util.h"
27		#include "user_strings.h"
28	+	#include "emul_op.h"
29	+	#include "thunks.h"
30
31		#define DEBUG 0
32		#include "debug.h"
#	Line 55 | Line 57 | static const uint8 ethernet_driver[] = {
57		#include "EthernetDriverStub.i"
58		};
59
60	+	// Helper for RegEntryID
61	+	struct SheepRegEntryID : public SheepArray<sizeof(RegEntryID)> {
62	+	RegEntryID *ptr() const { return (RegEntryID *)addr(); }
63	+	};
64	+
65	+	// Helper for a <uint32, uint32> pair
66	+	struct SheepPair : public SheepArray<8> {
67	+	SheepPair(uint32 base, uint32 size) : SheepArray<8>()
68	+	{ WriteMacInt32(addr(), base); WriteMacInt32(addr() + 4, size); }
69	+	uint32 *ptr() const
70	+	{ return (uint32 *)addr(); }
71	+	};
72	+
73
74		/*
75		*  Patch Name Registry during startup
76		*/
77
78	<	static void patch_name_registry(void)
78	>	void DoPatchNameRegistry(void)
79		{
80	<	uint32 u32;
80	>	SheepVar32 u32;
81		D(bug("Patching Name Registry..."));
82
83		// Create "device-tree"
84	<	RegEntryID device_tree;
85	<	if (!RegistryCStrEntryCreate(NULL, "Devices:device-tree", &device_tree)) {
86	<	u32 = BusClockSpeed;
87	<	RegistryPropertyCreate(&device_tree, "clock-frequency", &u32, 4);
88	<	RegistryPropertyCreateStr(&device_tree, "model", "Power Macintosh");
84	>	SheepRegEntryID device_tree;
85	>	if (!RegistryCStrEntryCreate(NULL, "Devices:device-tree", device_tree.ptr())) {
86	>	u32.set_value(BusClockSpeed);
87	>	RegistryPropertyCreate(device_tree.ptr(), "clock-frequency", u32.ptr(), 4);
88	>	RegistryPropertyCreateStr(device_tree.ptr(), "model", "Power Macintosh");
89
90		// Create "AAPL,ROM"
91	<	RegEntryID aapl_rom;
92	<	if (!RegistryCStrEntryCreate(&device_tree, "AAPL,ROM", &aapl_rom)) {
93	<	RegistryPropertyCreateStr(&aapl_rom, "device_type", "rom");
94	<	uint32 reg[2] = {ROM_BASE, ROM_SIZE};
95	<	RegistryPropertyCreate(&aapl_rom, "reg", &reg, 8);
91	>	SheepRegEntryID aapl_rom;
92	>	if (!RegistryCStrEntryCreate(device_tree.ptr(), "AAPL,ROM", aapl_rom.ptr())) {
93	>	RegistryPropertyCreateStr(aapl_rom.ptr(), "device_type", "rom");
94	>	SheepPair reg(ROM_BASE, ROM_SIZE);
95	>	RegistryPropertyCreate(aapl_rom.ptr(), "reg", reg.ptr(), 8);
96		}
97
98		// Create "PowerPC,60x"
99	<	RegEntryID power_pc;
99	>	SheepRegEntryID power_pc;
100		char *str;
101		switch (PVR >> 16) {
102		case 1:         // 601
#	Line 118 | Line 133 | static void patch_name_registry(void)
133		str = "PowerPC,???";
134		break;
135		}
136	<	if (!RegistryCStrEntryCreate(&device_tree, str, &power_pc)) {
137	<	u32 = CPUClockSpeed;
138	<	RegistryPropertyCreate(&power_pc, "clock-frequency", &u32, 4);
139	<	RegistryPropertyCreate(&power_pc, "cpu-version", &PVR, 4);
140	<	RegistryPropertyCreateStr(&power_pc, "device_type", "cpu");
136	>	if (!RegistryCStrEntryCreate(device_tree.ptr(), str, power_pc.ptr())) {
137	>	u32.set_value(CPUClockSpeed);
138	>	RegistryPropertyCreate(power_pc.ptr(), "clock-frequency", u32.ptr(), 4);
139	>	u32.set_value(BusClockSpeed);
140	>	RegistryPropertyCreate(power_pc.ptr(), "bus-frequency", u32.ptr(), 4);
141	>	u32.set_value(BusClockSpeed / 4);
142	>	RegistryPropertyCreate(power_pc.ptr(), "timebase-frequency", u32.ptr(), 4);
143	>	u32.set_value(PVR);
144	>	RegistryPropertyCreate(power_pc.ptr(), "cpu-version", u32.ptr(), 4);
145	>	RegistryPropertyCreateStr(power_pc.ptr(), "device_type", "cpu");
146		switch (PVR >> 16) {
147		case 1:         // 601
148	<	u32 = 64;
149	<	RegistryPropertyCreate(&power_pc, "d-cache-block-size", &u32, 4);
150	<	u32 = 128;
151	<	RegistryPropertyCreate(&power_pc, "d-cache-sets", &u32, 4);
152	<	u32 = 0x8000;
153	<	RegistryPropertyCreate(&power_pc, "d-cache-size", &u32, 4);
154	<	u32 = 64;
155	<	RegistryPropertyCreate(&power_pc, "i-cache-block-size", &u32, 4);
156	<	u32 = 128;
157	<	RegistryPropertyCreate(&power_pc, "i-cache-sets", &u32, 4);
158	<	u32 = 0x8000;
159	<	RegistryPropertyCreate(&power_pc, "i-cache-size", &u32, 4);
160	<	u32 = 128;
161	<	RegistryPropertyCreate(&power_pc, "tlb-sets", &u32, 4);
162	<	u32 = 256;
163	<	RegistryPropertyCreate(&power_pc, "tlb-size", &u32, 4);
148	>	u32.set_value(64);
149	>	RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4);
150	>	u32.set_value(128);
151	>	RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4);
152	>	u32.set_value(0x8000);
153	>	RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4);
154	>	u32.set_value(64);
155	>	RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4);
156	>	u32.set_value(128);
157	>	RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4);
158	>	u32.set_value(0x8000);
159	>	RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4);
160	>	u32.set_value(128);
161	>	RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4);
162	>	u32.set_value(256);
163	>	RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4);
164		break;
165		case 3:         // 603
166	<	u32 = 32;
167	<	RegistryPropertyCreate(&power_pc, "d-cache-block-size", &u32, 4);
168	<	u32 = 64;
169	<	RegistryPropertyCreate(&power_pc, "d-cache-sets", &u32, 4);
170	<	u32 = 0x2000;
171	<	RegistryPropertyCreate(&power_pc, "d-cache-size", &u32, 4);
172	<	u32 = 32;
173	<	RegistryPropertyCreate(&power_pc, "i-cache-block-size", &u32, 4);
174	<	u32 = 64;
175	<	RegistryPropertyCreate(&power_pc, "i-cache-sets", &u32, 4);
176	<	u32 = 0x2000;
177	<	RegistryPropertyCreate(&power_pc, "i-cache-size", &u32, 4);
178	<	u32 = 32;
179	<	RegistryPropertyCreate(&power_pc, "tlb-sets", &u32, 4);
180	<	u32 = 64;
181	<	RegistryPropertyCreate(&power_pc, "tlb-size", &u32, 4);
166	>	u32.set_value(32);
167	>	RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4);
168	>	u32.set_value(64);
169	>	RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4);
170	>	u32.set_value(0x2000);
171	>	RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4);
172	>	u32.set_value(32);
173	>	RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4);
174	>	u32.set_value(64);
175	>	RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4);
176	>	u32.set_value(0x2000);
177	>	RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4);
178	>	u32.set_value(32);
179	>	RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4);
180	>	u32.set_value(64);
181	>	RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4);
182		break;
183		case 4:         // 604
184	<	u32 = 32;
185	<	RegistryPropertyCreate(&power_pc, "d-cache-block-size", &u32, 4);
186	<	u32 = 128;
187	<	RegistryPropertyCreate(&power_pc, "d-cache-sets", &u32, 4);
188	<	u32 = 0x4000;
189	<	RegistryPropertyCreate(&power_pc, "d-cache-size", &u32, 4);
190	<	u32 = 32;
191	<	RegistryPropertyCreate(&power_pc, "i-cache-block-size", &u32, 4);
192	<	u32 = 128;
193	<	RegistryPropertyCreate(&power_pc, "i-cache-sets", &u32, 4);
194	<	u32 = 0x4000;
195	<	RegistryPropertyCreate(&power_pc, "i-cache-size", &u32, 4);
196	<	u32 = 64;
197	<	RegistryPropertyCreate(&power_pc, "tlb-sets", &u32, 4);
198	<	u32 = 128;
199	<	RegistryPropertyCreate(&power_pc, "tlb-size", &u32, 4);
184	>	u32.set_value(32);
185	>	RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4);
186	>	u32.set_value(128);
187	>	RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4);
188	>	u32.set_value(0x4000);
189	>	RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4);
190	>	u32.set_value(32);
191	>	RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4);
192	>	u32.set_value(128);
193	>	RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4);
194	>	u32.set_value(0x4000);
195	>	RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4);
196	>	u32.set_value(64);
197	>	RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4);
198	>	u32.set_value(128);
199	>	RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4);
200		break;
201		case 6:         // 603e
202		case 7:         // 603ev
203	<	u32 = 32;
204	<	RegistryPropertyCreate(&power_pc, "d-cache-block-size", &u32, 4);
205	<	u32 = 128;
206	<	RegistryPropertyCreate(&power_pc, "d-cache-sets", &u32, 4);
207	<	u32 = 0x4000;
208	<	RegistryPropertyCreate(&power_pc, "d-cache-size", &u32, 4);
209	<	u32 = 32;
210	<	RegistryPropertyCreate(&power_pc, "i-cache-block-size", &u32, 4);
211	<	u32 = 128;
212	<	RegistryPropertyCreate(&power_pc, "i-cache-sets", &u32, 4);
213	<	u32 = 0x4000;
214	<	RegistryPropertyCreate(&power_pc, "i-cache-size", &u32, 4);
215	<	u32 = 32;
216	<	RegistryPropertyCreate(&power_pc, "tlb-sets", &u32, 4);
217	<	u32 = 64;
218	<	RegistryPropertyCreate(&power_pc, "tlb-size", &u32, 4);
203	>	u32.set_value(32);
204	>	RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4);
205	>	u32.set_value(128);
206	>	RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4);
207	>	u32.set_value(0x4000);
208	>	RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4);
209	>	u32.set_value(32);
210	>	RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4);
211	>	u32.set_value(128);
212	>	RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4);
213	>	u32.set_value(0x4000);
214	>	RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4);
215	>	u32.set_value(32);
216	>	RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4);
217	>	u32.set_value(64);
218	>	RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4);
219		break;
220	<	case 8:         // 750
221	<	u32 = 32;
222	<	RegistryPropertyCreate(&power_pc, "d-cache-block-size", &u32, 4);
223	<	u32 = 256;
224	<	RegistryPropertyCreate(&power_pc, "d-cache-sets", &u32, 4);
225	<	u32 = 0x8000;
226	<	RegistryPropertyCreate(&power_pc, "d-cache-size", &u32, 4);
227	<	u32 = 32;
228	<	RegistryPropertyCreate(&power_pc, "i-cache-block-size", &u32, 4);
229	<	u32 = 256;
230	<	RegistryPropertyCreate(&power_pc, "i-cache-sets", &u32, 4);
231	<	u32 = 0x8000;
232	<	RegistryPropertyCreate(&power_pc, "i-cache-size", &u32, 4);
233	<	u32 = 64;
234	<	RegistryPropertyCreate(&power_pc, "tlb-sets", &u32, 4);
235	<	u32 = 128;
236	<	RegistryPropertyCreate(&power_pc, "tlb-size", &u32, 4);
220	>	case 8:         // 750, 750FX
221	>	case 0x7000:
222	>	u32.set_value(32);
223	>	RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4);
224	>	u32.set_value(256);
225	>	RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4);
226	>	u32.set_value(0x8000);
227	>	RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4);
228	>	u32.set_value(32);
229	>	RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4);
230	>	u32.set_value(256);
231	>	RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4);
232	>	u32.set_value(0x8000);
233	>	RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4);
234	>	u32.set_value(64);
235	>	RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4);
236	>	u32.set_value(128);
237	>	RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4);
238		break;
239		case 9:         // 604e
240		case 10:        // 604ev5
241	<	u32 = 32;
242	<	RegistryPropertyCreate(&power_pc, "d-cache-block-size", &u32, 4);
243	<	u32 = 256;
244	<	RegistryPropertyCreate(&power_pc, "d-cache-sets", &u32, 4);
245	<	u32 = 0x8000;
246	<	RegistryPropertyCreate(&power_pc, "d-cache-size", &u32, 4);
247	<	u32 = 32;
248	<	RegistryPropertyCreate(&power_pc, "i-cache-block-size", &u32, 4);
249	<	u32 = 256;
250	<	RegistryPropertyCreate(&power_pc, "i-cache-sets", &u32, 4);
251	<	u32 = 0x8000;
252	<	RegistryPropertyCreate(&power_pc, "i-cache-size", &u32, 4);
253	<	u32 = 64;
254	<	RegistryPropertyCreate(&power_pc, "tlb-sets", &u32, 4);
255	<	u32 = 128;
256	<	RegistryPropertyCreate(&power_pc, "tlb-size", &u32, 4);
241	>	u32.set_value(32);
242	>	RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4);
243	>	u32.set_value(256);
244	>	RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4);
245	>	u32.set_value(0x8000);
246	>	RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4);
247	>	u32.set_value(32);
248	>	RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4);
249	>	u32.set_value(256);
250	>	RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4);
251	>	u32.set_value(0x8000);
252	>	RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4);
253	>	u32.set_value(64);
254	>	RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4);
255	>	u32.set_value(128);
256	>	RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4);
257	>	break;
258	>	case 12:        // 7400, 7410, 7450, 7455, 7457
259	>	case 0x800c:
260	>	case 0x8000:
261	>	case 0x8001:
262	>	case 0x8002:
263	>	u32.set_value(32);
264	>	RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4);
265	>	u32.set_value(128);
266	>	RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4);
267	>	u32.set_value(0x8000);
268	>	RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4);
269	>	u32.set_value(32);
270	>	RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4);
271	>	u32.set_value(128);
272	>	RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4);
273	>	u32.set_value(0x8000);
274	>	RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4);
275	>	u32.set_value(64);
276	>	RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4);
277	>	u32.set_value(128);
278	>	RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4);
279		break;
280		default:
281		break;
282		}
283	<	u32 = 32;
284	<	RegistryPropertyCreate(&power_pc, "reservation-granularity", &u32, 4);
285	<	uint32 reg[2] = {0, 0};
286	<	RegistryPropertyCreate(&power_pc, "reg", &reg, 8);
283	>	u32.set_value(32);
284	>	RegistryPropertyCreate(power_pc.ptr(), "reservation-granularity", u32.ptr(), 4);
285	>	SheepPair reg(0, 0);
286	>	RegistryPropertyCreate(power_pc.ptr(), "reg", reg.ptr(), 8);
287		}
288
289		// Create "memory"
290	<	RegEntryID memory;
291	<	if (!RegistryCStrEntryCreate(&device_tree, "memory", &memory)) {
292	<	uint32 reg[2] = {RAMBase, RAMSize};
293	<	RegistryPropertyCreateStr(&memory, "device_type", "memory");
294	<	RegistryPropertyCreate(&memory, "reg", &reg, 8);
290	>	SheepRegEntryID memory;
291	>	if (!RegistryCStrEntryCreate(device_tree.ptr(), "memory", memory.ptr())) {
292	>	SheepPair reg(RAMBase, RAMSize);
293	>	RegistryPropertyCreateStr(memory.ptr(), "device_type", "memory");
294	>	RegistryPropertyCreate(memory.ptr(), "reg", reg.ptr(), 8);
295		}
296
297		// Create "video"
298	<	RegEntryID video;
299	<	if (!RegistryCStrEntryCreate(&device_tree, "video", &video)) {
300	<	RegistryPropertyCreateStr(&video, "AAPL,connector", "monitor");
301	<	RegistryPropertyCreateStr(&video, "device_type", "display");
302	<	RegistryPropertyCreate(&video, "driver,AAPL,MacOS,PowerPC", &video_driver, sizeof(video_driver));
303	<	RegistryPropertyCreateStr(&video, "model", "SheepShaver Video");
298	>	SheepRegEntryID video;
299	>	if (!RegistryCStrEntryCreate(device_tree.ptr(), "video", video.ptr())) {
300	>	RegistryPropertyCreateStr(video.ptr(), "AAPL,connector", "monitor");
301	>	RegistryPropertyCreateStr(video.ptr(), "device_type", "display");
302	>	RegistryPropertyCreate(video.ptr(), "driver,AAPL,MacOS,PowerPC", video_driver, sizeof(video_driver));
303	>	RegistryPropertyCreateStr(video.ptr(), "model", "SheepShaver Video");
304		}
305
306		// Create "ethernet"
307	<	RegEntryID ethernet;
308	<	if (!RegistryCStrEntryCreate(&device_tree, "ethernet", &ethernet)) {
309	<	RegistryPropertyCreateStr(&ethernet, "AAPL,connector", "ethernet");
310	<	RegistryPropertyCreateStr(&ethernet, "device_type", "network");
311	<	RegistryPropertyCreate(&ethernet, "driver,AAPL,MacOS,PowerPC", &ethernet_driver, sizeof(ethernet_driver));
307	>	SheepRegEntryID ethernet;
308	>	if (!RegistryCStrEntryCreate(device_tree.ptr(), "ethernet", ethernet.ptr())) {
309	>	RegistryPropertyCreateStr(ethernet.ptr(), "AAPL,connector", "ethernet");
310	>	RegistryPropertyCreateStr(ethernet.ptr(), "device_type", "network");
311	>	RegistryPropertyCreate(ethernet.ptr(), "driver,AAPL,MacOS,PowerPC", ethernet_driver, sizeof(ethernet_driver));
312		// local-mac-address
313		// max-frame-size 2048
314		}
#	Line 286 | Line 329 | void PatchNameRegistry(void)
329		}
330
331		// Main routine must be executed in PPC mode
332	<	ExecutePPC(patch_name_registry);
332	>	ExecuteNative(NATIVE_PATCH_NAME_REGISTRY);
333		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines