| .. | .. |
|---|
| 1 | | -/****************************************************************************** |
|---|
| 2 | | - * |
|---|
| 3 | | - * Copyright(c) 2009-2012 Realtek Corporation. |
|---|
| 4 | | - * |
|---|
| 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. |
|---|
| 8 | | - * |
|---|
| 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 |
|---|
| 12 | | - * more details. |
|---|
| 13 | | - * |
|---|
| 14 | | - * Tme full GNU General Public License is included in this distribution in the |
|---|
| 15 | | - * file called LICENSE. |
|---|
| 16 | | - * |
|---|
| 17 | | - * Contact Information: |
|---|
| 18 | | - * wlanfae <wlanfae@realtek.com> |
|---|
| 19 | | - * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park, |
|---|
| 20 | | - * Hsinchu 300, Taiwan. |
|---|
| 21 | | - * |
|---|
| 22 | | - * Larry Finger <Larry.Finger@lwfinger.net> |
|---|
| 23 | | - * |
|---|
| 24 | | - *****************************************************************************/ |
|---|
| 1 | +// SPDX-License-Identifier: GPL-2.0 |
|---|
| 2 | +/* Copyright(c) 2009-2012 Realtek Corporation.*/ |
|---|
| 3 | + |
|---|
| 25 | 4 | #include "wifi.h" |
|---|
| 26 | 5 | #include "efuse.h" |
|---|
| 27 | 6 | #include "pci.h" |
|---|
| 28 | 7 | #include <linux/export.h> |
|---|
| 29 | 8 | |
|---|
| 30 | | -static const u8 MAX_PGPKT_SIZE = 9; |
|---|
| 31 | 9 | static const u8 PGPKT_DATA_SIZE = 8; |
|---|
| 32 | 10 | static const int EFUSE_MAX_SIZE = 512; |
|---|
| 33 | 11 | |
|---|
| 34 | 12 | #define START_ADDRESS 0x1000 |
|---|
| 35 | 13 | #define REG_MCUFWDL 0x0080 |
|---|
| 36 | | - |
|---|
| 37 | | -static const struct efuse_map RTL8712_SDIO_EFUSE_TABLE[] = { |
|---|
| 38 | | - {0, 0, 0, 2}, |
|---|
| 39 | | - {0, 1, 0, 2}, |
|---|
| 40 | | - {0, 2, 0, 2}, |
|---|
| 41 | | - {1, 0, 0, 1}, |
|---|
| 42 | | - {1, 0, 1, 1}, |
|---|
| 43 | | - {1, 1, 0, 1}, |
|---|
| 44 | | - {1, 1, 1, 3}, |
|---|
| 45 | | - {1, 3, 0, 17}, |
|---|
| 46 | | - {3, 3, 1, 48}, |
|---|
| 47 | | - {10, 0, 0, 6}, |
|---|
| 48 | | - {10, 3, 0, 1}, |
|---|
| 49 | | - {10, 3, 1, 1}, |
|---|
| 50 | | - {11, 0, 0, 28} |
|---|
| 51 | | -}; |
|---|
| 52 | 14 | |
|---|
| 53 | 15 | static const struct rtl_efuse_ops efuse_ops = { |
|---|
| 54 | 16 | .efuse_onebyte_read = efuse_one_byte_read, |
|---|
| .. | .. |
|---|
| 138 | 100 | rtlpriv->cfg-> |
|---|
| 139 | 101 | maps[EFUSE_CTRL] + 3); |
|---|
| 140 | 102 | k++; |
|---|
| 141 | | - if (k == 1000) { |
|---|
| 142 | | - k = 0; |
|---|
| 103 | + if (k == 1000) |
|---|
| 143 | 104 | break; |
|---|
| 144 | | - } |
|---|
| 145 | 105 | } |
|---|
| 146 | 106 | data = rtl_read_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL]); |
|---|
| 147 | 107 | return data; |
|---|
| .. | .. |
|---|
| 160 | 120 | const u32 efuse_len = |
|---|
| 161 | 121 | rtlpriv->cfg->maps[EFUSE_REAL_CONTENT_SIZE]; |
|---|
| 162 | 122 | |
|---|
| 163 | | - RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD, "Addr=%x Data =%x\n", |
|---|
| 164 | | - address, value); |
|---|
| 123 | + rtl_dbg(rtlpriv, COMP_EFUSE, DBG_LOUD, "Addr=%x Data =%x\n", |
|---|
| 124 | + address, value); |
|---|
| 165 | 125 | |
|---|
| 166 | 126 | if (address < efuse_len) { |
|---|
| 167 | 127 | rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL], value); |
|---|
| .. | .. |
|---|
| 251 | 211 | u8 efuse_usage; |
|---|
| 252 | 212 | |
|---|
| 253 | 213 | if ((_offset + _size_byte) > rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE]) { |
|---|
| 254 | | - RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD, |
|---|
| 255 | | - "read_efuse(): Invalid offset(%#x) with read bytes(%#x)!!\n", |
|---|
| 256 | | - _offset, _size_byte); |
|---|
| 214 | + rtl_dbg(rtlpriv, COMP_EFUSE, DBG_LOUD, |
|---|
| 215 | + "%s: Invalid offset(%#x) with read bytes(%#x)!!\n", |
|---|
| 216 | + __func__, _offset, _size_byte); |
|---|
| 257 | 217 | return; |
|---|
| 258 | 218 | } |
|---|
| 259 | 219 | |
|---|
| .. | .. |
|---|
| 386 | 346 | { |
|---|
| 387 | 347 | struct rtl_priv *rtlpriv = rtl_priv(hw); |
|---|
| 388 | 348 | struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); |
|---|
| 389 | | - u8 section_idx, i, Base; |
|---|
| 349 | + u8 section_idx, i, base; |
|---|
| 390 | 350 | u16 words_need = 0, hdr_num = 0, totalbytes, efuse_used; |
|---|
| 391 | 351 | bool wordchanged, result = true; |
|---|
| 392 | 352 | |
|---|
| 393 | 353 | for (section_idx = 0; section_idx < 16; section_idx++) { |
|---|
| 394 | | - Base = section_idx * 8; |
|---|
| 354 | + base = section_idx * 8; |
|---|
| 395 | 355 | wordchanged = false; |
|---|
| 396 | 356 | |
|---|
| 397 | 357 | for (i = 0; i < 8; i = i + 2) { |
|---|
| 398 | | - if ((rtlefuse->efuse_map[EFUSE_INIT_MAP][Base + i] != |
|---|
| 399 | | - rtlefuse->efuse_map[EFUSE_MODIFY_MAP][Base + i]) || |
|---|
| 400 | | - (rtlefuse->efuse_map[EFUSE_INIT_MAP][Base + i + 1] != |
|---|
| 401 | | - rtlefuse->efuse_map[EFUSE_MODIFY_MAP][Base + i + |
|---|
| 402 | | - 1])) { |
|---|
| 358 | + if (rtlefuse->efuse_map[EFUSE_INIT_MAP][base + i] != |
|---|
| 359 | + rtlefuse->efuse_map[EFUSE_MODIFY_MAP][base + i] || |
|---|
| 360 | + rtlefuse->efuse_map[EFUSE_INIT_MAP][base + i + 1] != |
|---|
| 361 | + rtlefuse->efuse_map[EFUSE_MODIFY_MAP][base + i + |
|---|
| 362 | + 1]) { |
|---|
| 403 | 363 | words_need++; |
|---|
| 404 | 364 | wordchanged = true; |
|---|
| 405 | 365 | } |
|---|
| .. | .. |
|---|
| 416 | 376 | (EFUSE_MAX_SIZE - rtlpriv->cfg->maps[EFUSE_OOB_PROTECT_BYTES_LEN])) |
|---|
| 417 | 377 | result = false; |
|---|
| 418 | 378 | |
|---|
| 419 | | - RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD, |
|---|
| 420 | | - "efuse_shadow_update_chk(): totalbytes(%#x), hdr_num(%#x), words_need(%#x), efuse_used(%d)\n", |
|---|
| 421 | | - totalbytes, hdr_num, words_need, efuse_used); |
|---|
| 379 | + rtl_dbg(rtlpriv, COMP_EFUSE, DBG_LOUD, |
|---|
| 380 | + "%s: totalbytes(%#x), hdr_num(%#x), words_need(%#x), efuse_used(%d)\n", |
|---|
| 381 | + __func__, totalbytes, hdr_num, words_need, efuse_used); |
|---|
| 422 | 382 | |
|---|
| 423 | 383 | return result; |
|---|
| 424 | 384 | } |
|---|
| .. | .. |
|---|
| 456 | 416 | u8 word_en = 0x0F; |
|---|
| 457 | 417 | u8 first_pg = false; |
|---|
| 458 | 418 | |
|---|
| 459 | | - RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD, "\n"); |
|---|
| 419 | + rtl_dbg(rtlpriv, COMP_EFUSE, DBG_LOUD, "\n"); |
|---|
| 460 | 420 | |
|---|
| 461 | 421 | if (!efuse_shadow_update_chk(hw)) { |
|---|
| 462 | 422 | efuse_read_all_map(hw, &rtlefuse->efuse_map[EFUSE_INIT_MAP][0]); |
|---|
| .. | .. |
|---|
| 464 | 424 | &rtlefuse->efuse_map[EFUSE_INIT_MAP][0], |
|---|
| 465 | 425 | rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE]); |
|---|
| 466 | 426 | |
|---|
| 467 | | - RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD, |
|---|
| 468 | | - "efuse out of capacity!!\n"); |
|---|
| 427 | + rtl_dbg(rtlpriv, COMP_EFUSE, DBG_LOUD, |
|---|
| 428 | + "efuse out of capacity!!\n"); |
|---|
| 469 | 429 | return false; |
|---|
| 470 | 430 | } |
|---|
| 471 | 431 | efuse_power_switch(hw, true, true); |
|---|
| .. | .. |
|---|
| 495 | 455 | |
|---|
| 496 | 456 | if (word_en != 0x0F) { |
|---|
| 497 | 457 | u8 tmpdata[8]; |
|---|
| 458 | + |
|---|
| 498 | 459 | memcpy(tmpdata, |
|---|
| 499 | 460 | &rtlefuse->efuse_map[EFUSE_MODIFY_MAP][base], |
|---|
| 500 | 461 | 8); |
|---|
| .. | .. |
|---|
| 503 | 464 | |
|---|
| 504 | 465 | if (!efuse_pg_packet_write(hw, (u8) offset, word_en, |
|---|
| 505 | 466 | tmpdata)) { |
|---|
| 506 | | - RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING, |
|---|
| 507 | | - "PG section(%#x) fail!!\n", offset); |
|---|
| 467 | + rtl_dbg(rtlpriv, COMP_ERR, DBG_WARNING, |
|---|
| 468 | + "PG section(%#x) fail!!\n", offset); |
|---|
| 508 | 469 | break; |
|---|
| 509 | 470 | } |
|---|
| 510 | 471 | } |
|---|
| 511 | | - |
|---|
| 512 | 472 | } |
|---|
| 513 | 473 | |
|---|
| 514 | 474 | efuse_power_switch(hw, true, false); |
|---|
| .. | .. |
|---|
| 518 | 478 | &rtlefuse->efuse_map[EFUSE_INIT_MAP][0], |
|---|
| 519 | 479 | rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE]); |
|---|
| 520 | 480 | |
|---|
| 521 | | - RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD, "\n"); |
|---|
| 481 | + rtl_dbg(rtlpriv, COMP_EFUSE, DBG_LOUD, "\n"); |
|---|
| 522 | 482 | return true; |
|---|
| 523 | 483 | } |
|---|
| 524 | 484 | |
|---|
| .. | .. |
|---|
| 540 | 500 | } |
|---|
| 541 | 501 | EXPORT_SYMBOL(rtl_efuse_shadow_map_update); |
|---|
| 542 | 502 | |
|---|
| 543 | | -void efuse_force_write_vendor_Id(struct ieee80211_hw *hw) |
|---|
| 503 | +void efuse_force_write_vendor_id(struct ieee80211_hw *hw) |
|---|
| 544 | 504 | { |
|---|
| 545 | 505 | u8 tmpdata[8] = { 0xFF, 0xFF, 0xEC, 0x10, 0xFF, 0xFF, 0xFF, 0xFF }; |
|---|
| 546 | 506 | |
|---|
| .. | .. |
|---|
| 656 | 616 | struct rtl_priv *rtlpriv = rtl_priv(hw); |
|---|
| 657 | 617 | u8 tmpidx = 0; |
|---|
| 658 | 618 | |
|---|
| 659 | | - RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD, |
|---|
| 660 | | - "Addr = %x Data=%x\n", addr, data); |
|---|
| 619 | + rtl_dbg(rtlpriv, COMP_EFUSE, DBG_LOUD, |
|---|
| 620 | + "Addr = %x Data=%x\n", addr, data); |
|---|
| 661 | 621 | |
|---|
| 662 | 622 | rtl_write_byte(rtlpriv, |
|---|
| 663 | 623 | rtlpriv->cfg->maps[EFUSE_CTRL] + 1, (u8) (addr & 0xff)); |
|---|
| .. | .. |
|---|
| 683 | 643 | static void efuse_read_all_map(struct ieee80211_hw *hw, u8 *efuse) |
|---|
| 684 | 644 | { |
|---|
| 685 | 645 | struct rtl_priv *rtlpriv = rtl_priv(hw); |
|---|
| 646 | + |
|---|
| 686 | 647 | efuse_power_switch(hw, false, true); |
|---|
| 687 | 648 | read_efuse(hw, 0, rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE], efuse); |
|---|
| 688 | 649 | efuse_power_switch(hw, false, false); |
|---|
| .. | .. |
|---|
| 833 | 794 | if (0x0F != (badworden & 0x0F)) { |
|---|
| 834 | 795 | u8 reorg_offset = offset; |
|---|
| 835 | 796 | u8 reorg_worden = badworden; |
|---|
| 797 | + |
|---|
| 836 | 798 | efuse_pg_packet_write(hw, reorg_offset, |
|---|
| 837 | 799 | reorg_worden, |
|---|
| 838 | 800 | originaldata); |
|---|
| .. | .. |
|---|
| 922 | 884 | if (0x0F != (badworden & 0x0F)) { |
|---|
| 923 | 885 | u8 reorg_offset = tmp_pkt.offset; |
|---|
| 924 | 886 | u8 reorg_worden = badworden; |
|---|
| 887 | + |
|---|
| 925 | 888 | efuse_pg_packet_write(hw, reorg_offset, |
|---|
| 926 | 889 | reorg_worden, |
|---|
| 927 | 890 | originaldata); |
|---|
| .. | .. |
|---|
| 952 | 915 | struct rtl_priv *rtlpriv = rtl_priv(hw); |
|---|
| 953 | 916 | struct pgpkt_struct target_pkt; |
|---|
| 954 | 917 | u8 write_state = PG_STATE_HEADER; |
|---|
| 955 | | - int continual = true, dataempty = true, result = true; |
|---|
| 918 | + int continual = true, result = true; |
|---|
| 956 | 919 | u16 efuse_addr = 0; |
|---|
| 957 | 920 | u8 efuse_data; |
|---|
| 958 | 921 | u8 target_word_cnts = 0; |
|---|
| .. | .. |
|---|
| 978 | 941 | |
|---|
| 979 | 942 | while (continual && (efuse_addr < (EFUSE_MAX_SIZE - |
|---|
| 980 | 943 | rtlpriv->cfg->maps[EFUSE_OOB_PROTECT_BYTES_LEN]))) { |
|---|
| 981 | | - |
|---|
| 982 | 944 | if (write_state == PG_STATE_HEADER) { |
|---|
| 983 | | - dataempty = true; |
|---|
| 984 | 945 | badworden = 0x0F; |
|---|
| 985 | 946 | RTPRINT(rtlpriv, FEEPROM, EFUSE_PG, |
|---|
| 986 | 947 | "efuse PG_STATE_HEADER\n"); |
|---|
| .. | .. |
|---|
| 1005 | 966 | } else if (write_state == PG_STATE_DATA) { |
|---|
| 1006 | 967 | RTPRINT(rtlpriv, FEEPROM, EFUSE_PG, |
|---|
| 1007 | 968 | "efuse PG_STATE_DATA\n"); |
|---|
| 1008 | | - badworden = 0x0f; |
|---|
| 1009 | 969 | badworden = |
|---|
| 1010 | 970 | enable_efuse_data_write(hw, efuse_addr + 1, |
|---|
| 1011 | 971 | target_pkt.word_en, |
|---|
| .. | .. |
|---|
| 1036 | 996 | |
|---|
| 1037 | 997 | if (efuse_addr >= (EFUSE_MAX_SIZE - |
|---|
| 1038 | 998 | rtlpriv->cfg->maps[EFUSE_OOB_PROTECT_BYTES_LEN])) { |
|---|
| 1039 | | - RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD, |
|---|
| 1040 | | - "efuse_addr(%#x) Out of size!!\n", efuse_addr); |
|---|
| 999 | + rtl_dbg(rtlpriv, COMP_EFUSE, DBG_LOUD, |
|---|
| 1000 | + "efuse_addr(%#x) Out of size!!\n", efuse_addr); |
|---|
| 1041 | 1001 | } |
|---|
| 1042 | 1002 | |
|---|
| 1043 | 1003 | return true; |
|---|
| .. | .. |
|---|
| 1077 | 1037 | u8 tmpdata[8]; |
|---|
| 1078 | 1038 | |
|---|
| 1079 | 1039 | memset(tmpdata, 0xff, PGPKT_DATA_SIZE); |
|---|
| 1080 | | - RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD, |
|---|
| 1081 | | - "word_en = %x efuse_addr=%x\n", word_en, efuse_addr); |
|---|
| 1040 | + rtl_dbg(rtlpriv, COMP_EFUSE, DBG_LOUD, |
|---|
| 1041 | + "word_en = %x efuse_addr=%x\n", word_en, efuse_addr); |
|---|
| 1082 | 1042 | |
|---|
| 1083 | 1043 | if (!(word_en & BIT(0))) { |
|---|
| 1084 | 1044 | tmpaddr = start_addr; |
|---|
| .. | .. |
|---|
| 1132 | 1092 | struct rtl_priv *rtlpriv = rtl_priv(hw); |
|---|
| 1133 | 1093 | struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); |
|---|
| 1134 | 1094 | u8 tempval; |
|---|
| 1135 | | - u16 tmpV16; |
|---|
| 1095 | + u16 tmpv16; |
|---|
| 1136 | 1096 | |
|---|
| 1137 | 1097 | if (pwrstate && (rtlhal->hw_type != HARDWARE_TYPE_RTL8192SE)) { |
|---|
| 1138 | | - |
|---|
| 1139 | 1098 | if (rtlhal->hw_type != HARDWARE_TYPE_RTL8192CE && |
|---|
| 1140 | 1099 | rtlhal->hw_type != HARDWARE_TYPE_RTL8192DE) { |
|---|
| 1141 | 1100 | rtl_write_byte(rtlpriv, |
|---|
| 1142 | 1101 | rtlpriv->cfg->maps[EFUSE_ACCESS], 0x69); |
|---|
| 1143 | 1102 | } else { |
|---|
| 1144 | | - tmpV16 = |
|---|
| 1103 | + tmpv16 = |
|---|
| 1145 | 1104 | rtl_read_word(rtlpriv, |
|---|
| 1146 | 1105 | rtlpriv->cfg->maps[SYS_ISO_CTRL]); |
|---|
| 1147 | | - if (!(tmpV16 & rtlpriv->cfg->maps[EFUSE_PWC_EV12V])) { |
|---|
| 1148 | | - tmpV16 |= rtlpriv->cfg->maps[EFUSE_PWC_EV12V]; |
|---|
| 1106 | + if (!(tmpv16 & rtlpriv->cfg->maps[EFUSE_PWC_EV12V])) { |
|---|
| 1107 | + tmpv16 |= rtlpriv->cfg->maps[EFUSE_PWC_EV12V]; |
|---|
| 1149 | 1108 | rtl_write_word(rtlpriv, |
|---|
| 1150 | 1109 | rtlpriv->cfg->maps[SYS_ISO_CTRL], |
|---|
| 1151 | | - tmpV16); |
|---|
| 1110 | + tmpv16); |
|---|
| 1152 | 1111 | } |
|---|
| 1153 | 1112 | } |
|---|
| 1154 | | - tmpV16 = rtl_read_word(rtlpriv, |
|---|
| 1113 | + tmpv16 = rtl_read_word(rtlpriv, |
|---|
| 1155 | 1114 | rtlpriv->cfg->maps[SYS_FUNC_EN]); |
|---|
| 1156 | | - if (!(tmpV16 & rtlpriv->cfg->maps[EFUSE_FEN_ELDR])) { |
|---|
| 1157 | | - tmpV16 |= rtlpriv->cfg->maps[EFUSE_FEN_ELDR]; |
|---|
| 1115 | + if (!(tmpv16 & rtlpriv->cfg->maps[EFUSE_FEN_ELDR])) { |
|---|
| 1116 | + tmpv16 |= rtlpriv->cfg->maps[EFUSE_FEN_ELDR]; |
|---|
| 1158 | 1117 | rtl_write_word(rtlpriv, |
|---|
| 1159 | | - rtlpriv->cfg->maps[SYS_FUNC_EN], tmpV16); |
|---|
| 1118 | + rtlpriv->cfg->maps[SYS_FUNC_EN], tmpv16); |
|---|
| 1160 | 1119 | } |
|---|
| 1161 | 1120 | |
|---|
| 1162 | | - tmpV16 = rtl_read_word(rtlpriv, rtlpriv->cfg->maps[SYS_CLK]); |
|---|
| 1163 | | - if ((!(tmpV16 & rtlpriv->cfg->maps[EFUSE_LOADER_CLK_EN])) || |
|---|
| 1164 | | - (!(tmpV16 & rtlpriv->cfg->maps[EFUSE_ANA8M]))) { |
|---|
| 1165 | | - tmpV16 |= (rtlpriv->cfg->maps[EFUSE_LOADER_CLK_EN] | |
|---|
| 1121 | + tmpv16 = rtl_read_word(rtlpriv, rtlpriv->cfg->maps[SYS_CLK]); |
|---|
| 1122 | + if ((!(tmpv16 & rtlpriv->cfg->maps[EFUSE_LOADER_CLK_EN])) || |
|---|
| 1123 | + (!(tmpv16 & rtlpriv->cfg->maps[EFUSE_ANA8M]))) { |
|---|
| 1124 | + tmpv16 |= (rtlpriv->cfg->maps[EFUSE_LOADER_CLK_EN] | |
|---|
| 1166 | 1125 | rtlpriv->cfg->maps[EFUSE_ANA8M]); |
|---|
| 1167 | 1126 | rtl_write_word(rtlpriv, |
|---|
| 1168 | | - rtlpriv->cfg->maps[SYS_CLK], tmpV16); |
|---|
| 1127 | + rtlpriv->cfg->maps[SYS_CLK], tmpv16); |
|---|
| 1169 | 1128 | } |
|---|
| 1170 | 1129 | } |
|---|
| 1171 | 1130 | |
|---|
| .. | .. |
|---|
| 1219 | 1178 | { |
|---|
| 1220 | 1179 | int continual = true; |
|---|
| 1221 | 1180 | u16 efuse_addr = 0; |
|---|
| 1222 | | - u8 hoffset, hworden; |
|---|
| 1181 | + u8 hworden; |
|---|
| 1223 | 1182 | u8 efuse_data, word_cnts; |
|---|
| 1224 | 1183 | |
|---|
| 1225 | 1184 | while (continual && efuse_one_byte_read(hw, efuse_addr, &efuse_data) && |
|---|
| 1226 | 1185 | (efuse_addr < EFUSE_MAX_SIZE)) { |
|---|
| 1227 | 1186 | if (efuse_data != 0xFF) { |
|---|
| 1228 | | - hoffset = (efuse_data >> 4) & 0x0F; |
|---|
| 1229 | 1187 | hworden = efuse_data & 0x0F; |
|---|
| 1230 | 1188 | word_cnts = efuse_calculate_word_cnts(hworden); |
|---|
| 1231 | 1189 | efuse_addr = efuse_addr + (word_cnts * 2) + 1; |
|---|
| .. | .. |
|---|
| 1240 | 1198 | static u8 efuse_calculate_word_cnts(u8 word_en) |
|---|
| 1241 | 1199 | { |
|---|
| 1242 | 1200 | u8 word_cnts = 0; |
|---|
| 1201 | + |
|---|
| 1243 | 1202 | if (!(word_en & BIT(0))) |
|---|
| 1244 | 1203 | word_cnts++; |
|---|
| 1245 | 1204 | if (!(word_en & BIT(1))) |
|---|
| .. | .. |
|---|
| 1281 | 1240 | |
|---|
| 1282 | 1241 | eeprom_id = *((u16 *)&hwinfo[0]); |
|---|
| 1283 | 1242 | if (eeprom_id != params[0]) { |
|---|
| 1284 | | - RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING, |
|---|
| 1285 | | - "EEPROM ID(%#x) is invalid!!\n", eeprom_id); |
|---|
| 1243 | + rtl_dbg(rtlpriv, COMP_ERR, DBG_WARNING, |
|---|
| 1244 | + "EEPROM ID(%#x) is invalid!!\n", eeprom_id); |
|---|
| 1286 | 1245 | rtlefuse->autoload_failflag = true; |
|---|
| 1287 | 1246 | } else { |
|---|
| 1288 | | - RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "Autoload OK\n"); |
|---|
| 1247 | + rtl_dbg(rtlpriv, COMP_INIT, DBG_LOUD, "Autoload OK\n"); |
|---|
| 1289 | 1248 | rtlefuse->autoload_failflag = false; |
|---|
| 1290 | 1249 | } |
|---|
| 1291 | 1250 | |
|---|
| .. | .. |
|---|
| 1296 | 1255 | rtlefuse->eeprom_did = *(u16 *)&hwinfo[params[2]]; |
|---|
| 1297 | 1256 | rtlefuse->eeprom_svid = *(u16 *)&hwinfo[params[3]]; |
|---|
| 1298 | 1257 | rtlefuse->eeprom_smid = *(u16 *)&hwinfo[params[4]]; |
|---|
| 1299 | | - RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, |
|---|
| 1300 | | - "EEPROMId = 0x%4x\n", eeprom_id); |
|---|
| 1301 | | - RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, |
|---|
| 1302 | | - "EEPROM VID = 0x%4x\n", rtlefuse->eeprom_vid); |
|---|
| 1303 | | - RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, |
|---|
| 1304 | | - "EEPROM DID = 0x%4x\n", rtlefuse->eeprom_did); |
|---|
| 1305 | | - RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, |
|---|
| 1306 | | - "EEPROM SVID = 0x%4x\n", rtlefuse->eeprom_svid); |
|---|
| 1307 | | - RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, |
|---|
| 1308 | | - "EEPROM SMID = 0x%4x\n", rtlefuse->eeprom_smid); |
|---|
| 1258 | + rtl_dbg(rtlpriv, COMP_INIT, DBG_LOUD, |
|---|
| 1259 | + "EEPROMId = 0x%4x\n", eeprom_id); |
|---|
| 1260 | + rtl_dbg(rtlpriv, COMP_INIT, DBG_LOUD, |
|---|
| 1261 | + "EEPROM VID = 0x%4x\n", rtlefuse->eeprom_vid); |
|---|
| 1262 | + rtl_dbg(rtlpriv, COMP_INIT, DBG_LOUD, |
|---|
| 1263 | + "EEPROM DID = 0x%4x\n", rtlefuse->eeprom_did); |
|---|
| 1264 | + rtl_dbg(rtlpriv, COMP_INIT, DBG_LOUD, |
|---|
| 1265 | + "EEPROM SVID = 0x%4x\n", rtlefuse->eeprom_svid); |
|---|
| 1266 | + rtl_dbg(rtlpriv, COMP_INIT, DBG_LOUD, |
|---|
| 1267 | + "EEPROM SMID = 0x%4x\n", rtlefuse->eeprom_smid); |
|---|
| 1309 | 1268 | |
|---|
| 1310 | 1269 | for (i = 0; i < 6; i += 2) { |
|---|
| 1311 | 1270 | usvalue = *(u16 *)&hwinfo[params[5] + i]; |
|---|
| 1312 | 1271 | *((u16 *)(&rtlefuse->dev_addr[i])) = usvalue; |
|---|
| 1313 | 1272 | } |
|---|
| 1314 | | - RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "%pM\n", rtlefuse->dev_addr); |
|---|
| 1273 | + rtl_dbg(rtlpriv, COMP_INIT, DBG_DMESG, "%pM\n", rtlefuse->dev_addr); |
|---|
| 1315 | 1274 | |
|---|
| 1316 | 1275 | rtlefuse->eeprom_channelplan = *&hwinfo[params[6]]; |
|---|
| 1317 | 1276 | rtlefuse->eeprom_version = *(u16 *)&hwinfo[params[7]]; |
|---|
| 1318 | 1277 | rtlefuse->txpwr_fromeprom = true; |
|---|
| 1319 | 1278 | rtlefuse->eeprom_oemid = *&hwinfo[params[8]]; |
|---|
| 1320 | 1279 | |
|---|
| 1321 | | - RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, |
|---|
| 1322 | | - "EEPROM Customer ID: 0x%2x\n", rtlefuse->eeprom_oemid); |
|---|
| 1280 | + rtl_dbg(rtlpriv, COMP_INIT, DBG_LOUD, |
|---|
| 1281 | + "EEPROM Customer ID: 0x%2x\n", rtlefuse->eeprom_oemid); |
|---|
| 1323 | 1282 | |
|---|
| 1324 | 1283 | /* set channel plan to world wide 13 */ |
|---|
| 1325 | 1284 | rtlefuse->channel_plan = params[9]; |
|---|