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.12 by gbeauche, 2004-07-03T10:39:04Z vs.
Revision 1.16 by gbeauche, 2005-01-30T21:13:23Z

#	Line 35 | Line 35
35		// Function pointers
36		typedef int16 (*rcec_ptr)(const RegEntryID *, const char *, RegEntryID *);
37		static uint32 rcec_tvect = 0;
38	<	static inline int16 RegistryCStrEntryCreate(const RegEntryID *arg1, const char *arg2, RegEntryID *arg3)
38	>	static inline int16 RegistryCStrEntryCreate(uintptr arg1, const char *arg2, uint32 arg3)
39		{
40	<	return (int16)CallMacOS3(rcec_ptr, rcec_tvect, arg1, arg2, arg3);
40	>	SheepString arg2str(arg2);
41	>	return (int16)CallMacOS3(rcec_ptr, rcec_tvect, (const RegEntryID *)arg1, arg2str.addr(), arg3);
42		}
43		typedef int16 (*rpc_ptr)(const RegEntryID *, const char *, const void *, uint32);
44		static uint32 rpc_tvect = 0;
45	<	static inline int16 RegistryPropertyCreate(const RegEntryID *arg1, const char *arg2, const void *arg3, uint32 arg4)
45	>	static inline int16 RegistryPropertyCreate(uintptr arg1, const char *arg2, uintptr arg3, uint32 arg4)
46		{
47	<	return (int16)CallMacOS4(rpc_ptr, rpc_tvect, arg1, arg2, arg3, arg4);
47	>	SheepString arg2str(arg2);
48	>	return (int16)CallMacOS4(rpc_ptr, rpc_tvect, (const RegEntryID *)arg1, arg2str.addr(), (const void *)arg3, arg4);
49	>	}
50	>	static inline int16 RegistryPropertyCreateStr(uintptr arg1, const char *arg2, const char *arg3)
51	>	{
52	>	SheepString arg3str(arg3);
53	>	return RegistryPropertyCreate(arg1, arg2, arg3str.addr(), strlen(arg3) + 1);
54		}
48	–	#define RegistryPropertyCreateStr(e,n,s) RegistryPropertyCreate(e,n,s,strlen(s)+1)
55
56		// Video driver stub
57		static const uint8 video_driver[] = {
#	Line 58 | Line 64 | static const uint8 ethernet_driver[] = {
64		};
65
66		// Helper for RegEntryID
67	<	struct SheepRegEntryID : public SheepArray<sizeof(RegEntryID)> {
62	<	RegEntryID *ptr() const { return (RegEntryID *)addr(); }
63	<	};
67	>	typedef SheepArray<sizeof(RegEntryID)> SheepRegEntryID;
68
69		// Helper for a <uint32, uint32> pair
70		struct SheepPair : public SheepArray<8> {
71		SheepPair(uint32 base, uint32 size) : SheepArray<8>()
72		{ WriteMacInt32(addr(), base); WriteMacInt32(addr() + 4, size); }
69	–	uint32 *ptr() const
70	–	{ return (uint32 *)addr(); }
73		};
74
75
#	Line 82 | Line 84 | void DoPatchNameRegistry(void)
84
85		// Create "device-tree"
86		SheepRegEntryID device_tree;
87	<	if (!RegistryCStrEntryCreate(NULL, "Devices:device-tree", device_tree.ptr())) {
87	>	if (!RegistryCStrEntryCreate(0, "Devices:device-tree", device_tree.addr())) {
88		u32.set_value(BusClockSpeed);
89	<	RegistryPropertyCreate(device_tree.ptr(), "clock-frequency", u32.ptr(), 4);
90	<	RegistryPropertyCreateStr(device_tree.ptr(), "model", "Power Macintosh");
89	>	RegistryPropertyCreate(device_tree.addr(), "clock-frequency", u32.addr(), 4);
90	>	RegistryPropertyCreateStr(device_tree.addr(), "model", "Power Macintosh");
91
92		// Create "AAPL,ROM"
93		SheepRegEntryID aapl_rom;
94	<	if (!RegistryCStrEntryCreate(device_tree.ptr(), "AAPL,ROM", aapl_rom.ptr())) {
95	<	RegistryPropertyCreateStr(aapl_rom.ptr(), "device_type", "rom");
94	>	if (!RegistryCStrEntryCreate(device_tree.addr(), "AAPL,ROM", aapl_rom.addr())) {
95	>	RegistryPropertyCreateStr(aapl_rom.addr(), "device_type", "rom");
96		SheepPair reg(ROM_BASE, ROM_SIZE);
97	<	RegistryPropertyCreate(aapl_rom.ptr(), "reg", reg.ptr(), 8);
97	>	RegistryPropertyCreate(aapl_rom.addr(), "reg", reg.addr(), 8);
98		}
99
100		// Create "PowerPC,60x"
#	Line 129 | Line 131 | void DoPatchNameRegistry(void)
131		case 80:        // 860
132		str = "PowerPC,860";
133		break;
134	+	case 12:        // 7400, 7410, 7450, 7455, 7457
135	+	case 0x800c:
136	+	case 0x8000:
137	+	case 0x8001:
138	+	case 0x8002:
139	+	str = "PowerPC,G4";
140	+	break;
141		default:
142		str = "PowerPC,???";
143		break;
144		}
145	<	if (!RegistryCStrEntryCreate(device_tree.ptr(), str, power_pc.ptr())) {
145	>	if (!RegistryCStrEntryCreate(device_tree.addr(), str, power_pc.addr())) {
146		u32.set_value(CPUClockSpeed);
147	<	RegistryPropertyCreate(power_pc.ptr(), "clock-frequency", u32.ptr(), 4);
147	>	RegistryPropertyCreate(power_pc.addr(), "clock-frequency", u32.addr(), 4);
148		u32.set_value(BusClockSpeed);
149	<	RegistryPropertyCreate(power_pc.ptr(), "bus-frequency", u32.ptr(), 4);
149	>	RegistryPropertyCreate(power_pc.addr(), "bus-frequency", u32.addr(), 4);
150		u32.set_value(TimebaseSpeed);
151	<	RegistryPropertyCreate(power_pc.ptr(), "timebase-frequency", u32.ptr(), 4);
151	>	RegistryPropertyCreate(power_pc.addr(), "timebase-frequency", u32.addr(), 4);
152		u32.set_value(PVR);
153	<	RegistryPropertyCreate(power_pc.ptr(), "cpu-version", u32.ptr(), 4);
154	<	RegistryPropertyCreateStr(power_pc.ptr(), "device_type", "cpu");
153	>	RegistryPropertyCreate(power_pc.addr(), "cpu-version", u32.addr(), 4);
154	>	RegistryPropertyCreateStr(power_pc.addr(), "device_type", "cpu");
155		switch (PVR >> 16) {
156		case 1:         // 601
157		u32.set_value(64);
158	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4);
158	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4);
159		u32.set_value(128);
160	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4);
160	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4);
161		u32.set_value(0x8000);
162	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4);
162	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4);
163		u32.set_value(64);
164	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4);
164	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4);
165		u32.set_value(128);
166	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4);
166	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4);
167		u32.set_value(0x8000);
168	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4);
168	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4);
169		u32.set_value(128);
170	<	RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4);
170	>	RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4);
171		u32.set_value(256);
172	<	RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4);
172	>	RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4);
173		break;
174		case 3:         // 603
175		u32.set_value(32);
176	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4);
176	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4);
177		u32.set_value(64);
178	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4);
178	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4);
179		u32.set_value(0x2000);
180	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4);
180	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4);
181		u32.set_value(32);
182	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4);
182	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4);
183		u32.set_value(64);
184	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4);
184	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4);
185		u32.set_value(0x2000);
186	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4);
186	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4);
187		u32.set_value(32);
188	<	RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4);
188	>	RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4);
189		u32.set_value(64);
190	<	RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4);
190	>	RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4);
191		break;
192		case 4:         // 604
193		u32.set_value(32);
194	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4);
194	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4);
195		u32.set_value(128);
196	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4);
196	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4);
197		u32.set_value(0x4000);
198	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4);
198	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4);
199		u32.set_value(32);
200	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4);
200	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4);
201		u32.set_value(128);
202	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4);
202	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4);
203		u32.set_value(0x4000);
204	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4);
204	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4);
205		u32.set_value(64);
206	<	RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4);
206	>	RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4);
207		u32.set_value(128);
208	<	RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4);
208	>	RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4);
209		break;
210		case 6:         // 603e
211		case 7:         // 603ev
212		u32.set_value(32);
213	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4);
213	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4);
214		u32.set_value(128);
215	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4);
215	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4);
216		u32.set_value(0x4000);
217	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4);
217	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4);
218		u32.set_value(32);
219	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4);
219	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4);
220		u32.set_value(128);
221	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4);
221	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4);
222		u32.set_value(0x4000);
223	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4);
223	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4);
224		u32.set_value(32);
225	<	RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4);
225	>	RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4);
226		u32.set_value(64);
227	<	RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4);
227	>	RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4);
228		break;
229		case 8:         // 750, 750FX
230		case 0x7000:
231		u32.set_value(32);
232	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4);
232	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4);
233		u32.set_value(256);
234	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4);
234	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4);
235		u32.set_value(0x8000);
236	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4);
236	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4);
237		u32.set_value(32);
238	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4);
238	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4);
239		u32.set_value(256);
240	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4);
240	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4);
241		u32.set_value(0x8000);
242	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4);
242	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4);
243		u32.set_value(64);
244	<	RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4);
244	>	RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4);
245		u32.set_value(128);
246	<	RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4);
246	>	RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4);
247		break;
248		case 9:         // 604e
249		case 10:        // 604ev5
250		u32.set_value(32);
251	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4);
251	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4);
252		u32.set_value(256);
253	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4);
253	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4);
254		u32.set_value(0x8000);
255	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4);
255	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4);
256		u32.set_value(32);
257	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4);
257	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4);
258		u32.set_value(256);
259	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4);
259	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4);
260		u32.set_value(0x8000);
261	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4);
261	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4);
262		u32.set_value(64);
263	<	RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4);
263	>	RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4);
264		u32.set_value(128);
265	<	RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4);
265	>	RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4);
266		break;
267		case 12:        // 7400, 7410, 7450, 7455, 7457
268		case 0x800c:
#	Line 261 | Line 270 | void DoPatchNameRegistry(void)
270		case 0x8001:
271		case 0x8002:
272		u32.set_value(32);
273	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4);
273	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4);
274		u32.set_value(128);
275	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4);
275	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4);
276		u32.set_value(0x8000);
277	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4);
277	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4);
278		u32.set_value(32);
279	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4);
279	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4);
280		u32.set_value(128);
281	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4);
281	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4);
282		u32.set_value(0x8000);
283	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4);
283	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4);
284		u32.set_value(64);
285	<	RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4);
285	>	RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4);
286		u32.set_value(128);
287	<	RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4);
287	>	RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4);
288		break;
289		case 0x39:      // 970
290		u32.set_value(128);
291	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4);
291	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4);
292		u32.set_value(128);
293	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4);
293	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4);
294		u32.set_value(0x8000);
295	<	RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4);
295	>	RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4);
296		u32.set_value(128);
297	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4);
297	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4);
298		u32.set_value(512);
299	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4);
299	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4);
300		u32.set_value(0x10000);
301	<	RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4);
301	>	RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4);
302		u32.set_value(256);
303	<	RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4);
303	>	RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4);
304		u32.set_value(0x1000);
305	<	RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4);
305	>	RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4);
306		break;
307		default:
308		break;
309		}
310		u32.set_value(32);
311	<	RegistryPropertyCreate(power_pc.ptr(), "reservation-granularity", u32.ptr(), 4);
311	>	RegistryPropertyCreate(power_pc.addr(), "reservation-granularity", u32.addr(), 4);
312		SheepPair reg(0, 0);
313	<	RegistryPropertyCreate(power_pc.ptr(), "reg", reg.ptr(), 8);
313	>	RegistryPropertyCreate(power_pc.addr(), "reg", reg.addr(), 8);
314		}
315
316		// Create "memory"
317		SheepRegEntryID memory;
318	<	if (!RegistryCStrEntryCreate(device_tree.ptr(), "memory", memory.ptr())) {
318	>	if (!RegistryCStrEntryCreate(device_tree.addr(), "memory", memory.addr())) {
319		SheepPair reg(RAMBase, RAMSize);
320	<	RegistryPropertyCreateStr(memory.ptr(), "device_type", "memory");
321	<	RegistryPropertyCreate(memory.ptr(), "reg", reg.ptr(), 8);
320	>	RegistryPropertyCreateStr(memory.addr(), "device_type", "memory");
321	>	RegistryPropertyCreate(memory.addr(), "reg", reg.addr(), 8);
322		}
323
324		// Create "video"
325		SheepRegEntryID video;
326	<	if (!RegistryCStrEntryCreate(device_tree.ptr(), "video", video.ptr())) {
327	<	RegistryPropertyCreateStr(video.ptr(), "AAPL,connector", "monitor");
328	<	RegistryPropertyCreateStr(video.ptr(), "device_type", "display");
329	<	RegistryPropertyCreate(video.ptr(), "driver,AAPL,MacOS,PowerPC", video_driver, sizeof(video_driver));
330	<	RegistryPropertyCreateStr(video.ptr(), "model", "SheepShaver Video");
326	>	if (!RegistryCStrEntryCreate(device_tree.addr(), "video", video.addr())) {
327	>	RegistryPropertyCreateStr(video.addr(), "AAPL,connector", "monitor");
328	>	RegistryPropertyCreateStr(video.addr(), "device_type", "display");
329	>	SheepArray<sizeof(video_driver)> the_video_driver;
330	>	Host2Mac_memcpy(the_video_driver.addr(), video_driver, sizeof(video_driver));
331	>	RegistryPropertyCreate(video.addr(), "driver,AAPL,MacOS,PowerPC", the_video_driver.addr(), sizeof(video_driver));
332	>	RegistryPropertyCreateStr(video.addr(), "model", "SheepShaver Video");
333		}
334
335		// Create "ethernet"
336		SheepRegEntryID ethernet;
337	<	if (!RegistryCStrEntryCreate(device_tree.ptr(), "ethernet", ethernet.ptr())) {
338	<	RegistryPropertyCreateStr(ethernet.ptr(), "AAPL,connector", "ethernet");
339	<	RegistryPropertyCreateStr(ethernet.ptr(), "device_type", "network");
340	<	RegistryPropertyCreate(ethernet.ptr(), "driver,AAPL,MacOS,PowerPC", ethernet_driver, sizeof(ethernet_driver));
337	>	if (!RegistryCStrEntryCreate(device_tree.addr(), "ethernet", ethernet.addr())) {
338	>	RegistryPropertyCreateStr(ethernet.addr(), "AAPL,connector", "ethernet");
339	>	RegistryPropertyCreateStr(ethernet.addr(), "device_type", "network");
340	>	SheepArray<sizeof(ethernet_driver)> the_ethernet_driver;
341	>	Host2Mac_memcpy(the_ethernet_driver.addr(), ethernet_driver, sizeof(ethernet_driver));
342	>	RegistryPropertyCreate(ethernet.addr(), "driver,AAPL,MacOS,PowerPC", the_ethernet_driver.addr(), sizeof(ethernet_driver));
343		// local-mac-address
344		// max-frame-size 2048
345		}
#	Line 337 | Line 350 | void DoPatchNameRegistry(void)
350		void PatchNameRegistry(void)
351		{
352		// Find RegistryCStrEntryCreate() and RegistryPropertyCreate() TVECTs
353	<	rcec_tvect = (uint32)FindLibSymbol("\017NameRegistryLib", "\027RegistryCStrEntryCreate");
353	>	rcec_tvect = FindLibSymbol("\017NameRegistryLib", "\027RegistryCStrEntryCreate");
354		D(bug("RegistryCStrEntryCreate TVECT at %08x\n", rcec_tvect));
355	<	rpc_tvect = (uint32)FindLibSymbol("\017NameRegistryLib", "\026RegistryPropertyCreate");
355	>	rpc_tvect = FindLibSymbol("\017NameRegistryLib", "\026RegistryPropertyCreate");
356		D(bug("RegistryPropertyCreate TVECT at %08x\n", rpc_tvect));
357		if (rcec_tvect == 0 || rpc_tvect == 0) {
358		ErrorAlert(GetString(STR_NO_NAME_REGISTRY_ERR));

Diff Legend

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