Return to fakePPCDeviceTree.c CVS log

Up to [Apple XNU] / XNU / pexpert / i386

Annotation of XNU/pexpert/i386/fakePPCDeviceTree.c, revision 1.1.1.1

1.1       root        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: #include <pexpert/protos.h>
                     24: 
                     25: #include "fakePPCStructs.h"
                     26: 
                     27: void PE_pause(int);
                     28: 
                     29: boot_args fakePPCBootArgs = {
                     30:        0, // Revision
                     31:         kBootArgsVersion, // Version
                     32:         "",     // CommandLine
                     33:         0,      // PhysicalDRAM
                     34:         0,      // machine_type
                     35:         0,      // deviceTreeP
                     36:         0,      // deviceTreeLength
                     37:         0,      // topOfKernelData
                     38: };
                     39: 
                     40: void * createdt(dt_init *template, long *retSize)
                     41: {
                     42:     dt_init *  next;
                     43:     int        size, allocSize;
                     44:     vm_address_t out, saveout;
                     45:     void *     source;
                     46:     
                     47:     // calc size of expanded data
                     48:     for( next = template, allocSize = 0;
                     49:        next;
                     50:        next++) {
                     51: 
                     52:        if( next->nodeInit.zero == 0) {
                     53:            if( next->nodeInit.nProps == 0)
                     54:                break;
                     55:            allocSize += 2 * sizeof( long);
                     56:        } else
                     57:            allocSize += (32 + 4 + 3 + next->propInit.length) & (-4);
                     58:     }
                     59:     saveout = out = kalloc( allocSize);
                     60: 
                     61:     // copy out
                     62:     for( next = template;
                     63:        next;
                     64:        next++) {
                     65: 
                     66:        if( next->nodeInit.zero == 0) {
                     67: 
                     68:            if( next->nodeInit.nProps == 0)
                     69:                break;
                     70:            source = &next->nodeInit.nProps;
                     71:            size = 2 * sizeof( long);
                     72: 
                     73:        } else {
                     74: 
                     75:            bcopy( next->propInit.name, out, 32);
                     76:            out += 32;
                     77:            size = next->propInit.length;
                     78:            *(long *)out = size;
                     79:            out += sizeof( long);
                     80:            if( size == 4)
                     81:                source = &next->propInit.value;
                     82:            else {
                     83:                source = next->propInit.value;
                     84:                size = (size + 3) & (-4);
                     85:            }
                     86:        }
                     87:         bcopy( source, out, size);
                     88:        out += size;
                     89:     }
                     90: 
                     91:     if( allocSize != (out - saveout))
                     92:         printf("WARNING: DT corrupt (%x)\n", (out - saveout) - allocSize);
                     93: 
                     94:     *retSize = allocSize;
                     95:     return( (void *)saveout);
                     96: }
                     97: 
                     98: unsigned char *nptr;
                     99: 
                    100: #define kPropNameLength 32
                    101: 
                    102: typedef struct property_t {
                    103:     char                name[kPropNameLength];  // NUL terminated property name
                    104:     unsigned long       length;         // Length (bytes) of folloing prop value
                    105:     unsigned long       *value;         // Variable length value of property
                    106: } property_t;
                    107: 
                    108: typedef struct node_t {
                    109:     unsigned long       nProperties;    // Number of props[] elements (0 => end)
                    110:     unsigned long       nChildren;      // Number of children[] elements
                    111:     property_t *props;      // array size == nProperties
                    112:     struct node_t   *children;     // array size == nChildren
                    113: } node_t;
                    114: 
                    115: 
                    116: int indent = 0;
                    117: 
                    118: void printdt()
                    119: {
                    120:     node_t *nodeptr = (node_t *)nptr;
                    121:     long num_props    = nodeptr->nProperties;
                    122:     long len;
                    123:     int i, j;
                    124:     unsigned char *sptr;
                    125: 
                    126:     nptr = (unsigned char *)&nodeptr->props;
                    127:     for (i=0; i < num_props; i++)
                    128:     {
                    129:         for (j = 0; j < indent; j++)
                    130:             printf("    ");
                    131:         printf("'");
                    132:         printf("%s", nptr);
                    133:         nptr+=32;
                    134:         len = *((long*)nptr);
                    135:         nptr += 4;
                    136:         printf("'\t\t(%ld)  '", len);
                    137:         sptr = nptr;
                    138:         for (j = 0; j < len; j++)
                    139:             printf("%2.2x", *nptr++);
                    140:         printf("'\t('%s')\n", sptr);
                    141:         if (len % 4)
                    142:             nptr += (4 - (len % 4));
                    143:        PE_pause(20);
                    144:     }
                    145:     for (i=0; i<nodeptr->nChildren; i++)
                    146:     {
                    147:         indent++;
                    148:         printdt();
                    149:         indent--;
                    150:     }
                    151: }
                    152: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.