1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright(c) 2009-2012 Realtek Corporation.*/
7 #include <linux/export.h>
9 static const u8 MAX_PGPKT_SIZE = 9;
10 static const u8 PGPKT_DATA_SIZE = 8;
11 static const int EFUSE_MAX_SIZE = 512;
13 #define START_ADDRESS 0x1000
14 #define REG_MCUFWDL 0x0080
16 static const struct efuse_map RTL8712_SDIO_EFUSE_TABLE[] = {
32 static const struct rtl_efuse_ops efuse_ops = {
33 .efuse_onebyte_read = efuse_one_byte_read,
34 .efuse_logical_map_read = efuse_shadow_read,
37 static void efuse_shadow_read_1byte(struct ieee80211_hw *hw, u16 offset,
39 static void efuse_shadow_read_2byte(struct ieee80211_hw *hw, u16 offset,
41 static void efuse_shadow_read_4byte(struct ieee80211_hw *hw, u16 offset,
43 static void efuse_shadow_write_1byte(struct ieee80211_hw *hw, u16 offset,
45 static void efuse_shadow_write_2byte(struct ieee80211_hw *hw, u16 offset,
47 static void efuse_shadow_write_4byte(struct ieee80211_hw *hw, u16 offset,
49 static int efuse_one_byte_write(struct ieee80211_hw *hw, u16 addr,
51 static void efuse_read_all_map(struct ieee80211_hw *hw, u8 *efuse);
52 static int efuse_pg_packet_read(struct ieee80211_hw *hw, u8 offset,
54 static int efuse_pg_packet_write(struct ieee80211_hw *hw, u8 offset,
55 u8 word_en, u8 *data);
56 static void efuse_word_enable_data_read(u8 word_en, u8 *sourdata,
58 static u8 enable_efuse_data_write(struct ieee80211_hw *hw,
59 u16 efuse_addr, u8 word_en, u8 *data);
60 static u16 efuse_get_current_size(struct ieee80211_hw *hw);
61 static u8 efuse_calculate_word_cnts(u8 word_en);
63 void efuse_initialize(struct ieee80211_hw *hw)
65 struct rtl_priv *rtlpriv = rtl_priv(hw);
69 bytetemp = rtl_read_byte(rtlpriv, rtlpriv->cfg->maps[SYS_FUNC_EN] + 1);
70 temp = bytetemp | 0x20;
71 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[SYS_FUNC_EN] + 1, temp);
73 bytetemp = rtl_read_byte(rtlpriv, rtlpriv->cfg->maps[SYS_ISO_CTRL] + 1);
74 temp = bytetemp & 0xFE;
75 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[SYS_ISO_CTRL] + 1, temp);
77 bytetemp = rtl_read_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_TEST] + 3);
78 temp = bytetemp | 0x80;
79 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_TEST] + 3, temp);
81 rtl_write_byte(rtlpriv, 0x2F8, 0x3);
83 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 3, 0x72);
87 u8 efuse_read_1byte(struct ieee80211_hw *hw, u16 address)
89 struct rtl_priv *rtlpriv = rtl_priv(hw);
95 rtlpriv->cfg->maps[EFUSE_REAL_CONTENT_SIZE];
97 if (address < efuse_len) {
98 temp = address & 0xFF;
99 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 1,
101 bytetemp = rtl_read_byte(rtlpriv,
102 rtlpriv->cfg->maps[EFUSE_CTRL] + 2);
103 temp = ((address >> 8) & 0x03) | (bytetemp & 0xFC);
104 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 2,
107 bytetemp = rtl_read_byte(rtlpriv,
108 rtlpriv->cfg->maps[EFUSE_CTRL] + 3);
109 temp = bytetemp & 0x7F;
110 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 3,
113 bytetemp = rtl_read_byte(rtlpriv,
114 rtlpriv->cfg->maps[EFUSE_CTRL] + 3);
115 while (!(bytetemp & 0x80)) {
116 bytetemp = rtl_read_byte(rtlpriv,
118 maps[EFUSE_CTRL] + 3);
123 data = rtl_read_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL]);
129 EXPORT_SYMBOL(efuse_read_1byte);
131 void efuse_write_1byte(struct ieee80211_hw *hw, u16 address, u8 value)
133 struct rtl_priv *rtlpriv = rtl_priv(hw);
137 const u32 efuse_len =
138 rtlpriv->cfg->maps[EFUSE_REAL_CONTENT_SIZE];
140 RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD, "Addr=%x Data =%x\n",
143 if (address < efuse_len) {
144 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL], value);
146 temp = address & 0xFF;
147 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 1,
149 bytetemp = rtl_read_byte(rtlpriv,
150 rtlpriv->cfg->maps[EFUSE_CTRL] + 2);
152 temp = ((address >> 8) & 0x03) | (bytetemp & 0xFC);
153 rtl_write_byte(rtlpriv,
154 rtlpriv->cfg->maps[EFUSE_CTRL] + 2, temp);
156 bytetemp = rtl_read_byte(rtlpriv,
157 rtlpriv->cfg->maps[EFUSE_CTRL] + 3);
158 temp = bytetemp | 0x80;
159 rtl_write_byte(rtlpriv,
160 rtlpriv->cfg->maps[EFUSE_CTRL] + 3, temp);
162 bytetemp = rtl_read_byte(rtlpriv,
163 rtlpriv->cfg->maps[EFUSE_CTRL] + 3);
165 while (bytetemp & 0x80) {
166 bytetemp = rtl_read_byte(rtlpriv,
168 maps[EFUSE_CTRL] + 3);
179 void read_efuse_byte(struct ieee80211_hw *hw, u16 _offset, u8 *pbuf)
181 struct rtl_priv *rtlpriv = rtl_priv(hw);
186 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 1,
188 readbyte = rtl_read_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 2);
189 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 2,
190 ((_offset >> 8) & 0x03) | (readbyte & 0xfc));
192 readbyte = rtl_read_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 3);
193 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 3,
197 value32 = rtl_read_dword(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL]);
198 while (!(((value32 >> 24) & 0xff) & 0x80) && (retry < 10000)) {
199 value32 = rtl_read_dword(rtlpriv,
200 rtlpriv->cfg->maps[EFUSE_CTRL]);
205 value32 = rtl_read_dword(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL]);
207 *pbuf = (u8) (value32 & 0xff);
209 EXPORT_SYMBOL_GPL(read_efuse_byte);
211 void read_efuse(struct ieee80211_hw *hw, u16 _offset, u16 _size_byte, u8 *pbuf)
213 struct rtl_priv *rtlpriv = rtl_priv(hw);
214 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
222 const u16 efuse_max_section =
223 rtlpriv->cfg->maps[EFUSE_MAX_SECTION_MAP];
224 const u32 efuse_len =
225 rtlpriv->cfg->maps[EFUSE_REAL_CONTENT_SIZE];
227 u16 efuse_utilized = 0;
230 if ((_offset + _size_byte) > rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE]) {
231 RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD,
232 "read_efuse(): Invalid offset(%#x) with read bytes(%#x)!!\n",
233 _offset, _size_byte);
237 /* allocate memory for efuse_tbl and efuse_word */
238 efuse_tbl = kzalloc(rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE],
242 efuse_word = kcalloc(EFUSE_MAX_WORD_UNIT, sizeof(u16 *), GFP_ATOMIC);
245 for (i = 0; i < EFUSE_MAX_WORD_UNIT; i++) {
246 efuse_word[i] = kcalloc(efuse_max_section, sizeof(u16),
252 for (i = 0; i < efuse_max_section; i++)
253 for (j = 0; j < EFUSE_MAX_WORD_UNIT; j++)
254 efuse_word[j][i] = 0xFFFF;
256 read_efuse_byte(hw, efuse_addr, rtemp8);
257 if (*rtemp8 != 0xFF) {
259 RTPRINT(rtlpriv, FEEPROM, EFUSE_READ_ALL,
260 "Addr=%d\n", efuse_addr);
264 while ((*rtemp8 != 0xFF) && (efuse_addr < efuse_len)) {
265 /* Check PG header for section num. */
266 if ((*rtemp8 & 0x1F) == 0x0F) {/* extended header */
267 u1temp = ((*rtemp8 & 0xE0) >> 5);
268 read_efuse_byte(hw, efuse_addr, rtemp8);
270 if ((*rtemp8 & 0x0F) == 0x0F) {
272 read_efuse_byte(hw, efuse_addr, rtemp8);
274 if (*rtemp8 != 0xFF &&
275 (efuse_addr < efuse_len)) {
280 offset = ((*rtemp8 & 0xF0) >> 1) | u1temp;
281 wren = (*rtemp8 & 0x0F);
285 offset = ((*rtemp8 >> 4) & 0x0f);
286 wren = (*rtemp8 & 0x0f);
289 if (offset < efuse_max_section) {
290 RTPRINT(rtlpriv, FEEPROM, EFUSE_READ_ALL,
291 "offset-%d Worden=%x\n", offset, wren);
293 for (i = 0; i < EFUSE_MAX_WORD_UNIT; i++) {
294 if (!(wren & 0x01)) {
295 RTPRINT(rtlpriv, FEEPROM,
297 "Addr=%d\n", efuse_addr);
299 read_efuse_byte(hw, efuse_addr, rtemp8);
302 efuse_word[i][offset] =
305 if (efuse_addr >= efuse_len)
308 RTPRINT(rtlpriv, FEEPROM,
310 "Addr=%d\n", efuse_addr);
312 read_efuse_byte(hw, efuse_addr, rtemp8);
315 efuse_word[i][offset] |=
316 (((u16)*rtemp8 << 8) & 0xff00);
318 if (efuse_addr >= efuse_len)
326 RTPRINT(rtlpriv, FEEPROM, EFUSE_READ_ALL,
327 "Addr=%d\n", efuse_addr);
328 read_efuse_byte(hw, efuse_addr, rtemp8);
329 if (*rtemp8 != 0xFF && (efuse_addr < efuse_len)) {
335 for (i = 0; i < efuse_max_section; i++) {
336 for (j = 0; j < EFUSE_MAX_WORD_UNIT; j++) {
337 efuse_tbl[(i * 8) + (j * 2)] =
338 (efuse_word[j][i] & 0xff);
339 efuse_tbl[(i * 8) + ((j * 2) + 1)] =
340 ((efuse_word[j][i] >> 8) & 0xff);
344 for (i = 0; i < _size_byte; i++)
345 pbuf[i] = efuse_tbl[_offset + i];
347 rtlefuse->efuse_usedbytes = efuse_utilized;
348 efuse_usage = (u8) ((efuse_utilized * 100) / efuse_len);
349 rtlefuse->efuse_usedpercentage = efuse_usage;
350 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_EFUSE_BYTES,
351 (u8 *)&efuse_utilized);
352 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_EFUSE_USAGE,
355 for (i = 0; i < EFUSE_MAX_WORD_UNIT; i++)
356 kfree(efuse_word[i]);
362 bool efuse_shadow_update_chk(struct ieee80211_hw *hw)
364 struct rtl_priv *rtlpriv = rtl_priv(hw);
365 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
366 u8 section_idx, i, base;
367 u16 words_need = 0, hdr_num = 0, totalbytes, efuse_used;
368 bool wordchanged, result = true;
370 for (section_idx = 0; section_idx < 16; section_idx++) {
371 base = section_idx * 8;
374 for (i = 0; i < 8; i = i + 2) {
375 if (rtlefuse->efuse_map[EFUSE_INIT_MAP][base + i] !=
376 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][base + i] ||
377 rtlefuse->efuse_map[EFUSE_INIT_MAP][base + i + 1] !=
378 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][base + i +
389 totalbytes = hdr_num + words_need * 2;
390 efuse_used = rtlefuse->efuse_usedbytes;
392 if ((totalbytes + efuse_used) >=
393 (EFUSE_MAX_SIZE - rtlpriv->cfg->maps[EFUSE_OOB_PROTECT_BYTES_LEN]))
396 RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD,
397 "efuse_shadow_update_chk(): totalbytes(%#x), hdr_num(%#x), words_need(%#x), efuse_used(%d)\n",
398 totalbytes, hdr_num, words_need, efuse_used);
403 void efuse_shadow_read(struct ieee80211_hw *hw, u8 type,
404 u16 offset, u32 *value)
407 efuse_shadow_read_1byte(hw, offset, (u8 *)value);
409 efuse_shadow_read_2byte(hw, offset, (u16 *)value);
411 efuse_shadow_read_4byte(hw, offset, value);
414 EXPORT_SYMBOL(efuse_shadow_read);
416 void efuse_shadow_write(struct ieee80211_hw *hw, u8 type, u16 offset,
420 efuse_shadow_write_1byte(hw, offset, (u8) value);
422 efuse_shadow_write_2byte(hw, offset, (u16) value);
424 efuse_shadow_write_4byte(hw, offset, value);
428 bool efuse_shadow_update(struct ieee80211_hw *hw)
430 struct rtl_priv *rtlpriv = rtl_priv(hw);
431 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
436 RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD, "\n");
438 if (!efuse_shadow_update_chk(hw)) {
439 efuse_read_all_map(hw, &rtlefuse->efuse_map[EFUSE_INIT_MAP][0]);
440 memcpy(&rtlefuse->efuse_map[EFUSE_MODIFY_MAP][0],
441 &rtlefuse->efuse_map[EFUSE_INIT_MAP][0],
442 rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE]);
444 RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD,
445 "efuse out of capacity!!\n");
448 efuse_power_switch(hw, true, true);
450 for (offset = 0; offset < 16; offset++) {
455 for (i = 0; i < 8; i++) {
457 word_en &= ~(BIT(i / 2));
459 rtlefuse->efuse_map[EFUSE_INIT_MAP][base + i] =
460 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][base + i];
463 if (rtlefuse->efuse_map[EFUSE_INIT_MAP][base + i] !=
464 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][base + i]) {
465 word_en &= ~(BIT(i / 2));
467 rtlefuse->efuse_map[EFUSE_INIT_MAP][base + i] =
468 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][base + i];
473 if (word_en != 0x0F) {
477 &rtlefuse->efuse_map[EFUSE_MODIFY_MAP][base],
479 RT_PRINT_DATA(rtlpriv, COMP_INIT, DBG_LOUD,
480 "U-efuse\n", tmpdata, 8);
482 if (!efuse_pg_packet_write(hw, (u8) offset, word_en,
484 RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
485 "PG section(%#x) fail!!\n", offset);
491 efuse_power_switch(hw, true, false);
492 efuse_read_all_map(hw, &rtlefuse->efuse_map[EFUSE_INIT_MAP][0]);
494 memcpy(&rtlefuse->efuse_map[EFUSE_MODIFY_MAP][0],
495 &rtlefuse->efuse_map[EFUSE_INIT_MAP][0],
496 rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE]);
498 RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD, "\n");
502 void rtl_efuse_shadow_map_update(struct ieee80211_hw *hw)
504 struct rtl_priv *rtlpriv = rtl_priv(hw);
505 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
507 if (rtlefuse->autoload_failflag)
508 memset((&rtlefuse->efuse_map[EFUSE_INIT_MAP][0]),
509 0xFF, rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE]);
511 efuse_read_all_map(hw, &rtlefuse->efuse_map[EFUSE_INIT_MAP][0]);
513 memcpy(&rtlefuse->efuse_map[EFUSE_MODIFY_MAP][0],
514 &rtlefuse->efuse_map[EFUSE_INIT_MAP][0],
515 rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE]);
518 EXPORT_SYMBOL(rtl_efuse_shadow_map_update);
520 void efuse_force_write_vendor_id(struct ieee80211_hw *hw)
522 u8 tmpdata[8] = { 0xFF, 0xFF, 0xEC, 0x10, 0xFF, 0xFF, 0xFF, 0xFF };
524 efuse_power_switch(hw, true, true);
526 efuse_pg_packet_write(hw, 1, 0xD, tmpdata);
528 efuse_power_switch(hw, true, false);
532 void efuse_re_pg_section(struct ieee80211_hw *hw, u8 section_idx)
536 static void efuse_shadow_read_1byte(struct ieee80211_hw *hw,
537 u16 offset, u8 *value)
539 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
540 *value = rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset];
543 static void efuse_shadow_read_2byte(struct ieee80211_hw *hw,
544 u16 offset, u16 *value)
546 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
548 *value = rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset];
549 *value |= rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 1] << 8;
553 static void efuse_shadow_read_4byte(struct ieee80211_hw *hw,
554 u16 offset, u32 *value)
556 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
558 *value = rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset];
559 *value |= rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 1] << 8;
560 *value |= rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 2] << 16;
561 *value |= rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 3] << 24;
564 static void efuse_shadow_write_1byte(struct ieee80211_hw *hw,
565 u16 offset, u8 value)
567 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
569 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset] = value;
572 static void efuse_shadow_write_2byte(struct ieee80211_hw *hw,
573 u16 offset, u16 value)
575 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
577 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset] = value & 0x00FF;
578 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 1] = value >> 8;
582 static void efuse_shadow_write_4byte(struct ieee80211_hw *hw,
583 u16 offset, u32 value)
585 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
587 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset] =
588 (u8) (value & 0x000000FF);
589 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 1] =
590 (u8) ((value >> 8) & 0x0000FF);
591 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 2] =
592 (u8) ((value >> 16) & 0x00FF);
593 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 3] =
594 (u8) ((value >> 24) & 0xFF);
598 int efuse_one_byte_read(struct ieee80211_hw *hw, u16 addr, u8 *data)
600 struct rtl_priv *rtlpriv = rtl_priv(hw);
604 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 1,
606 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 2,
607 ((u8) ((addr >> 8) & 0x03)) |
608 (rtl_read_byte(rtlpriv,
609 rtlpriv->cfg->maps[EFUSE_CTRL] + 2) &
612 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 3, 0x72);
614 while (!(0x80 & rtl_read_byte(rtlpriv,
615 rtlpriv->cfg->maps[EFUSE_CTRL] + 3))
621 *data = rtl_read_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL]);
629 EXPORT_SYMBOL(efuse_one_byte_read);
631 static int efuse_one_byte_write(struct ieee80211_hw *hw, u16 addr, u8 data)
633 struct rtl_priv *rtlpriv = rtl_priv(hw);
636 RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD,
637 "Addr = %x Data=%x\n", addr, data);
639 rtl_write_byte(rtlpriv,
640 rtlpriv->cfg->maps[EFUSE_CTRL] + 1, (u8) (addr & 0xff));
641 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 2,
642 (rtl_read_byte(rtlpriv,
643 rtlpriv->cfg->maps[EFUSE_CTRL] +
644 2) & 0xFC) | (u8) ((addr >> 8) & 0x03));
646 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL], data);
647 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 3, 0xF2);
649 while ((0x80 & rtl_read_byte(rtlpriv,
650 rtlpriv->cfg->maps[EFUSE_CTRL] + 3))
660 static void efuse_read_all_map(struct ieee80211_hw *hw, u8 *efuse)
662 struct rtl_priv *rtlpriv = rtl_priv(hw);
664 efuse_power_switch(hw, false, true);
665 read_efuse(hw, 0, rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE], efuse);
666 efuse_power_switch(hw, false, false);
669 static void efuse_read_data_case1(struct ieee80211_hw *hw, u16 *efuse_addr,
670 u8 efuse_data, u8 offset, u8 *tmpdata,
673 bool dataempty = true;
679 hoffset = (efuse_data >> 4) & 0x0F;
680 hworden = efuse_data & 0x0F;
681 word_cnts = efuse_calculate_word_cnts(hworden);
683 if (hoffset == offset) {
684 for (tmpidx = 0; tmpidx < word_cnts * 2; tmpidx++) {
685 if (efuse_one_byte_read(hw, *efuse_addr + 1 + tmpidx,
687 tmpdata[tmpidx] = efuse_data;
688 if (efuse_data != 0xff)
694 *readstate = PG_STATE_DATA;
696 *efuse_addr = *efuse_addr + (word_cnts * 2) + 1;
697 *readstate = PG_STATE_HEADER;
701 *efuse_addr = *efuse_addr + (word_cnts * 2) + 1;
702 *readstate = PG_STATE_HEADER;
706 static int efuse_pg_packet_read(struct ieee80211_hw *hw, u8 offset, u8 *data)
708 u8 readstate = PG_STATE_HEADER;
710 bool continual = true;
712 u8 efuse_data, word_cnts = 0;
721 memset(data, 0xff, PGPKT_DATA_SIZE * sizeof(u8));
722 memset(tmpdata, 0xff, PGPKT_DATA_SIZE * sizeof(u8));
724 while (continual && (efuse_addr < EFUSE_MAX_SIZE)) {
725 if (readstate & PG_STATE_HEADER) {
726 if (efuse_one_byte_read(hw, efuse_addr, &efuse_data)
727 && (efuse_data != 0xFF))
728 efuse_read_data_case1(hw, &efuse_addr,
730 tmpdata, &readstate);
733 } else if (readstate & PG_STATE_DATA) {
734 efuse_word_enable_data_read(0, tmpdata, data);
735 efuse_addr = efuse_addr + (word_cnts * 2) + 1;
736 readstate = PG_STATE_HEADER;
741 if ((data[0] == 0xff) && (data[1] == 0xff) &&
742 (data[2] == 0xff) && (data[3] == 0xff) &&
743 (data[4] == 0xff) && (data[5] == 0xff) &&
744 (data[6] == 0xff) && (data[7] == 0xff))
751 static void efuse_write_data_case1(struct ieee80211_hw *hw, u16 *efuse_addr,
752 u8 efuse_data, u8 offset,
753 int *continual, u8 *write_state,
754 struct pgpkt_struct *target_pkt,
755 int *repeat_times, int *result, u8 word_en)
757 struct rtl_priv *rtlpriv = rtl_priv(hw);
758 struct pgpkt_struct tmp_pkt;
759 int dataempty = true;
760 u8 originaldata[8 * sizeof(u8)];
762 u8 match_word_en, tmp_word_en;
764 u8 tmp_header = efuse_data;
767 tmp_pkt.offset = (tmp_header >> 4) & 0x0F;
768 tmp_pkt.word_en = tmp_header & 0x0F;
769 tmp_word_cnts = efuse_calculate_word_cnts(tmp_pkt.word_en);
771 if (tmp_pkt.offset != target_pkt->offset) {
772 *efuse_addr = *efuse_addr + (tmp_word_cnts * 2) + 1;
773 *write_state = PG_STATE_HEADER;
775 for (tmpindex = 0; tmpindex < (tmp_word_cnts * 2); tmpindex++) {
776 if (efuse_one_byte_read(hw,
777 (*efuse_addr + 1 + tmpindex),
779 (efuse_data != 0xFF))
784 *efuse_addr = *efuse_addr + (tmp_word_cnts * 2) + 1;
785 *write_state = PG_STATE_HEADER;
787 match_word_en = 0x0F;
788 if (!((target_pkt->word_en & BIT(0)) |
789 (tmp_pkt.word_en & BIT(0))))
790 match_word_en &= (~BIT(0));
792 if (!((target_pkt->word_en & BIT(1)) |
793 (tmp_pkt.word_en & BIT(1))))
794 match_word_en &= (~BIT(1));
796 if (!((target_pkt->word_en & BIT(2)) |
797 (tmp_pkt.word_en & BIT(2))))
798 match_word_en &= (~BIT(2));
800 if (!((target_pkt->word_en & BIT(3)) |
801 (tmp_pkt.word_en & BIT(3))))
802 match_word_en &= (~BIT(3));
804 if ((match_word_en & 0x0F) != 0x0F) {
806 enable_efuse_data_write(hw,
811 if (0x0F != (badworden & 0x0F)) {
812 u8 reorg_offset = offset;
813 u8 reorg_worden = badworden;
815 efuse_pg_packet_write(hw, reorg_offset,
821 if ((target_pkt->word_en & BIT(0)) ^
822 (match_word_en & BIT(0)))
823 tmp_word_en &= (~BIT(0));
825 if ((target_pkt->word_en & BIT(1)) ^
826 (match_word_en & BIT(1)))
827 tmp_word_en &= (~BIT(1));
829 if ((target_pkt->word_en & BIT(2)) ^
830 (match_word_en & BIT(2)))
831 tmp_word_en &= (~BIT(2));
833 if ((target_pkt->word_en & BIT(3)) ^
834 (match_word_en & BIT(3)))
835 tmp_word_en &= (~BIT(3));
837 if ((tmp_word_en & 0x0F) != 0x0F) {
838 *efuse_addr = efuse_get_current_size(hw);
839 target_pkt->offset = offset;
840 target_pkt->word_en = tmp_word_en;
844 *write_state = PG_STATE_HEADER;
846 if (*repeat_times > EFUSE_REPEAT_THRESHOLD_) {
851 *efuse_addr += (2 * tmp_word_cnts) + 1;
852 target_pkt->offset = offset;
853 target_pkt->word_en = word_en;
854 *write_state = PG_STATE_HEADER;
858 RTPRINT(rtlpriv, FEEPROM, EFUSE_PG, "efuse PG_STATE_HEADER-1\n");
861 static void efuse_write_data_case2(struct ieee80211_hw *hw, u16 *efuse_addr,
862 int *continual, u8 *write_state,
863 struct pgpkt_struct target_pkt,
864 int *repeat_times, int *result)
866 struct rtl_priv *rtlpriv = rtl_priv(hw);
867 struct pgpkt_struct tmp_pkt;
870 u8 originaldata[8 * sizeof(u8)];
874 pg_header = ((target_pkt.offset << 4) & 0xf0) | target_pkt.word_en;
875 efuse_one_byte_write(hw, *efuse_addr, pg_header);
876 efuse_one_byte_read(hw, *efuse_addr, &tmp_header);
878 if (tmp_header == pg_header) {
879 *write_state = PG_STATE_DATA;
880 } else if (tmp_header == 0xFF) {
881 *write_state = PG_STATE_HEADER;
883 if (*repeat_times > EFUSE_REPEAT_THRESHOLD_) {
888 tmp_pkt.offset = (tmp_header >> 4) & 0x0F;
889 tmp_pkt.word_en = tmp_header & 0x0F;
891 tmp_word_cnts = efuse_calculate_word_cnts(tmp_pkt.word_en);
893 memset(originaldata, 0xff, 8 * sizeof(u8));
895 if (efuse_pg_packet_read(hw, tmp_pkt.offset, originaldata)) {
896 badworden = enable_efuse_data_write(hw,
901 if (0x0F != (badworden & 0x0F)) {
902 u8 reorg_offset = tmp_pkt.offset;
903 u8 reorg_worden = badworden;
905 efuse_pg_packet_write(hw, reorg_offset,
908 *efuse_addr = efuse_get_current_size(hw);
910 *efuse_addr = *efuse_addr +
911 (tmp_word_cnts * 2) + 1;
914 *efuse_addr = *efuse_addr + (tmp_word_cnts * 2) + 1;
917 *write_state = PG_STATE_HEADER;
919 if (*repeat_times > EFUSE_REPEAT_THRESHOLD_) {
924 RTPRINT(rtlpriv, FEEPROM, EFUSE_PG,
925 "efuse PG_STATE_HEADER-2\n");
929 static int efuse_pg_packet_write(struct ieee80211_hw *hw,
930 u8 offset, u8 word_en, u8 *data)
932 struct rtl_priv *rtlpriv = rtl_priv(hw);
933 struct pgpkt_struct target_pkt;
934 u8 write_state = PG_STATE_HEADER;
935 int continual = true, dataempty = true, result = true;
938 u8 target_word_cnts = 0;
940 static int repeat_times;
942 if (efuse_get_current_size(hw) >= (EFUSE_MAX_SIZE -
943 rtlpriv->cfg->maps[EFUSE_OOB_PROTECT_BYTES_LEN])) {
944 RTPRINT(rtlpriv, FEEPROM, EFUSE_PG,
945 "efuse_pg_packet_write error\n");
949 target_pkt.offset = offset;
950 target_pkt.word_en = word_en;
952 memset(target_pkt.data, 0xFF, 8 * sizeof(u8));
954 efuse_word_enable_data_read(word_en, data, target_pkt.data);
955 target_word_cnts = efuse_calculate_word_cnts(target_pkt.word_en);
957 RTPRINT(rtlpriv, FEEPROM, EFUSE_PG, "efuse Power ON\n");
959 while (continual && (efuse_addr < (EFUSE_MAX_SIZE -
960 rtlpriv->cfg->maps[EFUSE_OOB_PROTECT_BYTES_LEN]))) {
961 if (write_state == PG_STATE_HEADER) {
964 RTPRINT(rtlpriv, FEEPROM, EFUSE_PG,
965 "efuse PG_STATE_HEADER\n");
967 if (efuse_one_byte_read(hw, efuse_addr, &efuse_data) &&
968 (efuse_data != 0xFF))
969 efuse_write_data_case1(hw, &efuse_addr,
974 &repeat_times, &result,
977 efuse_write_data_case2(hw, &efuse_addr,
984 } else if (write_state == PG_STATE_DATA) {
985 RTPRINT(rtlpriv, FEEPROM, EFUSE_PG,
986 "efuse PG_STATE_DATA\n");
988 enable_efuse_data_write(hw, efuse_addr + 1,
992 if ((badworden & 0x0F) == 0x0F) {
996 efuse_addr + (2 * target_word_cnts) + 1;
998 target_pkt.offset = offset;
999 target_pkt.word_en = badworden;
1001 efuse_calculate_word_cnts(target_pkt.
1003 write_state = PG_STATE_HEADER;
1005 if (repeat_times > EFUSE_REPEAT_THRESHOLD_) {
1009 RTPRINT(rtlpriv, FEEPROM, EFUSE_PG,
1010 "efuse PG_STATE_HEADER-3\n");
1015 if (efuse_addr >= (EFUSE_MAX_SIZE -
1016 rtlpriv->cfg->maps[EFUSE_OOB_PROTECT_BYTES_LEN])) {
1017 RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD,
1018 "efuse_addr(%#x) Out of size!!\n", efuse_addr);
1024 static void efuse_word_enable_data_read(u8 word_en, u8 *sourdata,
1027 if (!(word_en & BIT(0))) {
1028 targetdata[0] = sourdata[0];
1029 targetdata[1] = sourdata[1];
1032 if (!(word_en & BIT(1))) {
1033 targetdata[2] = sourdata[2];
1034 targetdata[3] = sourdata[3];
1037 if (!(word_en & BIT(2))) {
1038 targetdata[4] = sourdata[4];
1039 targetdata[5] = sourdata[5];
1042 if (!(word_en & BIT(3))) {
1043 targetdata[6] = sourdata[6];
1044 targetdata[7] = sourdata[7];
1048 static u8 enable_efuse_data_write(struct ieee80211_hw *hw,
1049 u16 efuse_addr, u8 word_en, u8 *data)
1051 struct rtl_priv *rtlpriv = rtl_priv(hw);
1053 u16 start_addr = efuse_addr;
1054 u8 badworden = 0x0F;
1057 memset(tmpdata, 0xff, PGPKT_DATA_SIZE);
1058 RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD,
1059 "word_en = %x efuse_addr=%x\n", word_en, efuse_addr);
1061 if (!(word_en & BIT(0))) {
1062 tmpaddr = start_addr;
1063 efuse_one_byte_write(hw, start_addr++, data[0]);
1064 efuse_one_byte_write(hw, start_addr++, data[1]);
1066 efuse_one_byte_read(hw, tmpaddr, &tmpdata[0]);
1067 efuse_one_byte_read(hw, tmpaddr + 1, &tmpdata[1]);
1068 if ((data[0] != tmpdata[0]) || (data[1] != tmpdata[1]))
1069 badworden &= (~BIT(0));
1072 if (!(word_en & BIT(1))) {
1073 tmpaddr = start_addr;
1074 efuse_one_byte_write(hw, start_addr++, data[2]);
1075 efuse_one_byte_write(hw, start_addr++, data[3]);
1077 efuse_one_byte_read(hw, tmpaddr, &tmpdata[2]);
1078 efuse_one_byte_read(hw, tmpaddr + 1, &tmpdata[3]);
1079 if ((data[2] != tmpdata[2]) || (data[3] != tmpdata[3]))
1080 badworden &= (~BIT(1));
1083 if (!(word_en & BIT(2))) {
1084 tmpaddr = start_addr;
1085 efuse_one_byte_write(hw, start_addr++, data[4]);
1086 efuse_one_byte_write(hw, start_addr++, data[5]);
1088 efuse_one_byte_read(hw, tmpaddr, &tmpdata[4]);
1089 efuse_one_byte_read(hw, tmpaddr + 1, &tmpdata[5]);
1090 if ((data[4] != tmpdata[4]) || (data[5] != tmpdata[5]))
1091 badworden &= (~BIT(2));
1094 if (!(word_en & BIT(3))) {
1095 tmpaddr = start_addr;
1096 efuse_one_byte_write(hw, start_addr++, data[6]);
1097 efuse_one_byte_write(hw, start_addr++, data[7]);
1099 efuse_one_byte_read(hw, tmpaddr, &tmpdata[6]);
1100 efuse_one_byte_read(hw, tmpaddr + 1, &tmpdata[7]);
1101 if ((data[6] != tmpdata[6]) || (data[7] != tmpdata[7]))
1102 badworden &= (~BIT(3));
1108 void efuse_power_switch(struct ieee80211_hw *hw, u8 write, u8 pwrstate)
1110 struct rtl_priv *rtlpriv = rtl_priv(hw);
1111 struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
1115 if (pwrstate && (rtlhal->hw_type != HARDWARE_TYPE_RTL8192SE)) {
1116 if (rtlhal->hw_type != HARDWARE_TYPE_RTL8192CE &&
1117 rtlhal->hw_type != HARDWARE_TYPE_RTL8192DE) {
1118 rtl_write_byte(rtlpriv,
1119 rtlpriv->cfg->maps[EFUSE_ACCESS], 0x69);
1122 rtl_read_word(rtlpriv,
1123 rtlpriv->cfg->maps[SYS_ISO_CTRL]);
1124 if (!(tmpv16 & rtlpriv->cfg->maps[EFUSE_PWC_EV12V])) {
1125 tmpv16 |= rtlpriv->cfg->maps[EFUSE_PWC_EV12V];
1126 rtl_write_word(rtlpriv,
1127 rtlpriv->cfg->maps[SYS_ISO_CTRL],
1131 tmpv16 = rtl_read_word(rtlpriv,
1132 rtlpriv->cfg->maps[SYS_FUNC_EN]);
1133 if (!(tmpv16 & rtlpriv->cfg->maps[EFUSE_FEN_ELDR])) {
1134 tmpv16 |= rtlpriv->cfg->maps[EFUSE_FEN_ELDR];
1135 rtl_write_word(rtlpriv,
1136 rtlpriv->cfg->maps[SYS_FUNC_EN], tmpv16);
1139 tmpv16 = rtl_read_word(rtlpriv, rtlpriv->cfg->maps[SYS_CLK]);
1140 if ((!(tmpv16 & rtlpriv->cfg->maps[EFUSE_LOADER_CLK_EN])) ||
1141 (!(tmpv16 & rtlpriv->cfg->maps[EFUSE_ANA8M]))) {
1142 tmpv16 |= (rtlpriv->cfg->maps[EFUSE_LOADER_CLK_EN] |
1143 rtlpriv->cfg->maps[EFUSE_ANA8M]);
1144 rtl_write_word(rtlpriv,
1145 rtlpriv->cfg->maps[SYS_CLK], tmpv16);
1151 tempval = rtl_read_byte(rtlpriv,
1152 rtlpriv->cfg->maps[EFUSE_TEST] +
1155 if (rtlhal->hw_type == HARDWARE_TYPE_RTL8812AE) {
1156 tempval &= ~(BIT(3) | BIT(4) | BIT(5) | BIT(6));
1157 tempval |= (VOLTAGE_V25 << 3);
1158 } else if (rtlhal->hw_type != HARDWARE_TYPE_RTL8192SE) {
1160 tempval |= (VOLTAGE_V25 << 4);
1163 rtl_write_byte(rtlpriv,
1164 rtlpriv->cfg->maps[EFUSE_TEST] + 3,
1168 if (rtlhal->hw_type == HARDWARE_TYPE_RTL8192SE) {
1169 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CLK],
1173 if (rtlhal->hw_type != HARDWARE_TYPE_RTL8192CE &&
1174 rtlhal->hw_type != HARDWARE_TYPE_RTL8192DE)
1175 rtl_write_byte(rtlpriv,
1176 rtlpriv->cfg->maps[EFUSE_ACCESS], 0);
1179 tempval = rtl_read_byte(rtlpriv,
1180 rtlpriv->cfg->maps[EFUSE_TEST] +
1182 rtl_write_byte(rtlpriv,
1183 rtlpriv->cfg->maps[EFUSE_TEST] + 3,
1187 if (rtlhal->hw_type == HARDWARE_TYPE_RTL8192SE) {
1188 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CLK],
1193 EXPORT_SYMBOL(efuse_power_switch);
1195 static u16 efuse_get_current_size(struct ieee80211_hw *hw)
1197 int continual = true;
1199 u8 hoffset, hworden;
1200 u8 efuse_data, word_cnts;
1202 while (continual && efuse_one_byte_read(hw, efuse_addr, &efuse_data) &&
1203 (efuse_addr < EFUSE_MAX_SIZE)) {
1204 if (efuse_data != 0xFF) {
1205 hoffset = (efuse_data >> 4) & 0x0F;
1206 hworden = efuse_data & 0x0F;
1207 word_cnts = efuse_calculate_word_cnts(hworden);
1208 efuse_addr = efuse_addr + (word_cnts * 2) + 1;
1217 static u8 efuse_calculate_word_cnts(u8 word_en)
1221 if (!(word_en & BIT(0)))
1223 if (!(word_en & BIT(1)))
1225 if (!(word_en & BIT(2)))
1227 if (!(word_en & BIT(3)))
1232 int rtl_get_hwinfo(struct ieee80211_hw *hw, struct rtl_priv *rtlpriv,
1233 int max_size, u8 *hwinfo, int *params)
1235 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
1236 struct rtl_pci_priv *rtlpcipriv = rtl_pcipriv(hw);
1237 struct device *dev = &rtlpcipriv->dev.pdev->dev;
1241 switch (rtlefuse->epromtype) {
1242 case EEPROM_BOOT_EFUSE:
1243 rtl_efuse_shadow_map_update(hw);
1247 pr_err("RTL8XXX did not boot from eeprom, check it !!\n");
1251 dev_warn(dev, "no efuse data\n");
1255 memcpy(hwinfo, &rtlefuse->efuse_map[EFUSE_INIT_MAP][0], max_size);
1257 RT_PRINT_DATA(rtlpriv, COMP_INIT, DBG_DMESG, "MAP",
1260 eeprom_id = *((u16 *)&hwinfo[0]);
1261 if (eeprom_id != params[0]) {
1262 RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
1263 "EEPROM ID(%#x) is invalid!!\n", eeprom_id);
1264 rtlefuse->autoload_failflag = true;
1266 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "Autoload OK\n");
1267 rtlefuse->autoload_failflag = false;
1270 if (rtlefuse->autoload_failflag)
1273 rtlefuse->eeprom_vid = *(u16 *)&hwinfo[params[1]];
1274 rtlefuse->eeprom_did = *(u16 *)&hwinfo[params[2]];
1275 rtlefuse->eeprom_svid = *(u16 *)&hwinfo[params[3]];
1276 rtlefuse->eeprom_smid = *(u16 *)&hwinfo[params[4]];
1277 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
1278 "EEPROMId = 0x%4x\n", eeprom_id);
1279 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
1280 "EEPROM VID = 0x%4x\n", rtlefuse->eeprom_vid);
1281 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
1282 "EEPROM DID = 0x%4x\n", rtlefuse->eeprom_did);
1283 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
1284 "EEPROM SVID = 0x%4x\n", rtlefuse->eeprom_svid);
1285 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
1286 "EEPROM SMID = 0x%4x\n", rtlefuse->eeprom_smid);
1288 for (i = 0; i < 6; i += 2) {
1289 usvalue = *(u16 *)&hwinfo[params[5] + i];
1290 *((u16 *)(&rtlefuse->dev_addr[i])) = usvalue;
1292 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "%pM\n", rtlefuse->dev_addr);
1294 rtlefuse->eeprom_channelplan = *&hwinfo[params[6]];
1295 rtlefuse->eeprom_version = *(u16 *)&hwinfo[params[7]];
1296 rtlefuse->txpwr_fromeprom = true;
1297 rtlefuse->eeprom_oemid = *&hwinfo[params[8]];
1299 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
1300 "EEPROM Customer ID: 0x%2x\n", rtlefuse->eeprom_oemid);
1302 /* set channel plan to world wide 13 */
1303 rtlefuse->channel_plan = params[9];
1307 EXPORT_SYMBOL_GPL(rtl_get_hwinfo);
1309 void rtl_fw_block_write(struct ieee80211_hw *hw, const u8 *buffer, u32 size)
1311 struct rtl_priv *rtlpriv = rtl_priv(hw);
1312 u8 *pu4byteptr = (u8 *)buffer;
1315 for (i = 0; i < size; i++)
1316 rtl_write_byte(rtlpriv, (START_ADDRESS + i), *(pu4byteptr + i));
1318 EXPORT_SYMBOL_GPL(rtl_fw_block_write);
1320 void rtl_fw_page_write(struct ieee80211_hw *hw, u32 page, const u8 *buffer,
1323 struct rtl_priv *rtlpriv = rtl_priv(hw);
1325 u8 u8page = (u8)(page & 0x07);
1327 value8 = (rtl_read_byte(rtlpriv, REG_MCUFWDL + 2) & 0xF8) | u8page;
1329 rtl_write_byte(rtlpriv, (REG_MCUFWDL + 2), value8);
1330 rtl_fw_block_write(hw, buffer, size);
1332 EXPORT_SYMBOL_GPL(rtl_fw_page_write);
1334 void rtl_fill_dummy(u8 *pfwbuf, u32 *pfwlen)
1336 u32 fwlen = *pfwlen;
1337 u8 remain = (u8)(fwlen % 4);
1339 remain = (remain == 0) ? 0 : (4 - remain);
1341 while (remain > 0) {
1349 EXPORT_SYMBOL_GPL(rtl_fill_dummy);
1351 void rtl_efuse_ops_init(struct ieee80211_hw *hw)
1353 struct rtl_priv *rtlpriv = rtl_priv(hw);
1355 rtlpriv->efuse.efuse_ops = &efuse_ops;
1357 EXPORT_SYMBOL_GPL(rtl_efuse_ops_init);