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

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: }