1 /******************************************************************************
2 *
3 * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
17 *
18 *
19 ******************************************************************************/
20 #define _HAL_PHY_C_
21
22 #include <drv_types.h>
23
24 //================================================================================
25 // Constant.
26 //================================================================================
27 // 2008/11/20 MH For Debug only, RF
28 static RF_SHADOW_T RF_Shadow[RF6052_MAX_PATH][RF6052_MAX_REG];
29
30 /**
31 * Function: PHY_CalculateBitShift
32 *
33 * OverView: Get shifted position of the BitMask
34 *
35 * Input:
36 * u4Byte BitMask,
37 *
38 * Output: none
39 * Return: u4Byte Return the shift bit bit position of the mask
40 */
41 u32
PHY_CalculateBitShift(u32 BitMask)42 PHY_CalculateBitShift(
43 u32 BitMask
44 )
45 {
46 u32 i;
47
48 for(i=0; i<=31; i++)
49 {
50 if ( ((BitMask>>i) & 0x1 ) == 1)
51 break;
52 }
53
54 return (i);
55 }
56
57
58 //
59 // ==> RF shadow Operation API Code Section!!!
60 //
61 /*-----------------------------------------------------------------------------
62 * Function: PHY_RFShadowRead
63 * PHY_RFShadowWrite
64 * PHY_RFShadowCompare
65 * PHY_RFShadowRecorver
66 * PHY_RFShadowCompareAll
67 * PHY_RFShadowRecorverAll
68 * PHY_RFShadowCompareFlagSet
69 * PHY_RFShadowRecorverFlagSet
70 *
71 * Overview: When we set RF register, we must write shadow at first.
72 * When we are running, we must compare shadow abd locate error addr.
73 * Decide to recorver or not.
74 *
75 * Input: NONE
76 *
77 * Output: NONE
78 *
79 * Return: NONE
80 *
81 * Revised History:
82 * When Who Remark
83 * 11/20/2008 MHC Create Version 0.
84 *
85 *---------------------------------------------------------------------------*/
86 u32
PHY_RFShadowRead(IN PADAPTER Adapter,IN u8 eRFPath,IN u32 Offset)87 PHY_RFShadowRead(
88 IN PADAPTER Adapter,
89 IN u8 eRFPath,
90 IN u32 Offset)
91 {
92 return RF_Shadow[eRFPath][Offset].Value;
93
94 } /* PHY_RFShadowRead */
95
96
97 VOID
PHY_RFShadowWrite(IN PADAPTER Adapter,IN u8 eRFPath,IN u32 Offset,IN u32 Data)98 PHY_RFShadowWrite(
99 IN PADAPTER Adapter,
100 IN u8 eRFPath,
101 IN u32 Offset,
102 IN u32 Data)
103 {
104 RF_Shadow[eRFPath][Offset].Value = (Data & bRFRegOffsetMask);
105 RF_Shadow[eRFPath][Offset].Driver_Write = _TRUE;
106
107 } /* PHY_RFShadowWrite */
108
109
110 BOOLEAN
PHY_RFShadowCompare(IN PADAPTER Adapter,IN u8 eRFPath,IN u32 Offset)111 PHY_RFShadowCompare(
112 IN PADAPTER Adapter,
113 IN u8 eRFPath,
114 IN u32 Offset)
115 {
116 u32 reg;
117 // Check if we need to check the register
118 if (RF_Shadow[eRFPath][Offset].Compare == _TRUE)
119 {
120 reg = rtw_hal_read_rfreg(Adapter, eRFPath, Offset, bRFRegOffsetMask);
121 // Compare shadow and real rf register for 20bits!!
122 if (RF_Shadow[eRFPath][Offset].Value != reg)
123 {
124 // Locate error position.
125 RF_Shadow[eRFPath][Offset].ErrorOrNot = _TRUE;
126 //RT_TRACE(COMP_INIT, DBG_LOUD,
127 //("PHY_RFShadowCompare RF-%d Addr%02lx Err = %05lx\n",
128 //eRFPath, Offset, reg));
129 }
130 return RF_Shadow[eRFPath][Offset].ErrorOrNot ;
131 }
132 return _FALSE;
133 } /* PHY_RFShadowCompare */
134
135
136 VOID
PHY_RFShadowRecorver(IN PADAPTER Adapter,IN u8 eRFPath,IN u32 Offset)137 PHY_RFShadowRecorver(
138 IN PADAPTER Adapter,
139 IN u8 eRFPath,
140 IN u32 Offset)
141 {
142 // Check if the address is error
143 if (RF_Shadow[eRFPath][Offset].ErrorOrNot == _TRUE)
144 {
145 // Check if we need to recorver the register.
146 if (RF_Shadow[eRFPath][Offset].Recorver == _TRUE)
147 {
148 rtw_hal_write_rfreg(Adapter, eRFPath, Offset, bRFRegOffsetMask,
149 RF_Shadow[eRFPath][Offset].Value);
150 //RT_TRACE(COMP_INIT, DBG_LOUD,
151 //("PHY_RFShadowRecorver RF-%d Addr%02lx=%05lx",
152 //eRFPath, Offset, RF_Shadow[eRFPath][Offset].Value));
153 }
154 }
155
156 } /* PHY_RFShadowRecorver */
157
158
159 VOID
PHY_RFShadowCompareAll(IN PADAPTER Adapter)160 PHY_RFShadowCompareAll(
161 IN PADAPTER Adapter)
162 {
163 u8 eRFPath = 0 ;
164 u32 Offset = 0, maxReg= GET_RF6052_REAL_MAX_REG(Adapter);
165
166 for (eRFPath = 0; eRFPath < RF6052_MAX_PATH; eRFPath++)
167 {
168 for (Offset = 0; Offset < maxReg; Offset++)
169 {
170 PHY_RFShadowCompare(Adapter, eRFPath, Offset);
171 }
172 }
173
174 } /* PHY_RFShadowCompareAll */
175
176
177 VOID
PHY_RFShadowRecorverAll(IN PADAPTER Adapter)178 PHY_RFShadowRecorverAll(
179 IN PADAPTER Adapter)
180 {
181 u8 eRFPath =0;
182 u32 Offset = 0, maxReg= GET_RF6052_REAL_MAX_REG(Adapter);
183
184 for (eRFPath = 0; eRFPath < RF6052_MAX_PATH; eRFPath++)
185 {
186 for (Offset = 0; Offset < maxReg; Offset++)
187 {
188 PHY_RFShadowRecorver(Adapter, eRFPath, Offset);
189 }
190 }
191
192 } /* PHY_RFShadowRecorverAll */
193
194
195 VOID
PHY_RFShadowCompareFlagSet(IN PADAPTER Adapter,IN u8 eRFPath,IN u32 Offset,IN u8 Type)196 PHY_RFShadowCompareFlagSet(
197 IN PADAPTER Adapter,
198 IN u8 eRFPath,
199 IN u32 Offset,
200 IN u8 Type)
201 {
202 // Set True or False!!!
203 RF_Shadow[eRFPath][Offset].Compare = Type;
204
205 } /* PHY_RFShadowCompareFlagSet */
206
207
208 VOID
PHY_RFShadowRecorverFlagSet(IN PADAPTER Adapter,IN u8 eRFPath,IN u32 Offset,IN u8 Type)209 PHY_RFShadowRecorverFlagSet(
210 IN PADAPTER Adapter,
211 IN u8 eRFPath,
212 IN u32 Offset,
213 IN u8 Type)
214 {
215 // Set True or False!!!
216 RF_Shadow[eRFPath][Offset].Recorver= Type;
217
218 } /* PHY_RFShadowRecorverFlagSet */
219
220
221 VOID
PHY_RFShadowCompareFlagSetAll(IN PADAPTER Adapter)222 PHY_RFShadowCompareFlagSetAll(
223 IN PADAPTER Adapter)
224 {
225 u8 eRFPath = 0;
226 u32 Offset = 0, maxReg= GET_RF6052_REAL_MAX_REG(Adapter);
227
228 for (eRFPath = 0; eRFPath < RF6052_MAX_PATH; eRFPath++)
229 {
230 for (Offset = 0; Offset < maxReg; Offset++)
231 {
232 // 2008/11/20 MH For S3S4 test, we only check reg 26/27 now!!!!
233 if (Offset != 0x26 && Offset != 0x27)
234 PHY_RFShadowCompareFlagSet(Adapter, eRFPath, Offset, _FALSE);
235 else
236 PHY_RFShadowCompareFlagSet(Adapter, eRFPath, Offset, _TRUE);
237 }
238 }
239
240 } /* PHY_RFShadowCompareFlagSetAll */
241
242
243 VOID
PHY_RFShadowRecorverFlagSetAll(IN PADAPTER Adapter)244 PHY_RFShadowRecorverFlagSetAll(
245 IN PADAPTER Adapter)
246 {
247 u8 eRFPath = 0;
248 u32 Offset = 0, maxReg= GET_RF6052_REAL_MAX_REG(Adapter);
249
250 for (eRFPath = 0; eRFPath < RF6052_MAX_PATH; eRFPath++)
251 {
252 for (Offset = 0; Offset < maxReg; Offset++)
253 {
254 // 2008/11/20 MH For S3S4 test, we only check reg 26/27 now!!!!
255 if (Offset != 0x26 && Offset != 0x27)
256 PHY_RFShadowRecorverFlagSet(Adapter, eRFPath, Offset, _FALSE);
257 else
258 PHY_RFShadowRecorverFlagSet(Adapter, eRFPath, Offset, _TRUE);
259 }
260 }
261
262 } /* PHY_RFShadowCompareFlagSetAll */
263
264 VOID
PHY_RFShadowRefresh(IN PADAPTER Adapter)265 PHY_RFShadowRefresh(
266 IN PADAPTER Adapter)
267 {
268 u8 eRFPath = 0;
269 u32 Offset = 0, maxReg= GET_RF6052_REAL_MAX_REG(Adapter);
270
271 for (eRFPath = 0; eRFPath < RF6052_MAX_PATH; eRFPath++)
272 {
273 for (Offset = 0; Offset < maxReg; Offset++)
274 {
275 RF_Shadow[eRFPath][Offset].Value = 0;
276 RF_Shadow[eRFPath][Offset].Compare = _FALSE;
277 RF_Shadow[eRFPath][Offset].Recorver = _FALSE;
278 RF_Shadow[eRFPath][Offset].ErrorOrNot = _FALSE;
279 RF_Shadow[eRFPath][Offset].Driver_Write = _FALSE;
280 }
281 }
282
283 } /* PHY_RFShadowRead */
284
285
286