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

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