1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
|
/******************************************************************************
* LEGAL NOTICE *
* *
* USE OF THIS SOFTWARE (including any copy or compiled version thereof) AND *
* DOCUMENTATION IS SUBJECT TO THE SOFTWARE LICENSE AND RESTRICTIONS AND THE *
* WARRANTY DISLCAIMER SET FORTH IN LEGAL_NOTICE.TXT FILE. IF YOU DO NOT *
* FULLY ACCEPT THE TERMS, YOU MAY NOT INSTALL OR OTHERWISE USE THE SOFTWARE *
* OR DOCUMENTATION. *
* NOTWITHSTANDING ANYTHING TO THE CONTRARY IN THIS NOTICE, INSTALLING OR *
* OTHERISE USING THE SOFTWARE OR DOCUMENTATION INDICATES YOUR ACCEPTANCE OF *
* THE LICENSE TERMS AS STATED. *
* *
******************************************************************************/
/* Version: 1.8.9\3686 */
/* Build : 13 */
/* Date : 12/08/2012 */
/**
\file
\brief CellGuide Common code
\attention This file should not be modified.
If you think something is wrong here, please contact CellGuide
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include "CgxDriverCore.h"
#include "CgCpu.h"
// Swap helper functions
TCgByteSwapType CgGetByteSwapTypeU32(TCgByteOrder aFrom, TCgByteOrder aTo);
void * CgGetSwapFunctionU32(TCgByteSwapType type);
static const U32 fullMask[32] = {
0x00000001, 0x00000003, 0x00000007, 0x0000000F,
0x0000001F, 0x0000003F, 0x0000007F, 0x000000FF,
0x000001FF, 0x000003FF, 0x000007FF, 0x00000FFF,
0x00001FFF, 0x00003FFF, 0x00007FFF, 0x0000FFFF,
0x0001FFFF, 0x0003FFFF, 0x0007FFFF, 0x000FFFFF,
0x001FFFFF, 0x003FFFFF, 0x007FFFFF, 0x00FFFFFF,
0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF, 0x0FFFFFFF,
0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF };
U32 CgGetU32Mask(U32 bitsInU32)
{
return fullMask[bitsInU32];
}
TCgReturnCode CgSetRegisterBits(volatile U32 *aReg, TCgBitField aBitFieldDef, U32 aValue)
{
U32 value = aValue & fullMask[aBitFieldDef.length-1];
U32 mask = (fullMask[aBitFieldDef.length-1]) & ~value;
// clear
*aReg &= ~(mask << aBitFieldDef.start);
// set
*aReg |= (value << aBitFieldDef.start);
return ECgOk;
}
TCgReturnCode CgGetRegisterBits(volatile U32 aReg, TCgBitField aBitFieldDef, U32 *apValue)
{
*apValue = ((aReg) >> aBitFieldDef.start) & fullMask[aBitFieldDef.length-1];
return ECgOk;
}
TCgByteSwapType CgGetByteSwapTypeU32(TCgByteOrder aFrom, TCgByteOrder aTo)
{
switch (aFrom){
case ECG_BYTE_ORDER_1234 :
switch( aTo ){
case ECG_BYTE_ORDER_1234 : return ECG_SWAP_NONE;
case ECG_BYTE_ORDER_2143 : return ECG_SWAP_BYTES;
case ECG_BYTE_ORDER_3412 : return ECG_SWAP_WORDS;
case ECG_BYTE_ORDER_4321 : return ECG_SWAP_BYTES_AND_WORDS;
}
break;
case ECG_BYTE_ORDER_2143 :
switch( aTo ){
case ECG_BYTE_ORDER_1234 : return ECG_SWAP_BYTES;
case ECG_BYTE_ORDER_2143 : return ECG_SWAP_NONE;
case ECG_BYTE_ORDER_3412 : return ECG_SWAP_BYTES_AND_WORDS;
case ECG_BYTE_ORDER_4321 : return ECG_SWAP_WORDS;
}
break;
case ECG_BYTE_ORDER_3412 :
switch( aTo ) {
case ECG_BYTE_ORDER_1234 : return ECG_SWAP_WORDS;
case ECG_BYTE_ORDER_2143 : return ECG_SWAP_BYTES_AND_WORDS;
case ECG_BYTE_ORDER_3412 : return ECG_SWAP_NONE;
case ECG_BYTE_ORDER_4321 : return ECG_SWAP_BYTES;
}
break;
case ECG_BYTE_ORDER_4321 :
switch( aTo ) {
case ECG_BYTE_ORDER_1234 : return ECG_SWAP_BYTES_AND_WORDS;
case ECG_BYTE_ORDER_2143 : return ECG_SWAP_WORDS;
case ECG_BYTE_ORDER_3412 : return ECG_SWAP_BYTES;
case ECG_BYTE_ORDER_4321 : return ECG_SWAP_NONE;
}
break;
default :
return ECG_SWAP_NONE;
break;
}
return ECG_SWAP_NONE;
}
TCgReturnCode CgSwapBytesInBlock(void * aSource,void * aDest, long aSizeInBytes, TCgByteOrder aFrom, TCgByteOrder aTo)
{
TCgReturnCode rc = ECgOk;
long index = 0, sizeInDword = 0;
u32* source = NULL, * dest = NULL;
TCgByteSwapType swapType = CgGetByteSwapTypeU32(aFrom, aTo);
sizeInDword = aSizeInBytes / 4;
source = (u32*)aSource;
dest = (u32*)aDest;
switch (swapType) {
case ECG_SWAP_NONE :
break;
case ECG_SWAP_BYTES :
for ( ; index < sizeInDword; index ++ )
dest[index] = CgSwapBytesU32(source[index]);
break;
case ECG_SWAP_WORDS :
for ( ; index < sizeInDword; index ++ )
dest[index] = CgSwapWordsU32(source[index]);
break;
case ECG_SWAP_BYTES_AND_WORDS :
for ( ; index < sizeInDword; index ++ )
dest[index] = CgSwapBytesAndWordsU32(source[index]);
break;
}
return rc;
}
TCgReturnCode CgCpuDelay(unsigned long aCount)
{
volatile unsigned long cnt = 0;
volatile unsigned long z =2 ;
for(cnt = 0; cnt<aCount; cnt++) {
z *=2;
}
return ECgOk;
}
TCgReturnCode CgCpuRFControlWriteByte(unsigned char aValue)
{
printk(" CgCpuControlWriteByte.\n");
if(aValue == 1)
CgxDriverRFPowerUp();
else if(aValue == 0)
CgxDriverRFPowerDown();
else
printk(" invalid arg.\n");
return ECgOk;
}
#ifdef CG_STORE_ERROR_LINE
BOOL cgRetCode_store_error_line(const char * aFileName, long lineNumber, TCgReturnCode aRc) {
return TRUE;
}
#endif
|
