Return to srec.c CVS log

Up to [local] / sys / arch / mvme88k / stand / sboot

Annotation of sys/arch/mvme88k/stand/sboot/srec.c, Revision 1.1

1.1     ! nbrk        1: /*     $OpenBSD: srec.c,v 1.3 2006/05/16 22:52:26 miod Exp $   */
        !             2:
        !             3: /*
        !             4:  * Public domain, believed to be by Mike Price.
        !             5:  *
        !             6:  * convert binary file to Srecord format
        !             7:  */
        !             8: #include <stdio.h>
        !             9: #include <ctype.h>
        !            10:
        !            11: int get32();
        !            12: void put32();
        !            13: void sput();
        !            14: void put();
        !            15: int checksum();
        !            16:
        !            17: int mask;
        !            18: int size;
        !            19:
        !            20: main(argc, argv)
        !            21:        int argc;
        !            22:        char *argv[];
        !            23: {
        !            24:        char buf[32];
        !            25:        int cc;
        !            26:        int base;
        !            27:        int addr;
        !            28:        char *name;
        !            29:
        !            30:        if (argc != 4) {
        !            31:                fprintf(stderr, "usage: %s {size} {hex_addr} {name}\n", argv[0]);
        !            32:                fprintf(stderr, "Size = 2, 3, or 4 byte address\n");
        !            33:                exit(1);
        !            34:        }
        !            35:        sscanf(argv[1], "%x", &size);
        !            36:        mask = (1 << (size * 8)) - 1;
        !            37:        if (!mask)
        !            38:                mask = (-1);
        !            39:        sscanf(argv[2], "%x", &base);
        !            40:        name = argv[3];
        !            41:
        !            42:        if (size == 2)
        !            43:                printf("S0%02X%04X", 2 + strlen(name) + 1, 0);
        !            44:        if (size == 3)
        !            45:                printf("S0%02X%06X", 3 + strlen(name) + 1, 0);
        !            46:        if (size == 4)
        !            47:                printf("S0%02X%08X", 4 + strlen(name) + 1, 0);
        !            48:        sput(name);
        !            49:        printf("%02X\n", checksum(0, name, strlen(name), size));
        !            50:
        !            51:        addr = base;
        !            52:        for (;;) {
        !            53:                cc = get32(buf);
        !            54:                if (cc > 0) {
        !            55:                        put32(cc, addr, buf, size, mask);
        !            56:                        addr += cc;
        !            57:                } else
        !            58:                        break;
        !            59:        }
        !            60:
        !            61:        buf[0] = base >> 8;
        !            62:        buf[1] = base;
        !            63:        printf("S%d%02X", 11 - size, 2 + 1);
        !            64:        switch (size) {
        !            65:        case 2:
        !            66:                printf("%04X", base & mask);
        !            67:                break;
        !            68:        case 3:
        !            69:                printf("%06X", base & mask);
        !            70:                break;
        !            71:        case 4:
        !            72:                printf("%08X", base & mask);
        !            73:                break;
        !            74:        }
        !            75:
        !            76:        /*
        !            77:         * kludge -> some sizes need an extra count (1 if size == 3, 2 if
        !            78:         * size == 4).  Don't ask why.
        !            79:         */
        !            80:        printf("%02X\n", checksum(base, (char *) 0, 0, size) +
        !            81:            (size - 2));
        !            82:        exit (0);
        !            83: }
        !            84:
        !            85: int
        !            86: get32(buf)
        !            87:        char buf[];
        !            88: {
        !            89:        char *cp = buf;
        !            90:        int i;
        !            91:        int c;
        !            92:
        !            93:        for (i = 0; i < 32; ++i) {
        !            94:                if ((c = getchar()) != EOF)
        !            95:                        *cp++ = c;
        !            96:                else
        !            97:                        break;
        !            98:        }
        !            99:        return (cp - buf);
        !           100: }
        !           101:
        !           102: void
        !           103: put32(len, addr, buf, size, mask)
        !           104:        int len;
        !           105:        int addr;
        !           106:        char buf[];
        !           107:        int size, mask;
        !           108: {
        !           109:        char *cp = buf;
        !           110:        int i;
        !           111:
        !           112:        if (size == 2)
        !           113:                printf("S1%02X%04X", 2 + len + 1, addr & mask);
        !           114:        if (size == 3)
        !           115:                printf("S2%02X%06X", 3 + len + 1, addr & mask);
        !           116:        if (size == 4)
        !           117:                printf("S3%02X%08X", 4 + len + 1, addr & mask);
        !           118:        for (i = 0; i < len; ++i)
        !           119:                put(*cp++);
        !           120:        printf("%02X\n", checksum(addr, buf, len, size));
        !           121: }
        !           122:
        !           123: void
        !           124: sput(s)
        !           125:        char *s;
        !           126: {
        !           127:        while (*s != '\0')
        !           128:                put(*s++);
        !           129: }
        !           130:
        !           131: void
        !           132: put(c)
        !           133:        int c;
        !           134: {
        !           135:        printf("%02X", c & 0xff);
        !           136: }
        !           137:
        !           138: int
        !           139: checksum(addr, buf, len, size)
        !           140:        int addr;
        !           141:        char buf[];
        !           142:        int len;
        !           143:        int size;
        !           144: {
        !           145:        char *cp = buf;
        !           146:        int sum = 0xff - 1 - size - (len & 0xff);
        !           147:        int i;
        !           148:
        !           149:        if (size == 4)
        !           150:                sum -= (addr >> 24) & 0xff;
        !           151:        if (size >= 3)
        !           152:                sum -= (addr >> 16) & 0xff;
        !           153:        sum -= (addr >> 8) & 0xff;
        !           154:        sum -= addr & 0xff;
        !           155:        for (i = 0; i < len; ++i) {
        !           156:                sum -= *cp++ & 0xff;
        !           157:        }
        !           158:        return (sum & 0xff);
        !           159: }