← Back to branch summary

~ubuntu-branches/ubuntu/quantal/linux-linaro-mx51/quantal

« back to all changes in this revision

Viewing changes to drivers/staging/keucr/smilecc.c

  • Committer: Package Import Robot
  • Author(s): John Rigby, John Rigby
  • Date: 2011-09-26 10:44:23 UTC
  • Revision ID: package-import@ubuntu.com-20110926104423-3o58a3c1bj7x00rs
Tags: 3.0.0-1007.9
https://launchpad.net/bugs/826021
[ John Rigby ]

Enable crypto modules and remove crypto-modules from
exclude-module files
LP: #826021

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/staging/keucr/smilecc.c
1
1
#include "usb.h"
2
2
#include "scsiglue.h"
3
3
#include "transport.h"
4
 
//#include "stdlib.h"
5
 
//#include "EUCR6SK.h"
 
4
/* #include "stdlib.h" */
 
5
/* #include "EUCR6SK.h" */
6
6
#include "smcommon.h"
7
7
#include "smil.h"
8
8
 
9
 
//#include <stdio.h>
10
 
//#include <stdlib.h>
11
 
//#include <string.h>
12
 
//#include <dos.h>
13
 
//
14
 
//#include "EMCRIOS.h"
 
9
/* #include <stdio.h> */
 
10
/* #include <stdlib.h> */
 
11
/* #include <string.h> */
 
12
/* #include <dos.h> */
 
13
/* #include "EMCRIOS.h" */
15
14
 
16
 
// CP0-CP5 code table
 
15
/* CP0-CP5 code table */
17
16
static BYTE ecctable[256] = {
18
 
0x00,0x55,0x56,0x03,0x59,0x0C,0x0F,0x5A,0x5A,0x0F,0x0C,0x59,0x03,0x56,0x55,0x00,
19
 
0x65,0x30,0x33,0x66,0x3C,0x69,0x6A,0x3F,0x3F,0x6A,0x69,0x3C,0x66,0x33,0x30,0x65,
20
 
0x66,0x33,0x30,0x65,0x3F,0x6A,0x69,0x3C,0x3C,0x69,0x6A,0x3F,0x65,0x30,0x33,0x66,
21
 
0x03,0x56,0x55,0x00,0x5A,0x0F,0x0C,0x59,0x59,0x0C,0x0F,0x5A,0x00,0x55,0x56,0x03,
22
 
0x69,0x3C,0x3F,0x6A,0x30,0x65,0x66,0x33,0x33,0x66,0x65,0x30,0x6A,0x3F,0x3C,0x69,
23
 
0x0C,0x59,0x5A,0x0F,0x55,0x00,0x03,0x56,0x56,0x03,0x00,0x55,0x0F,0x5A,0x59,0x0C,
24
 
0x0F,0x5A,0x59,0x0C,0x56,0x03,0x00,0x55,0x55,0x00,0x03,0x56,0x0C,0x59,0x5A,0x0F,
25
 
0x6A,0x3F,0x3C,0x69,0x33,0x66,0x65,0x30,0x30,0x65,0x66,0x33,0x69,0x3C,0x3F,0x6A,
26
 
0x6A,0x3F,0x3C,0x69,0x33,0x66,0x65,0x30,0x30,0x65,0x66,0x33,0x69,0x3C,0x3F,0x6A,
27
 
0x0F,0x5A,0x59,0x0C,0x56,0x03,0x00,0x55,0x55,0x00,0x03,0x56,0x0C,0x59,0x5A,0x0F,
28
 
0x0C,0x59,0x5A,0x0F,0x55,0x00,0x03,0x56,0x56,0x03,0x00,0x55,0x0F,0x5A,0x59,0x0C,
29
 
0x69,0x3C,0x3F,0x6A,0x30,0x65,0x66,0x33,0x33,0x66,0x65,0x30,0x6A,0x3F,0x3C,0x69,
30
 
0x03,0x56,0x55,0x00,0x5A,0x0F,0x0C,0x59,0x59,0x0C,0x0F,0x5A,0x00,0x55,0x56,0x03,
31
 
0x66,0x33,0x30,0x65,0x3F,0x6A,0x69,0x3C,0x3C,0x69,0x6A,0x3F,0x65,0x30,0x33,0x66,
32
 
0x65,0x30,0x33,0x66,0x3C,0x69,0x6A,0x3F,0x3F,0x6A,0x69,0x3C,0x66,0x33,0x30,0x65,
33
 
0x00,0x55,0x56,0x03,0x59,0x0C,0x0F,0x5A,0x5A,0x0F,0x0C,0x59,0x03,0x56,0x55,0x00
 
17
0x00, 0x55, 0x56, 0x03, 0x59, 0x0C, 0x0F, 0x5A, 0x5A, 0x0F, 0x0C, 0x59, 0x03,
 
18
0x56, 0x55, 0x00, 0x65, 0x30, 0x33, 0x66, 0x3C, 0x69, 0x6A, 0x3F, 0x3F, 0x6A,
 
19
0x69, 0x3C, 0x66, 0x33, 0x30, 0x65, 0x66, 0x33, 0x30, 0x65, 0x3F, 0x6A, 0x69,
 
20
0x3C, 0x3C, 0x69, 0x6A, 0x3F, 0x65, 0x30, 0x33, 0x66, 0x03, 0x56, 0x55, 0x00,
 
21
0x5A, 0x0F, 0x0C, 0x59, 0x59, 0x0C, 0x0F, 0x5A, 0x00, 0x55, 0x56, 0x03, 0x69,
 
22
0x3C, 0x3F, 0x6A, 0x30, 0x65, 0x66, 0x33, 0x33, 0x66, 0x65, 0x30, 0x6A, 0x3F,
 
23
0x3C, 0x69, 0x0C, 0x59, 0x5A, 0x0F, 0x55, 0x00, 0x03, 0x56, 0x56, 0x03, 0x00,
 
24
0x55, 0x0F, 0x5A, 0x59, 0x0C, 0x0F, 0x5A, 0x59, 0x0C, 0x56, 0x03, 0x00, 0x55,
 
25
0x55, 0x00, 0x03, 0x56, 0x0C, 0x59, 0x5A, 0x0F, 0x6A, 0x3F, 0x3C, 0x69, 0x33,
 
26
0x66, 0x65, 0x30, 0x30, 0x65, 0x66, 0x33, 0x69, 0x3C, 0x3F, 0x6A, 0x6A, 0x3F,
 
27
0x3C, 0x69, 0x33, 0x66, 0x65, 0x30, 0x30, 0x65, 0x66, 0x33, 0x69, 0x3C, 0x3F,
 
28
0x6A, 0x0F, 0x5A, 0x59, 0x0C, 0x56, 0x03, 0x00, 0x55, 0x55, 0x00, 0x03, 0x56,
 
29
0x0C, 0x59, 0x5A, 0x0F, 0x0C, 0x59, 0x5A, 0x0F, 0x55, 0x00, 0x03, 0x56, 0x56,
 
30
0x03, 0x00, 0x55, 0x0F, 0x5A, 0x59, 0x0C, 0x69, 0x3C, 0x3F, 0x6A, 0x30, 0x65,
 
31
0x66, 0x33, 0x33, 0x66, 0x65, 0x30, 0x6A, 0x3F, 0x3C, 0x69, 0x03, 0x56, 0x55,
 
32
0x00, 0x5A, 0x0F, 0x0C, 0x59, 0x59, 0x0C, 0x0F, 0x5A, 0x00, 0x55, 0x56, 0x03,
 
33
0x66, 0x33, 0x30, 0x65, 0x3F, 0x6A, 0x69, 0x3C, 0x3C, 0x69, 0x6A, 0x3F, 0x65,
 
34
0x30, 0x33, 0x66, 0x65, 0x30, 0x33, 0x66, 0x3C, 0x69, 0x6A, 0x3F, 0x3F, 0x6A,
 
35
0x69, 0x3C, 0x66, 0x33, 0x30, 0x65, 0x00, 0x55, 0x56, 0x03, 0x59, 0x0C, 0x0F,
 
36
0x5A, 0x5A, 0x0F, 0x0C, 0x59, 0x03, 0x56, 0x55, 0x00
34
37
};
35
38
 
36
 
static void   trans_result  (BYTE,   BYTE,   BYTE *, BYTE *);
 
39
static void   trans_result(BYTE,   BYTE,   BYTE *, BYTE *);
37
40
 
38
41
#define BIT7        0x80
39
42
#define BIT6        0x40
48
51
#define MASK_CPS    0x3f
49
52
#define CORRECTABLE 0x00555554L
50
53
 
51
 
static void trans_result(reg2,reg3,ecc1,ecc2)
52
 
BYTE reg2; // LP14,LP12,LP10,...
53
 
BYTE reg3; // LP15,LP13,LP11,...
54
 
BYTE *ecc1; // LP15,LP14,LP13,...
55
 
BYTE *ecc2; // LP07,LP06,LP05,...
56
 
{
57
 
    BYTE a; // Working for reg2,reg3
58
 
    BYTE b; // Working for ecc1,ecc2
59
 
    BYTE i; // For counting
60
 
 
61
 
    a=BIT7; b=BIT7; // 80h=10000000b
62
 
    *ecc1=*ecc2=0; // Clear ecc1,ecc2
63
 
    for(i=0; i<4; ++i) {
64
 
        if ((reg3&a)!=0)
65
 
            *ecc1|=b; // LP15,13,11,9 -> ecc1
66
 
        b=b>>1; // Right shift
67
 
        if ((reg2&a)!=0)
68
 
            *ecc1|=b; // LP14,12,10,8 -> ecc1
69
 
        b=b>>1; // Right shift
70
 
        a=a>>1; // Right shift
71
 
    }
72
 
 
73
 
    b=BIT7; // 80h=10000000b
74
 
    for(i=0; i<4; ++i) {
75
 
        if ((reg3&a)!=0)
76
 
            *ecc2|=b; // LP7,5,3,1 -> ecc2
77
 
        b=b>>1; // Right shift
78
 
        if ((reg2&a)!=0)
79
 
            *ecc2|=b; // LP6,4,2,0 -> ecc2
80
 
        b=b>>1; // Right shift
81
 
        a=a>>1; // Right shift
82
 
    }
83
 
}
84
 
 
85
 
//static void calculate_ecc(table,data,ecc1,ecc2,ecc3)
86
 
void calculate_ecc(table,data,ecc1,ecc2,ecc3)
87
 
BYTE *table; // CP0-CP5 code table
88
 
BYTE *data; // DATA
89
 
BYTE *ecc1; // LP15,LP14,LP13,...
90
 
BYTE *ecc2; // LP07,LP06,LP05,...
91
 
BYTE *ecc3; // CP5,CP4,CP3,...,"1","1"
92
 
{
93
 
    DWORD  i;    // For counting
94
 
    BYTE a;    // Working for table
95
 
    BYTE reg1; // D-all,CP5,CP4,CP3,...
96
 
    BYTE reg2; // LP14,LP12,L10,...
97
 
    BYTE reg3; // LP15,LP13,L11,...
98
 
 
99
 
    reg1=reg2=reg3=0;   // Clear parameter
100
 
    for(i=0; i<256; ++i) {
101
 
        a=table[data[i]]; // Get CP0-CP5 code from table
102
 
        reg1^=(a&MASK_CPS); // XOR with a
103
 
        if ((a&BIT6)!=0)
104
 
        { // If D_all(all bit XOR) = 1
105
 
            reg3^=(BYTE)i; // XOR with counter
106
 
            reg2^=~((BYTE)i); // XOR with inv. of counter
107
 
        }
108
 
    }
109
 
 
110
 
    // Trans LP14,12,10,... & LP15,13,11,... -> LP15,14,13,... & LP7,6,5,..
111
 
    trans_result(reg2,reg3,ecc1,ecc2);
112
 
    *ecc1=~(*ecc1); *ecc2=~(*ecc2); // Inv. ecc2 & ecc3
113
 
    *ecc3=((~reg1)<<2)|BIT1BIT0; // Make TEL format
114
 
}
115
 
 
116
 
BYTE correct_data(data,eccdata,ecc1,ecc2,ecc3)
117
 
BYTE *data; // DATA
118
 
BYTE *eccdata; // ECC DATA
119
 
BYTE ecc1; // LP15,LP14,LP13,...
120
 
BYTE ecc2; // LP07,LP06,LP05,...
121
 
BYTE ecc3; // CP5,CP4,CP3,...,"1","1"
122
 
{
123
 
    DWORD l; // Working to check d
124
 
    DWORD d; // Result of comparison
125
 
    DWORD i; // For counting
126
 
    BYTE d1,d2,d3; // Result of comparison
127
 
    BYTE a; // Working for add
128
 
    BYTE add; // Byte address of cor. DATA
129
 
    BYTE b; // Working for bit
130
 
    BYTE bit; // Bit address of cor. DATA
131
 
 
132
 
    d1=ecc1^eccdata[1]; d2=ecc2^eccdata[0]; // Compare LP's
133
 
    d3=ecc3^eccdata[2]; // Comapre CP's
134
 
    d=((DWORD)d1<<16) // Result of comparison
135
 
    +((DWORD)d2<<8)
136
 
    +(DWORD)d3;
137
 
 
138
 
    if (d==0) return(0); // If No error, return
139
 
 
140
 
    if (((d^(d>>1))&CORRECTABLE)==CORRECTABLE)
141
 
    { // If correctable
142
 
        l=BIT23;
143
 
        add=0; // Clear parameter
144
 
        a=BIT7;
145
 
 
146
 
        for(i=0; i<8; ++i) { // Checking 8 bit
147
 
            if ((d&l)!=0) add|=a; // Make byte address from LP's
148
 
            l>>=2; a>>=1; // Right Shift
149
 
        }
150
 
 
151
 
        bit=0; // Clear parameter
152
 
        b=BIT2;
153
 
        for(i=0; i<3; ++i) { // Checking 3 bit
154
 
            if ((d&l)!=0) bit|=b; // Make bit address from CP's
155
 
            l>>=2; b>>=1; // Right shift
156
 
        }
157
 
 
158
 
        b=BIT0;
159
 
        data[add]^=(b<<bit); // Put corrected data
160
 
        return(1);
161
 
    }
162
 
 
163
 
    i=0; // Clear count
164
 
    d&=0x00ffffffL; // Masking
165
 
 
166
 
    while(d) { // If d=0 finish counting
167
 
        if (d&BIT0) ++i; // Count number of 1 bit
168
 
        d>>=1; // Right shift
169
 
    }
170
 
 
171
 
    if (i==1)
172
 
    { // If ECC error
173
 
        eccdata[1]=ecc1; eccdata[0]=ecc2; // Put right ECC code
174
 
        eccdata[2]=ecc3;
175
 
        return(2);
176
 
    }
177
 
    return(3); // Uncorrectable error
178
 
}
179
 
 
180
 
int _Correct_D_SwECC(buf,redundant_ecc,calculate_ecc)
181
 
BYTE *buf;
182
 
BYTE *redundant_ecc;
183
 
BYTE *calculate_ecc;
 
54
/*
 
55
 * reg2; * LP14,LP12,LP10,...
 
56
 * reg3; * LP15,LP13,LP11,...
 
57
 * *ecc1; * LP15,LP14,LP13,...
 
58
 * *ecc2; * LP07,LP06,LP05,...
 
59
 */
 
60
static void trans_result(BYTE reg2, BYTE reg3, BYTE *ecc1, BYTE *ecc2)
 
61
{
 
62
        BYTE a; /* Working for reg2,reg3 */
 
63
        BYTE b; /* Working for ecc1,ecc2 */
 
64
        BYTE i; /* For counting */
 
65
 
 
66
        a = BIT7; b = BIT7; /* 80h=10000000b */
 
67
        *ecc1 = *ecc2 = 0; /* Clear ecc1,ecc2 */
 
68
        for (i = 0; i < 4; ++i) {
 
69
                if ((reg3&a) != 0)
 
70
                        *ecc1 |= b; /* LP15,13,11,9 -> ecc1 */
 
71
                b = b>>1; /* Right shift */
 
72
                if ((reg2&a) != 0)
 
73
                        *ecc1 |= b; /* LP14,12,10,8 -> ecc1 */
 
74
                b = b>>1; /* Right shift */
 
75
                a = a>>1; /* Right shift */
 
76
        }
 
77
 
 
78
        b = BIT7; /* 80h=10000000b */
 
79
        for (i = 0; i < 4; ++i) {
 
80
                if ((reg3&a) != 0)
 
81
                        *ecc2 |= b; /* LP7,5,3,1 -> ecc2 */
 
82
                b = b>>1; /* Right shift */
 
83
                if ((reg2&a) != 0)
 
84
                        *ecc2 |= b; /* LP6,4,2,0 -> ecc2 */
 
85
                b = b>>1; /* Right shift */
 
86
                a = a>>1; /* Right shift */
 
87
        }
 
88
}
 
89
 
 
90
/*static void calculate_ecc(table,data,ecc1,ecc2,ecc3) */
 
91
/*
 
92
 * *table; * CP0-CP5 code table
 
93
 * *data; * DATA
 
94
 * *ecc1; * LP15,LP14,LP13,...
 
95
 * *ecc2; * LP07,LP06,LP05,...
 
96
 * *ecc3; * CP5,CP4,CP3,...,"1","1"
 
97
 */
 
98
void calculate_ecc(BYTE *table, BYTE *data, BYTE *ecc1, BYTE *ecc2, BYTE *ecc3)
 
99
{
 
100
        DWORD  i;    /* For counting */
 
101
        BYTE a;    /* Working for table */
 
102
        BYTE reg1; /* D-all,CP5,CP4,CP3,... */
 
103
        BYTE reg2; /* LP14,LP12,L10,... */
 
104
        BYTE reg3; /* LP15,LP13,L11,... */
 
105
 
 
106
        reg1 = reg2 = reg3 = 0;   /* Clear parameter */
 
107
        for (i = 0; i < 256; ++i) {
 
108
                a = table[data[i]]; /* Get CP0-CP5 code from table */
 
109
                reg1 ^= (a&MASK_CPS); /* XOR with a */
 
110
                if ((a&BIT6) != 0) { /* If D_all(all bit XOR) = 1 */
 
111
                        reg3 ^= (BYTE)i; /* XOR with counter */
 
112
                        reg2 ^= ~((BYTE)i); /* XOR with inv. of counter */
 
113
                }
 
114
        }
 
115
 
 
116
        /* Trans LP14,12,10,... & LP15,13,11,... ->
 
117
                                                LP15,14,13,... & LP7,6,5,.. */
 
118
        trans_result(reg2, reg3, ecc1, ecc2);
 
119
        *ecc1 = ~(*ecc1); *ecc2 = ~(*ecc2); /* Inv. ecc2 & ecc3 */
 
120
        *ecc3 = ((~reg1)<<2)|BIT1BIT0; /* Make TEL format */
 
121
}
 
122
 
 
123
/*
 
124
 * *data; * DATA
 
125
 * *eccdata; * ECC DATA
 
126
 * ecc1; * LP15,LP14,LP13,...
 
127
 * ecc2; * LP07,LP06,LP05,...
 
128
 * ecc3; * CP5,CP4,CP3,...,"1","1"
 
129
 */
 
130
BYTE correct_data(BYTE *data, BYTE *eccdata, BYTE ecc1, BYTE ecc2, BYTE ecc3)
 
131
{
 
132
        DWORD l; /* Working to check d */
 
133
        DWORD d; /* Result of comparison */
 
134
        DWORD i; /* For counting */
 
135
        BYTE d1, d2, d3; /* Result of comparison */
 
136
        BYTE a; /* Working for add */
 
137
        BYTE add; /* Byte address of cor. DATA */
 
138
        BYTE b; /* Working for bit */
 
139
        BYTE bit; /* Bit address of cor. DATA */
 
140
 
 
141
        d1 = ecc1^eccdata[1]; d2 = ecc2^eccdata[0]; /* Compare LP's */
 
142
        d3 = ecc3^eccdata[2]; /* Comapre CP's */
 
143
        d = ((DWORD)d1<<16) /* Result of comparison */
 
144
        +((DWORD)d2<<8)
 
145
        +(DWORD)d3;
 
146
 
 
147
        if (d == 0)
 
148
                return 0; /* If No error, return */
 
149
 
 
150
        if (((d^(d>>1))&CORRECTABLE) == CORRECTABLE) { /* If correctable */
 
151
                l = BIT23;
 
152
                add = 0; /* Clear parameter */
 
153
                a = BIT7;
 
154
 
 
155
                for (i = 0; i < 8; ++i) { /* Checking 8 bit */
 
156
                        if ((d&l) != 0)
 
157
                                add |= a; /* Make byte address from LP's */
 
158
                        l >>= 2; a >>= 1; /* Right Shift */
 
159
                }
 
160
 
 
161
                bit = 0; /* Clear parameter */
 
162
                b = BIT2;
 
163
                for (i = 0; i < 3; ++i) { /* Checking 3 bit */
 
164
                        if ((d&l) != 0)
 
165
                                bit |= b; /* Make bit address from CP's */
 
166
                        l >>= 2; b >>= 1; /* Right shift */
 
167
                }
 
168
 
 
169
                b = BIT0;
 
170
                data[add] ^= (b<<bit); /* Put corrected data */
 
171
                return 1;
 
172
        }
 
173
 
 
174
        i = 0; /* Clear count */
 
175
        d &= 0x00ffffffL; /* Masking */
 
176
 
 
177
        while (d) { /* If d=0 finish counting */
 
178
                if (d&BIT0)
 
179
                        ++i; /* Count number of 1 bit */
 
180
                d >>= 1; /* Right shift */
 
181
        }
 
182
 
 
183
        if (i == 1) { /* If ECC error */
 
184
                eccdata[1] = ecc1; eccdata[0] = ecc2; /* Put right ECC code */
 
185
                eccdata[2] = ecc3;
 
186
                return 2;
 
187
        }
 
188
        return 3; /* Uncorrectable error */
 
189
}
 
190
 
 
191
int _Correct_D_SwECC(BYTE *buf, BYTE *redundant_ecc, BYTE *calculate_ecc)
184
192
{
185
193
        DWORD err;
186
194
 
195
203
        return -1;
196
204
}
197
205
 
198
 
void _Calculate_D_SwECC(buf,ecc)
199
 
BYTE *buf;
200
 
BYTE *ecc;
 
206
void _Calculate_D_SwECC(BYTE *buf, BYTE *ecc)
201
207
{
202
 
    calculate_ecc(ecctable,buf,ecc+1,ecc+0,ecc+2);
 
208
        calculate_ecc(ecctable, buf, ecc+1, ecc+0, ecc+2);
203
209
}
204
210
 
205
211