Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* Copyright(c) 2009-2012  Realtek Corporation.*/
0003 
0004 #include "wifi.h"
0005 #include "efuse.h"
0006 #include "pci.h"
0007 #include <linux/export.h>
0008 
0009 static const u8 PGPKT_DATA_SIZE = 8;
0010 static const int EFUSE_MAX_SIZE = 512;
0011 
0012 #define START_ADDRESS       0x1000
0013 #define REG_MCUFWDL     0x0080
0014 
0015 static const struct rtl_efuse_ops efuse_ops = {
0016     .efuse_onebyte_read = efuse_one_byte_read,
0017     .efuse_logical_map_read = efuse_shadow_read,
0018 };
0019 
0020 static void efuse_shadow_read_1byte(struct ieee80211_hw *hw, u16 offset,
0021                     u8 *value);
0022 static void efuse_shadow_read_2byte(struct ieee80211_hw *hw, u16 offset,
0023                     u16 *value);
0024 static void efuse_shadow_read_4byte(struct ieee80211_hw *hw, u16 offset,
0025                     u32 *value);
0026 static void efuse_shadow_write_1byte(struct ieee80211_hw *hw, u16 offset,
0027                      u8 value);
0028 static void efuse_shadow_write_2byte(struct ieee80211_hw *hw, u16 offset,
0029                      u16 value);
0030 static void efuse_shadow_write_4byte(struct ieee80211_hw *hw, u16 offset,
0031                      u32 value);
0032 static int efuse_one_byte_write(struct ieee80211_hw *hw, u16 addr,
0033                 u8 data);
0034 static void efuse_read_all_map(struct ieee80211_hw *hw, u8 *efuse);
0035 static int efuse_pg_packet_read(struct ieee80211_hw *hw, u8 offset,
0036                 u8 *data);
0037 static int efuse_pg_packet_write(struct ieee80211_hw *hw, u8 offset,
0038                  u8 word_en, u8 *data);
0039 static void efuse_word_enable_data_read(u8 word_en, u8 *sourdata,
0040                     u8 *targetdata);
0041 static u8 enable_efuse_data_write(struct ieee80211_hw *hw,
0042                   u16 efuse_addr, u8 word_en, u8 *data);
0043 static u16 efuse_get_current_size(struct ieee80211_hw *hw);
0044 static u8 efuse_calculate_word_cnts(u8 word_en);
0045 
0046 void efuse_initialize(struct ieee80211_hw *hw)
0047 {
0048     struct rtl_priv *rtlpriv = rtl_priv(hw);
0049     u8 bytetemp;
0050     u8 temp;
0051 
0052     bytetemp = rtl_read_byte(rtlpriv, rtlpriv->cfg->maps[SYS_FUNC_EN] + 1);
0053     temp = bytetemp | 0x20;
0054     rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[SYS_FUNC_EN] + 1, temp);
0055 
0056     bytetemp = rtl_read_byte(rtlpriv, rtlpriv->cfg->maps[SYS_ISO_CTRL] + 1);
0057     temp = bytetemp & 0xFE;
0058     rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[SYS_ISO_CTRL] + 1, temp);
0059 
0060     bytetemp = rtl_read_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_TEST] + 3);
0061     temp = bytetemp | 0x80;
0062     rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_TEST] + 3, temp);
0063 
0064     rtl_write_byte(rtlpriv, 0x2F8, 0x3);
0065 
0066     rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 3, 0x72);
0067 
0068 }
0069 
0070 u8 efuse_read_1byte(struct ieee80211_hw *hw, u16 address)
0071 {
0072     struct rtl_priv *rtlpriv = rtl_priv(hw);
0073     u8 data;
0074     u8 bytetemp;
0075     u8 temp;
0076     u32 k = 0;
0077     const u32 efuse_len =
0078         rtlpriv->cfg->maps[EFUSE_REAL_CONTENT_SIZE];
0079 
0080     if (address < efuse_len) {
0081         temp = address & 0xFF;
0082         rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 1,
0083                    temp);
0084         bytetemp = rtl_read_byte(rtlpriv,
0085                      rtlpriv->cfg->maps[EFUSE_CTRL] + 2);
0086         temp = ((address >> 8) & 0x03) | (bytetemp & 0xFC);
0087         rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 2,
0088                    temp);
0089 
0090         bytetemp = rtl_read_byte(rtlpriv,
0091                      rtlpriv->cfg->maps[EFUSE_CTRL] + 3);
0092         temp = bytetemp & 0x7F;
0093         rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 3,
0094                    temp);
0095 
0096         bytetemp = rtl_read_byte(rtlpriv,
0097                      rtlpriv->cfg->maps[EFUSE_CTRL] + 3);
0098         while (!(bytetemp & 0x80)) {
0099             bytetemp = rtl_read_byte(rtlpriv,
0100                          rtlpriv->cfg->
0101                          maps[EFUSE_CTRL] + 3);
0102             k++;
0103             if (k == 1000)
0104                 break;
0105         }
0106         data = rtl_read_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL]);
0107         return data;
0108     } else
0109         return 0xFF;
0110 
0111 }
0112 EXPORT_SYMBOL(efuse_read_1byte);
0113 
0114 void efuse_write_1byte(struct ieee80211_hw *hw, u16 address, u8 value)
0115 {
0116     struct rtl_priv *rtlpriv = rtl_priv(hw);
0117     u8 bytetemp;
0118     u8 temp;
0119     u32 k = 0;
0120     const u32 efuse_len =
0121         rtlpriv->cfg->maps[EFUSE_REAL_CONTENT_SIZE];
0122 
0123     rtl_dbg(rtlpriv, COMP_EFUSE, DBG_LOUD, "Addr=%x Data =%x\n",
0124         address, value);
0125 
0126     if (address < efuse_len) {
0127         rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL], value);
0128 
0129         temp = address & 0xFF;
0130         rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 1,
0131                    temp);
0132         bytetemp = rtl_read_byte(rtlpriv,
0133                      rtlpriv->cfg->maps[EFUSE_CTRL] + 2);
0134 
0135         temp = ((address >> 8) & 0x03) | (bytetemp & 0xFC);
0136         rtl_write_byte(rtlpriv,
0137                    rtlpriv->cfg->maps[EFUSE_CTRL] + 2, temp);
0138 
0139         bytetemp = rtl_read_byte(rtlpriv,
0140                      rtlpriv->cfg->maps[EFUSE_CTRL] + 3);
0141         temp = bytetemp | 0x80;
0142         rtl_write_byte(rtlpriv,
0143                    rtlpriv->cfg->maps[EFUSE_CTRL] + 3, temp);
0144 
0145         bytetemp = rtl_read_byte(rtlpriv,
0146                      rtlpriv->cfg->maps[EFUSE_CTRL] + 3);
0147 
0148         while (bytetemp & 0x80) {
0149             bytetemp = rtl_read_byte(rtlpriv,
0150                          rtlpriv->cfg->
0151                          maps[EFUSE_CTRL] + 3);
0152             k++;
0153             if (k == 100) {
0154                 k = 0;
0155                 break;
0156             }
0157         }
0158     }
0159 
0160 }
0161 
0162 void read_efuse_byte(struct ieee80211_hw *hw, u16 _offset, u8 *pbuf)
0163 {
0164     struct rtl_priv *rtlpriv = rtl_priv(hw);
0165     u32 value32;
0166     u8 readbyte;
0167     u16 retry;
0168 
0169     rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 1,
0170                (_offset & 0xff));
0171     readbyte = rtl_read_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 2);
0172     rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 2,
0173                ((_offset >> 8) & 0x03) | (readbyte & 0xfc));
0174 
0175     readbyte = rtl_read_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 3);
0176     rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 3,
0177                (readbyte & 0x7f));
0178 
0179     retry = 0;
0180     value32 = rtl_read_dword(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL]);
0181     while (!(((value32 >> 24) & 0xff) & 0x80) && (retry < 10000)) {
0182         value32 = rtl_read_dword(rtlpriv,
0183                      rtlpriv->cfg->maps[EFUSE_CTRL]);
0184         retry++;
0185     }
0186 
0187     udelay(50);
0188     value32 = rtl_read_dword(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL]);
0189 
0190     *pbuf = (u8) (value32 & 0xff);
0191 }
0192 EXPORT_SYMBOL_GPL(read_efuse_byte);
0193 
0194 void read_efuse(struct ieee80211_hw *hw, u16 _offset, u16 _size_byte, u8 *pbuf)
0195 {
0196     struct rtl_priv *rtlpriv = rtl_priv(hw);
0197     struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
0198     u8 *efuse_tbl;
0199     u8 rtemp8[1];
0200     u16 efuse_addr = 0;
0201     u8 offset, wren;
0202     u8 u1temp = 0;
0203     u16 i;
0204     u16 j;
0205     const u16 efuse_max_section =
0206         rtlpriv->cfg->maps[EFUSE_MAX_SECTION_MAP];
0207     const u32 efuse_len =
0208         rtlpriv->cfg->maps[EFUSE_REAL_CONTENT_SIZE];
0209     u16 **efuse_word;
0210     u16 efuse_utilized = 0;
0211     u8 efuse_usage;
0212 
0213     if ((_offset + _size_byte) > rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE]) {
0214         rtl_dbg(rtlpriv, COMP_EFUSE, DBG_LOUD,
0215             "%s: Invalid offset(%#x) with read bytes(%#x)!!\n",
0216             __func__, _offset, _size_byte);
0217         return;
0218     }
0219 
0220     /* allocate memory for efuse_tbl and efuse_word */
0221     efuse_tbl = kzalloc(rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE],
0222                 GFP_ATOMIC);
0223     if (!efuse_tbl)
0224         return;
0225     efuse_word = kcalloc(EFUSE_MAX_WORD_UNIT, sizeof(u16 *), GFP_ATOMIC);
0226     if (!efuse_word)
0227         goto out;
0228     for (i = 0; i < EFUSE_MAX_WORD_UNIT; i++) {
0229         efuse_word[i] = kcalloc(efuse_max_section, sizeof(u16),
0230                     GFP_ATOMIC);
0231         if (!efuse_word[i])
0232             goto done;
0233     }
0234 
0235     for (i = 0; i < efuse_max_section; i++)
0236         for (j = 0; j < EFUSE_MAX_WORD_UNIT; j++)
0237             efuse_word[j][i] = 0xFFFF;
0238 
0239     read_efuse_byte(hw, efuse_addr, rtemp8);
0240     if (*rtemp8 != 0xFF) {
0241         efuse_utilized++;
0242         RTPRINT(rtlpriv, FEEPROM, EFUSE_READ_ALL,
0243             "Addr=%d\n", efuse_addr);
0244         efuse_addr++;
0245     }
0246 
0247     while ((*rtemp8 != 0xFF) && (efuse_addr < efuse_len)) {
0248         /*  Check PG header for section num.  */
0249         if ((*rtemp8 & 0x1F) == 0x0F) {/* extended header */
0250             u1temp = ((*rtemp8 & 0xE0) >> 5);
0251             read_efuse_byte(hw, efuse_addr, rtemp8);
0252 
0253             if ((*rtemp8 & 0x0F) == 0x0F) {
0254                 efuse_addr++;
0255                 read_efuse_byte(hw, efuse_addr, rtemp8);
0256 
0257                 if (*rtemp8 != 0xFF &&
0258                     (efuse_addr < efuse_len)) {
0259                     efuse_addr++;
0260                 }
0261                 continue;
0262             } else {
0263                 offset = ((*rtemp8 & 0xF0) >> 1) | u1temp;
0264                 wren = (*rtemp8 & 0x0F);
0265                 efuse_addr++;
0266             }
0267         } else {
0268             offset = ((*rtemp8 >> 4) & 0x0f);
0269             wren = (*rtemp8 & 0x0f);
0270         }
0271 
0272         if (offset < efuse_max_section) {
0273             RTPRINT(rtlpriv, FEEPROM, EFUSE_READ_ALL,
0274                 "offset-%d Worden=%x\n", offset, wren);
0275 
0276             for (i = 0; i < EFUSE_MAX_WORD_UNIT; i++) {
0277                 if (!(wren & 0x01)) {
0278                     RTPRINT(rtlpriv, FEEPROM,
0279                         EFUSE_READ_ALL,
0280                         "Addr=%d\n", efuse_addr);
0281 
0282                     read_efuse_byte(hw, efuse_addr, rtemp8);
0283                     efuse_addr++;
0284                     efuse_utilized++;
0285                     efuse_word[i][offset] =
0286                              (*rtemp8 & 0xff);
0287 
0288                     if (efuse_addr >= efuse_len)
0289                         break;
0290 
0291                     RTPRINT(rtlpriv, FEEPROM,
0292                         EFUSE_READ_ALL,
0293                         "Addr=%d\n", efuse_addr);
0294 
0295                     read_efuse_byte(hw, efuse_addr, rtemp8);
0296                     efuse_addr++;
0297                     efuse_utilized++;
0298                     efuse_word[i][offset] |=
0299                         (((u16)*rtemp8 << 8) & 0xff00);
0300 
0301                     if (efuse_addr >= efuse_len)
0302                         break;
0303                 }
0304 
0305                 wren >>= 1;
0306             }
0307         }
0308 
0309         RTPRINT(rtlpriv, FEEPROM, EFUSE_READ_ALL,
0310             "Addr=%d\n", efuse_addr);
0311         read_efuse_byte(hw, efuse_addr, rtemp8);
0312         if (*rtemp8 != 0xFF && (efuse_addr < efuse_len)) {
0313             efuse_utilized++;
0314             efuse_addr++;
0315         }
0316     }
0317 
0318     for (i = 0; i < efuse_max_section; i++) {
0319         for (j = 0; j < EFUSE_MAX_WORD_UNIT; j++) {
0320             efuse_tbl[(i * 8) + (j * 2)] =
0321                 (efuse_word[j][i] & 0xff);
0322             efuse_tbl[(i * 8) + ((j * 2) + 1)] =
0323                 ((efuse_word[j][i] >> 8) & 0xff);
0324         }
0325     }
0326 
0327     for (i = 0; i < _size_byte; i++)
0328         pbuf[i] = efuse_tbl[_offset + i];
0329 
0330     rtlefuse->efuse_usedbytes = efuse_utilized;
0331     efuse_usage = (u8) ((efuse_utilized * 100) / efuse_len);
0332     rtlefuse->efuse_usedpercentage = efuse_usage;
0333     rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_EFUSE_BYTES,
0334                       (u8 *)&efuse_utilized);
0335     rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_EFUSE_USAGE,
0336                       &efuse_usage);
0337 done:
0338     for (i = 0; i < EFUSE_MAX_WORD_UNIT; i++)
0339         kfree(efuse_word[i]);
0340     kfree(efuse_word);
0341 out:
0342     kfree(efuse_tbl);
0343 }
0344 
0345 bool efuse_shadow_update_chk(struct ieee80211_hw *hw)
0346 {
0347     struct rtl_priv *rtlpriv = rtl_priv(hw);
0348     struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
0349     u8 section_idx, i, base;
0350     u16 words_need = 0, hdr_num = 0, totalbytes, efuse_used;
0351     bool wordchanged, result = true;
0352 
0353     for (section_idx = 0; section_idx < 16; section_idx++) {
0354         base = section_idx * 8;
0355         wordchanged = false;
0356 
0357         for (i = 0; i < 8; i = i + 2) {
0358             if (rtlefuse->efuse_map[EFUSE_INIT_MAP][base + i] !=
0359                 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][base + i] ||
0360                 rtlefuse->efuse_map[EFUSE_INIT_MAP][base + i + 1] !=
0361                 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][base + i +
0362                                    1]) {
0363                 words_need++;
0364                 wordchanged = true;
0365             }
0366         }
0367 
0368         if (wordchanged)
0369             hdr_num++;
0370     }
0371 
0372     totalbytes = hdr_num + words_need * 2;
0373     efuse_used = rtlefuse->efuse_usedbytes;
0374 
0375     if ((totalbytes + efuse_used) >=
0376         (EFUSE_MAX_SIZE - rtlpriv->cfg->maps[EFUSE_OOB_PROTECT_BYTES_LEN]))
0377         result = false;
0378 
0379     rtl_dbg(rtlpriv, COMP_EFUSE, DBG_LOUD,
0380         "%s: totalbytes(%#x), hdr_num(%#x), words_need(%#x), efuse_used(%d)\n",
0381         __func__, totalbytes, hdr_num, words_need, efuse_used);
0382 
0383     return result;
0384 }
0385 
0386 void efuse_shadow_read(struct ieee80211_hw *hw, u8 type,
0387                u16 offset, u32 *value)
0388 {
0389     if (type == 1)
0390         efuse_shadow_read_1byte(hw, offset, (u8 *)value);
0391     else if (type == 2)
0392         efuse_shadow_read_2byte(hw, offset, (u16 *)value);
0393     else if (type == 4)
0394         efuse_shadow_read_4byte(hw, offset, value);
0395 
0396 }
0397 EXPORT_SYMBOL(efuse_shadow_read);
0398 
0399 void efuse_shadow_write(struct ieee80211_hw *hw, u8 type, u16 offset,
0400                 u32 value)
0401 {
0402     if (type == 1)
0403         efuse_shadow_write_1byte(hw, offset, (u8) value);
0404     else if (type == 2)
0405         efuse_shadow_write_2byte(hw, offset, (u16) value);
0406     else if (type == 4)
0407         efuse_shadow_write_4byte(hw, offset, value);
0408 
0409 }
0410 
0411 bool efuse_shadow_update(struct ieee80211_hw *hw)
0412 {
0413     struct rtl_priv *rtlpriv = rtl_priv(hw);
0414     struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
0415     u16 i, offset, base;
0416     u8 word_en = 0x0F;
0417     u8 first_pg = false;
0418 
0419     rtl_dbg(rtlpriv, COMP_EFUSE, DBG_LOUD, "\n");
0420 
0421     if (!efuse_shadow_update_chk(hw)) {
0422         efuse_read_all_map(hw, &rtlefuse->efuse_map[EFUSE_INIT_MAP][0]);
0423         memcpy(&rtlefuse->efuse_map[EFUSE_MODIFY_MAP][0],
0424                &rtlefuse->efuse_map[EFUSE_INIT_MAP][0],
0425                rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE]);
0426 
0427         rtl_dbg(rtlpriv, COMP_EFUSE, DBG_LOUD,
0428             "efuse out of capacity!!\n");
0429         return false;
0430     }
0431     efuse_power_switch(hw, true, true);
0432 
0433     for (offset = 0; offset < 16; offset++) {
0434 
0435         word_en = 0x0F;
0436         base = offset * 8;
0437 
0438         for (i = 0; i < 8; i++) {
0439             if (first_pg) {
0440                 word_en &= ~(BIT(i / 2));
0441 
0442                 rtlefuse->efuse_map[EFUSE_INIT_MAP][base + i] =
0443                     rtlefuse->efuse_map[EFUSE_MODIFY_MAP][base + i];
0444             } else {
0445 
0446                 if (rtlefuse->efuse_map[EFUSE_INIT_MAP][base + i] !=
0447                     rtlefuse->efuse_map[EFUSE_MODIFY_MAP][base + i]) {
0448                     word_en &= ~(BIT(i / 2));
0449 
0450                     rtlefuse->efuse_map[EFUSE_INIT_MAP][base + i] =
0451                         rtlefuse->efuse_map[EFUSE_MODIFY_MAP][base + i];
0452                 }
0453             }
0454         }
0455 
0456         if (word_en != 0x0F) {
0457             u8 tmpdata[8];
0458 
0459             memcpy(tmpdata,
0460                    &rtlefuse->efuse_map[EFUSE_MODIFY_MAP][base],
0461                    8);
0462             RT_PRINT_DATA(rtlpriv, COMP_INIT, DBG_LOUD,
0463                       "U-efuse\n", tmpdata, 8);
0464 
0465             if (!efuse_pg_packet_write(hw, (u8) offset, word_en,
0466                            tmpdata)) {
0467                 rtl_dbg(rtlpriv, COMP_ERR, DBG_WARNING,
0468                     "PG section(%#x) fail!!\n", offset);
0469                 break;
0470             }
0471         }
0472     }
0473 
0474     efuse_power_switch(hw, true, false);
0475     efuse_read_all_map(hw, &rtlefuse->efuse_map[EFUSE_INIT_MAP][0]);
0476 
0477     memcpy(&rtlefuse->efuse_map[EFUSE_MODIFY_MAP][0],
0478            &rtlefuse->efuse_map[EFUSE_INIT_MAP][0],
0479            rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE]);
0480 
0481     rtl_dbg(rtlpriv, COMP_EFUSE, DBG_LOUD, "\n");
0482     return true;
0483 }
0484 
0485 void rtl_efuse_shadow_map_update(struct ieee80211_hw *hw)
0486 {
0487     struct rtl_priv *rtlpriv = rtl_priv(hw);
0488     struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
0489 
0490     if (rtlefuse->autoload_failflag)
0491         memset((&rtlefuse->efuse_map[EFUSE_INIT_MAP][0]),
0492                0xFF, rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE]);
0493     else
0494         efuse_read_all_map(hw, &rtlefuse->efuse_map[EFUSE_INIT_MAP][0]);
0495 
0496     memcpy(&rtlefuse->efuse_map[EFUSE_MODIFY_MAP][0],
0497             &rtlefuse->efuse_map[EFUSE_INIT_MAP][0],
0498             rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE]);
0499 
0500 }
0501 EXPORT_SYMBOL(rtl_efuse_shadow_map_update);
0502 
0503 void efuse_force_write_vendor_id(struct ieee80211_hw *hw)
0504 {
0505     u8 tmpdata[8] = { 0xFF, 0xFF, 0xEC, 0x10, 0xFF, 0xFF, 0xFF, 0xFF };
0506 
0507     efuse_power_switch(hw, true, true);
0508 
0509     efuse_pg_packet_write(hw, 1, 0xD, tmpdata);
0510 
0511     efuse_power_switch(hw, true, false);
0512 
0513 }
0514 
0515 void efuse_re_pg_section(struct ieee80211_hw *hw, u8 section_idx)
0516 {
0517 }
0518 
0519 static void efuse_shadow_read_1byte(struct ieee80211_hw *hw,
0520                     u16 offset, u8 *value)
0521 {
0522     struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
0523     *value = rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset];
0524 }
0525 
0526 static void efuse_shadow_read_2byte(struct ieee80211_hw *hw,
0527                     u16 offset, u16 *value)
0528 {
0529     struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
0530 
0531     *value = rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset];
0532     *value |= rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 1] << 8;
0533 
0534 }
0535 
0536 static void efuse_shadow_read_4byte(struct ieee80211_hw *hw,
0537                     u16 offset, u32 *value)
0538 {
0539     struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
0540 
0541     *value = rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset];
0542     *value |= rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 1] << 8;
0543     *value |= rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 2] << 16;
0544     *value |= rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 3] << 24;
0545 }
0546 
0547 static void efuse_shadow_write_1byte(struct ieee80211_hw *hw,
0548                      u16 offset, u8 value)
0549 {
0550     struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
0551 
0552     rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset] = value;
0553 }
0554 
0555 static void efuse_shadow_write_2byte(struct ieee80211_hw *hw,
0556                      u16 offset, u16 value)
0557 {
0558     struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
0559 
0560     rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset] = value & 0x00FF;
0561     rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 1] = value >> 8;
0562 
0563 }
0564 
0565 static void efuse_shadow_write_4byte(struct ieee80211_hw *hw,
0566                      u16 offset, u32 value)
0567 {
0568     struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
0569 
0570     rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset] =
0571         (u8) (value & 0x000000FF);
0572     rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 1] =
0573         (u8) ((value >> 8) & 0x0000FF);
0574     rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 2] =
0575         (u8) ((value >> 16) & 0x00FF);
0576     rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 3] =
0577         (u8) ((value >> 24) & 0xFF);
0578 
0579 }
0580 
0581 int efuse_one_byte_read(struct ieee80211_hw *hw, u16 addr, u8 *data)
0582 {
0583     struct rtl_priv *rtlpriv = rtl_priv(hw);
0584     u8 tmpidx = 0;
0585     int result;
0586 
0587     rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 1,
0588                (u8) (addr & 0xff));
0589     rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 2,
0590                ((u8) ((addr >> 8) & 0x03)) |
0591                (rtl_read_byte(rtlpriv,
0592                       rtlpriv->cfg->maps[EFUSE_CTRL] + 2) &
0593             0xFC));
0594 
0595     rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 3, 0x72);
0596 
0597     while (!(0x80 & rtl_read_byte(rtlpriv,
0598                       rtlpriv->cfg->maps[EFUSE_CTRL] + 3))
0599            && (tmpidx < 100)) {
0600         tmpidx++;
0601     }
0602 
0603     if (tmpidx < 100) {
0604         *data = rtl_read_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL]);
0605         result = true;
0606     } else {
0607         *data = 0xff;
0608         result = false;
0609     }
0610     return result;
0611 }
0612 EXPORT_SYMBOL(efuse_one_byte_read);
0613 
0614 static int efuse_one_byte_write(struct ieee80211_hw *hw, u16 addr, u8 data)
0615 {
0616     struct rtl_priv *rtlpriv = rtl_priv(hw);
0617     u8 tmpidx = 0;
0618 
0619     rtl_dbg(rtlpriv, COMP_EFUSE, DBG_LOUD,
0620         "Addr = %x Data=%x\n", addr, data);
0621 
0622     rtl_write_byte(rtlpriv,
0623                rtlpriv->cfg->maps[EFUSE_CTRL] + 1, (u8) (addr & 0xff));
0624     rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 2,
0625                (rtl_read_byte(rtlpriv,
0626              rtlpriv->cfg->maps[EFUSE_CTRL] +
0627              2) & 0xFC) | (u8) ((addr >> 8) & 0x03));
0628 
0629     rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL], data);
0630     rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 3, 0xF2);
0631 
0632     while ((0x80 & rtl_read_byte(rtlpriv,
0633                      rtlpriv->cfg->maps[EFUSE_CTRL] + 3))
0634            && (tmpidx < 100)) {
0635         tmpidx++;
0636     }
0637 
0638     if (tmpidx < 100)
0639         return true;
0640     return false;
0641 }
0642 
0643 static void efuse_read_all_map(struct ieee80211_hw *hw, u8 *efuse)
0644 {
0645     struct rtl_priv *rtlpriv = rtl_priv(hw);
0646 
0647     efuse_power_switch(hw, false, true);
0648     read_efuse(hw, 0, rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE], efuse);
0649     efuse_power_switch(hw, false, false);
0650 }
0651 
0652 static void efuse_read_data_case1(struct ieee80211_hw *hw, u16 *efuse_addr,
0653                 u8 efuse_data, u8 offset, u8 *tmpdata,
0654                 u8 *readstate)
0655 {
0656     bool dataempty = true;
0657     u8 hoffset;
0658     u8 tmpidx;
0659     u8 hworden;
0660     u8 word_cnts;
0661 
0662     hoffset = (efuse_data >> 4) & 0x0F;
0663     hworden = efuse_data & 0x0F;
0664     word_cnts = efuse_calculate_word_cnts(hworden);
0665 
0666     if (hoffset == offset) {
0667         for (tmpidx = 0; tmpidx < word_cnts * 2; tmpidx++) {
0668             if (efuse_one_byte_read(hw, *efuse_addr + 1 + tmpidx,
0669                         &efuse_data)) {
0670                 tmpdata[tmpidx] = efuse_data;
0671                 if (efuse_data != 0xff)
0672                     dataempty = false;
0673             }
0674         }
0675 
0676         if (!dataempty) {
0677             *readstate = PG_STATE_DATA;
0678         } else {
0679             *efuse_addr = *efuse_addr + (word_cnts * 2) + 1;
0680             *readstate = PG_STATE_HEADER;
0681         }
0682 
0683     } else {
0684         *efuse_addr = *efuse_addr + (word_cnts * 2) + 1;
0685         *readstate = PG_STATE_HEADER;
0686     }
0687 }
0688 
0689 static int efuse_pg_packet_read(struct ieee80211_hw *hw, u8 offset, u8 *data)
0690 {
0691     u8 readstate = PG_STATE_HEADER;
0692 
0693     bool continual = true;
0694 
0695     u8 efuse_data, word_cnts = 0;
0696     u16 efuse_addr = 0;
0697     u8 tmpdata[8];
0698 
0699     if (data == NULL)
0700         return false;
0701     if (offset > 15)
0702         return false;
0703 
0704     memset(data, 0xff, PGPKT_DATA_SIZE * sizeof(u8));
0705     memset(tmpdata, 0xff, PGPKT_DATA_SIZE * sizeof(u8));
0706 
0707     while (continual && (efuse_addr < EFUSE_MAX_SIZE)) {
0708         if (readstate & PG_STATE_HEADER) {
0709             if (efuse_one_byte_read(hw, efuse_addr, &efuse_data)
0710                 && (efuse_data != 0xFF))
0711                 efuse_read_data_case1(hw, &efuse_addr,
0712                               efuse_data, offset,
0713                               tmpdata, &readstate);
0714             else
0715                 continual = false;
0716         } else if (readstate & PG_STATE_DATA) {
0717             efuse_word_enable_data_read(0, tmpdata, data);
0718             efuse_addr = efuse_addr + (word_cnts * 2) + 1;
0719             readstate = PG_STATE_HEADER;
0720         }
0721 
0722     }
0723 
0724     if ((data[0] == 0xff) && (data[1] == 0xff) &&
0725         (data[2] == 0xff) && (data[3] == 0xff) &&
0726         (data[4] == 0xff) && (data[5] == 0xff) &&
0727         (data[6] == 0xff) && (data[7] == 0xff))
0728         return false;
0729     else
0730         return true;
0731 
0732 }
0733 
0734 static void efuse_write_data_case1(struct ieee80211_hw *hw, u16 *efuse_addr,
0735                    u8 efuse_data, u8 offset,
0736                    int *continual, u8 *write_state,
0737                    struct pgpkt_struct *target_pkt,
0738                    int *repeat_times, int *result, u8 word_en)
0739 {
0740     struct rtl_priv *rtlpriv = rtl_priv(hw);
0741     struct pgpkt_struct tmp_pkt;
0742     int dataempty = true;
0743     u8 originaldata[8 * sizeof(u8)];
0744     u8 badworden = 0x0F;
0745     u8 match_word_en, tmp_word_en;
0746     u8 tmpindex;
0747     u8 tmp_header = efuse_data;
0748     u8 tmp_word_cnts;
0749 
0750     tmp_pkt.offset = (tmp_header >> 4) & 0x0F;
0751     tmp_pkt.word_en = tmp_header & 0x0F;
0752     tmp_word_cnts = efuse_calculate_word_cnts(tmp_pkt.word_en);
0753 
0754     if (tmp_pkt.offset != target_pkt->offset) {
0755         *efuse_addr = *efuse_addr + (tmp_word_cnts * 2) + 1;
0756         *write_state = PG_STATE_HEADER;
0757     } else {
0758         for (tmpindex = 0; tmpindex < (tmp_word_cnts * 2); tmpindex++) {
0759             if (efuse_one_byte_read(hw,
0760                         (*efuse_addr + 1 + tmpindex),
0761                         &efuse_data) &&
0762                 (efuse_data != 0xFF))
0763                 dataempty = false;
0764         }
0765 
0766         if (!dataempty) {
0767             *efuse_addr = *efuse_addr + (tmp_word_cnts * 2) + 1;
0768             *write_state = PG_STATE_HEADER;
0769         } else {
0770             match_word_en = 0x0F;
0771             if (!((target_pkt->word_en & BIT(0)) |
0772                 (tmp_pkt.word_en & BIT(0))))
0773                 match_word_en &= (~BIT(0));
0774 
0775             if (!((target_pkt->word_en & BIT(1)) |
0776                 (tmp_pkt.word_en & BIT(1))))
0777                 match_word_en &= (~BIT(1));
0778 
0779             if (!((target_pkt->word_en & BIT(2)) |
0780                 (tmp_pkt.word_en & BIT(2))))
0781                 match_word_en &= (~BIT(2));
0782 
0783             if (!((target_pkt->word_en & BIT(3)) |
0784                 (tmp_pkt.word_en & BIT(3))))
0785                 match_word_en &= (~BIT(3));
0786 
0787             if ((match_word_en & 0x0F) != 0x0F) {
0788                 badworden =
0789                   enable_efuse_data_write(hw,
0790                               *efuse_addr + 1,
0791                               tmp_pkt.word_en,
0792                               target_pkt->data);
0793 
0794                 if (0x0F != (badworden & 0x0F)) {
0795                     u8 reorg_offset = offset;
0796                     u8 reorg_worden = badworden;
0797 
0798                     efuse_pg_packet_write(hw, reorg_offset,
0799                                   reorg_worden,
0800                                   originaldata);
0801                 }
0802 
0803                 tmp_word_en = 0x0F;
0804                 if ((target_pkt->word_en & BIT(0)) ^
0805                     (match_word_en & BIT(0)))
0806                     tmp_word_en &= (~BIT(0));
0807 
0808                 if ((target_pkt->word_en & BIT(1)) ^
0809                     (match_word_en & BIT(1)))
0810                     tmp_word_en &= (~BIT(1));
0811 
0812                 if ((target_pkt->word_en & BIT(2)) ^
0813                     (match_word_en & BIT(2)))
0814                     tmp_word_en &= (~BIT(2));
0815 
0816                 if ((target_pkt->word_en & BIT(3)) ^
0817                     (match_word_en & BIT(3)))
0818                     tmp_word_en &= (~BIT(3));
0819 
0820                 if ((tmp_word_en & 0x0F) != 0x0F) {
0821                     *efuse_addr = efuse_get_current_size(hw);
0822                     target_pkt->offset = offset;
0823                     target_pkt->word_en = tmp_word_en;
0824                 } else {
0825                     *continual = false;
0826                 }
0827                 *write_state = PG_STATE_HEADER;
0828                 *repeat_times += 1;
0829                 if (*repeat_times > EFUSE_REPEAT_THRESHOLD_) {
0830                     *continual = false;
0831                     *result = false;
0832                 }
0833             } else {
0834                 *efuse_addr += (2 * tmp_word_cnts) + 1;
0835                 target_pkt->offset = offset;
0836                 target_pkt->word_en = word_en;
0837                 *write_state = PG_STATE_HEADER;
0838             }
0839         }
0840     }
0841     RTPRINT(rtlpriv, FEEPROM, EFUSE_PG, "efuse PG_STATE_HEADER-1\n");
0842 }
0843 
0844 static void efuse_write_data_case2(struct ieee80211_hw *hw, u16 *efuse_addr,
0845                    int *continual, u8 *write_state,
0846                    struct pgpkt_struct target_pkt,
0847                    int *repeat_times, int *result)
0848 {
0849     struct rtl_priv *rtlpriv = rtl_priv(hw);
0850     struct pgpkt_struct tmp_pkt;
0851     u8 pg_header;
0852     u8 tmp_header;
0853     u8 originaldata[8 * sizeof(u8)];
0854     u8 tmp_word_cnts;
0855     u8 badworden = 0x0F;
0856 
0857     pg_header = ((target_pkt.offset << 4) & 0xf0) | target_pkt.word_en;
0858     efuse_one_byte_write(hw, *efuse_addr, pg_header);
0859     efuse_one_byte_read(hw, *efuse_addr, &tmp_header);
0860 
0861     if (tmp_header == pg_header) {
0862         *write_state = PG_STATE_DATA;
0863     } else if (tmp_header == 0xFF) {
0864         *write_state = PG_STATE_HEADER;
0865         *repeat_times += 1;
0866         if (*repeat_times > EFUSE_REPEAT_THRESHOLD_) {
0867             *continual = false;
0868             *result = false;
0869         }
0870     } else {
0871         tmp_pkt.offset = (tmp_header >> 4) & 0x0F;
0872         tmp_pkt.word_en = tmp_header & 0x0F;
0873 
0874         tmp_word_cnts = efuse_calculate_word_cnts(tmp_pkt.word_en);
0875 
0876         memset(originaldata, 0xff,  8 * sizeof(u8));
0877 
0878         if (efuse_pg_packet_read(hw, tmp_pkt.offset, originaldata)) {
0879             badworden = enable_efuse_data_write(hw,
0880                                 *efuse_addr + 1,
0881                                 tmp_pkt.word_en,
0882                                 originaldata);
0883 
0884             if (0x0F != (badworden & 0x0F)) {
0885                 u8 reorg_offset = tmp_pkt.offset;
0886                 u8 reorg_worden = badworden;
0887 
0888                 efuse_pg_packet_write(hw, reorg_offset,
0889                               reorg_worden,
0890                               originaldata);
0891                 *efuse_addr = efuse_get_current_size(hw);
0892             } else {
0893                 *efuse_addr = *efuse_addr +
0894                           (tmp_word_cnts * 2) + 1;
0895             }
0896         } else {
0897             *efuse_addr = *efuse_addr + (tmp_word_cnts * 2) + 1;
0898         }
0899 
0900         *write_state = PG_STATE_HEADER;
0901         *repeat_times += 1;
0902         if (*repeat_times > EFUSE_REPEAT_THRESHOLD_) {
0903             *continual = false;
0904             *result = false;
0905         }
0906 
0907         RTPRINT(rtlpriv, FEEPROM, EFUSE_PG,
0908             "efuse PG_STATE_HEADER-2\n");
0909     }
0910 }
0911 
0912 static int efuse_pg_packet_write(struct ieee80211_hw *hw,
0913                  u8 offset, u8 word_en, u8 *data)
0914 {
0915     struct rtl_priv *rtlpriv = rtl_priv(hw);
0916     struct pgpkt_struct target_pkt;
0917     u8 write_state = PG_STATE_HEADER;
0918     int continual = true, result = true;
0919     u16 efuse_addr = 0;
0920     u8 efuse_data;
0921     u8 target_word_cnts = 0;
0922     u8 badworden = 0x0F;
0923     static int repeat_times;
0924 
0925     if (efuse_get_current_size(hw) >= (EFUSE_MAX_SIZE -
0926         rtlpriv->cfg->maps[EFUSE_OOB_PROTECT_BYTES_LEN])) {
0927         RTPRINT(rtlpriv, FEEPROM, EFUSE_PG,
0928             "efuse_pg_packet_write error\n");
0929         return false;
0930     }
0931 
0932     target_pkt.offset = offset;
0933     target_pkt.word_en = word_en;
0934 
0935     memset(target_pkt.data, 0xFF,  8 * sizeof(u8));
0936 
0937     efuse_word_enable_data_read(word_en, data, target_pkt.data);
0938     target_word_cnts = efuse_calculate_word_cnts(target_pkt.word_en);
0939 
0940     RTPRINT(rtlpriv, FEEPROM, EFUSE_PG, "efuse Power ON\n");
0941 
0942     while (continual && (efuse_addr < (EFUSE_MAX_SIZE -
0943         rtlpriv->cfg->maps[EFUSE_OOB_PROTECT_BYTES_LEN]))) {
0944         if (write_state == PG_STATE_HEADER) {
0945             badworden = 0x0F;
0946             RTPRINT(rtlpriv, FEEPROM, EFUSE_PG,
0947                 "efuse PG_STATE_HEADER\n");
0948 
0949             if (efuse_one_byte_read(hw, efuse_addr, &efuse_data) &&
0950                 (efuse_data != 0xFF))
0951                 efuse_write_data_case1(hw, &efuse_addr,
0952                                efuse_data, offset,
0953                                &continual,
0954                                &write_state,
0955                                &target_pkt,
0956                                &repeat_times, &result,
0957                                word_en);
0958             else
0959                 efuse_write_data_case2(hw, &efuse_addr,
0960                                &continual,
0961                                &write_state,
0962                                target_pkt,
0963                                &repeat_times,
0964                                &result);
0965 
0966         } else if (write_state == PG_STATE_DATA) {
0967             RTPRINT(rtlpriv, FEEPROM, EFUSE_PG,
0968                 "efuse PG_STATE_DATA\n");
0969             badworden =
0970                 enable_efuse_data_write(hw, efuse_addr + 1,
0971                             target_pkt.word_en,
0972                             target_pkt.data);
0973 
0974             if ((badworden & 0x0F) == 0x0F) {
0975                 continual = false;
0976             } else {
0977                 efuse_addr =
0978                     efuse_addr + (2 * target_word_cnts) + 1;
0979 
0980                 target_pkt.offset = offset;
0981                 target_pkt.word_en = badworden;
0982                 target_word_cnts =
0983                     efuse_calculate_word_cnts(target_pkt.
0984                                   word_en);
0985                 write_state = PG_STATE_HEADER;
0986                 repeat_times++;
0987                 if (repeat_times > EFUSE_REPEAT_THRESHOLD_) {
0988                     continual = false;
0989                     result = false;
0990                 }
0991                 RTPRINT(rtlpriv, FEEPROM, EFUSE_PG,
0992                     "efuse PG_STATE_HEADER-3\n");
0993             }
0994         }
0995     }
0996 
0997     if (efuse_addr >= (EFUSE_MAX_SIZE -
0998         rtlpriv->cfg->maps[EFUSE_OOB_PROTECT_BYTES_LEN])) {
0999         rtl_dbg(rtlpriv, COMP_EFUSE, DBG_LOUD,
1000             "efuse_addr(%#x) Out of size!!\n", efuse_addr);
1001     }
1002 
1003     return true;
1004 }
1005 
1006 static void efuse_word_enable_data_read(u8 word_en, u8 *sourdata,
1007                     u8 *targetdata)
1008 {
1009     if (!(word_en & BIT(0))) {
1010         targetdata[0] = sourdata[0];
1011         targetdata[1] = sourdata[1];
1012     }
1013 
1014     if (!(word_en & BIT(1))) {
1015         targetdata[2] = sourdata[2];
1016         targetdata[3] = sourdata[3];
1017     }
1018 
1019     if (!(word_en & BIT(2))) {
1020         targetdata[4] = sourdata[4];
1021         targetdata[5] = sourdata[5];
1022     }
1023 
1024     if (!(word_en & BIT(3))) {
1025         targetdata[6] = sourdata[6];
1026         targetdata[7] = sourdata[7];
1027     }
1028 }
1029 
1030 static u8 enable_efuse_data_write(struct ieee80211_hw *hw,
1031                   u16 efuse_addr, u8 word_en, u8 *data)
1032 {
1033     struct rtl_priv *rtlpriv = rtl_priv(hw);
1034     u16 tmpaddr;
1035     u16 start_addr = efuse_addr;
1036     u8 badworden = 0x0F;
1037     u8 tmpdata[8];
1038 
1039     memset(tmpdata, 0xff, PGPKT_DATA_SIZE);
1040     rtl_dbg(rtlpriv, COMP_EFUSE, DBG_LOUD,
1041         "word_en = %x efuse_addr=%x\n", word_en, efuse_addr);
1042 
1043     if (!(word_en & BIT(0))) {
1044         tmpaddr = start_addr;
1045         efuse_one_byte_write(hw, start_addr++, data[0]);
1046         efuse_one_byte_write(hw, start_addr++, data[1]);
1047 
1048         efuse_one_byte_read(hw, tmpaddr, &tmpdata[0]);
1049         efuse_one_byte_read(hw, tmpaddr + 1, &tmpdata[1]);
1050         if ((data[0] != tmpdata[0]) || (data[1] != tmpdata[1]))
1051             badworden &= (~BIT(0));
1052     }
1053 
1054     if (!(word_en & BIT(1))) {
1055         tmpaddr = start_addr;
1056         efuse_one_byte_write(hw, start_addr++, data[2]);
1057         efuse_one_byte_write(hw, start_addr++, data[3]);
1058 
1059         efuse_one_byte_read(hw, tmpaddr, &tmpdata[2]);
1060         efuse_one_byte_read(hw, tmpaddr + 1, &tmpdata[3]);
1061         if ((data[2] != tmpdata[2]) || (data[3] != tmpdata[3]))
1062             badworden &= (~BIT(1));
1063     }
1064 
1065     if (!(word_en & BIT(2))) {
1066         tmpaddr = start_addr;
1067         efuse_one_byte_write(hw, start_addr++, data[4]);
1068         efuse_one_byte_write(hw, start_addr++, data[5]);
1069 
1070         efuse_one_byte_read(hw, tmpaddr, &tmpdata[4]);
1071         efuse_one_byte_read(hw, tmpaddr + 1, &tmpdata[5]);
1072         if ((data[4] != tmpdata[4]) || (data[5] != tmpdata[5]))
1073             badworden &= (~BIT(2));
1074     }
1075 
1076     if (!(word_en & BIT(3))) {
1077         tmpaddr = start_addr;
1078         efuse_one_byte_write(hw, start_addr++, data[6]);
1079         efuse_one_byte_write(hw, start_addr++, data[7]);
1080 
1081         efuse_one_byte_read(hw, tmpaddr, &tmpdata[6]);
1082         efuse_one_byte_read(hw, tmpaddr + 1, &tmpdata[7]);
1083         if ((data[6] != tmpdata[6]) || (data[7] != tmpdata[7]))
1084             badworden &= (~BIT(3));
1085     }
1086 
1087     return badworden;
1088 }
1089 
1090 void efuse_power_switch(struct ieee80211_hw *hw, u8 write, u8 pwrstate)
1091 {
1092     struct rtl_priv *rtlpriv = rtl_priv(hw);
1093     struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
1094     u8 tempval;
1095     u16 tmpv16;
1096 
1097     if (pwrstate && (rtlhal->hw_type != HARDWARE_TYPE_RTL8192SE)) {
1098         if (rtlhal->hw_type != HARDWARE_TYPE_RTL8192CE &&
1099             rtlhal->hw_type != HARDWARE_TYPE_RTL8192DE) {
1100             rtl_write_byte(rtlpriv,
1101                        rtlpriv->cfg->maps[EFUSE_ACCESS], 0x69);
1102         } else {
1103             tmpv16 =
1104               rtl_read_word(rtlpriv,
1105                     rtlpriv->cfg->maps[SYS_ISO_CTRL]);
1106             if (!(tmpv16 & rtlpriv->cfg->maps[EFUSE_PWC_EV12V])) {
1107                 tmpv16 |= rtlpriv->cfg->maps[EFUSE_PWC_EV12V];
1108                 rtl_write_word(rtlpriv,
1109                            rtlpriv->cfg->maps[SYS_ISO_CTRL],
1110                            tmpv16);
1111             }
1112         }
1113         tmpv16 = rtl_read_word(rtlpriv,
1114                        rtlpriv->cfg->maps[SYS_FUNC_EN]);
1115         if (!(tmpv16 & rtlpriv->cfg->maps[EFUSE_FEN_ELDR])) {
1116             tmpv16 |= rtlpriv->cfg->maps[EFUSE_FEN_ELDR];
1117             rtl_write_word(rtlpriv,
1118                        rtlpriv->cfg->maps[SYS_FUNC_EN], tmpv16);
1119         }
1120 
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] |
1125                    rtlpriv->cfg->maps[EFUSE_ANA8M]);
1126             rtl_write_word(rtlpriv,
1127                        rtlpriv->cfg->maps[SYS_CLK], tmpv16);
1128         }
1129     }
1130 
1131     if (pwrstate) {
1132         if (write) {
1133             tempval = rtl_read_byte(rtlpriv,
1134                         rtlpriv->cfg->maps[EFUSE_TEST] +
1135                         3);
1136 
1137             if (rtlhal->hw_type == HARDWARE_TYPE_RTL8812AE) {
1138                 tempval &= ~(BIT(3) | BIT(4) | BIT(5) | BIT(6));
1139                 tempval |= (VOLTAGE_V25 << 3);
1140             } else if (rtlhal->hw_type != HARDWARE_TYPE_RTL8192SE) {
1141                 tempval &= 0x0F;
1142                 tempval |= (VOLTAGE_V25 << 4);
1143             }
1144 
1145             rtl_write_byte(rtlpriv,
1146                        rtlpriv->cfg->maps[EFUSE_TEST] + 3,
1147                        (tempval | 0x80));
1148         }
1149 
1150         if (rtlhal->hw_type == HARDWARE_TYPE_RTL8192SE) {
1151             rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CLK],
1152                        0x03);
1153         }
1154     } else {
1155         if (rtlhal->hw_type != HARDWARE_TYPE_RTL8192CE &&
1156             rtlhal->hw_type != HARDWARE_TYPE_RTL8192DE)
1157             rtl_write_byte(rtlpriv,
1158                        rtlpriv->cfg->maps[EFUSE_ACCESS], 0);
1159 
1160         if (write) {
1161             tempval = rtl_read_byte(rtlpriv,
1162                         rtlpriv->cfg->maps[EFUSE_TEST] +
1163                         3);
1164             rtl_write_byte(rtlpriv,
1165                        rtlpriv->cfg->maps[EFUSE_TEST] + 3,
1166                        (tempval & 0x7F));
1167         }
1168 
1169         if (rtlhal->hw_type == HARDWARE_TYPE_RTL8192SE) {
1170             rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CLK],
1171                        0x02);
1172         }
1173     }
1174 }
1175 EXPORT_SYMBOL(efuse_power_switch);
1176 
1177 static u16 efuse_get_current_size(struct ieee80211_hw *hw)
1178 {
1179     int continual = true;
1180     u16 efuse_addr = 0;
1181     u8 hworden;
1182     u8 efuse_data, word_cnts;
1183 
1184     while (continual && efuse_one_byte_read(hw, efuse_addr, &efuse_data) &&
1185            (efuse_addr < EFUSE_MAX_SIZE)) {
1186         if (efuse_data != 0xFF) {
1187             hworden = efuse_data & 0x0F;
1188             word_cnts = efuse_calculate_word_cnts(hworden);
1189             efuse_addr = efuse_addr + (word_cnts * 2) + 1;
1190         } else {
1191             continual = false;
1192         }
1193     }
1194 
1195     return efuse_addr;
1196 }
1197 
1198 static u8 efuse_calculate_word_cnts(u8 word_en)
1199 {
1200     u8 word_cnts = 0;
1201 
1202     if (!(word_en & BIT(0)))
1203         word_cnts++;
1204     if (!(word_en & BIT(1)))
1205         word_cnts++;
1206     if (!(word_en & BIT(2)))
1207         word_cnts++;
1208     if (!(word_en & BIT(3)))
1209         word_cnts++;
1210     return word_cnts;
1211 }
1212 
1213 int rtl_get_hwinfo(struct ieee80211_hw *hw, struct rtl_priv *rtlpriv,
1214            int max_size, u8 *hwinfo, int *params)
1215 {
1216     struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
1217     struct rtl_pci_priv *rtlpcipriv = rtl_pcipriv(hw);
1218     struct device *dev = &rtlpcipriv->dev.pdev->dev;
1219     u16 eeprom_id;
1220     u16 i, usvalue;
1221 
1222     switch (rtlefuse->epromtype) {
1223     case EEPROM_BOOT_EFUSE:
1224         rtl_efuse_shadow_map_update(hw);
1225         break;
1226 
1227     case EEPROM_93C46:
1228         pr_err("RTL8XXX did not boot from eeprom, check it !!\n");
1229         return 1;
1230 
1231     default:
1232         dev_warn(dev, "no efuse data\n");
1233         return 1;
1234     }
1235 
1236     memcpy(hwinfo, &rtlefuse->efuse_map[EFUSE_INIT_MAP][0], max_size);
1237 
1238     RT_PRINT_DATA(rtlpriv, COMP_INIT, DBG_DMESG, "MAP",
1239               hwinfo, max_size);
1240 
1241     eeprom_id = *((u16 *)&hwinfo[0]);
1242     if (eeprom_id != params[0]) {
1243         rtl_dbg(rtlpriv, COMP_ERR, DBG_WARNING,
1244             "EEPROM ID(%#x) is invalid!!\n", eeprom_id);
1245         rtlefuse->autoload_failflag = true;
1246     } else {
1247         rtl_dbg(rtlpriv, COMP_INIT, DBG_LOUD, "Autoload OK\n");
1248         rtlefuse->autoload_failflag = false;
1249     }
1250 
1251     if (rtlefuse->autoload_failflag)
1252         return 1;
1253 
1254     rtlefuse->eeprom_vid = *(u16 *)&hwinfo[params[1]];
1255     rtlefuse->eeprom_did = *(u16 *)&hwinfo[params[2]];
1256     rtlefuse->eeprom_svid = *(u16 *)&hwinfo[params[3]];
1257     rtlefuse->eeprom_smid = *(u16 *)&hwinfo[params[4]];
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);
1268 
1269     for (i = 0; i < 6; i += 2) {
1270         usvalue = *(u16 *)&hwinfo[params[5] + i];
1271         *((u16 *)(&rtlefuse->dev_addr[i])) = usvalue;
1272     }
1273     rtl_dbg(rtlpriv, COMP_INIT, DBG_DMESG, "%pM\n", rtlefuse->dev_addr);
1274 
1275     rtlefuse->eeprom_channelplan = *&hwinfo[params[6]];
1276     rtlefuse->eeprom_version = *(u16 *)&hwinfo[params[7]];
1277     rtlefuse->txpwr_fromeprom = true;
1278     rtlefuse->eeprom_oemid = *&hwinfo[params[8]];
1279 
1280     rtl_dbg(rtlpriv, COMP_INIT, DBG_LOUD,
1281         "EEPROM Customer ID: 0x%2x\n", rtlefuse->eeprom_oemid);
1282 
1283     /* set channel plan to world wide 13 */
1284     rtlefuse->channel_plan = params[9];
1285 
1286     return 0;
1287 }
1288 EXPORT_SYMBOL_GPL(rtl_get_hwinfo);
1289 
1290 void rtl_fw_block_write(struct ieee80211_hw *hw, const u8 *buffer, u32 size)
1291 {
1292     struct rtl_priv *rtlpriv = rtl_priv(hw);
1293     u8 *pu4byteptr = (u8 *)buffer;
1294     u32 i;
1295 
1296     for (i = 0; i < size; i++)
1297         rtl_write_byte(rtlpriv, (START_ADDRESS + i), *(pu4byteptr + i));
1298 }
1299 EXPORT_SYMBOL_GPL(rtl_fw_block_write);
1300 
1301 void rtl_fw_page_write(struct ieee80211_hw *hw, u32 page, const u8 *buffer,
1302                u32 size)
1303 {
1304     struct rtl_priv *rtlpriv = rtl_priv(hw);
1305     u8 value8;
1306     u8 u8page = (u8)(page & 0x07);
1307 
1308     value8 = (rtl_read_byte(rtlpriv, REG_MCUFWDL + 2) & 0xF8) | u8page;
1309 
1310     rtl_write_byte(rtlpriv, (REG_MCUFWDL + 2), value8);
1311     rtl_fw_block_write(hw, buffer, size);
1312 }
1313 EXPORT_SYMBOL_GPL(rtl_fw_page_write);
1314 
1315 void rtl_fill_dummy(u8 *pfwbuf, u32 *pfwlen)
1316 {
1317     u32 fwlen = *pfwlen;
1318     u8 remain = (u8)(fwlen % 4);
1319 
1320     remain = (remain == 0) ? 0 : (4 - remain);
1321 
1322     while (remain > 0) {
1323         pfwbuf[fwlen] = 0;
1324         fwlen++;
1325         remain--;
1326     }
1327 
1328     *pfwlen = fwlen;
1329 }
1330 EXPORT_SYMBOL_GPL(rtl_fill_dummy);
1331 
1332 void rtl_efuse_ops_init(struct ieee80211_hw *hw)
1333 {
1334     struct rtl_priv *rtlpriv = rtl_priv(hw);
1335 
1336     rtlpriv->efuse.efuse_ops = &efuse_ops;
1337 }
1338 EXPORT_SYMBOL_GPL(rtl_efuse_ops_init);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!