Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 65cdcf36 authored by Cho, Yu-Chen's avatar Cho, Yu-Chen Committed by Greg Kroah-Hartman
Browse files

staging/keucr: fix keucr smilecc.c coding style 



fix keucr smilecc.c coding style

Signed-off-by: default avatarCho, Yu-Chen <acho@novell.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 8a25a2cf

drivers/staging/keucr/smilecc.c

+149 −144
Original line number Diff line number Diff line 
#include "usb.h"

#include "scsiglue.h"

#include "transport.h"

//#include "stdlib.h"

//#include "EUCR6SK.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"

/* #include <stdio.h> */

/* #include <stdlib.h> */

/* #include <string.h> */

/* #include <dos.h> */

/* #include "EMCRIOS.h" */



// CP0-CP5 code table

/* 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

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 *);
@@ -49,138 +52,140 @@ static void trans_result (BYTE, BYTE, BYTE *, BYTE *); 
#define CORRECTABLE 0x00555554L



/*

 * reg2; // LP14,LP12,LP10,...

 * reg3; // LP15,LP13,LP11,...

 * *ecc1; // LP15,LP14,LP13,...

 * *ecc2; // LP07,LP06,LP05,...

 * 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

	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

	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

			*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

			*ecc1 |= b; /* LP14,12,10,8 -> ecc1 */

		b = b>>1; /* Right shift */

		a = a>>1; /* Right shift */

	}



    b=BIT7; // 80h=10000000b

	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

			*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

			*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)

/*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"

 * *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,...

	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

	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

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

	*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"

 * *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 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 == 0)

		return 0; /* If No error, return */



    if (((d^(d>>1))&CORRECTABLE)==CORRECTABLE)

    { // If correctable

	if (((d^(d>>1))&CORRECTABLE) == CORRECTABLE) { /* If correctable */

		l = BIT23;

        add=0; // Clear parameter

		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

		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

		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

		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);

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

		return 1;

	}



    i=0; // Clear count

    d&=0x00ffffffL; // Masking

	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

	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

	if (i == 1) { /* If ECC error */

		eccdata[1] = ecc1; eccdata[0] = ecc2; /* Put right ECC code */

		eccdata[2] = ecc3;

        return(2);

		return 2;

	}

    return(3); // Uncorrectable error

	return 3; /* Uncorrectable error */

}



int _Correct_D_SwECC(BYTE *buf, BYTE *redundant_ecc, BYTE *calculate_ecc)