1 // SPDX-License-Identifier: GPL-2.0
2 /******************************************************************************
3  *
4  * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
5  *
6  ******************************************************************************/
7 #include <drv_types.h>
8 #include <rtw_debug.h>
9 #include <hal_data.h>
10 #include <linux/jiffies.h>
11 
12 
13 /* Define global variables */
14 u8 fakeEfuseBank;
15 u32 fakeEfuseUsedBytes;
16 u8 fakeEfuseContent[EFUSE_MAX_HW_SIZE] = {0};
17 u8 fakeEfuseInitMap[EFUSE_MAX_MAP_LEN] = {0};
18 u8 fakeEfuseModifiedMap[EFUSE_MAX_MAP_LEN] = {0};
19 
20 u32 BTEfuseUsedBytes;
21 u8 BTEfuseContent[EFUSE_MAX_BT_BANK][EFUSE_MAX_HW_SIZE];
22 u8 BTEfuseInitMap[EFUSE_BT_MAX_MAP_LEN] = {0};
23 u8 BTEfuseModifiedMap[EFUSE_BT_MAX_MAP_LEN] = {0};
24 
25 u32 fakeBTEfuseUsedBytes;
26 u8 fakeBTEfuseContent[EFUSE_MAX_BT_BANK][EFUSE_MAX_HW_SIZE];
27 u8 fakeBTEfuseInitMap[EFUSE_BT_MAX_MAP_LEN] = {0};
28 u8 fakeBTEfuseModifiedMap[EFUSE_BT_MAX_MAP_LEN] = {0};
29 
30 #define REG_EFUSE_CTRL		0x0030
31 #define EFUSE_CTRL			REG_EFUSE_CTRL		/*  E-Fuse Control. */
32 
33 static bool
Efuse_Read1ByteFromFakeContent(u16 Offset,u8 * Value)34 Efuse_Read1ByteFromFakeContent(u16 Offset, u8 *Value)
35 {
36 	if (Offset >= EFUSE_MAX_HW_SIZE)
37 		return false;
38 	if (fakeEfuseBank == 0)
39 		*Value = fakeEfuseContent[Offset];
40 	else
41 		*Value = fakeBTEfuseContent[fakeEfuseBank-1][Offset];
42 	return true;
43 }
44 
45 static bool
Efuse_Write1ByteToFakeContent(u16 Offset,u8 Value)46 Efuse_Write1ByteToFakeContent(u16 Offset, u8 Value)
47 {
48 	if (Offset >= EFUSE_MAX_HW_SIZE)
49 		return false;
50 	if (fakeEfuseBank == 0)
51 		fakeEfuseContent[Offset] = Value;
52 	else
53 		fakeBTEfuseContent[fakeEfuseBank-1][Offset] = Value;
54 	return true;
55 }
56 
57 /*-----------------------------------------------------------------------------
58  * Function:	Efuse_PowerSwitch
59  *
60  * Overview:	When we want to enable write operation, we should change to
61  *			pwr on state. When we stop write, we should switch to 500k mode
62  *			and disable LDO 2.5V.
63  *
64  * Input:       NONE
65  *
66  * Output:      NONE
67  *
68  * Return:      NONE
69  *
70  * Revised History:
71  * When			Who		Remark
72  * 11/17/2008	MHC		Create Version 0.
73  *
74  *---------------------------------------------------------------------------*/
75 void
Efuse_PowerSwitch(struct adapter * padapter,u8 bWrite,u8 PwrState)76 Efuse_PowerSwitch(
77 struct adapter *padapter,
78 u8 bWrite,
79 u8 PwrState)
80 {
81 	padapter->HalFunc.EfusePowerSwitch(padapter, bWrite, PwrState);
82 }
83 
84 /*-----------------------------------------------------------------------------
85  * Function:	Efuse_GetCurrentSize
86  *
87  * Overview:	Get current efuse size!!!
88  *
89  * Input:       NONE
90  *
91  * Output:      NONE
92  *
93  * Return:      NONE
94  *
95  * Revised History:
96  * When			Who		Remark
97  * 11/16/2008	MHC		Create Version 0.
98  *
99  *---------------------------------------------------------------------------*/
100 u16
Efuse_GetCurrentSize(struct adapter * padapter,u8 efuseType,bool bPseudoTest)101 Efuse_GetCurrentSize(
102 	struct adapter *padapter,
103 	u8	efuseType,
104 	bool		bPseudoTest)
105 {
106 	return padapter->HalFunc.EfuseGetCurrentSize(padapter, efuseType,
107 						     bPseudoTest);
108 }
109 
110 /*  11/16/2008 MH Add description. Get current efuse area enabled word!!. */
111 u8
Efuse_CalculateWordCnts(u8 word_en)112 Efuse_CalculateWordCnts(u8 word_en)
113 {
114 	u8 word_cnts = 0;
115 	if (!(word_en & BIT(0)))
116 		word_cnts++; /*  0 : write enable */
117 	if (!(word_en & BIT(1)))
118 		word_cnts++;
119 	if (!(word_en & BIT(2)))
120 		word_cnts++;
121 	if (!(word_en & BIT(3)))
122 		word_cnts++;
123 	return word_cnts;
124 }
125 
126 /*  */
127 /* Description: */
128 /*		1. Execute E-Fuse read byte operation according as map offset and */
129 /*			save to E-Fuse table. */
130 /*		2. Referred from SD1 Richard. */
131 /*  */
132 /* Assumption: */
133 /*		1. Boot from E-Fuse and successfully auto-load. */
134 /*		2. PASSIVE_LEVEL (USB interface) */
135 /*  */
136 /* Created by Roger, 2008.10.21. */
137 /*  */
138 /* 2008/12/12 MH	1. Reorganize code flow and reserve bytes. and add description. */
139 /*					2. Add efuse utilization collect. */
140 /* 2008/12/22 MH	Read Efuse must check if we write section 1 data again!!! Sec1 */
141 /*					write addr must be after sec5. */
142 /*  */
143 
144 void
145 efuse_ReadEFuse(
146 	struct adapter *Adapter,
147 	u8 efuseType,
148 	u16		_offset,
149 	u16		_size_byte,
150 	u8 *pbuf,
151 bool	bPseudoTest
152 	);
153 void
efuse_ReadEFuse(struct adapter * Adapter,u8 efuseType,u16 _offset,u16 _size_byte,u8 * pbuf,bool bPseudoTest)154 efuse_ReadEFuse(
155 	struct adapter *Adapter,
156 	u8 efuseType,
157 	u16		_offset,
158 	u16		_size_byte,
159 	u8 *pbuf,
160 bool	bPseudoTest
161 	)
162 {
163 	Adapter->HalFunc.ReadEFuse(Adapter, efuseType, _offset, _size_byte, pbuf, bPseudoTest);
164 }
165 
166 void
EFUSE_GetEfuseDefinition(struct adapter * padapter,u8 efuseType,u8 type,void * pOut,bool bPseudoTest)167 EFUSE_GetEfuseDefinition(
168 	struct adapter *padapter,
169 	u8 efuseType,
170 	u8 type,
171 	void	*pOut,
172 	bool		bPseudoTest
173 	)
174 {
175 	padapter->HalFunc.EFUSEGetEfuseDefinition(padapter, efuseType, type, pOut, bPseudoTest);
176 }
177 
178 /*-----------------------------------------------------------------------------
179  * Function:	EFUSE_Read1Byte
180  *
181  * Overview:	Copy from WMAC fot EFUSE read 1 byte.
182  *
183  * Input:       NONE
184  *
185  * Output:      NONE
186  *
187  * Return:      NONE
188  *
189  * Revised History:
190  * When			Who		Remark
191  * 09/23/2008	MHC		Copy from WMAC.
192  *
193  *---------------------------------------------------------------------------*/
194 u8
EFUSE_Read1Byte(struct adapter * Adapter,u16 Address)195 EFUSE_Read1Byte(
196 struct adapter *Adapter,
197 u16		Address)
198 {
199 	u8 Bytetemp = {0x00};
200 	u8 temp = {0x00};
201 	u32 k = 0;
202 	u16 contentLen = 0;
203 
204 	EFUSE_GetEfuseDefinition(Adapter, EFUSE_WIFI, TYPE_EFUSE_REAL_CONTENT_LEN, (void *)&contentLen, false);
205 
206 	if (Address < contentLen) {/* E-fuse 512Byte */
207 		/* Write E-fuse Register address bit0~7 */
208 		temp = Address & 0xFF;
209 		rtw_write8(Adapter, EFUSE_CTRL+1, temp);
210 		Bytetemp = rtw_read8(Adapter, EFUSE_CTRL+2);
211 		/* Write E-fuse Register address bit8~9 */
212 		temp = ((Address >> 8) & 0x03) | (Bytetemp & 0xFC);
213 		rtw_write8(Adapter, EFUSE_CTRL+2, temp);
214 
215 		/* Write 0x30[31]= 0 */
216 		Bytetemp = rtw_read8(Adapter, EFUSE_CTRL+3);
217 		temp = Bytetemp & 0x7F;
218 		rtw_write8(Adapter, EFUSE_CTRL+3, temp);
219 
220 		/* Wait Write-ready (0x30[31]= 1) */
221 		Bytetemp = rtw_read8(Adapter, EFUSE_CTRL+3);
222 		while (!(Bytetemp & 0x80)) {
223 			Bytetemp = rtw_read8(Adapter, EFUSE_CTRL+3);
224 			k++;
225 			if (k == 1000)
226 				break;
227 		}
228 		return rtw_read8(Adapter, EFUSE_CTRL);
229 	} else
230 		return 0xFF;
231 
232 } /* EFUSE_Read1Byte */
233 
234 /*  11/16/2008 MH Read one byte from real Efuse. */
235 u8
efuse_OneByteRead(struct adapter * padapter,u16 addr,u8 * data,bool bPseudoTest)236 efuse_OneByteRead(
237 struct adapter *padapter,
238 u16	addr,
239 u8	*data,
240 bool		bPseudoTest)
241 {
242 	u32 tmpidx = 0;
243 	u8 bResult;
244 	u8 readbyte;
245 
246 	if (bPseudoTest)
247 		return Efuse_Read1ByteFromFakeContent(addr, data);
248 
249 	/*  <20130121, Kordan> For SMIC EFUSE specificatoin. */
250 	/* 0x34[11]: SW force PGMEN input of efuse to high. (for the bank selected by 0x34[9:8]) */
251 	/* PHY_SetMacReg(padapter, 0x34, BIT11, 0); */
252 	rtw_write16(padapter, 0x34, rtw_read16(padapter, 0x34) & (~BIT11));
253 
254 	/*  -----------------e-fuse reg ctrl --------------------------------- */
255 	/* address */
256 	rtw_write8(padapter, EFUSE_CTRL+1, (u8)(addr&0xff));
257 	rtw_write8(padapter, EFUSE_CTRL+2, ((u8)((addr>>8) & 0x03)) |
258 	(rtw_read8(padapter, EFUSE_CTRL+2)&0xFC));
259 
260 	/* rtw_write8(padapter, EFUSE_CTRL+3,  0x72); read cmd */
261 	/* Write bit 32 0 */
262 	readbyte = rtw_read8(padapter, EFUSE_CTRL+3);
263 	rtw_write8(padapter, EFUSE_CTRL+3, (readbyte & 0x7f));
264 
265 	while (!(0x80 & rtw_read8(padapter, EFUSE_CTRL+3)) && (tmpidx < 1000)) {
266 		mdelay(1);
267 		tmpidx++;
268 	}
269 	if (tmpidx < 100) {
270 		*data = rtw_read8(padapter, EFUSE_CTRL);
271 		bResult = true;
272 	} else {
273 		*data = 0xff;
274 		bResult = false;
275 	}
276 
277 	return bResult;
278 }
279 
280 /*  11/16/2008 MH Write one byte to reald Efuse. */
efuse_OneByteWrite(struct adapter * padapter,u16 addr,u8 data,bool bPseudoTest)281 u8 efuse_OneByteWrite(struct adapter *padapter, u16 addr, u8 data, bool bPseudoTest)
282 {
283 	u8 tmpidx = 0;
284 	u8 bResult = false;
285 	u32 efuseValue;
286 
287 	if (bPseudoTest)
288 		return Efuse_Write1ByteToFakeContent(addr, data);
289 
290 
291 	/*  -----------------e-fuse reg ctrl --------------------------------- */
292 	/* address */
293 
294 
295 	efuseValue = rtw_read32(padapter, EFUSE_CTRL);
296 	efuseValue |= (BIT21|BIT31);
297 	efuseValue &= ~(0x3FFFF);
298 	efuseValue |= ((addr<<8 | data) & 0x3FFFF);
299 
300 
301 	/*  <20130227, Kordan> 8192E MP chip A-cut had better not set 0x34[11] until B-Cut. */
302 
303 	/*  <20130121, Kordan> For SMIC EFUSE specificatoin. */
304 	/* 0x34[11]: SW force PGMEN input of efuse to high. (for the bank selected by 0x34[9:8]) */
305 	/* PHY_SetMacReg(padapter, 0x34, BIT11, 1); */
306 	rtw_write16(padapter, 0x34, rtw_read16(padapter, 0x34) | (BIT11));
307 	rtw_write32(padapter, EFUSE_CTRL, 0x90600000|((addr<<8 | data)));
308 
309 	while ((0x80 &  rtw_read8(padapter, EFUSE_CTRL+3)) && (tmpidx < 100)) {
310 		mdelay(1);
311 		tmpidx++;
312 	}
313 
314 	if (tmpidx < 100)
315 		bResult = true;
316 	else
317 		bResult = false;
318 
319 	/*  disable Efuse program enable */
320 	PHY_SetMacReg(padapter, EFUSE_TEST, BIT(11), 0);
321 
322 	return bResult;
323 }
324 
325 int
Efuse_PgPacketRead(struct adapter * padapter,u8 offset,u8 * data,bool bPseudoTest)326 Efuse_PgPacketRead(struct adapter *padapter,
327 				u8	offset,
328 				u8	*data,
329 				bool		bPseudoTest)
330 {
331 	return padapter->HalFunc.Efuse_PgPacketRead(padapter, offset, data,
332 						    bPseudoTest);
333 }
334 
335 int
Efuse_PgPacketWrite(struct adapter * padapter,u8 offset,u8 word_en,u8 * data,bool bPseudoTest)336 Efuse_PgPacketWrite(struct adapter *padapter,
337 				u8	offset,
338 				u8	word_en,
339 				u8	*data,
340 				bool		bPseudoTest)
341 {
342 	return padapter->HalFunc.Efuse_PgPacketWrite(padapter, offset, word_en,
343 						     data, bPseudoTest);
344 }
345 
346 /*-----------------------------------------------------------------------------
347  * Function:	efuse_WordEnableDataRead
348  *
349  * Overview:	Read allowed word in current efuse section data.
350  *
351  * Input:       NONE
352  *
353  * Output:      NONE
354  *
355  * Return:      NONE
356  *
357  * Revised History:
358  * When			Who		Remark
359  * 11/16/2008	MHC		Create Version 0.
360  * 11/21/2008	MHC		Fix Write bug when we only enable late word.
361  *
362  *---------------------------------------------------------------------------*/
363 void
efuse_WordEnableDataRead(u8 word_en,u8 * sourdata,u8 * targetdata)364 efuse_WordEnableDataRead(u8 word_en,
365 						u8 *sourdata,
366 						u8 *targetdata)
367 {
368 	if (!(word_en&BIT(0))) {
369 		targetdata[0] = sourdata[0];
370 		targetdata[1] = sourdata[1];
371 	}
372 	if (!(word_en&BIT(1))) {
373 		targetdata[2] = sourdata[2];
374 		targetdata[3] = sourdata[3];
375 	}
376 	if (!(word_en&BIT(2))) {
377 		targetdata[4] = sourdata[4];
378 		targetdata[5] = sourdata[5];
379 	}
380 	if (!(word_en&BIT(3))) {
381 		targetdata[6] = sourdata[6];
382 		targetdata[7] = sourdata[7];
383 	}
384 }
385 
386 
387 u8
Efuse_WordEnableDataWrite(struct adapter * padapter,u16 efuse_addr,u8 word_en,u8 * data,bool bPseudoTest)388 Efuse_WordEnableDataWrite(struct adapter *padapter,
389 						u16		efuse_addr,
390 						u8 word_en,
391 						u8 *data,
392 						bool		bPseudoTest)
393 {
394 	return padapter->HalFunc.Efuse_WordEnableDataWrite(padapter, efuse_addr,
395 							   word_en, data,
396 							   bPseudoTest);
397 }
398 
399 /*-----------------------------------------------------------------------------
400  * Function:	Efuse_ReadAllMap
401  *
402  * Overview:	Read All Efuse content
403  *
404  * Input:       NONE
405  *
406  * Output:      NONE
407  *
408  * Return:      NONE
409  *
410  * Revised History:
411  * When			Who		Remark
412  * 11/11/2008	MHC		Create Version 0.
413  *
414  *---------------------------------------------------------------------------*/
415 void
416 Efuse_ReadAllMap(
417 	struct adapter *padapter,
418 	u8 efuseType,
419 	u8 *Efuse,
420 	bool		bPseudoTest);
Efuse_ReadAllMap(struct adapter * padapter,u8 efuseType,u8 * Efuse,bool bPseudoTest)421 void Efuse_ReadAllMap(struct adapter *padapter, u8 efuseType, u8 *Efuse, bool bPseudoTest)
422 {
423 	u16 mapLen = 0;
424 
425 	Efuse_PowerSwitch(padapter, false, true);
426 
427 	EFUSE_GetEfuseDefinition(padapter, efuseType, TYPE_EFUSE_MAP_LEN, (void *)&mapLen, bPseudoTest);
428 
429 	efuse_ReadEFuse(padapter, efuseType, 0, mapLen, Efuse, bPseudoTest);
430 
431 	Efuse_PowerSwitch(padapter, false, false);
432 }
433 
434 /*-----------------------------------------------------------------------------
435  * Function:	efuse_ShadowRead1Byte
436  *		efuse_ShadowRead2Byte
437  *		efuse_ShadowRead4Byte
438  *
439  * Overview:	Read from efuse init map by one/two/four bytes !!!!!
440  *
441  * Input:       NONE
442  *
443  * Output:      NONE
444  *
445  * Return:      NONE
446  *
447  * Revised History:
448  * When			Who		Remark
449  * 11/12/2008	MHC		Create Version 0.
450  *
451  *---------------------------------------------------------------------------*/
efuse_ShadowRead1Byte(struct adapter * padapter,u16 Offset,u8 * Value)452 static void efuse_ShadowRead1Byte(struct adapter *padapter, u16 Offset, u8 *Value)
453 {
454 	struct eeprom_priv *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
455 
456 	*Value = pEEPROM->efuse_eeprom_data[Offset];
457 
458 }	/*  EFUSE_ShadowRead1Byte */
459 
460 /* Read Two Bytes */
efuse_ShadowRead2Byte(struct adapter * padapter,u16 Offset,u16 * Value)461 static void efuse_ShadowRead2Byte(struct adapter *padapter, u16 Offset, u16 *Value)
462 {
463 	struct eeprom_priv *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
464 
465 	*Value = pEEPROM->efuse_eeprom_data[Offset];
466 	*Value |= pEEPROM->efuse_eeprom_data[Offset+1]<<8;
467 
468 }	/*  EFUSE_ShadowRead2Byte */
469 
470 /* Read Four Bytes */
efuse_ShadowRead4Byte(struct adapter * padapter,u16 Offset,u32 * Value)471 static void efuse_ShadowRead4Byte(struct adapter *padapter, u16 Offset, u32 *Value)
472 {
473 	struct eeprom_priv *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
474 
475 	*Value = pEEPROM->efuse_eeprom_data[Offset];
476 	*Value |= pEEPROM->efuse_eeprom_data[Offset+1]<<8;
477 	*Value |= pEEPROM->efuse_eeprom_data[Offset+2]<<16;
478 	*Value |= pEEPROM->efuse_eeprom_data[Offset+3]<<24;
479 
480 }	/*  efuse_ShadowRead4Byte */
481 
482 /*-----------------------------------------------------------------------------
483  * Function:	EFUSE_ShadowMapUpdate
484  *
485  * Overview:	Transfer current EFUSE content to shadow init and modify map.
486  *
487  * Input:       NONE
488  *
489  * Output:      NONE
490  *
491  * Return:      NONE
492  *
493  * Revised History:
494  * When			Who		Remark
495  * 11/13/2008	MHC		Create Version 0.
496  *
497  *---------------------------------------------------------------------------*/
EFUSE_ShadowMapUpdate(struct adapter * padapter,u8 efuseType,bool bPseudoTest)498 void EFUSE_ShadowMapUpdate(struct adapter *padapter, u8 efuseType, bool bPseudoTest)
499 {
500 	struct eeprom_priv *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
501 	u16 mapLen = 0;
502 
503 	EFUSE_GetEfuseDefinition(padapter, efuseType, TYPE_EFUSE_MAP_LEN, (void *)&mapLen, bPseudoTest);
504 
505 	if (pEEPROM->bautoload_fail_flag)
506 		memset(pEEPROM->efuse_eeprom_data, 0xFF, mapLen);
507 	else
508 		Efuse_ReadAllMap(padapter, efuseType, pEEPROM->efuse_eeprom_data, bPseudoTest);
509 
510 	/* PlatformMoveMemory((void *)&pHalData->EfuseMap[EFUSE_MODIFY_MAP][0], */
511 	/* void *)&pHalData->EfuseMap[EFUSE_INIT_MAP][0], mapLen); */
512 } /*  EFUSE_ShadowMapUpdate */
513 
514 
515 /*-----------------------------------------------------------------------------
516  * Function:	EFUSE_ShadowRead
517  *
518  * Overview:	Read from efuse init map !!!!!
519  *
520  * Input:       NONE
521  *
522  * Output:      NONE
523  *
524  * Return:      NONE
525  *
526  * Revised History:
527  * When			Who		Remark
528  * 11/12/2008	MHC		Create Version 0.
529  *
530  *---------------------------------------------------------------------------*/
EFUSE_ShadowRead(struct adapter * padapter,u8 Type,u16 Offset,u32 * Value)531 void EFUSE_ShadowRead(struct adapter *padapter, u8 Type, u16 Offset, u32 *Value)
532 {
533 	if (Type == 1)
534 		efuse_ShadowRead1Byte(padapter, Offset, (u8 *)Value);
535 	else if (Type == 2)
536 		efuse_ShadowRead2Byte(padapter, Offset, (u16 *)Value);
537 	else if (Type == 4)
538 		efuse_ShadowRead4Byte(padapter, Offset, (u32 *)Value);
539 
540 }	/* EFUSE_ShadowRead*/
541