Chameleon

Chameleon Svn Source Tree

Root/branches/xZenu/src/arch/ppc/boot2/ci.c

Source at commit 1317 created 12 years 8 months ago.
By meklort, Update ppc boot2 file. File now compiles.
1/*␊
2 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.␊
3 *␊
4 * @APPLE_LICENSE_HEADER_START@␊
5 * ␊
6 * The contents of this file constitute Original Code as defined in and␊
7 * are subject to the Apple Public Source License Version 1.1 (the␊
8 * "License"). You may not use this file except in compliance with the␊
9 * License. Please obtain a copy of the License at␊
10 * http://www.apple.com/publicsource and read it before using this file.␊
11 * ␊
12 * This Original Code and all software distributed under the License are␊
13 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER␊
14 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,␊
15 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,␊
16 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the␊
17 * License for the specific language governing rights and limitations␊
18 * under the License.␊
19 * ␊
20 * @APPLE_LICENSE_HEADER_END@␊
21 */␊
22/*␊
23 * ci.c - Functions for accessing Open Firmware's Client Interface␊
24 *␊
25 * Copyright (c) 1998-2002 Apple Computer, Inc.␊
26 *␊
27 * DRI: Josh de Cesare␊
28 */␊
29␊
30#include <sl.h>␊
31␊
32static ClientInterfacePtr gCIPtr;␊
33␊
34long InitCI(ClientInterfacePtr ciPtr)␊
35{␊
36 gCIPtr = ciPtr;␊
37 ␊
38 return 0;␊
39}␊
40␊
41long CallCI(CIArgs *ciArgsPtr)␊
42{␊
43 long ret;␊
44 ␊
45 ret = (*gCIPtr)(ciArgsPtr);␊
46 return ret;␊
47}␊
48␊
49␊
50// Device Tree␊
51␊
52// Peer take a phandle and returns the next peer.␊
53// It returns zero of there are no more peers.␊
54CICell Peer(CICell phandle)␊
55{␊
56 CIArgs ciArgs;␊
57 CICell peer_ph;␊
58 long ret;␊
59 ␊
60 ciArgs.service = "peer";␊
61 ciArgs.nArgs = 1;␊
62 ciArgs.nReturns = 1;␊
63 ciArgs.args.peer.phandle = phandle;␊
64 ␊
65 ret = CallCI(&ciArgs);␊
66 if (ret != 0) return kCIError;␊
67 ␊
68 peer_ph = ciArgs.args.peer.peerPhandle;␊
69 ␊
70 return peer_ph;␊
71}␊
72␊
73// Child take a phandle and returns the first child.␊
74// It returns zero of there in no child.␊
75CICell Child(CICell phandle)␊
76{␊
77 CIArgs ciArgs;␊
78 CICell child_ph;␊
79 long ret;␊
80 ␊
81 ciArgs.service = "child";␊
82 ciArgs.nArgs = 1;␊
83 ciArgs.nReturns = 1;␊
84 ciArgs.args.child.phandle = phandle;␊
85 ␊
86 ret = CallCI(&ciArgs);␊
87 if (ret != 0) return kCIError;␊
88 ␊
89 child_ph = ciArgs.args.child.childPhandle;␊
90 ␊
91 return child_ph;␊
92}␊
93␊
94// Parent take a phandle and returns the parent node.␊
95// It returns zero of if the phandle is the root node.␊
96CICell Parent(CICell phandle)␊
97{␊
98 CIArgs ciArgs;␊
99 CICell parent_ph;␊
100 long ret;␊
101 ␊
102 ciArgs.service = "parent";␊
103 ciArgs.nArgs = 1;␊
104 ciArgs.nReturns = 1;␊
105 ciArgs.args.parent.childPhandle = phandle;␊
106 ␊
107 ret = CallCI(&ciArgs);␊
108 if (ret != 0) return kCIError;␊
109 ␊
110 parent_ph = ciArgs.args.parent.parentPhandle;␊
111 ␊
112 return parent_ph;␊
113}␊
114␊
115// FindDevice take a device spec and returns the phandle.␊
116// It returns zero of if the device was not found.␊
117CICell FindDevice(char *devSpec)␊
118{␊
119 CIArgs ciArgs;␊
120 CICell phandle;␊
121 long ret;␊
122 ␊
123 ciArgs.service = "finddevice";␊
124 ciArgs.nArgs = 1;␊
125 ciArgs.nReturns = 1;␊
126 ciArgs.args.finddevice.devSpec = devSpec;␊
127 ␊
128 ret = CallCI(&ciArgs);␊
129 if (ret != 0) return kCIError;␊
130 ␊
131 phandle = ciArgs.args.finddevice.phandle;␊
132 ␊
133 return phandle;␊
134}␊
135␊
136// InstanceToPath take an ihandle, buf and buflen. Set the device path␊
137// to the package in buf upto buflen characters and returns the length␊
138// Length will be -1 if the ihandle is invalid.␊
139CICell InstanceToPath(CICell ihandle, char *buf, long buflen)␊
140{␊
141 CIArgs ciArgs;␊
142 CICell length;␊
143 long ret;␊
144 ␊
145 ciArgs.service = "instance-to-path";␊
146 ciArgs.nArgs = 3;␊
147 ciArgs.nReturns = 1;␊
148 ciArgs.args.instanceToPath.ihandle = ihandle;␊
149 ciArgs.args.instanceToPath.buf = buf;␊
150 ciArgs.args.instanceToPath.buflen = buflen;␊
151 ␊
152 ret = CallCI(&ciArgs);␊
153 if (ret != 0) return kCIError;␊
154 ␊
155 length = ciArgs.args.instanceToPath.length;␊
156 ␊
157 return length;␊
158}␊
159␊
160// InstanceToPackage take an ihandle and returns the phandle for it.␊
161// returns -1 if the phandle can't be found.␊
162CICell InstanceToPackage(CICell ihandle)␊
163{␊
164 CIArgs ciArgs;␊
165 CICell phandle;␊
166 long ret;␊
167 ␊
168 ciArgs.service = "instance-to-package";␊
169 ciArgs.nArgs = 1;␊
170 ciArgs.nReturns = 1;␊
171 ciArgs.args.instanceToPackage.ihandle = ihandle;␊
172 ␊
173 ret = CallCI(&ciArgs);␊
174 if (ret != 0) return kCIError;␊
175 ␊
176 phandle = ciArgs.args.instanceToPackage.phandle;␊
177 ␊
178 return phandle;␊
179}␊
180␊
181// InstanceToPackages␊
182␊
183// PackageToPath take a phandle, buf and buflen. Set the device path␊
184// to the package in buf upto buflen characters and returns the length␊
185// Length will be -1 if the phandle is invalid.␊
186CICell PackageToPath(CICell phandle, char *buf, long buflen)␊
187{␊
188 CIArgs ciArgs;␊
189 CICell length;␊
190 long ret;␊
191 ␊
192 if (gOFVersion >= kOFVersion2x) {␊
193 ciArgs.service = "package-to-path";␊
194 ciArgs.nArgs = 3;␊
195 ciArgs.nReturns = 1;␊
196 ciArgs.args.packageToPath.phandle = phandle;␊
197 ciArgs.args.packageToPath.buf = buf;␊
198 ciArgs.args.packageToPath.buflen = buflen;␊
199 ␊
200 ret = CallCI(&ciArgs);␊
201 if (ret != 0) return kCIError;␊
202 ␊
203 length = ciArgs.args.packageToPath.length;␊
204 } else {␊
205 ret = CallMethod(3, 1, SLWordsIH, "slw_pwd", phandle,␊
206␉␉ (CICell)buf, buflen, &length);␊
207 if (ret != 0) return kCIError;␊
208 ␊
209 buf[length] = '\0';␊
210 }␊
211 ␊
212 return length;␊
213}␊
214␊
215// Canon␊
216␊
217// GetPropLen takes a phandle and prop name␊
218// and returns the size of the property␊
219// or -1 if the property is not valid.␊
220CICell GetPropLen(CICell phandle, char *name)␊
221{␊
222 CIArgs ciArgs;␊
223 CICell size;␊
224 long ret;␊
225 ␊
226 ciArgs.service = "getproplen";␊
227 ciArgs.nArgs = 2;␊
228 ciArgs.nReturns = 1;␊
229 ciArgs.args.getproplen.phandle = phandle;␊
230 ciArgs.args.getproplen.name = name;␊
231 ␊
232 ret = CallCI(&ciArgs);␊
233 if (ret != 0) return kCIError;␊
234 ␊
235 size = ciArgs.args.getproplen.size;␊
236 ␊
237 return size;␊
238}␊
239␊
240// GetProp takes a phandle, prop name, buffer and length␊
241// and copied the property value in to the buffer.␊
242// returns -1 if the property is not valid.␊
243CICell GetProp(CICell phandle, char *name, char *buf, long buflen)␊
244{␊
245 CIArgs ciArgs;␊
246 CICell size;␊
247 long ret;␊
248 ␊
249 ciArgs.service = "getprop";␊
250 ciArgs.nArgs = 4;␊
251 ciArgs.nReturns = 1;␊
252 ciArgs.args.getprop.phandle = phandle;␊
253 ciArgs.args.getprop.name = name;␊
254 ciArgs.args.getprop.buf = buf;␊
255 ciArgs.args.getprop.buflen = buflen;␊
256 ␊
257 ret = CallCI(&ciArgs);␊
258 if (ret != 0) return kCIError;␊
259 ␊
260 size = ciArgs.args.getprop.size;␊
261 ␊
262 return size;␊
263}␊
264␊
265// NextProp takes a phandle, prev name, and a buffer␊
266// and copied the next property name in to the buffer.␊
267// returns -1 if the property is not valid.␊
268// returns 0 if the prev was the last property.␊
269// returns 1 otherwise.␊
270CICell NextProp(CICell phandle, char *previous, char *buf)␊
271{␊
272 CIArgs ciArgs;␊
273 CICell flag;␊
274 long ret;␊
275 ␊
276 ciArgs.service = "nextprop";␊
277 ciArgs.nArgs = 3;␊
278 ciArgs.nReturns = 1;␊
279 ciArgs.args.nextprop.phandle = phandle;␊
280 ciArgs.args.nextprop.previous = previous;␊
281 ciArgs.args.nextprop.buf = buf;␊
282 ␊
283 ret = CallCI(&ciArgs);␊
284 if (ret != 0) return kCIError;␊
285 ␊
286 flag = ciArgs.args.nextprop.flag;␊
287 ␊
288 return flag;␊
289}␊
290␊
291// SetProp takes a phandle, prop name, buffer and length␊
292// and copied the buffer in to the property value.␊
293// returns -1 if the property could not be set or created.␊
294CICell SetProp(CICell phandle, char *name, char *buf, long buflen)␊
295{␊
296 CIArgs ciArgs;␊
297 CICell size;␊
298 long ret;␊
299 ␊
300 ciArgs.service = "setprop";␊
301 ciArgs.nArgs = 4;␊
302 ciArgs.nReturns = 1;␊
303 ciArgs.args.setprop.phandle = phandle;␊
304 ciArgs.args.setprop.name = name;␊
305 ciArgs.args.setprop.buf = buf;␊
306 ciArgs.args.setprop.buflen = buflen;␊
307 ␊
308 ret = CallCI(&ciArgs);␊
309 if (ret != 0) return kCIError;␊
310 ␊
311 size = ciArgs.args.setprop.size;␊
312 ␊
313 return size;␊
314}␊
315␊
316␊
317// Device I/O␊
318␊
319// Open takes a device specifier and returns an iHandle␊
320// It returns zero if the device can not be found or opened.␊
321CICell Open(char *devSpec)␊
322{␊
323 CIArgs ciArgs;␊
324 CICell ihandle;␊
325 long ret;␊
326 ␊
327 ciArgs.service = "open";␊
328 ciArgs.nArgs = 1;␊
329 ciArgs.nReturns = 1;␊
330 ciArgs.args.open.devSpec = devSpec;␊
331 ␊
332 ret = CallCI(&ciArgs);␊
333 if (ret != 0) return 0;␊
334 ␊
335 ihandle = ciArgs.args.open.ihandle;␊
336 ␊
337 return ihandle;␊
338}␊
339␊
340// Close takes an iHandle and closes the device.␊
341void Close(CICell ihandle)␊
342{␊
343 CIArgs ciArgs;␊
344 ␊
345 ciArgs.service = "close";␊
346 ciArgs.nArgs = 1;␊
347 ciArgs.nReturns = 0;␊
348 ciArgs.args.close.ihandle = ihandle;␊
349 ␊
350 CallCI(&ciArgs);␊
351}␊
352␊
353// Read takes an iHandle, an address and a length and return the actual␊
354// Length read. Returns -1 if the operaction failed.␊
355CICell Read(CICell ihandle, long addr, long length)␊
356{␊
357 CIArgs ciArgs;␊
358 long actual;␊
359 long ret;␊
360 ␊
361 ciArgs.service = "read";␊
362 ciArgs.nArgs = 3;␊
363 ciArgs.nReturns = 1;␊
364 ciArgs.args.read.ihandle = ihandle;␊
365 ciArgs.args.read.addr = addr;␊
366 ciArgs.args.read.length = length;␊
367 ␊
368 ret = CallCI(&ciArgs);␊
369 if (ret != 0) return kCIError;␊
370 ␊
371 actual = ciArgs.args.read.actual;␊
372 ␊
373 // Spin the wait cursor.␊
374 Spin();␊
375 ␊
376 return actual;␊
377}␊
378␊
379// Write takes an iHandle, an address and a length and return the actual␊
380// Length written. Returns -1 if the operaction failed.␊
381CICell Write(CICell ihandle, long addr, long length)␊
382{␊
383 CIArgs ciArgs;␊
384 long actual;␊
385 long ret;␊
386 ␊
387 ciArgs.service = "write";␊
388 ciArgs.nArgs = 3;␊
389 ciArgs.nReturns = 1;␊
390 ciArgs.args.write.ihandle = ihandle;␊
391 ciArgs.args.write.addr = addr;␊
392 ciArgs.args.write.length = length;␊
393 ␊
394 ret = CallCI(&ciArgs);␊
395 if (ret != 0) return kCIError;␊
396 ␊
397 actual = ciArgs.args.write.actual;␊
398 ␊
399 return actual;␊
400}␊
401␊
402// Seek takes an iHandle, and a 64 bit position␊
403// and moves to that address in file.␊
404// returns seeks result, or -1 if seek is not supported.␊
405CICell Seek(CICell ihandle, long long position)␊
406{␊
407 CIArgs ciArgs;␊
408 long ret;␊
409 ␊
410 ciArgs.service = "seek";␊
411 ciArgs.nArgs = 3;␊
412 ciArgs.nReturns = 1;␊
413 ciArgs.args.seek.ihandle = ihandle;␊
414 ciArgs.args.seek.pos_high = position >> 32;␊
415 ciArgs.args.seek.pos_low = position & 0x00000000FFFFFFFFULL;␊
416 ␊
417 ret = CallCI(&ciArgs);␊
418 if (ret != 0) return kCIError;␊
419 ␊
420 ret = ciArgs.args.seek.result;␊
421 ␊
422 return ret;␊
423}␊
424␊
425␊
426// Other Device Method Invocation␊
427␊
428// Call the specified method on the given iHandle with the listed arguments.␊
429long CallMethod(long args, long rets, CICell iHandle, const char *method, ...)␊
430{␊
431 va_list argList;␊
432 CIArgs ciArgs;␊
433 long ret, cnt, error = kCINoError;␊
434 ␊
435 va_start(argList, method);␊
436 ␊
437 ciArgs.service = "call-method";␊
438 ciArgs.nArgs = args + 2;␊
439 ciArgs.nReturns = rets + 1;␊
440 ciArgs.args.callMethod.iHandle = iHandle;␊
441 ciArgs.args.callMethod.method = method;␊
442 ␊
443 for (cnt = 0; cnt < args; cnt++) {␊
444 ciArgs.args.callMethod.cells[args - cnt - 1] = va_arg(argList, CICell);␊
445 }␊
446 ␊
447 ret = CallCI(&ciArgs);␊
448 if (ret != 0) error = kCIError;␊
449 else if (ciArgs.args.callMethod.cells[args] != 0) error = kCICatch;␊
450 ␊
451 if (error == kCINoError) {␊
452 for (cnt = 0; cnt < rets; cnt++) {␊
453 *(va_arg(argList, CICell *)) =␊
454␉ciArgs.args.callMethod.cells[args + rets - cnt];␊
455 }␊
456 }␊
457 ␊
458 va_end(argList);␊
459 ␊
460 return error;␊
461}␊
462␊
463␊
464// Memory␊
465␊
466// Claim takes a virt address, a size, and an alignment.␊
467// It return baseaddr or -1 for claim failed.␊
468CICell Claim(CICell virt, CICell size, CICell align)␊
469{␊
470 CIArgs ciArgs;␊
471 CICell baseaddr;␊
472 long ret;␊
473␊
474 if (gOFVersion >= kOFVersion2x) {␊
475 // Claim actually works, so use it.␊
476 ciArgs.service = "claim";␊
477 ciArgs.nArgs = 3;␊
478 ciArgs.nReturns = 1;␊
479 ciArgs.args.claim.virt = virt;␊
480 ciArgs.args.claim.size = size;␊
481 ciArgs.args.claim.align = align;␊
482 ␊
483 ret = CallCI(&ciArgs);␊
484 if (ret != 0) return kCIError;␊
485 ␊
486 baseaddr = ciArgs.args.claim.baseaddr;␊
487 } else {␊
488 // Claim does not work. Do it by hand.␊
489 if ((gMMUIH == 0) || (gMMUIH == 0)) return kCIError;␊
490 ␊
491 // Get the physical memory␊
492 ret = CallMethod(3, 1, gMemoryIH, "claim", virt, size, 0, &baseaddr);␊
493 if ((ret != kCINoError) || (virt != baseaddr)) return kCIError;␊
494 ␊
495 // Get the logical memory␊
496 ret = CallMethod(3, 1, gMMUIH, "claim", virt, size, 0, &baseaddr);␊
497 if ((ret != kCINoError) || (virt != baseaddr)) return kCIError;␊
498 ␊
499 // Map them together.␊
500 ret = CallMethod(4, 0, gMMUIH, "map", virt, virt, size, 0);␊
501 if (ret != kCINoError) return kCIError;␊
502 }␊
503 ␊
504 return baseaddr;␊
505}␊
506␊
507// Release takes a virt address, a size␊
508void Release(CICell virt, CICell size)␊
509{␊
510 CIArgs ciArgs;␊
511 ␊
512 ciArgs.service = "release";␊
513 ciArgs.nArgs = 2;␊
514 ciArgs.nReturns = 0;␊
515 ciArgs.args.claim.virt = virt;␊
516 ciArgs.args.claim.size = size;␊
517 ␊
518 CallCI(&ciArgs);␊
519}␊
520␊
521␊
522// Control Transfer␊
523␊
524// Boot trys to boot the bootspec␊
525void Boot(char *bootspec)␊
526{␊
527 CIArgs ciArgs;␊
528 ␊
529 ciArgs.service = "boot";␊
530 ciArgs.nArgs = 1;␊
531 ciArgs.nReturns = 0;␊
532 ciArgs.args.boot.bootspec = bootspec;␊
533 ␊
534 CallCI(&ciArgs);␊
535}␊
536␊
537// Enter the user interface.␊
538// Executing the 'go' command returns to the client.␊
539void Enter(void)␊
540{␊
541 CIArgs ciArgs;␊
542 ␊
543 ciArgs.service = "enter";␊
544 ciArgs.nArgs = 0;␊
545 ciArgs.nReturns = 0;␊
546 ␊
547 CallCI(&ciArgs);␊
548}␊
549␊
550// Exit the client program.␊
551void Exit(void)␊
552{␊
553 CIArgs ciArgs;␊
554 ␊
555 ciArgs.service = "exit";␊
556 ciArgs.nArgs = 0;␊
557 ciArgs.nReturns = 0;␊
558 ␊
559 CallCI(&ciArgs);␊
560}␊
561␊
562// Clain␊
563␊
564// Quiesce stops any async tasks in Open Firmware.␊
565void Quiesce(void)␊
566{␊
567 CIArgs ciArgs;␊
568 ␊
569 ciArgs.service = "quiesce";␊
570 ciArgs.nArgs = 0;␊
571 ciArgs.nReturns = 0;␊
572 ␊
573 CallCI(&ciArgs);␊
574}␊
575␊
576␊
577// User Interface␊
578␊
579// Interpret the given forth string with the listed arguments.␊
580long Interpret(long args, long rets, const char *forthString, ...)␊
581{␊
582 va_list argList;␊
583 CIArgs ciArgs;␊
584 long ret, cnt, error = kCINoError;␊
585 ␊
586 va_start(argList, forthString);␊
587 ␊
588 ciArgs.service = "interpret";␊
589 ciArgs.nArgs = args + 1;␊
590 ciArgs.nReturns = rets + 1;␊
591 ciArgs.args.interpret.forth = forthString;␊
592 ␊
593 for (cnt = 0; cnt < args; cnt++) {␊
594 ciArgs.args.interpret.cells[args - cnt - 1] = va_arg(argList, CICell);␊
595 }␊
596 ␊
597 ret = CallCI(&ciArgs);␊
598 if (ret != 0) error = kCIError;␊
599 else if (ciArgs.args.interpret.cells[args] != 0) error = kCICatch;␊
600 ␊
601 if (error == kCINoError) {␊
602 for (cnt = 0; cnt < rets; cnt++) {␊
603 *(va_arg(argList, CICell *)) =␊
604␉ciArgs.args.interpret.cells[args + rets - cnt];␊
605 }␊
606 }␊
607 ␊
608 va_end(argList);␊
609 ␊
610 return error;␊
611}␊
612

Archive Download this file

Revision: 1317