smilecc.c

Go to the documentation of this file.

#include "usb.h"
#include "scsiglue.h"
#include "transport.h"
/* #include "stdlib.h" */
/* #include "EUCR6SK.h" */
#include "smcommon.h"
#include "smil.h"

/* #include <stdio.h> */
/* #include <stdlib.h> */
/* #include <string.h> */
/* #include <dos.h> */
/* #include "EMCRIOS.h" */

/* CP0-CP5 code table */
static BYTE ecctable[256] = {
0x00, 0x55, 0x56, 0x03, 0x59, 0x0C, 0x0F, 0x5A, 0x5A, 0x0F, 0x0C, 0x59, 0x03,
0x56, 0x55, 0x00, 0x65, 0x30, 0x33, 0x66, 0x3C, 0x69, 0x6A, 0x3F, 0x3F, 0x6A,
0x69, 0x3C, 0x66, 0x33, 0x30, 0x65, 0x66, 0x33, 0x30, 0x65, 0x3F, 0x6A, 0x69,
0x3C, 0x3C, 0x69, 0x6A, 0x3F, 0x65, 0x30, 0x33, 0x66, 0x03, 0x56, 0x55, 0x00,
0x5A, 0x0F, 0x0C, 0x59, 0x59, 0x0C, 0x0F, 0x5A, 0x00, 0x55, 0x56, 0x03, 0x69,
0x3C, 0x3F, 0x6A, 0x30, 0x65, 0x66, 0x33, 0x33, 0x66, 0x65, 0x30, 0x6A, 0x3F,
0x3C, 0x69, 0x0C, 0x59, 0x5A, 0x0F, 0x55, 0x00, 0x03, 0x56, 0x56, 0x03, 0x00,
0x55, 0x0F, 0x5A, 0x59, 0x0C, 0x0F, 0x5A, 0x59, 0x0C, 0x56, 0x03, 0x00, 0x55,
0x55, 0x00, 0x03, 0x56, 0x0C, 0x59, 0x5A, 0x0F, 0x6A, 0x3F, 0x3C, 0x69, 0x33,
0x66, 0x65, 0x30, 0x30, 0x65, 0x66, 0x33, 0x69, 0x3C, 0x3F, 0x6A, 0x6A, 0x3F,
0x3C, 0x69, 0x33, 0x66, 0x65, 0x30, 0x30, 0x65, 0x66, 0x33, 0x69, 0x3C, 0x3F,
0x6A, 0x0F, 0x5A, 0x59, 0x0C, 0x56, 0x03, 0x00, 0x55, 0x55, 0x00, 0x03, 0x56,
0x0C, 0x59, 0x5A, 0x0F, 0x0C, 0x59, 0x5A, 0x0F, 0x55, 0x00, 0x03, 0x56, 0x56,
0x03, 0x00, 0x55, 0x0F, 0x5A, 0x59, 0x0C, 0x69, 0x3C, 0x3F, 0x6A, 0x30, 0x65,
0x66, 0x33, 0x33, 0x66, 0x65, 0x30, 0x6A, 0x3F, 0x3C, 0x69, 0x03, 0x56, 0x55,
0x00, 0x5A, 0x0F, 0x0C, 0x59, 0x59, 0x0C, 0x0F, 0x5A, 0x00, 0x55, 0x56, 0x03,
0x66, 0x33, 0x30, 0x65, 0x3F, 0x6A, 0x69, 0x3C, 0x3C, 0x69, 0x6A, 0x3F, 0x65,
0x30, 0x33, 0x66, 0x65, 0x30, 0x33, 0x66, 0x3C, 0x69, 0x6A, 0x3F, 0x3F, 0x6A,
0x69, 0x3C, 0x66, 0x33, 0x30, 0x65, 0x00, 0x55, 0x56, 0x03, 0x59, 0x0C, 0x0F,
0x5A, 0x5A, 0x0F, 0x0C, 0x59, 0x03, 0x56, 0x55, 0x00
};

static void   trans_result(BYTE,   BYTE,   BYTE *, BYTE *);

#define BIT7        0x80
#define BIT6        0x40
#define BIT5        0x20
#define BIT4        0x10
#define BIT3        0x08
#define BIT2        0x04
#define BIT1        0x02
#define BIT0        0x01
#define BIT1BIT0    0x03
#define BIT23       0x00800000L
#define MASK_CPS    0x3f
#define CORRECTABLE 0x00555554L

/*
 * reg2; * LP14,LP12,LP10,...
 * reg3; * LP15,LP13,LP11,...
 * *ecc1; * LP15,LP14,LP13,...
 * *ecc2; * LP07,LP06,LP05,...
 */
static void trans_result(BYTE reg2, BYTE reg3, BYTE *ecc1, BYTE *ecc2)
{
    BYTE a; /* Working for reg2,reg3 */
    BYTE b; /* Working for ecc1,ecc2 */
    BYTE i; /* For counting */

    a = BIT7; b = BIT7; /* 80h=10000000b */
    *ecc1 = *ecc2 = 0; /* Clear ecc1,ecc2 */
    for (i = 0; i < 4; ++i) {
        if ((reg3&a) != 0)
            *ecc1 |= b; /* LP15,13,11,9 -> ecc1 */
        b = b>>1; /* Right shift */
        if ((reg2&a) != 0)
            *ecc1 |= b; /* LP14,12,10,8 -> ecc1 */
        b = b>>1; /* Right shift */
        a = a>>1; /* Right shift */
    }

    b = BIT7; /* 80h=10000000b */
    for (i = 0; i < 4; ++i) {
        if ((reg3&a) != 0)
            *ecc2 |= b; /* LP7,5,3,1 -> ecc2 */
        b = b>>1; /* Right shift */
        if ((reg2&a) != 0)
            *ecc2 |= b; /* LP6,4,2,0 -> ecc2 */
        b = b>>1; /* Right shift */
        a = a>>1; /* Right shift */
    }
}

/*static void calculate_ecc(table,data,ecc1,ecc2,ecc3) */
/*
 * *table; * CP0-CP5 code table
 * *data; * DATA
 * *ecc1; * LP15,LP14,LP13,...
 * *ecc2; * LP07,LP06,LP05,...
 * *ecc3; * CP5,CP4,CP3,...,"1","1"
 */
void calculate_ecc(BYTE *table, BYTE *data, BYTE *ecc1, BYTE *ecc2, BYTE *ecc3)
{
    DWORD  i;    /* For counting */
    BYTE a;    /* Working for table */
    BYTE reg1; /* D-all,CP5,CP4,CP3,... */
    BYTE reg2; /* LP14,LP12,L10,... */
    BYTE reg3; /* LP15,LP13,L11,... */

    reg1 = reg2 = reg3 = 0;   /* Clear parameter */
    for (i = 0; i < 256; ++i) {
        a = table[data[i]]; /* Get CP0-CP5 code from table */
        reg1 ^= (a&MASK_CPS); /* XOR with a */
        if ((a&BIT6) != 0) { /* If D_all(all bit XOR) = 1 */
            reg3 ^= (BYTE)i; /* XOR with counter */
            reg2 ^= ~((BYTE)i); /* XOR with inv. of counter */
        }
    }

    /* Trans LP14,12,10,... & LP15,13,11,... ->
                        LP15,14,13,... & LP7,6,5,.. */
    trans_result(reg2, reg3, ecc1, ecc2);
    *ecc1 = ~(*ecc1); *ecc2 = ~(*ecc2); /* Inv. ecc2 & ecc3 */
    *ecc3 = ((~reg1)<<2)|BIT1BIT0; /* Make TEL format */
}

/*
 * *data; * DATA
 * *eccdata; * ECC DATA
 * ecc1; * LP15,LP14,LP13,...
 * ecc2; * LP07,LP06,LP05,...
 * ecc3; * CP5,CP4,CP3,...,"1","1"
 */
BYTE correct_data(BYTE *data, BYTE *eccdata, BYTE ecc1, BYTE ecc2, BYTE ecc3)
{
    DWORD l; /* Working to check d */
    DWORD d; /* Result of comparison */
    DWORD i; /* For counting */
    BYTE d1, d2, d3; /* Result of comparison */
    BYTE a; /* Working for add */
    BYTE add; /* Byte address of cor. DATA */
    BYTE b; /* Working for bit */
    BYTE bit; /* Bit address of cor. DATA */

    d1 = ecc1^eccdata[1]; d2 = ecc2^eccdata[0]; /* Compare LP's */
    d3 = ecc3^eccdata[2]; /* Comapre CP's */
    d = ((DWORD)d1<<16) /* Result of comparison */
    +((DWORD)d2<<8)
    +(DWORD)d3;

    if (d == 0)
        return 0; /* If No error, return */

    if (((d^(d>>1))&CORRECTABLE) == CORRECTABLE) { /* If correctable */
        l = BIT23;
        add = 0; /* Clear parameter */
        a = BIT7;

        for (i = 0; i < 8; ++i) { /* Checking 8 bit */
            if ((d&l) != 0)
                add |= a; /* Make byte address from LP's */
            l >>= 2; a >>= 1; /* Right Shift */
        }

        bit = 0; /* Clear parameter */
        b = BIT2;
        for (i = 0; i < 3; ++i) { /* Checking 3 bit */
            if ((d&l) != 0)
                bit |= b; /* Make bit address from CP's */
            l >>= 2; b >>= 1; /* Right shift */
        }

        b = BIT0;
        data[add] ^= (b<<bit); /* Put corrected data */
        return 1;
    }

    i = 0; /* Clear count */
    d &= 0x00ffffffL; /* Masking */

    while (d) { /* If d=0 finish counting */
        if (d&BIT0)
            ++i; /* Count number of 1 bit */
        d >>= 1; /* Right shift */
    }

    if (i == 1) { /* If ECC error */
        eccdata[1] = ecc1; eccdata[0] = ecc2; /* Put right ECC code */
        eccdata[2] = ecc3;
        return 2;
    }
    return 3; /* Uncorrectable error */
}

int _Correct_D_SwECC(BYTE *buf, BYTE *redundant_ecc, BYTE *calculate_ecc)
{
    DWORD err;

    err = correct_data(buf, redundant_ecc, *(calculate_ecc + 1),
               *(calculate_ecc), *(calculate_ecc + 2));
    if (err == 1)
        memcpy(calculate_ecc, redundant_ecc, 3);

    if (err == 0 || err == 1 || err == 2)
        return 0;

    return -1;
}

void _Calculate_D_SwECC(BYTE *buf, BYTE *ecc)
{
    calculate_ecc(ecctable, buf, ecc+1, ecc+0, ecc+2);
}