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 if (((BitMask >> i) & 0x1) == 1)
50 break;
51 }
52
53 return i;
54 }
55
56
57 /*
58 * ==> RF shadow Operation API Code Section!!!
59 *
60 *-----------------------------------------------------------------------------
61 * Function: PHY_RFShadowRead
62 * PHY_RFShadowWrite
63 * PHY_RFShadowCompare
64 * PHY_RFShadowRecorver
65 * PHY_RFShadowCompareAll
66 * PHY_RFShadowRecorverAll
67 * PHY_RFShadowCompareFlagSet
68 * PHY_RFShadowRecorverFlagSet
69 *
70 * Overview: When we set RF register, we must write shadow at first.
71 * When we are running, we must compare shadow abd locate error addr.
72 * Decide to recorver or not.
73 *
74 * Input: NONE
75 *
76 * Output: NONE
77 *
78 * Return: NONE
79 *
80 * Revised History:
81 * When Who Remark
82 * 11/20/2008 MHC Create Version 0.
83 *
84 *---------------------------------------------------------------------------*/
85 u32
PHY_RFShadowRead(IN PADAPTER Adapter,IN u8 eRFPath,IN u32 Offset)86 PHY_RFShadowRead(
87 IN PADAPTER Adapter,
88 IN u8 eRFPath,
89 IN u32 Offset)
90 {
91 return RF_Shadow[eRFPath][Offset].Value;
92
93 } /* PHY_RFShadowRead */
94
95
96 VOID
PHY_RFShadowWrite(IN PADAPTER Adapter,IN u8 eRFPath,IN u32 Offset,IN u32 Data)97 PHY_RFShadowWrite(
98 IN PADAPTER Adapter,
99 IN u8 eRFPath,
100 IN u32 Offset,
101 IN u32 Data)
102 {
103 RF_Shadow[eRFPath][Offset].Value = (Data & bRFRegOffsetMask);
104 RF_Shadow[eRFPath][Offset].Driver_Write = _TRUE;
105
106 } /* PHY_RFShadowWrite */
107
108
109 BOOLEAN
PHY_RFShadowCompare(IN PADAPTER Adapter,IN u8 eRFPath,IN u32 Offset)110 PHY_RFShadowCompare(
111 IN PADAPTER Adapter,
112 IN u8 eRFPath,
113 IN u32 Offset)
114 {
115 u32 reg;
116 /* Check if we need to check the register */
117 if (RF_Shadow[eRFPath][Offset].Compare == _TRUE) {
118 reg = rtw_hal_read_rfreg(Adapter, eRFPath, Offset, bRFRegOffsetMask);
119 /* Compare shadow and real rf register for 20bits!! */
120 if (RF_Shadow[eRFPath][Offset].Value != reg) {
121 /* Locate error position. */
122 RF_Shadow[eRFPath][Offset].ErrorOrNot = _TRUE;
123 /* RT_TRACE(COMP_INIT, DBG_LOUD, */
124 /* ("PHY_RFShadowCompare RF-%d Addr%02lx Err = %05lx\n", */
125 /* eRFPath, Offset, reg)); */
126 }
127 return RF_Shadow[eRFPath][Offset].ErrorOrNot ;
128 }
129 return _FALSE;
130 } /* PHY_RFShadowCompare */
131
132
133 VOID
PHY_RFShadowRecorver(IN PADAPTER Adapter,IN u8 eRFPath,IN u32 Offset)134 PHY_RFShadowRecorver(
135 IN PADAPTER Adapter,
136 IN u8 eRFPath,
137 IN u32 Offset)
138 {
139 /* Check if the address is error */
140 if (RF_Shadow[eRFPath][Offset].ErrorOrNot == _TRUE) {
141 /* Check if we need to recorver the register. */
142 if (RF_Shadow[eRFPath][Offset].Recorver == _TRUE) {
143 rtw_hal_write_rfreg(Adapter, eRFPath, Offset, bRFRegOffsetMask,
144 RF_Shadow[eRFPath][Offset].Value);
145 /* RT_TRACE(COMP_INIT, DBG_LOUD, */
146 /* ("PHY_RFShadowRecorver RF-%d Addr%02lx=%05lx", */
147 /* eRFPath, Offset, RF_Shadow[eRFPath][Offset].Value)); */
148 }
149 }
150
151 } /* PHY_RFShadowRecorver */
152
153
154 VOID
PHY_RFShadowCompareAll(IN PADAPTER Adapter)155 PHY_RFShadowCompareAll(
156 IN PADAPTER Adapter)
157 {
158 u8 eRFPath = 0 ;
159 u32 Offset = 0, maxReg = GET_RF6052_REAL_MAX_REG(Adapter);
160
161 for (eRFPath = 0; eRFPath < RF6052_MAX_PATH; eRFPath++) {
162 for (Offset = 0; Offset < maxReg; Offset++)
163 PHY_RFShadowCompare(Adapter, eRFPath, Offset);
164 }
165
166 } /* PHY_RFShadowCompareAll */
167
168
169 VOID
PHY_RFShadowRecorverAll(IN PADAPTER Adapter)170 PHY_RFShadowRecorverAll(
171 IN PADAPTER Adapter)
172 {
173 u8 eRFPath = 0;
174 u32 Offset = 0, maxReg = GET_RF6052_REAL_MAX_REG(Adapter);
175
176 for (eRFPath = 0; eRFPath < RF6052_MAX_PATH; eRFPath++) {
177 for (Offset = 0; Offset < maxReg; Offset++)
178 PHY_RFShadowRecorver(Adapter, eRFPath, Offset);
179 }
180
181 } /* PHY_RFShadowRecorverAll */
182
183
184 VOID
PHY_RFShadowCompareFlagSet(IN PADAPTER Adapter,IN u8 eRFPath,IN u32 Offset,IN u8 Type)185 PHY_RFShadowCompareFlagSet(
186 IN PADAPTER Adapter,
187 IN u8 eRFPath,
188 IN u32 Offset,
189 IN u8 Type)
190 {
191 /* Set True or False!!! */
192 RF_Shadow[eRFPath][Offset].Compare = Type;
193
194 } /* PHY_RFShadowCompareFlagSet */
195
196
197 VOID
PHY_RFShadowRecorverFlagSet(IN PADAPTER Adapter,IN u8 eRFPath,IN u32 Offset,IN u8 Type)198 PHY_RFShadowRecorverFlagSet(
199 IN PADAPTER Adapter,
200 IN u8 eRFPath,
201 IN u32 Offset,
202 IN u8 Type)
203 {
204 /* Set True or False!!! */
205 RF_Shadow[eRFPath][Offset].Recorver = Type;
206
207 } /* PHY_RFShadowRecorverFlagSet */
208
209
210 VOID
PHY_RFShadowCompareFlagSetAll(IN PADAPTER Adapter)211 PHY_RFShadowCompareFlagSetAll(
212 IN PADAPTER Adapter)
213 {
214 u8 eRFPath = 0;
215 u32 Offset = 0, maxReg = GET_RF6052_REAL_MAX_REG(Adapter);
216
217 for (eRFPath = 0; eRFPath < RF6052_MAX_PATH; eRFPath++) {
218 for (Offset = 0; Offset < maxReg; Offset++) {
219 /* 2008/11/20 MH For S3S4 test, we only check reg 26/27 now!!!! */
220 if (Offset != 0x26 && Offset != 0x27)
221 PHY_RFShadowCompareFlagSet(Adapter, eRFPath, Offset, _FALSE);
222 else
223 PHY_RFShadowCompareFlagSet(Adapter, eRFPath, Offset, _TRUE);
224 }
225 }
226
227 } /* PHY_RFShadowCompareFlagSetAll */
228
229
230 VOID
PHY_RFShadowRecorverFlagSetAll(IN PADAPTER Adapter)231 PHY_RFShadowRecorverFlagSetAll(
232 IN PADAPTER Adapter)
233 {
234 u8 eRFPath = 0;
235 u32 Offset = 0, maxReg = GET_RF6052_REAL_MAX_REG(Adapter);
236
237 for (eRFPath = 0; eRFPath < RF6052_MAX_PATH; eRFPath++) {
238 for (Offset = 0; Offset < maxReg; Offset++) {
239 /* 2008/11/20 MH For S3S4 test, we only check reg 26/27 now!!!! */
240 if (Offset != 0x26 && Offset != 0x27)
241 PHY_RFShadowRecorverFlagSet(Adapter, eRFPath, Offset, _FALSE);
242 else
243 PHY_RFShadowRecorverFlagSet(Adapter, eRFPath, Offset, _TRUE);
244 }
245 }
246
247 } /* PHY_RFShadowCompareFlagSetAll */
248
249 VOID
PHY_RFShadowRefresh(IN PADAPTER Adapter)250 PHY_RFShadowRefresh(
251 IN PADAPTER Adapter)
252 {
253 u8 eRFPath = 0;
254 u32 Offset = 0, maxReg = GET_RF6052_REAL_MAX_REG(Adapter);
255
256 for (eRFPath = 0; eRFPath < RF6052_MAX_PATH; eRFPath++) {
257 for (Offset = 0; Offset < maxReg; Offset++) {
258 RF_Shadow[eRFPath][Offset].Value = 0;
259 RF_Shadow[eRFPath][Offset].Compare = _FALSE;
260 RF_Shadow[eRFPath][Offset].Recorver = _FALSE;
261 RF_Shadow[eRFPath][Offset].ErrorOrNot = _FALSE;
262 RF_Shadow[eRFPath][Offset].Driver_Write = _FALSE;
263 }
264 }
265
266 } /* PHY_RFShadowRead */
267