Return to srec.c CVS log

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

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

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