Return to of1275.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / utils / ofclient

Annotation of qemu/roms/openbios/utils/ofclient/of1275.c, revision 1.1

1.1     ! root        1: 
        !             2: #include "of1275.h"
        !             3: #include "endian.h"
        !             4: static int (*of1275_server) (void *) = (int (*)(void *)) -1;
        !             5: 
        !             6: _start(void *residual_data_structure,
        !             7:        void *program_entry_point,
        !             8:        int (*client_interface_handler) (void *), void *args, int argslen)
        !             9: {
        !            10:        int status;
        !            11:        of1275_server = client_interface_handler;
        !            12:        status = main();
        !            13:        of1275_exit(status);
        !            14: }
        !            15: 
        !            16: /* 6.3.2.1 Client interface */
        !            17: 
        !            18: 
        !            19: int of1275_test(const char *name, int *missing)
        !            20: {
        !            21:        int result;
        !            22:        static of1275_test_service s;
        !            23:        s.service = "test";
        !            24:        s.n_args = 1;
        !            25:        s.n_returns = 1;
        !            26:        s.name = name;
        !            27:        result = of1275_server(&s);
        !            28:        *missing = s.missing;
        !            29:        return result;
        !            30: }
        !            31: 
        !            32: 
        !            33: /* 6.3.2.2 Device tree */
        !            34: 
        !            35: 
        !            36: int of1275_peer(int phandle, int *sibling_phandle)
        !            37: {
        !            38:        int result;
        !            39:        static of1275_peer_service s;
        !            40:        s.service = "peer";
        !            41:        s.n_args = 1;
        !            42:        s.n_returns = 1;
        !            43:        s.phandle = phandle;
        !            44:        result = of1275_server(&s);
        !            45:        *sibling_phandle = s.sibling_phandle;
        !            46:        return result;
        !            47: }
        !            48: 
        !            49: int of1275_child(int phandle, int *child_phandle)
        !            50: {
        !            51:        int result;
        !            52:        static of1275_child_service s;
        !            53:        s.service = "child";
        !            54:        s.n_args = 1;
        !            55:        s.n_returns = 1;
        !            56:        s.phandle = phandle;
        !            57:        result = of1275_server(&s);
        !            58:        *child_phandle = s.child_phandle;
        !            59:        return result;
        !            60: }
        !            61: 
        !            62: int of1275_parent(int phandle, int *parent_phandle)
        !            63: {
        !            64:        int result;
        !            65:        static of1275_parent_service s;
        !            66:        s.service = "parent";
        !            67:        s.n_args = 1;
        !            68:        s.n_returns = 1;
        !            69:        s.phandle = phandle;
        !            70:        result = of1275_server(&s);
        !            71:        *parent_phandle = s.parent_phandle;
        !            72:        return result;
        !            73: }
        !            74: 
        !            75: int of1275_instance_to_package(int ihandle, int *phandle)
        !            76: {
        !            77:        int result;
        !            78:        static of1275_instance_to_package_service s;
        !            79:        s.service = "instance-to-package";
        !            80:        s.n_args = 1;
        !            81:        s.n_returns = 1;
        !            82:        s.ihandle = ihandle;
        !            83:        result = of1275_server(&s);
        !            84:        *phandle = s.phandle;
        !            85:        return result;
        !            86: }
        !            87: 
        !            88: int of1275_getproplen(int phandle, const char *name, int *proplen)
        !            89: {
        !            90:        int result;
        !            91:        static of1275_getproplen_service s;
        !            92:        s.service = "getproplen";
        !            93:        s.n_args = 2;
        !            94:        s.n_returns = 1;
        !            95:        s.phandle = phandle;
        !            96:        s.name = name;
        !            97:        result = of1275_server(&s);
        !            98:        *proplen = s.proplen;
        !            99:        return result;
        !           100: }
        !           101: 
        !           102: int
        !           103: of1275_getprop(int phandle, const char *name, void *buf, int buflen,
        !           104:               int *size)
        !           105: {
        !           106:        int result;
        !           107:        static of1275_getprop_service s;
        !           108:        s.service = "getprop";
        !           109:        s.n_args = 4;
        !           110:        s.n_returns = 1;
        !           111:        s.phandle = phandle;
        !           112:        s.name = name;
        !           113:        s.buf = buf;
        !           114:        s.buflen = buflen;
        !           115:        result = of1275_server(&s);
        !           116:        *size = s.size;
        !           117:        return result;
        !           118: }
        !           119: 
        !           120: int
        !           121: of1275_nextprop(int phandle, const char *previous, void *buf, int *flag)
        !           122: {
        !           123:        int result;
        !           124:        static of1275_nextprop_service s;
        !           125:        s.service = "nextprop";
        !           126:        s.n_args = 3;
        !           127:        s.n_returns = 1;
        !           128:        s.phandle = phandle;
        !           129:        s.previous = previous;
        !           130:        s.buf = buf;
        !           131:        result = of1275_server(&s);
        !           132:        *flag = s.flag;
        !           133:        return result;
        !           134: }
        !           135: 
        !           136: int
        !           137: of1275_setprop(int phandle, const char *name, void *buf, int len,
        !           138:               int *size)
        !           139: {
        !           140:        int result;
        !           141:        static of1275_setprop_service s;
        !           142:        s.service = "setprop";
        !           143:        s.n_args = 4;
        !           144:        s.n_returns = 1;
        !           145:        s.phandle = phandle;
        !           146:        s.name = name;
        !           147:        s.buf = buf;
        !           148:        s.len = len;
        !           149:        result = of1275_server(&s);
        !           150:        *size = s.size;
        !           151:        return result;
        !           152: }
        !           153: 
        !           154: int
        !           155: of1275_canon(const char *device_specifier, void *buf, int buflen,
        !           156:             int *length)
        !           157: {
        !           158:        int result;
        !           159:        static of1275_canon_service s;
        !           160:        s.service = "canon";
        !           161:        s.n_args = 3;
        !           162:        s.n_returns = 1;
        !           163:        s.device_specifier = device_specifier;
        !           164:        s.buf = buf;
        !           165:        s.buflen = buflen;
        !           166:        result = of1275_server(&s);
        !           167:        *length = s.length;
        !           168:        return result;
        !           169: }
        !           170: 
        !           171: int of1275_finddevice(const char *device_specifier, int *phandle)
        !           172: {
        !           173:        int result;
        !           174:        static of1275_finddevice_service s;
        !           175:        s.service = "finddevice";
        !           176:        s.n_args = 1;
        !           177:        s.n_returns = 1;
        !           178:        s.device_specifier = device_specifier;
        !           179:        result = of1275_server(&s);
        !           180:        *phandle = s.phandle;
        !           181:        return result;
        !           182: }
        !           183: 
        !           184: int
        !           185: of1275_instance_to_path(int ihandle, void *buf, int buflen, int *length)
        !           186: {
        !           187:        int result;
        !           188:        static of1275_instance_to_path_service s;
        !           189:        s.service = "instance-to-path";
        !           190:        s.n_args = 3;
        !           191:        s.n_returns = 1;
        !           192:        s.ihandle = ihandle;
        !           193:        s.buf = buf;
        !           194:        s.buflen = buflen;
        !           195:        result = of1275_server(&s);
        !           196:        *length = s.length;
        !           197:        return result;
        !           198: }
        !           199: 
        !           200: int of1275_package_to_path(int phandle, void *buf, int buflen, int *length)
        !           201: {
        !           202:        int result;
        !           203:        static of1275_package_to_path_service s;
        !           204:        s.service = "package-to-path";
        !           205:        s.n_args = 3;
        !           206:        s.n_returns = 1;
        !           207:        s.phandle = phandle;
        !           208:        s.buf = buf;
        !           209:        s.buflen = buflen;
        !           210:        result = of1275_server(&s);
        !           211:        *length = s.length;
        !           212:        return result;
        !           213: }
        !           214: 
        !           215: /* int of1275_call_method(const char *method, int ihandle, ...); */
        !           216: 
        !           217: 
        !           218: /* 6.3.2.3 Device I/O */
        !           219: 
        !           220: 
        !           221: int of1275_open(const char *device_specifier, int *ihandle)
        !           222: {
        !           223:        int result;
        !           224:        static of1275_open_service s;
        !           225:        s.service = "open";
        !           226:        s.n_args = 1;
        !           227:        s.n_returns = 1;
        !           228:        s.device_specifier = device_specifier;
        !           229:        result = of1275_server(&s);
        !           230:        *ihandle = s.ihandle;
        !           231:        return result;
        !           232: }
        !           233: 
        !           234: int of1275_close(int ihandle)
        !           235: {
        !           236:        int result;
        !           237:        static of1275_close_service s;
        !           238:        s.service = "close";
        !           239:        s.n_args = 1;
        !           240:        s.n_returns = 0;
        !           241:        s.ihandle = ihandle;
        !           242:        result = of1275_server(&s);
        !           243:        return result;
        !           244: }
        !           245: 
        !           246: int of1275_read(int ihandle, void *addr, int len, int *actual)
        !           247: {
        !           248:        int result;
        !           249:        static of1275_read_service s;
        !           250:        s.service = "read";
        !           251:        s.n_args = 3;
        !           252:        s.n_returns = 1;
        !           253:        s.ihandle = ihandle;
        !           254:        s.addr = addr;
        !           255:        s.len = len;
        !           256:        result = of1275_server(&s);
        !           257:        *actual = s.actual;
        !           258:        return result;
        !           259: }
        !           260: 
        !           261: int of1275_write(int ihandle, void *addr, int len, int *actual)
        !           262: {
        !           263:        int result;
        !           264:        static of1275_write_service s;
        !           265:        s.service = "write";
        !           266:        s.n_args = 3;
        !           267:        s.n_returns = 1;
        !           268:        s.ihandle = ihandle;
        !           269:        s.addr = addr;
        !           270:        s.len = len;
        !           271:        result = of1275_server(&s);
        !           272:        *actual = s.actual;
        !           273:        return result;
        !           274: }
        !           275: 
        !           276: int of1275_seek(int ihandle, int pos_hi, int pos_lo, int *status)
        !           277: {
        !           278:        int result;
        !           279:        static of1275_seek_service s;
        !           280:        s.service = "seek";
        !           281:        s.n_args = 3;
        !           282:        s.n_returns = 1;
        !           283:        s.ihandle = ihandle;
        !           284:        s.pos_hi = pos_hi;
        !           285:        s.pos_lo = pos_lo;
        !           286:        result = of1275_server(&s);
        !           287:        *status = s.status;
        !           288:        return result;
        !           289: }
        !           290: 
        !           291: 
        !           292: /* 6.3.2.4 Memory */
        !           293: 
        !           294: 
        !           295: int of1275_claim(void *virt, int size, int align, void **baseaddr)
        !           296: {
        !           297:        int result;
        !           298:        static of1275_claim_service s;
        !           299:        s.service = "claim";
        !           300:        s.n_args = 3;
        !           301:        s.n_returns = 1;
        !           302:        s.virt = virt;
        !           303:        s.size = size;
        !           304:        s.align = align;
        !           305:        result = of1275_server(&s);
        !           306:        *baseaddr = s.baseaddr;
        !           307:        return result;
        !           308: }
        !           309: 
        !           310: int of1275_release(void *virt, int size)
        !           311: {
        !           312:        int result;
        !           313:        static of1275_release_service s;
        !           314:        s.service = "release";
        !           315:        s.n_args = 2;
        !           316:        s.n_returns = 0;
        !           317:        s.virt = virt;
        !           318:        s.size = size;
        !           319:        result = of1275_server(&s);
        !           320:        return result;
        !           321: }
        !           322: 
        !           323: 
        !           324: /* 6.3.2.5 Control transfer */
        !           325: 
        !           326: 
        !           327: int of1275_boot(const char *bootspec)
        !           328: {
        !           329:        int result;
        !           330:        static of1275_boot_service s;
        !           331:        s.service = "boot";
        !           332:        s.n_args = 1;
        !           333:        s.n_returns = 0;
        !           334:        s.bootspec = bootspec;
        !           335:        result = of1275_server(&s);
        !           336:        return result;
        !           337: }
        !           338: 
        !           339: int of1275_enter(void)
        !           340: {
        !           341:        int result;
        !           342:        static of1275_enter_service s;
        !           343:        s.service = "enter";
        !           344:        s.n_args = 0;
        !           345:        s.n_returns = 0;
        !           346:        result = of1275_server(&s);
        !           347:        return result;
        !           348: }
        !           349: 
        !           350: int of1275_exit(int status)
        !           351: {
        !           352:        int result;
        !           353:        static of1275_exit_service s;
        !           354:        s.service = "exit";
        !           355:        s.n_args = 1;
        !           356:        s.n_returns = 0;
        !           357:        s.status = status;
        !           358:        result = of1275_server(&s);
        !           359:        return result;
        !           360: }
        !           361: 
        !           362: /* int of1275_chain(void *virt, int size, void *entry, void *args, int len); */
        !           363: 
        !           364: 
        !           365: /* 6.3.2.6 User interface */
        !           366: 
        !           367: 
        !           368: /* int of1275_interpret(const char *arg, ...); */
        !           369: 
        !           370: int of1275_set_callback(void *newfunc, void **oldfunc)
        !           371: {
        !           372:        int result;
        !           373:        static of1275_set_callback_service s;
        !           374:        s.service = "set-callback";
        !           375:        s.n_args = 1;
        !           376:        s.n_returns = 1;
        !           377:        s.newfunc = newfunc;
        !           378:        result = of1275_server(&s);
        !           379:        *oldfunc = s.oldfunc;
        !           380:        return result;
        !           381: }
        !           382: 
        !           383: int of1275_set_symbol_lookup(void *sym_to_value, void *value_to_sym)
        !           384: {
        !           385:        int result;
        !           386:        static of1275_set_symbol_lookup_service s;
        !           387:        s.service = "set-symbol-lookup";
        !           388:        s.n_args = 2;
        !           389:        s.n_returns = 0;
        !           390:        s.sym_to_value = sym_to_value;
        !           391:        s.value_to_sym = s.value_to_sym;
        !           392:        result = of1275_server(&s);
        !           393:        return result;
        !           394: }
        !           395: 
        !           396: 
        !           397: /* 6.3.2.7 Time */
        !           398: 
        !           399: int of1275_milliseconds(int *ms)
        !           400: {
        !           401:        int result;
        !           402:        static of1275_milliseconds_service s;
        !           403:        s.service = "milliseconds";
        !           404:        s.n_args = 0;
        !           405:        s.n_returns = 1;
        !           406:        result = of1275_server(&s);
        !           407:        *ms = s.ms;
        !           408:        return result;
        !           409: }
        !           410: 
        !           411: 
        !           412: int of_find_integer_property(const char *device, const char *property)
        !           413: {
        !           414:        int phandle;
        !           415:        int integer;
        !           416:        int size;
        !           417:        /* find the device's phandle */
        !           418:        if (of1275_finddevice(device, &phandle) < 0) {
        !           419:                //printk("of1275: no such device '%s'\n", device);
        !           420:                exit(1);
        !           421:        }
        !           422:        /* find the device's property */
        !           423:        of1275_getprop(phandle, property, &integer,
        !           424:                       sizeof(integer), &size);
        !           425:        if (size < sizeof(integer)) {
        !           426:                //printk("of1275: unknown integer property '%s'\n", property);
        !           427:                exit(1);
        !           428:        }
        !           429:        return ntohl(integer);
        !           430: }
        !           431: 
        !           432: void
        !           433: of_find_string_property(const char *device,
        !           434:                        const char *property,
        !           435:                        char *string, int sizeof_string)
        !           436: {
        !           437:        int phandle;
        !           438:        int size;
        !           439:        /* find the device's phandle */
        !           440:        if (of1275_finddevice(device, &phandle) < 0) {
        !           441:                //printk("of1275: no such device '%s'\n", device);
        !           442:                exit(1);
        !           443:        }
        !           444:        
        !           445:        /* find the device's property */
        !           446:        of1275_getprop(phandle, property, string, sizeof_string, &size);
        !           447:        if (size == 0 || size >= sizeof_string) {
        !           448:                //printk("of1275: unknown string property '%s'\n", property);
        !           449:                exit(1);
        !           450:        }
        !           451: }

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