1 /******************************************************************************
3 * Copyright(c) 2009-2012 Realtek Corporation.
5 * Tmis 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.
9 * Tmis 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
14 * You should have received a copy of the GNU General Public License along with
15 * tmis program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
18 * Tme full GNU General Public License is included in this distribution in the
19 * file called LICENSE.
21 * Contact Information:
22 * wlanfae <wlanfae@realtek.com>
23 * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
24 * Hsinchu 300, Taiwan.
26 * Larry Finger <Larry.Finger@lwfinger.net>
28 *****************************************************************************/
30 #include <linux/export.h>
34 static const u8 MAX_PGPKT_SIZE
= 9;
35 static const u8 PGPKT_DATA_SIZE
= 8;
36 static const int EFUSE_MAX_SIZE
= 512;
38 static const struct efuse_map RTL8712_SDIO_EFUSE_TABLE
[] = {
54 static void efuse_shadow_read_1byte(struct ieee80211_hw
*hw
, u16 offset
,
56 static void efuse_shadow_read_2byte(struct ieee80211_hw
*hw
, u16 offset
,
58 static void efuse_shadow_read_4byte(struct ieee80211_hw
*hw
, u16 offset
,
60 static void efuse_shadow_write_1byte(struct ieee80211_hw
*hw
, u16 offset
,
62 static void efuse_shadow_write_2byte(struct ieee80211_hw
*hw
, u16 offset
,
64 static void efuse_shadow_write_4byte(struct ieee80211_hw
*hw
, u16 offset
,
66 static int efuse_one_byte_read(struct ieee80211_hw
*hw
, u16 addr
,
68 static int efuse_one_byte_write(struct ieee80211_hw
*hw
, u16 addr
,
70 static void efuse_read_all_map(struct ieee80211_hw
*hw
, u8
*efuse
);
71 static int efuse_pg_packet_read(struct ieee80211_hw
*hw
, u8 offset
,
73 static int efuse_pg_packet_write(struct ieee80211_hw
*hw
, u8 offset
,
74 u8 word_en
, u8
*data
);
75 static void efuse_word_enable_data_read(u8 word_en
, u8
*sourdata
,
77 static u8
efuse_word_enable_data_write(struct ieee80211_hw
*hw
,
78 u16 efuse_addr
, u8 word_en
, u8
*data
);
79 static void efuse_power_switch(struct ieee80211_hw
*hw
, u8 write
,
81 static u16
efuse_get_current_size(struct ieee80211_hw
*hw
);
82 static u8
efuse_calculate_word_cnts(u8 word_en
);
84 void efuse_initialize(struct ieee80211_hw
*hw
)
86 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
90 bytetemp
= rtl_read_byte(rtlpriv
, rtlpriv
->cfg
->maps
[SYS_FUNC_EN
] + 1);
91 temp
= bytetemp
| 0x20;
92 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[SYS_FUNC_EN
] + 1, temp
);
94 bytetemp
= rtl_read_byte(rtlpriv
, rtlpriv
->cfg
->maps
[SYS_ISO_CTRL
] + 1);
95 temp
= bytetemp
& 0xFE;
96 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[SYS_ISO_CTRL
] + 1, temp
);
98 bytetemp
= rtl_read_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_TEST
] + 3);
99 temp
= bytetemp
| 0x80;
100 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_TEST
] + 3, temp
);
102 rtl_write_byte(rtlpriv
, 0x2F8, 0x3);
104 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3, 0x72);
108 u8
efuse_read_1byte(struct ieee80211_hw
*hw
, u16 address
)
110 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
115 const u32 efuse_len
=
116 rtlpriv
->cfg
->maps
[EFUSE_REAL_CONTENT_SIZE
];
118 if (address
< efuse_len
) {
119 temp
= address
& 0xFF;
120 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 1,
122 bytetemp
= rtl_read_byte(rtlpriv
,
123 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 2);
124 temp
= ((address
>> 8) & 0x03) | (bytetemp
& 0xFC);
125 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 2,
128 bytetemp
= rtl_read_byte(rtlpriv
,
129 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3);
130 temp
= bytetemp
& 0x7F;
131 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3,
134 bytetemp
= rtl_read_byte(rtlpriv
,
135 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3);
136 while (!(bytetemp
& 0x80)) {
137 bytetemp
= rtl_read_byte(rtlpriv
,
139 maps
[EFUSE_CTRL
] + 3);
146 data
= rtl_read_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
]);
152 EXPORT_SYMBOL(efuse_read_1byte
);
154 void efuse_write_1byte(struct ieee80211_hw
*hw
, u16 address
, u8 value
)
156 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
160 const u32 efuse_len
=
161 rtlpriv
->cfg
->maps
[EFUSE_REAL_CONTENT_SIZE
];
163 RT_TRACE(rtlpriv
, COMP_EFUSE
, DBG_LOUD
, "Addr=%x Data =%x\n",
166 if (address
< efuse_len
) {
167 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
], value
);
169 temp
= address
& 0xFF;
170 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 1,
172 bytetemp
= rtl_read_byte(rtlpriv
,
173 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 2);
175 temp
= ((address
>> 8) & 0x03) | (bytetemp
& 0xFC);
176 rtl_write_byte(rtlpriv
,
177 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 2, temp
);
179 bytetemp
= rtl_read_byte(rtlpriv
,
180 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3);
181 temp
= bytetemp
| 0x80;
182 rtl_write_byte(rtlpriv
,
183 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3, temp
);
185 bytetemp
= rtl_read_byte(rtlpriv
,
186 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3);
188 while (bytetemp
& 0x80) {
189 bytetemp
= rtl_read_byte(rtlpriv
,
191 maps
[EFUSE_CTRL
] + 3);
202 void read_efuse_byte(struct ieee80211_hw
*hw
, u16 _offset
, u8
*pbuf
)
204 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
209 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 1,
211 readbyte
= rtl_read_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 2);
212 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 2,
213 ((_offset
>> 8) & 0x03) | (readbyte
& 0xfc));
215 readbyte
= rtl_read_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3);
216 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3,
220 value32
= rtl_read_dword(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
]);
221 while (!(((value32
>> 24) & 0xff) & 0x80) && (retry
< 10000)) {
222 value32
= rtl_read_dword(rtlpriv
,
223 rtlpriv
->cfg
->maps
[EFUSE_CTRL
]);
228 value32
= rtl_read_dword(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
]);
230 *pbuf
= (u8
) (value32
& 0xff);
233 void read_efuse(struct ieee80211_hw
*hw
, u16 _offset
, u16 _size_byte
, u8
*pbuf
)
235 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
236 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
244 const u16 efuse_max_section
=
245 rtlpriv
->cfg
->maps
[EFUSE_MAX_SECTION_MAP
];
246 const u32 efuse_len
=
247 rtlpriv
->cfg
->maps
[EFUSE_REAL_CONTENT_SIZE
];
249 u16 efuse_utilized
= 0;
252 if ((_offset
+ _size_byte
) > rtlpriv
->cfg
->maps
[EFUSE_HWSET_MAX_SIZE
]) {
253 RT_TRACE(rtlpriv
, COMP_EFUSE
, DBG_LOUD
,
254 "read_efuse(): Invalid offset(%#x) with read bytes(%#x)!!\n",
255 _offset
, _size_byte
);
259 /* allocate memory for efuse_tbl and efuse_word */
260 efuse_tbl
= kmalloc(rtlpriv
->cfg
->maps
[EFUSE_HWSET_MAX_SIZE
] *
261 sizeof(u8
), GFP_ATOMIC
);
264 efuse_word
= kmalloc(EFUSE_MAX_WORD_UNIT
* sizeof(u16
*), GFP_ATOMIC
);
267 for (i
= 0; i
< EFUSE_MAX_WORD_UNIT
; i
++) {
268 efuse_word
[i
] = kmalloc(efuse_max_section
* sizeof(u16
),
274 for (i
= 0; i
< efuse_max_section
; i
++)
275 for (j
= 0; j
< EFUSE_MAX_WORD_UNIT
; j
++)
276 efuse_word
[j
][i
] = 0xFFFF;
278 read_efuse_byte(hw
, efuse_addr
, rtemp8
);
279 if (*rtemp8
!= 0xFF) {
281 RTPRINT(rtlpriv
, FEEPROM
, EFUSE_READ_ALL
,
282 "Addr=%d\n", efuse_addr
);
286 while ((*rtemp8
!= 0xFF) && (efuse_addr
< efuse_len
)) {
287 /* Check PG header for section num. */
288 if ((*rtemp8
& 0x1F) == 0x0F) {/* extended header */
289 u1temp
= ((*rtemp8
& 0xE0) >> 5);
290 read_efuse_byte(hw
, efuse_addr
, rtemp8
);
292 if ((*rtemp8
& 0x0F) == 0x0F) {
294 read_efuse_byte(hw
, efuse_addr
, rtemp8
);
296 if (*rtemp8
!= 0xFF &&
297 (efuse_addr
< efuse_len
)) {
302 offset
= ((*rtemp8
& 0xF0) >> 1) | u1temp
;
303 wren
= (*rtemp8
& 0x0F);
307 offset
= ((*rtemp8
>> 4) & 0x0f);
308 wren
= (*rtemp8
& 0x0f);
311 if (offset
< efuse_max_section
) {
312 RTPRINT(rtlpriv
, FEEPROM
, EFUSE_READ_ALL
,
313 "offset-%d Worden=%x\n", offset
, wren
);
315 for (i
= 0; i
< EFUSE_MAX_WORD_UNIT
; i
++) {
316 if (!(wren
& 0x01)) {
317 RTPRINT(rtlpriv
, FEEPROM
,
319 "Addr=%d\n", efuse_addr
);
321 read_efuse_byte(hw
, efuse_addr
, rtemp8
);
324 efuse_word
[i
][offset
] =
327 if (efuse_addr
>= efuse_len
)
330 RTPRINT(rtlpriv
, FEEPROM
,
332 "Addr=%d\n", efuse_addr
);
334 read_efuse_byte(hw
, efuse_addr
, rtemp8
);
337 efuse_word
[i
][offset
] |=
338 (((u16
)*rtemp8
<< 8) & 0xff00);
340 if (efuse_addr
>= efuse_len
)
348 RTPRINT(rtlpriv
, FEEPROM
, EFUSE_READ_ALL
,
349 "Addr=%d\n", efuse_addr
);
350 read_efuse_byte(hw
, efuse_addr
, rtemp8
);
351 if (*rtemp8
!= 0xFF && (efuse_addr
< efuse_len
)) {
357 for (i
= 0; i
< efuse_max_section
; i
++) {
358 for (j
= 0; j
< EFUSE_MAX_WORD_UNIT
; j
++) {
359 efuse_tbl
[(i
* 8) + (j
* 2)] =
360 (efuse_word
[j
][i
] & 0xff);
361 efuse_tbl
[(i
* 8) + ((j
* 2) + 1)] =
362 ((efuse_word
[j
][i
] >> 8) & 0xff);
366 for (i
= 0; i
< _size_byte
; i
++)
367 pbuf
[i
] = efuse_tbl
[_offset
+ i
];
369 rtlefuse
->efuse_usedbytes
= efuse_utilized
;
370 efuse_usage
= (u8
) ((efuse_utilized
* 100) / efuse_len
);
371 rtlefuse
->efuse_usedpercentage
= efuse_usage
;
372 rtlpriv
->cfg
->ops
->set_hw_reg(hw
, HW_VAR_EFUSE_BYTES
,
373 (u8
*)&efuse_utilized
);
374 rtlpriv
->cfg
->ops
->set_hw_reg(hw
, HW_VAR_EFUSE_USAGE
,
377 for (i
= 0; i
< EFUSE_MAX_WORD_UNIT
; i
++)
378 kfree(efuse_word
[i
]);
383 bool efuse_shadow_update_chk(struct ieee80211_hw
*hw
)
385 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
386 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
387 u8 section_idx
, i
, Base
;
388 u16 words_need
= 0, hdr_num
= 0, totalbytes
, efuse_used
;
389 bool wordchanged
, result
= true;
391 for (section_idx
= 0; section_idx
< 16; section_idx
++) {
392 Base
= section_idx
* 8;
395 for (i
= 0; i
< 8; i
= i
+ 2) {
396 if ((rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][Base
+ i
] !=
397 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][Base
+ i
]) ||
398 (rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][Base
+ i
+ 1] !=
399 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][Base
+ i
+
410 totalbytes
= hdr_num
+ words_need
* 2;
411 efuse_used
= rtlefuse
->efuse_usedbytes
;
413 if ((totalbytes
+ efuse_used
) >=
415 rtlpriv
->cfg
->maps
[EFUSE_OOB_PROTECT_BYTES_LEN
]))
418 RT_TRACE(rtlpriv
, COMP_EFUSE
, DBG_LOUD
,
419 "efuse_shadow_update_chk(): totalbytes(%#x), hdr_num(%#x), words_need(%#x), efuse_used(%d)\n",
420 totalbytes
, hdr_num
, words_need
, efuse_used
);
425 void efuse_shadow_read(struct ieee80211_hw
*hw
, u8 type
,
426 u16 offset
, u32
*value
)
429 efuse_shadow_read_1byte(hw
, offset
, (u8
*) value
);
431 efuse_shadow_read_2byte(hw
, offset
, (u16
*) value
);
433 efuse_shadow_read_4byte(hw
, offset
, value
);
437 void efuse_shadow_write(struct ieee80211_hw
*hw
, u8 type
, u16 offset
,
441 efuse_shadow_write_1byte(hw
, offset
, (u8
) value
);
443 efuse_shadow_write_2byte(hw
, offset
, (u16
) value
);
445 efuse_shadow_write_4byte(hw
, offset
, value
);
449 bool efuse_shadow_update(struct ieee80211_hw
*hw
)
451 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
452 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
457 RT_TRACE(rtlpriv
, COMP_EFUSE
, DBG_LOUD
, "--->\n");
459 if (!efuse_shadow_update_chk(hw
)) {
460 efuse_read_all_map(hw
, &rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][0]);
461 memcpy(&rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][0],
462 &rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][0],
463 rtlpriv
->cfg
->maps
[EFUSE_HWSET_MAX_SIZE
]);
465 RT_TRACE(rtlpriv
, COMP_EFUSE
, DBG_LOUD
,
466 "<---efuse out of capacity!!\n");
469 efuse_power_switch(hw
, true, true);
471 for (offset
= 0; offset
< 16; offset
++) {
476 for (i
= 0; i
< 8; i
++) {
479 word_en
&= ~(BIT(i
/ 2));
481 rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][base
+ i
] =
482 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][base
+ i
];
485 if (rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][base
+ i
] !=
486 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][base
+ i
]) {
487 word_en
&= ~(BIT(i
/ 2));
489 rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][base
+ i
] =
490 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][base
+ i
];
495 if (word_en
!= 0x0F) {
498 &rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][base
],
500 RT_PRINT_DATA(rtlpriv
, COMP_INIT
, DBG_LOUD
,
501 "U-efuse", tmpdata
, 8);
503 if (!efuse_pg_packet_write(hw
, (u8
) offset
, word_en
,
505 RT_TRACE(rtlpriv
, COMP_ERR
, DBG_WARNING
,
506 "PG section(%#x) fail!!\n", offset
);
513 efuse_power_switch(hw
, true, false);
514 efuse_read_all_map(hw
, &rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][0]);
516 memcpy(&rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][0],
517 &rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][0],
518 rtlpriv
->cfg
->maps
[EFUSE_HWSET_MAX_SIZE
]);
520 RT_TRACE(rtlpriv
, COMP_EFUSE
, DBG_LOUD
, "<---\n");
524 void rtl_efuse_shadow_map_update(struct ieee80211_hw
*hw
)
526 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
527 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
529 if (rtlefuse
->autoload_failflag
)
530 memset(&rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][0], 0xFF,
531 rtlpriv
->cfg
->maps
[EFUSE_HWSET_MAX_SIZE
]);
533 efuse_read_all_map(hw
, &rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][0]);
535 memcpy(&rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][0],
536 &rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][0],
537 rtlpriv
->cfg
->maps
[EFUSE_HWSET_MAX_SIZE
]);
540 EXPORT_SYMBOL(rtl_efuse_shadow_map_update
);
542 void efuse_force_write_vendor_Id(struct ieee80211_hw
*hw
)
544 u8 tmpdata
[8] = { 0xFF, 0xFF, 0xEC, 0x10, 0xFF, 0xFF, 0xFF, 0xFF };
546 efuse_power_switch(hw
, true, true);
548 efuse_pg_packet_write(hw
, 1, 0xD, tmpdata
);
550 efuse_power_switch(hw
, true, false);
554 void efuse_re_pg_section(struct ieee80211_hw
*hw
, u8 section_idx
)
558 static void efuse_shadow_read_1byte(struct ieee80211_hw
*hw
,
559 u16 offset
, u8
*value
)
561 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
562 *value
= rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
];
565 static void efuse_shadow_read_2byte(struct ieee80211_hw
*hw
,
566 u16 offset
, u16
*value
)
568 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
570 *value
= rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
];
571 *value
|= rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
+ 1] << 8;
575 static void efuse_shadow_read_4byte(struct ieee80211_hw
*hw
,
576 u16 offset
, u32
*value
)
578 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
580 *value
= rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
];
581 *value
|= rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
+ 1] << 8;
582 *value
|= rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
+ 2] << 16;
583 *value
|= rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
+ 3] << 24;
586 static void efuse_shadow_write_1byte(struct ieee80211_hw
*hw
,
587 u16 offset
, u8 value
)
589 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
591 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
] = value
;
594 static void efuse_shadow_write_2byte(struct ieee80211_hw
*hw
,
595 u16 offset
, u16 value
)
597 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
599 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
] = value
& 0x00FF;
600 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
+ 1] = value
>> 8;
604 static void efuse_shadow_write_4byte(struct ieee80211_hw
*hw
,
605 u16 offset
, u32 value
)
607 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
609 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
] =
610 (u8
) (value
& 0x000000FF);
611 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
+ 1] =
612 (u8
) ((value
>> 8) & 0x0000FF);
613 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
+ 2] =
614 (u8
) ((value
>> 16) & 0x00FF);
615 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
+ 3] =
616 (u8
) ((value
>> 24) & 0xFF);
620 static int efuse_one_byte_read(struct ieee80211_hw
*hw
, u16 addr
, u8
*data
)
622 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
626 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 1,
628 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 2,
629 ((u8
) ((addr
>> 8) & 0x03)) |
630 (rtl_read_byte(rtlpriv
,
631 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 2) &
634 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3, 0x72);
636 while (!(0x80 & rtl_read_byte(rtlpriv
,
637 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3))
643 *data
= rtl_read_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
]);
652 static int efuse_one_byte_write(struct ieee80211_hw
*hw
, u16 addr
, u8 data
)
654 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
657 RT_TRACE(rtlpriv
, COMP_EFUSE
, DBG_LOUD
, "Addr = %x Data=%x\n",
660 rtl_write_byte(rtlpriv
,
661 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 1, (u8
) (addr
& 0xff));
662 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 2,
663 (rtl_read_byte(rtlpriv
,
664 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] +
665 2) & 0xFC) | (u8
) ((addr
>> 8) & 0x03));
667 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
], data
);
668 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3, 0xF2);
670 while ((0x80 & rtl_read_byte(rtlpriv
,
671 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3))
682 static void efuse_read_all_map(struct ieee80211_hw
*hw
, u8
* efuse
)
684 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
685 efuse_power_switch(hw
, false, true);
686 read_efuse(hw
, 0, rtlpriv
->cfg
->maps
[EFUSE_HWSET_MAX_SIZE
], efuse
);
687 efuse_power_switch(hw
, false, false);
690 static void efuse_read_data_case1(struct ieee80211_hw
*hw
, u16
*efuse_addr
,
691 u8 efuse_data
, u8 offset
, u8
*tmpdata
,
694 bool dataempty
= true;
700 hoffset
= (efuse_data
>> 4) & 0x0F;
701 hworden
= efuse_data
& 0x0F;
702 word_cnts
= efuse_calculate_word_cnts(hworden
);
704 if (hoffset
== offset
) {
705 for (tmpidx
= 0; tmpidx
< word_cnts
* 2; tmpidx
++) {
706 if (efuse_one_byte_read(hw
, *efuse_addr
+ 1 + tmpidx
,
708 tmpdata
[tmpidx
] = efuse_data
;
709 if (efuse_data
!= 0xff)
715 *readstate
= PG_STATE_DATA
;
717 *efuse_addr
= *efuse_addr
+ (word_cnts
* 2) + 1;
718 *readstate
= PG_STATE_HEADER
;
722 *efuse_addr
= *efuse_addr
+ (word_cnts
* 2) + 1;
723 *readstate
= PG_STATE_HEADER
;
727 static int efuse_pg_packet_read(struct ieee80211_hw
*hw
, u8 offset
, u8
*data
)
729 u8 readstate
= PG_STATE_HEADER
;
730 bool continual
= true;
731 u8 efuse_data
, word_cnts
= 0;
740 memset(data
, 0xff, PGPKT_DATA_SIZE
* sizeof(u8
));
741 memset(tmpdata
, 0xff, PGPKT_DATA_SIZE
* sizeof(u8
));
743 while (continual
&& (efuse_addr
< EFUSE_MAX_SIZE
)) {
744 if (readstate
& PG_STATE_HEADER
) {
745 if (efuse_one_byte_read(hw
, efuse_addr
, &efuse_data
)
746 && (efuse_data
!= 0xFF))
747 efuse_read_data_case1(hw
, &efuse_addr
,
753 } else if (readstate
& PG_STATE_DATA
) {
754 efuse_word_enable_data_read(0, tmpdata
, data
);
755 efuse_addr
= efuse_addr
+ (word_cnts
* 2) + 1;
756 readstate
= PG_STATE_HEADER
;
761 if ((data
[0] == 0xff) && (data
[1] == 0xff) &&
762 (data
[2] == 0xff) && (data
[3] == 0xff) &&
763 (data
[4] == 0xff) && (data
[5] == 0xff) &&
764 (data
[6] == 0xff) && (data
[7] == 0xff))
771 static void efuse_write_data_case1(struct ieee80211_hw
*hw
, u16
*efuse_addr
,
772 u8 efuse_data
, u8 offset
, int *continual
,
773 u8
*write_state
, struct pgpkt_struct
*target_pkt
,
774 int *repeat_times
, int *result
, u8 word_en
)
776 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
777 struct pgpkt_struct tmp_pkt
;
778 bool dataempty
= true;
779 u8 originaldata
[8 * sizeof(u8
)];
781 u8 match_word_en
, tmp_word_en
;
783 u8 tmp_header
= efuse_data
;
786 tmp_pkt
.offset
= (tmp_header
>> 4) & 0x0F;
787 tmp_pkt
.word_en
= tmp_header
& 0x0F;
788 tmp_word_cnts
= efuse_calculate_word_cnts(tmp_pkt
.word_en
);
790 if (tmp_pkt
.offset
!= target_pkt
->offset
) {
791 *efuse_addr
= *efuse_addr
+ (tmp_word_cnts
* 2) + 1;
792 *write_state
= PG_STATE_HEADER
;
794 for (tmpindex
= 0; tmpindex
< (tmp_word_cnts
* 2); tmpindex
++) {
795 u16 address
= *efuse_addr
+ 1 + tmpindex
;
796 if (efuse_one_byte_read(hw
, address
,
797 &efuse_data
) && (efuse_data
!= 0xFF))
802 *efuse_addr
= *efuse_addr
+ (tmp_word_cnts
* 2) + 1;
803 *write_state
= PG_STATE_HEADER
;
805 match_word_en
= 0x0F;
806 if (!((target_pkt
->word_en
& BIT(0)) |
807 (tmp_pkt
.word_en
& BIT(0))))
808 match_word_en
&= (~BIT(0));
810 if (!((target_pkt
->word_en
& BIT(1)) |
811 (tmp_pkt
.word_en
& BIT(1))))
812 match_word_en
&= (~BIT(1));
814 if (!((target_pkt
->word_en
& BIT(2)) |
815 (tmp_pkt
.word_en
& BIT(2))))
816 match_word_en
&= (~BIT(2));
818 if (!((target_pkt
->word_en
& BIT(3)) |
819 (tmp_pkt
.word_en
& BIT(3))))
820 match_word_en
&= (~BIT(3));
822 if ((match_word_en
& 0x0F) != 0x0F) {
823 badworden
= efuse_word_enable_data_write(
828 if (0x0F != (badworden
& 0x0F)) {
829 u8 reorg_offset
= offset
;
830 u8 reorg_worden
= badworden
;
831 efuse_pg_packet_write(hw
, reorg_offset
,
837 if ((target_pkt
->word_en
& BIT(0)) ^
838 (match_word_en
& BIT(0)))
839 tmp_word_en
&= (~BIT(0));
841 if ((target_pkt
->word_en
& BIT(1)) ^
842 (match_word_en
& BIT(1)))
843 tmp_word_en
&= (~BIT(1));
845 if ((target_pkt
->word_en
& BIT(2)) ^
846 (match_word_en
& BIT(2)))
847 tmp_word_en
&= (~BIT(2));
849 if ((target_pkt
->word_en
& BIT(3)) ^
850 (match_word_en
& BIT(3)))
851 tmp_word_en
&= (~BIT(3));
853 if ((tmp_word_en
& 0x0F) != 0x0F) {
854 *efuse_addr
= efuse_get_current_size(hw
);
855 target_pkt
->offset
= offset
;
856 target_pkt
->word_en
= tmp_word_en
;
860 *write_state
= PG_STATE_HEADER
;
862 if (*repeat_times
> EFUSE_REPEAT_THRESHOLD_
) {
867 *efuse_addr
+= (2 * tmp_word_cnts
) + 1;
868 target_pkt
->offset
= offset
;
869 target_pkt
->word_en
= word_en
;
870 *write_state
= PG_STATE_HEADER
;
874 RTPRINT(rtlpriv
, FEEPROM
, EFUSE_PG
, "efuse PG_STATE_HEADER-1\n");
877 static void efuse_write_data_case2(struct ieee80211_hw
*hw
, u16
*efuse_addr
,
878 int *continual
, u8
*write_state
,
879 struct pgpkt_struct target_pkt
,
880 int *repeat_times
, int *result
)
882 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
883 struct pgpkt_struct tmp_pkt
;
886 u8 originaldata
[8 * sizeof(u8
)];
890 pg_header
= ((target_pkt
.offset
<< 4) & 0xf0) | target_pkt
.word_en
;
891 efuse_one_byte_write(hw
, *efuse_addr
, pg_header
);
892 efuse_one_byte_read(hw
, *efuse_addr
, &tmp_header
);
894 if (tmp_header
== pg_header
) {
895 *write_state
= PG_STATE_DATA
;
896 } else if (tmp_header
== 0xFF) {
897 *write_state
= PG_STATE_HEADER
;
899 if (*repeat_times
> EFUSE_REPEAT_THRESHOLD_
) {
904 tmp_pkt
.offset
= (tmp_header
>> 4) & 0x0F;
905 tmp_pkt
.word_en
= tmp_header
& 0x0F;
907 tmp_word_cnts
= efuse_calculate_word_cnts(tmp_pkt
.word_en
);
909 memset(originaldata
, 0xff, 8 * sizeof(u8
));
911 if (efuse_pg_packet_read(hw
, tmp_pkt
.offset
, originaldata
)) {
912 badworden
= efuse_word_enable_data_write(hw
,
913 *efuse_addr
+ 1, tmp_pkt
.word_en
,
916 if (0x0F != (badworden
& 0x0F)) {
917 u8 reorg_offset
= tmp_pkt
.offset
;
918 u8 reorg_worden
= badworden
;
919 efuse_pg_packet_write(hw
, reorg_offset
,
922 *efuse_addr
= efuse_get_current_size(hw
);
924 *efuse_addr
= *efuse_addr
+ (tmp_word_cnts
* 2)
928 *efuse_addr
= *efuse_addr
+ (tmp_word_cnts
* 2) + 1;
931 *write_state
= PG_STATE_HEADER
;
933 if (*repeat_times
> EFUSE_REPEAT_THRESHOLD_
) {
938 RTPRINT(rtlpriv
, FEEPROM
, EFUSE_PG
,
939 "efuse PG_STATE_HEADER-2\n");
943 static int efuse_pg_packet_write(struct ieee80211_hw
*hw
,
944 u8 offset
, u8 word_en
, u8
*data
)
946 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
947 struct pgpkt_struct target_pkt
;
948 u8 write_state
= PG_STATE_HEADER
;
949 int continual
= true, result
= true;
952 u8 target_word_cnts
= 0;
954 static int repeat_times
;
956 if (efuse_get_current_size(hw
) >= (EFUSE_MAX_SIZE
-
957 rtlpriv
->cfg
->maps
[EFUSE_OOB_PROTECT_BYTES_LEN
])) {
958 RTPRINT(rtlpriv
, FEEPROM
, EFUSE_PG
,
959 "efuse_pg_packet_write error\n");
963 target_pkt
.offset
= offset
;
964 target_pkt
.word_en
= word_en
;
966 memset(target_pkt
.data
, 0xFF, 8 * sizeof(u8
));
968 efuse_word_enable_data_read(word_en
, data
, target_pkt
.data
);
969 target_word_cnts
= efuse_calculate_word_cnts(target_pkt
.word_en
);
971 RTPRINT(rtlpriv
, FEEPROM
, EFUSE_PG
, "efuse Power ON\n");
973 while (continual
&& (efuse_addr
< (EFUSE_MAX_SIZE
-
974 rtlpriv
->cfg
->maps
[EFUSE_OOB_PROTECT_BYTES_LEN
]))) {
976 if (write_state
== PG_STATE_HEADER
) {
978 RTPRINT(rtlpriv
, FEEPROM
, EFUSE_PG
,
979 "efuse PG_STATE_HEADER\n");
981 if (efuse_one_byte_read(hw
, efuse_addr
, &efuse_data
) &&
982 (efuse_data
!= 0xFF))
983 efuse_write_data_case1(hw
, &efuse_addr
,
986 &write_state
, &target_pkt
,
987 &repeat_times
, &result
,
990 efuse_write_data_case2(hw
, &efuse_addr
,
997 } else if (write_state
== PG_STATE_DATA
) {
998 RTPRINT(rtlpriv
, FEEPROM
, EFUSE_PG
,
999 "efuse PG_STATE_DATA\n");
1001 efuse_word_enable_data_write(hw
, efuse_addr
+ 1,
1005 if ((badworden
& 0x0F) == 0x0F) {
1008 efuse_addr
+= (2 * target_word_cnts
) + 1;
1010 target_pkt
.offset
= offset
;
1011 target_pkt
.word_en
= badworden
;
1013 efuse_calculate_word_cnts(target_pkt
.
1015 write_state
= PG_STATE_HEADER
;
1017 if (repeat_times
> EFUSE_REPEAT_THRESHOLD_
) {
1021 RTPRINT(rtlpriv
, FEEPROM
, EFUSE_PG
,
1022 "efuse PG_STATE_HEADER-3\n");
1027 if (efuse_addr
>= (EFUSE_MAX_SIZE
-
1028 rtlpriv
->cfg
->maps
[EFUSE_OOB_PROTECT_BYTES_LEN
])) {
1029 RT_TRACE(rtlpriv
, COMP_EFUSE
, DBG_LOUD
,
1030 "efuse_addr(%#x) Out of size!!\n", efuse_addr
);
1036 static void efuse_word_enable_data_read(u8 word_en
,
1037 u8
*sourdata
, u8
*targetdata
)
1039 if (!(word_en
& BIT(0))) {
1040 targetdata
[0] = sourdata
[0];
1041 targetdata
[1] = sourdata
[1];
1044 if (!(word_en
& BIT(1))) {
1045 targetdata
[2] = sourdata
[2];
1046 targetdata
[3] = sourdata
[3];
1049 if (!(word_en
& BIT(2))) {
1050 targetdata
[4] = sourdata
[4];
1051 targetdata
[5] = sourdata
[5];
1054 if (!(word_en
& BIT(3))) {
1055 targetdata
[6] = sourdata
[6];
1056 targetdata
[7] = sourdata
[7];
1060 static u8
efuse_word_enable_data_write(struct ieee80211_hw
*hw
,
1061 u16 efuse_addr
, u8 word_en
, u8
*data
)
1063 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1065 u16 start_addr
= efuse_addr
;
1066 u8 badworden
= 0x0F;
1069 memset(tmpdata
, 0xff, PGPKT_DATA_SIZE
);
1070 RT_TRACE(rtlpriv
, COMP_EFUSE
, DBG_LOUD
, "word_en = %x efuse_addr=%x\n",
1071 word_en
, efuse_addr
);
1073 if (!(word_en
& BIT(0))) {
1074 tmpaddr
= start_addr
;
1075 efuse_one_byte_write(hw
, start_addr
++, data
[0]);
1076 efuse_one_byte_write(hw
, start_addr
++, data
[1]);
1078 efuse_one_byte_read(hw
, tmpaddr
, &tmpdata
[0]);
1079 efuse_one_byte_read(hw
, tmpaddr
+ 1, &tmpdata
[1]);
1080 if ((data
[0] != tmpdata
[0]) || (data
[1] != tmpdata
[1]))
1081 badworden
&= (~BIT(0));
1084 if (!(word_en
& BIT(1))) {
1085 tmpaddr
= start_addr
;
1086 efuse_one_byte_write(hw
, start_addr
++, data
[2]);
1087 efuse_one_byte_write(hw
, start_addr
++, data
[3]);
1089 efuse_one_byte_read(hw
, tmpaddr
, &tmpdata
[2]);
1090 efuse_one_byte_read(hw
, tmpaddr
+ 1, &tmpdata
[3]);
1091 if ((data
[2] != tmpdata
[2]) || (data
[3] != tmpdata
[3]))
1092 badworden
&= (~BIT(1));
1095 if (!(word_en
& BIT(2))) {
1096 tmpaddr
= start_addr
;
1097 efuse_one_byte_write(hw
, start_addr
++, data
[4]);
1098 efuse_one_byte_write(hw
, start_addr
++, data
[5]);
1100 efuse_one_byte_read(hw
, tmpaddr
, &tmpdata
[4]);
1101 efuse_one_byte_read(hw
, tmpaddr
+ 1, &tmpdata
[5]);
1102 if ((data
[4] != tmpdata
[4]) || (data
[5] != tmpdata
[5]))
1103 badworden
&= (~BIT(2));
1106 if (!(word_en
& BIT(3))) {
1107 tmpaddr
= start_addr
;
1108 efuse_one_byte_write(hw
, start_addr
++, data
[6]);
1109 efuse_one_byte_write(hw
, start_addr
++, data
[7]);
1111 efuse_one_byte_read(hw
, tmpaddr
, &tmpdata
[6]);
1112 efuse_one_byte_read(hw
, tmpaddr
+ 1, &tmpdata
[7]);
1113 if ((data
[6] != tmpdata
[6]) || (data
[7] != tmpdata
[7]))
1114 badworden
&= (~BIT(3));
1120 static void efuse_power_switch(struct ieee80211_hw
*hw
, u8 write
, u8 pwrstate
)
1122 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1123 struct rtl_hal
*rtlhal
= rtl_hal(rtl_priv(hw
));
1127 if (pwrstate
&& (rtlhal
->hw_type
!= HARDWARE_TYPE_RTL8192SE
)) {
1128 if (rtlhal
->hw_type
== HARDWARE_TYPE_RTL8188EE
)
1129 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_ACCESS
],
1132 tmpV16
= rtl_read_word(rtlpriv
,
1133 rtlpriv
->cfg
->maps
[SYS_ISO_CTRL
]);
1134 if (!(tmpV16
& rtlpriv
->cfg
->maps
[EFUSE_PWC_EV12V
])) {
1135 tmpV16
|= rtlpriv
->cfg
->maps
[EFUSE_PWC_EV12V
];
1136 rtl_write_word(rtlpriv
,
1137 rtlpriv
->cfg
->maps
[SYS_ISO_CTRL
],
1141 tmpV16
= rtl_read_word(rtlpriv
,
1142 rtlpriv
->cfg
->maps
[SYS_FUNC_EN
]);
1143 if (!(tmpV16
& rtlpriv
->cfg
->maps
[EFUSE_FEN_ELDR
])) {
1144 tmpV16
|= rtlpriv
->cfg
->maps
[EFUSE_FEN_ELDR
];
1145 rtl_write_word(rtlpriv
,
1146 rtlpriv
->cfg
->maps
[SYS_FUNC_EN
], tmpV16
);
1149 tmpV16
= rtl_read_word(rtlpriv
, rtlpriv
->cfg
->maps
[SYS_CLK
]);
1150 if ((!(tmpV16
& rtlpriv
->cfg
->maps
[EFUSE_LOADER_CLK_EN
])) ||
1151 (!(tmpV16
& rtlpriv
->cfg
->maps
[EFUSE_ANA8M
]))) {
1152 tmpV16
|= (rtlpriv
->cfg
->maps
[EFUSE_LOADER_CLK_EN
] |
1153 rtlpriv
->cfg
->maps
[EFUSE_ANA8M
]);
1154 rtl_write_word(rtlpriv
,
1155 rtlpriv
->cfg
->maps
[SYS_CLK
], tmpV16
);
1161 tempval
= rtl_read_byte(rtlpriv
,
1162 rtlpriv
->cfg
->maps
[EFUSE_TEST
] +
1165 if (rtlhal
->hw_type
!= HARDWARE_TYPE_RTL8192SE
) {
1167 tempval
|= (VOLTAGE_V25
<< 4);
1170 rtl_write_byte(rtlpriv
,
1171 rtlpriv
->cfg
->maps
[EFUSE_TEST
] + 3,
1175 if (rtlhal
->hw_type
== HARDWARE_TYPE_RTL8192SE
) {
1176 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CLK
],
1181 if (rtlhal
->hw_type
== HARDWARE_TYPE_RTL8188EE
)
1182 rtl_write_byte(rtlpriv
,
1183 rtlpriv
->cfg
->maps
[EFUSE_ACCESS
], 0);
1186 tempval
= rtl_read_byte(rtlpriv
,
1187 rtlpriv
->cfg
->maps
[EFUSE_TEST
] +
1189 rtl_write_byte(rtlpriv
,
1190 rtlpriv
->cfg
->maps
[EFUSE_TEST
] + 3,
1194 if (rtlhal
->hw_type
== HARDWARE_TYPE_RTL8192SE
) {
1195 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CLK
],
1203 static u16
efuse_get_current_size(struct ieee80211_hw
*hw
)
1205 int continual
= true;
1208 u8 efuse_data
, word_cnts
;
1210 while (continual
&& efuse_one_byte_read(hw
, efuse_addr
, &efuse_data
)
1211 && (efuse_addr
< EFUSE_MAX_SIZE
)) {
1212 if (efuse_data
!= 0xFF) {
1213 hworden
= efuse_data
& 0x0F;
1214 word_cnts
= efuse_calculate_word_cnts(hworden
);
1215 efuse_addr
= efuse_addr
+ (word_cnts
* 2) + 1;
1224 static u8
efuse_calculate_word_cnts(u8 word_en
)
1227 if (!(word_en
& BIT(0)))
1229 if (!(word_en
& BIT(1)))
1231 if (!(word_en
& BIT(2)))
1233 if (!(word_en
& BIT(3)))