This source file includes following definitions.
- efuse_initialize
- efuse_read_1byte
- efuse_write_1byte
- read_efuse_byte
- read_efuse
- efuse_shadow_update_chk
- efuse_shadow_read
- efuse_shadow_write
- efuse_shadow_update
- rtl_efuse_shadow_map_update
- efuse_force_write_vendor_id
- efuse_re_pg_section
- efuse_shadow_read_1byte
- efuse_shadow_read_2byte
- efuse_shadow_read_4byte
- efuse_shadow_write_1byte
- efuse_shadow_write_2byte
- efuse_shadow_write_4byte
- efuse_one_byte_read
- efuse_one_byte_write
- efuse_read_all_map
- efuse_read_data_case1
- efuse_pg_packet_read
- efuse_write_data_case1
- efuse_write_data_case2
- efuse_pg_packet_write
- efuse_word_enable_data_read
- enable_efuse_data_write
- efuse_power_switch
- efuse_get_current_size
- efuse_calculate_word_cnts
- rtl_get_hwinfo
- rtl_fw_block_write
- rtl_fw_page_write
- rtl_fill_dummy
- rtl_efuse_ops_init
1
2
3
4 #include "wifi.h"
5 #include "efuse.h"
6 #include "pci.h"
7 #include <linux/export.h>
8
9 static const u8 PGPKT_DATA_SIZE = 8;
10 static const int EFUSE_MAX_SIZE = 512;
11
12 #define START_ADDRESS 0x1000
13 #define REG_MCUFWDL 0x0080
14
15 static const struct rtl_efuse_ops efuse_ops = {
16 .efuse_onebyte_read = efuse_one_byte_read,
17 .efuse_logical_map_read = efuse_shadow_read,
18 };
19
20 static void efuse_shadow_read_1byte(struct ieee80211_hw *hw, u16 offset,
21 u8 *value);
22 static void efuse_shadow_read_2byte(struct ieee80211_hw *hw, u16 offset,
23 u16 *value);
24 static void efuse_shadow_read_4byte(struct ieee80211_hw *hw, u16 offset,
25 u32 *value);
26 static void efuse_shadow_write_1byte(struct ieee80211_hw *hw, u16 offset,
27 u8 value);
28 static void efuse_shadow_write_2byte(struct ieee80211_hw *hw, u16 offset,
29 u16 value);
30 static void efuse_shadow_write_4byte(struct ieee80211_hw *hw, u16 offset,
31 u32 value);
32 static int efuse_one_byte_write(struct ieee80211_hw *hw, u16 addr,
33 u8 data);
34 static void efuse_read_all_map(struct ieee80211_hw *hw, u8 *efuse);
35 static int efuse_pg_packet_read(struct ieee80211_hw *hw, u8 offset,
36 u8 *data);
37 static int efuse_pg_packet_write(struct ieee80211_hw *hw, u8 offset,
38 u8 word_en, u8 *data);
39 static void efuse_word_enable_data_read(u8 word_en, u8 *sourdata,
40 u8 *targetdata);
41 static u8 enable_efuse_data_write(struct ieee80211_hw *hw,
42 u16 efuse_addr, u8 word_en, u8 *data);
43 static u16 efuse_get_current_size(struct ieee80211_hw *hw);
44 static u8 efuse_calculate_word_cnts(u8 word_en);
45
46 void efuse_initialize(struct ieee80211_hw *hw)
47 {
48 struct rtl_priv *rtlpriv = rtl_priv(hw);
49 u8 bytetemp;
50 u8 temp;
51
52 bytetemp = rtl_read_byte(rtlpriv, rtlpriv->cfg->maps[SYS_FUNC_EN] + 1);
53 temp = bytetemp | 0x20;
54 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[SYS_FUNC_EN] + 1, temp);
55
56 bytetemp = rtl_read_byte(rtlpriv, rtlpriv->cfg->maps[SYS_ISO_CTRL] + 1);
57 temp = bytetemp & 0xFE;
58 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[SYS_ISO_CTRL] + 1, temp);
59
60 bytetemp = rtl_read_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_TEST] + 3);
61 temp = bytetemp | 0x80;
62 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_TEST] + 3, temp);
63
64 rtl_write_byte(rtlpriv, 0x2F8, 0x3);
65
66 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 3, 0x72);
67
68 }
69
70 u8 efuse_read_1byte(struct ieee80211_hw *hw, u16 address)
71 {
72 struct rtl_priv *rtlpriv = rtl_priv(hw);
73 u8 data;
74 u8 bytetemp;
75 u8 temp;
76 u32 k = 0;
77 const u32 efuse_len =
78 rtlpriv->cfg->maps[EFUSE_REAL_CONTENT_SIZE];
79
80 if (address < efuse_len) {
81 temp = address & 0xFF;
82 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 1,
83 temp);
84 bytetemp = rtl_read_byte(rtlpriv,
85 rtlpriv->cfg->maps[EFUSE_CTRL] + 2);
86 temp = ((address >> 8) & 0x03) | (bytetemp & 0xFC);
87 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 2,
88 temp);
89
90 bytetemp = rtl_read_byte(rtlpriv,
91 rtlpriv->cfg->maps[EFUSE_CTRL] + 3);
92 temp = bytetemp & 0x7F;
93 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 3,
94 temp);
95
96 bytetemp = rtl_read_byte(rtlpriv,
97 rtlpriv->cfg->maps[EFUSE_CTRL] + 3);
98 while (!(bytetemp & 0x80)) {
99 bytetemp = rtl_read_byte(rtlpriv,
100 rtlpriv->cfg->
101 maps[EFUSE_CTRL] + 3);
102 k++;
103 if (k == 1000)
104 break;
105 }
106 data = rtl_read_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL]);
107 return data;
108 } else
109 return 0xFF;
110
111 }
112 EXPORT_SYMBOL(efuse_read_1byte);
113
114 void efuse_write_1byte(struct ieee80211_hw *hw, u16 address, u8 value)
115 {
116 struct rtl_priv *rtlpriv = rtl_priv(hw);
117 u8 bytetemp;
118 u8 temp;
119 u32 k = 0;
120 const u32 efuse_len =
121 rtlpriv->cfg->maps[EFUSE_REAL_CONTENT_SIZE];
122
123 RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD, "Addr=%x Data =%x\n",
124 address, value);
125
126 if (address < efuse_len) {
127 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL], value);
128
129 temp = address & 0xFF;
130 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 1,
131 temp);
132 bytetemp = rtl_read_byte(rtlpriv,
133 rtlpriv->cfg->maps[EFUSE_CTRL] + 2);
134
135 temp = ((address >> 8) & 0x03) | (bytetemp & 0xFC);
136 rtl_write_byte(rtlpriv,
137 rtlpriv->cfg->maps[EFUSE_CTRL] + 2, temp);
138
139 bytetemp = rtl_read_byte(rtlpriv,
140 rtlpriv->cfg->maps[EFUSE_CTRL] + 3);
141 temp = bytetemp | 0x80;
142 rtl_write_byte(rtlpriv,
143 rtlpriv->cfg->maps[EFUSE_CTRL] + 3, temp);
144
145 bytetemp = rtl_read_byte(rtlpriv,
146 rtlpriv->cfg->maps[EFUSE_CTRL] + 3);
147
148 while (bytetemp & 0x80) {
149 bytetemp = rtl_read_byte(rtlpriv,
150 rtlpriv->cfg->
151 maps[EFUSE_CTRL] + 3);
152 k++;
153 if (k == 100) {
154 k = 0;
155 break;
156 }
157 }
158 }
159
160 }
161
162 void read_efuse_byte(struct ieee80211_hw *hw, u16 _offset, u8 *pbuf)
163 {
164 struct rtl_priv *rtlpriv = rtl_priv(hw);
165 u32 value32;
166 u8 readbyte;
167 u16 retry;
168
169 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 1,
170 (_offset & 0xff));
171 readbyte = rtl_read_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 2);
172 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 2,
173 ((_offset >> 8) & 0x03) | (readbyte & 0xfc));
174
175 readbyte = rtl_read_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 3);
176 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 3,
177 (readbyte & 0x7f));
178
179 retry = 0;
180 value32 = rtl_read_dword(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL]);
181 while (!(((value32 >> 24) & 0xff) & 0x80) && (retry < 10000)) {
182 value32 = rtl_read_dword(rtlpriv,
183 rtlpriv->cfg->maps[EFUSE_CTRL]);
184 retry++;
185 }
186
187 udelay(50);
188 value32 = rtl_read_dword(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL]);
189
190 *pbuf = (u8) (value32 & 0xff);
191 }
192 EXPORT_SYMBOL_GPL(read_efuse_byte);
193
194 void read_efuse(struct ieee80211_hw *hw, u16 _offset, u16 _size_byte, u8 *pbuf)
195 {
196 struct rtl_priv *rtlpriv = rtl_priv(hw);
197 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
198 u8 *efuse_tbl;
199 u8 rtemp8[1];
200 u16 efuse_addr = 0;
201 u8 offset, wren;
202 u8 u1temp = 0;
203 u16 i;
204 u16 j;
205 const u16 efuse_max_section =
206 rtlpriv->cfg->maps[EFUSE_MAX_SECTION_MAP];
207 const u32 efuse_len =
208 rtlpriv->cfg->maps[EFUSE_REAL_CONTENT_SIZE];
209 u16 **efuse_word;
210 u16 efuse_utilized = 0;
211 u8 efuse_usage;
212
213 if ((_offset + _size_byte) > rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE]) {
214 RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD,
215 "read_efuse(): Invalid offset(%#x) with read bytes(%#x)!!\n",
216 _offset, _size_byte);
217 return;
218 }
219
220
221 efuse_tbl = kzalloc(rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE],
222 GFP_ATOMIC);
223 if (!efuse_tbl)
224 return;
225 efuse_word = kcalloc(EFUSE_MAX_WORD_UNIT, sizeof(u16 *), GFP_ATOMIC);
226 if (!efuse_word)
227 goto out;
228 for (i = 0; i < EFUSE_MAX_WORD_UNIT; i++) {
229 efuse_word[i] = kcalloc(efuse_max_section, sizeof(u16),
230 GFP_ATOMIC);
231 if (!efuse_word[i])
232 goto done;
233 }
234
235 for (i = 0; i < efuse_max_section; i++)
236 for (j = 0; j < EFUSE_MAX_WORD_UNIT; j++)
237 efuse_word[j][i] = 0xFFFF;
238
239 read_efuse_byte(hw, efuse_addr, rtemp8);
240 if (*rtemp8 != 0xFF) {
241 efuse_utilized++;
242 RTPRINT(rtlpriv, FEEPROM, EFUSE_READ_ALL,
243 "Addr=%d\n", efuse_addr);
244 efuse_addr++;
245 }
246
247 while ((*rtemp8 != 0xFF) && (efuse_addr < efuse_len)) {
248
249 if ((*rtemp8 & 0x1F) == 0x0F) {
250 u1temp = ((*rtemp8 & 0xE0) >> 5);
251 read_efuse_byte(hw, efuse_addr, rtemp8);
252
253 if ((*rtemp8 & 0x0F) == 0x0F) {
254 efuse_addr++;
255 read_efuse_byte(hw, efuse_addr, rtemp8);
256
257 if (*rtemp8 != 0xFF &&
258 (efuse_addr < efuse_len)) {
259 efuse_addr++;
260 }
261 continue;
262 } else {
263 offset = ((*rtemp8 & 0xF0) >> 1) | u1temp;
264 wren = (*rtemp8 & 0x0F);
265 efuse_addr++;
266 }
267 } else {
268 offset = ((*rtemp8 >> 4) & 0x0f);
269 wren = (*rtemp8 & 0x0f);
270 }
271
272 if (offset < efuse_max_section) {
273 RTPRINT(rtlpriv, FEEPROM, EFUSE_READ_ALL,
274 "offset-%d Worden=%x\n", offset, wren);
275
276 for (i = 0; i < EFUSE_MAX_WORD_UNIT; i++) {
277 if (!(wren & 0x01)) {
278 RTPRINT(rtlpriv, FEEPROM,
279 EFUSE_READ_ALL,
280 "Addr=%d\n", efuse_addr);
281
282 read_efuse_byte(hw, efuse_addr, rtemp8);
283 efuse_addr++;
284 efuse_utilized++;
285 efuse_word[i][offset] =
286 (*rtemp8 & 0xff);
287
288 if (efuse_addr >= efuse_len)
289 break;
290
291 RTPRINT(rtlpriv, FEEPROM,
292 EFUSE_READ_ALL,
293 "Addr=%d\n", efuse_addr);
294
295 read_efuse_byte(hw, efuse_addr, rtemp8);
296 efuse_addr++;
297 efuse_utilized++;
298 efuse_word[i][offset] |=
299 (((u16)*rtemp8 << 8) & 0xff00);
300
301 if (efuse_addr >= efuse_len)
302 break;
303 }
304
305 wren >>= 1;
306 }
307 }
308
309 RTPRINT(rtlpriv, FEEPROM, EFUSE_READ_ALL,
310 "Addr=%d\n", efuse_addr);
311 read_efuse_byte(hw, efuse_addr, rtemp8);
312 if (*rtemp8 != 0xFF && (efuse_addr < efuse_len)) {
313 efuse_utilized++;
314 efuse_addr++;
315 }
316 }
317
318 for (i = 0; i < efuse_max_section; i++) {
319 for (j = 0; j < EFUSE_MAX_WORD_UNIT; j++) {
320 efuse_tbl[(i * 8) + (j * 2)] =
321 (efuse_word[j][i] & 0xff);
322 efuse_tbl[(i * 8) + ((j * 2) + 1)] =
323 ((efuse_word[j][i] >> 8) & 0xff);
324 }
325 }
326
327 for (i = 0; i < _size_byte; i++)
328 pbuf[i] = efuse_tbl[_offset + i];
329
330 rtlefuse->efuse_usedbytes = efuse_utilized;
331 efuse_usage = (u8) ((efuse_utilized * 100) / efuse_len);
332 rtlefuse->efuse_usedpercentage = efuse_usage;
333 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_EFUSE_BYTES,
334 (u8 *)&efuse_utilized);
335 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_EFUSE_USAGE,
336 &efuse_usage);
337 done:
338 for (i = 0; i < EFUSE_MAX_WORD_UNIT; i++)
339 kfree(efuse_word[i]);
340 kfree(efuse_word);
341 out:
342 kfree(efuse_tbl);
343 }
344
345 bool efuse_shadow_update_chk(struct ieee80211_hw *hw)
346 {
347 struct rtl_priv *rtlpriv = rtl_priv(hw);
348 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
349 u8 section_idx, i, base;
350 u16 words_need = 0, hdr_num = 0, totalbytes, efuse_used;
351 bool wordchanged, result = true;
352
353 for (section_idx = 0; section_idx < 16; section_idx++) {
354 base = section_idx * 8;
355 wordchanged = false;
356
357 for (i = 0; i < 8; i = i + 2) {
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]) {
363 words_need++;
364 wordchanged = true;
365 }
366 }
367
368 if (wordchanged)
369 hdr_num++;
370 }
371
372 totalbytes = hdr_num + words_need * 2;
373 efuse_used = rtlefuse->efuse_usedbytes;
374
375 if ((totalbytes + efuse_used) >=
376 (EFUSE_MAX_SIZE - rtlpriv->cfg->maps[EFUSE_OOB_PROTECT_BYTES_LEN]))
377 result = false;
378
379 RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD,
380 "efuse_shadow_update_chk(): totalbytes(%#x), hdr_num(%#x), words_need(%#x), efuse_used(%d)\n",
381 totalbytes, hdr_num, words_need, efuse_used);
382
383 return result;
384 }
385
386 void efuse_shadow_read(struct ieee80211_hw *hw, u8 type,
387 u16 offset, u32 *value)
388 {
389 if (type == 1)
390 efuse_shadow_read_1byte(hw, offset, (u8 *)value);
391 else if (type == 2)
392 efuse_shadow_read_2byte(hw, offset, (u16 *)value);
393 else if (type == 4)
394 efuse_shadow_read_4byte(hw, offset, value);
395
396 }
397 EXPORT_SYMBOL(efuse_shadow_read);
398
399 void efuse_shadow_write(struct ieee80211_hw *hw, u8 type, u16 offset,
400 u32 value)
401 {
402 if (type == 1)
403 efuse_shadow_write_1byte(hw, offset, (u8) value);
404 else if (type == 2)
405 efuse_shadow_write_2byte(hw, offset, (u16) value);
406 else if (type == 4)
407 efuse_shadow_write_4byte(hw, offset, value);
408
409 }
410
411 bool efuse_shadow_update(struct ieee80211_hw *hw)
412 {
413 struct rtl_priv *rtlpriv = rtl_priv(hw);
414 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
415 u16 i, offset, base;
416 u8 word_en = 0x0F;
417 u8 first_pg = false;
418
419 RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD, "\n");
420
421 if (!efuse_shadow_update_chk(hw)) {
422 efuse_read_all_map(hw, &rtlefuse->efuse_map[EFUSE_INIT_MAP][0]);
423 memcpy(&rtlefuse->efuse_map[EFUSE_MODIFY_MAP][0],
424 &rtlefuse->efuse_map[EFUSE_INIT_MAP][0],
425 rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE]);
426
427 RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD,
428 "efuse out of capacity!!\n");
429 return false;
430 }
431 efuse_power_switch(hw, true, true);
432
433 for (offset = 0; offset < 16; offset++) {
434
435 word_en = 0x0F;
436 base = offset * 8;
437
438 for (i = 0; i < 8; i++) {
439 if (first_pg) {
440 word_en &= ~(BIT(i / 2));
441
442 rtlefuse->efuse_map[EFUSE_INIT_MAP][base + i] =
443 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][base + i];
444 } else {
445
446 if (rtlefuse->efuse_map[EFUSE_INIT_MAP][base + i] !=
447 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][base + i]) {
448 word_en &= ~(BIT(i / 2));
449
450 rtlefuse->efuse_map[EFUSE_INIT_MAP][base + i] =
451 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][base + i];
452 }
453 }
454 }
455
456 if (word_en != 0x0F) {
457 u8 tmpdata[8];
458
459 memcpy(tmpdata,
460 &rtlefuse->efuse_map[EFUSE_MODIFY_MAP][base],
461 8);
462 RT_PRINT_DATA(rtlpriv, COMP_INIT, DBG_LOUD,
463 "U-efuse\n", tmpdata, 8);
464
465 if (!efuse_pg_packet_write(hw, (u8) offset, word_en,
466 tmpdata)) {
467 RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
468 "PG section(%#x) fail!!\n", offset);
469 break;
470 }
471 }
472 }
473
474 efuse_power_switch(hw, true, false);
475 efuse_read_all_map(hw, &rtlefuse->efuse_map[EFUSE_INIT_MAP][0]);
476
477 memcpy(&rtlefuse->efuse_map[EFUSE_MODIFY_MAP][0],
478 &rtlefuse->efuse_map[EFUSE_INIT_MAP][0],
479 rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE]);
480
481 RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD, "\n");
482 return true;
483 }
484
485 void rtl_efuse_shadow_map_update(struct ieee80211_hw *hw)
486 {
487 struct rtl_priv *rtlpriv = rtl_priv(hw);
488 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
489
490 if (rtlefuse->autoload_failflag)
491 memset((&rtlefuse->efuse_map[EFUSE_INIT_MAP][0]),
492 0xFF, rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE]);
493 else
494 efuse_read_all_map(hw, &rtlefuse->efuse_map[EFUSE_INIT_MAP][0]);
495
496 memcpy(&rtlefuse->efuse_map[EFUSE_MODIFY_MAP][0],
497 &rtlefuse->efuse_map[EFUSE_INIT_MAP][0],
498 rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE]);
499
500 }
501 EXPORT_SYMBOL(rtl_efuse_shadow_map_update);
502
503 void efuse_force_write_vendor_id(struct ieee80211_hw *hw)
504 {
505 u8 tmpdata[8] = { 0xFF, 0xFF, 0xEC, 0x10, 0xFF, 0xFF, 0xFF, 0xFF };
506
507 efuse_power_switch(hw, true, true);
508
509 efuse_pg_packet_write(hw, 1, 0xD, tmpdata);
510
511 efuse_power_switch(hw, true, false);
512
513 }
514
515 void efuse_re_pg_section(struct ieee80211_hw *hw, u8 section_idx)
516 {
517 }
518
519 static void efuse_shadow_read_1byte(struct ieee80211_hw *hw,
520 u16 offset, u8 *value)
521 {
522 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
523 *value = rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset];
524 }
525
526 static void efuse_shadow_read_2byte(struct ieee80211_hw *hw,
527 u16 offset, u16 *value)
528 {
529 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
530
531 *value = rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset];
532 *value |= rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 1] << 8;
533
534 }
535
536 static void efuse_shadow_read_4byte(struct ieee80211_hw *hw,
537 u16 offset, u32 *value)
538 {
539 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
540
541 *value = rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset];
542 *value |= rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 1] << 8;
543 *value |= rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 2] << 16;
544 *value |= rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 3] << 24;
545 }
546
547 static void efuse_shadow_write_1byte(struct ieee80211_hw *hw,
548 u16 offset, u8 value)
549 {
550 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
551
552 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset] = value;
553 }
554
555 static void efuse_shadow_write_2byte(struct ieee80211_hw *hw,
556 u16 offset, u16 value)
557 {
558 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
559
560 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset] = value & 0x00FF;
561 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 1] = value >> 8;
562
563 }
564
565 static void efuse_shadow_write_4byte(struct ieee80211_hw *hw,
566 u16 offset, u32 value)
567 {
568 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
569
570 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset] =
571 (u8) (value & 0x000000FF);
572 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 1] =
573 (u8) ((value >> 8) & 0x0000FF);
574 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 2] =
575 (u8) ((value >> 16) & 0x00FF);
576 rtlefuse->efuse_map[EFUSE_MODIFY_MAP][offset + 3] =
577 (u8) ((value >> 24) & 0xFF);
578
579 }
580
581 int efuse_one_byte_read(struct ieee80211_hw *hw, u16 addr, u8 *data)
582 {
583 struct rtl_priv *rtlpriv = rtl_priv(hw);
584 u8 tmpidx = 0;
585 int result;
586
587 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 1,
588 (u8) (addr & 0xff));
589 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 2,
590 ((u8) ((addr >> 8) & 0x03)) |
591 (rtl_read_byte(rtlpriv,
592 rtlpriv->cfg->maps[EFUSE_CTRL] + 2) &
593 0xFC));
594
595 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 3, 0x72);
596
597 while (!(0x80 & rtl_read_byte(rtlpriv,
598 rtlpriv->cfg->maps[EFUSE_CTRL] + 3))
599 && (tmpidx < 100)) {
600 tmpidx++;
601 }
602
603 if (tmpidx < 100) {
604 *data = rtl_read_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL]);
605 result = true;
606 } else {
607 *data = 0xff;
608 result = false;
609 }
610 return result;
611 }
612 EXPORT_SYMBOL(efuse_one_byte_read);
613
614 static int efuse_one_byte_write(struct ieee80211_hw *hw, u16 addr, u8 data)
615 {
616 struct rtl_priv *rtlpriv = rtl_priv(hw);
617 u8 tmpidx = 0;
618
619 RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD,
620 "Addr = %x Data=%x\n", addr, data);
621
622 rtl_write_byte(rtlpriv,
623 rtlpriv->cfg->maps[EFUSE_CTRL] + 1, (u8) (addr & 0xff));
624 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 2,
625 (rtl_read_byte(rtlpriv,
626 rtlpriv->cfg->maps[EFUSE_CTRL] +
627 2) & 0xFC) | (u8) ((addr >> 8) & 0x03));
628
629 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL], data);
630 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CTRL] + 3, 0xF2);
631
632 while ((0x80 & rtl_read_byte(rtlpriv,
633 rtlpriv->cfg->maps[EFUSE_CTRL] + 3))
634 && (tmpidx < 100)) {
635 tmpidx++;
636 }
637
638 if (tmpidx < 100)
639 return true;
640 return false;
641 }
642
643 static void efuse_read_all_map(struct ieee80211_hw *hw, u8 *efuse)
644 {
645 struct rtl_priv *rtlpriv = rtl_priv(hw);
646
647 efuse_power_switch(hw, false, true);
648 read_efuse(hw, 0, rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE], efuse);
649 efuse_power_switch(hw, false, false);
650 }
651
652 static void efuse_read_data_case1(struct ieee80211_hw *hw, u16 *efuse_addr,
653 u8 efuse_data, u8 offset, u8 *tmpdata,
654 u8 *readstate)
655 {
656 bool dataempty = true;
657 u8 hoffset;
658 u8 tmpidx;
659 u8 hworden;
660 u8 word_cnts;
661
662 hoffset = (efuse_data >> 4) & 0x0F;
663 hworden = efuse_data & 0x0F;
664 word_cnts = efuse_calculate_word_cnts(hworden);
665
666 if (hoffset == offset) {
667 for (tmpidx = 0; tmpidx < word_cnts * 2; tmpidx++) {
668 if (efuse_one_byte_read(hw, *efuse_addr + 1 + tmpidx,
669 &efuse_data)) {
670 tmpdata[tmpidx] = efuse_data;
671 if (efuse_data != 0xff)
672 dataempty = false;
673 }
674 }
675
676 if (!dataempty) {
677 *readstate = PG_STATE_DATA;
678 } else {
679 *efuse_addr = *efuse_addr + (word_cnts * 2) + 1;
680 *readstate = PG_STATE_HEADER;
681 }
682
683 } else {
684 *efuse_addr = *efuse_addr + (word_cnts * 2) + 1;
685 *readstate = PG_STATE_HEADER;
686 }
687 }
688
689 static int efuse_pg_packet_read(struct ieee80211_hw *hw, u8 offset, u8 *data)
690 {
691 u8 readstate = PG_STATE_HEADER;
692
693 bool continual = true;
694
695 u8 efuse_data, word_cnts = 0;
696 u16 efuse_addr = 0;
697 u8 tmpdata[8];
698
699 if (data == NULL)
700 return false;
701 if (offset > 15)
702 return false;
703
704 memset(data, 0xff, PGPKT_DATA_SIZE * sizeof(u8));
705 memset(tmpdata, 0xff, PGPKT_DATA_SIZE * sizeof(u8));
706
707 while (continual && (efuse_addr < EFUSE_MAX_SIZE)) {
708 if (readstate & PG_STATE_HEADER) {
709 if (efuse_one_byte_read(hw, efuse_addr, &efuse_data)
710 && (efuse_data != 0xFF))
711 efuse_read_data_case1(hw, &efuse_addr,
712 efuse_data, offset,
713 tmpdata, &readstate);
714 else
715 continual = false;
716 } else if (readstate & PG_STATE_DATA) {
717 efuse_word_enable_data_read(0, tmpdata, data);
718 efuse_addr = efuse_addr + (word_cnts * 2) + 1;
719 readstate = PG_STATE_HEADER;
720 }
721
722 }
723
724 if ((data[0] == 0xff) && (data[1] == 0xff) &&
725 (data[2] == 0xff) && (data[3] == 0xff) &&
726 (data[4] == 0xff) && (data[5] == 0xff) &&
727 (data[6] == 0xff) && (data[7] == 0xff))
728 return false;
729 else
730 return true;
731
732 }
733
734 static void efuse_write_data_case1(struct ieee80211_hw *hw, u16 *efuse_addr,
735 u8 efuse_data, u8 offset,
736 int *continual, u8 *write_state,
737 struct pgpkt_struct *target_pkt,
738 int *repeat_times, int *result, u8 word_en)
739 {
740 struct rtl_priv *rtlpriv = rtl_priv(hw);
741 struct pgpkt_struct tmp_pkt;
742 int dataempty = true;
743 u8 originaldata[8 * sizeof(u8)];
744 u8 badworden = 0x0F;
745 u8 match_word_en, tmp_word_en;
746 u8 tmpindex;
747 u8 tmp_header = efuse_data;
748 u8 tmp_word_cnts;
749
750 tmp_pkt.offset = (tmp_header >> 4) & 0x0F;
751 tmp_pkt.word_en = tmp_header & 0x0F;
752 tmp_word_cnts = efuse_calculate_word_cnts(tmp_pkt.word_en);
753
754 if (tmp_pkt.offset != target_pkt->offset) {
755 *efuse_addr = *efuse_addr + (tmp_word_cnts * 2) + 1;
756 *write_state = PG_STATE_HEADER;
757 } else {
758 for (tmpindex = 0; tmpindex < (tmp_word_cnts * 2); tmpindex++) {
759 if (efuse_one_byte_read(hw,
760 (*efuse_addr + 1 + tmpindex),
761 &efuse_data) &&
762 (efuse_data != 0xFF))
763 dataempty = false;
764 }
765
766 if (!dataempty) {
767 *efuse_addr = *efuse_addr + (tmp_word_cnts * 2) + 1;
768 *write_state = PG_STATE_HEADER;
769 } else {
770 match_word_en = 0x0F;
771 if (!((target_pkt->word_en & BIT(0)) |
772 (tmp_pkt.word_en & BIT(0))))
773 match_word_en &= (~BIT(0));
774
775 if (!((target_pkt->word_en & BIT(1)) |
776 (tmp_pkt.word_en & BIT(1))))
777 match_word_en &= (~BIT(1));
778
779 if (!((target_pkt->word_en & BIT(2)) |
780 (tmp_pkt.word_en & BIT(2))))
781 match_word_en &= (~BIT(2));
782
783 if (!((target_pkt->word_en & BIT(3)) |
784 (tmp_pkt.word_en & BIT(3))))
785 match_word_en &= (~BIT(3));
786
787 if ((match_word_en & 0x0F) != 0x0F) {
788 badworden =
789 enable_efuse_data_write(hw,
790 *efuse_addr + 1,
791 tmp_pkt.word_en,
792 target_pkt->data);
793
794 if (0x0F != (badworden & 0x0F)) {
795 u8 reorg_offset = offset;
796 u8 reorg_worden = badworden;
797
798 efuse_pg_packet_write(hw, reorg_offset,
799 reorg_worden,
800 originaldata);
801 }
802
803 tmp_word_en = 0x0F;
804 if ((target_pkt->word_en & BIT(0)) ^
805 (match_word_en & BIT(0)))
806 tmp_word_en &= (~BIT(0));
807
808 if ((target_pkt->word_en & BIT(1)) ^
809 (match_word_en & BIT(1)))
810 tmp_word_en &= (~BIT(1));
811
812 if ((target_pkt->word_en & BIT(2)) ^
813 (match_word_en & BIT(2)))
814 tmp_word_en &= (~BIT(2));
815
816 if ((target_pkt->word_en & BIT(3)) ^
817 (match_word_en & BIT(3)))
818 tmp_word_en &= (~BIT(3));
819
820 if ((tmp_word_en & 0x0F) != 0x0F) {
821 *efuse_addr = efuse_get_current_size(hw);
822 target_pkt->offset = offset;
823 target_pkt->word_en = tmp_word_en;
824 } else {
825 *continual = false;
826 }
827 *write_state = PG_STATE_HEADER;
828 *repeat_times += 1;
829 if (*repeat_times > EFUSE_REPEAT_THRESHOLD_) {
830 *continual = false;
831 *result = false;
832 }
833 } else {
834 *efuse_addr += (2 * tmp_word_cnts) + 1;
835 target_pkt->offset = offset;
836 target_pkt->word_en = word_en;
837 *write_state = PG_STATE_HEADER;
838 }
839 }
840 }
841 RTPRINT(rtlpriv, FEEPROM, EFUSE_PG, "efuse PG_STATE_HEADER-1\n");
842 }
843
844 static void efuse_write_data_case2(struct ieee80211_hw *hw, u16 *efuse_addr,
845 int *continual, u8 *write_state,
846 struct pgpkt_struct target_pkt,
847 int *repeat_times, int *result)
848 {
849 struct rtl_priv *rtlpriv = rtl_priv(hw);
850 struct pgpkt_struct tmp_pkt;
851 u8 pg_header;
852 u8 tmp_header;
853 u8 originaldata[8 * sizeof(u8)];
854 u8 tmp_word_cnts;
855 u8 badworden = 0x0F;
856
857 pg_header = ((target_pkt.offset << 4) & 0xf0) | target_pkt.word_en;
858 efuse_one_byte_write(hw, *efuse_addr, pg_header);
859 efuse_one_byte_read(hw, *efuse_addr, &tmp_header);
860
861 if (tmp_header == pg_header) {
862 *write_state = PG_STATE_DATA;
863 } else if (tmp_header == 0xFF) {
864 *write_state = PG_STATE_HEADER;
865 *repeat_times += 1;
866 if (*repeat_times > EFUSE_REPEAT_THRESHOLD_) {
867 *continual = false;
868 *result = false;
869 }
870 } else {
871 tmp_pkt.offset = (tmp_header >> 4) & 0x0F;
872 tmp_pkt.word_en = tmp_header & 0x0F;
873
874 tmp_word_cnts = efuse_calculate_word_cnts(tmp_pkt.word_en);
875
876 memset(originaldata, 0xff, 8 * sizeof(u8));
877
878 if (efuse_pg_packet_read(hw, tmp_pkt.offset, originaldata)) {
879 badworden = enable_efuse_data_write(hw,
880 *efuse_addr + 1,
881 tmp_pkt.word_en,
882 originaldata);
883
884 if (0x0F != (badworden & 0x0F)) {
885 u8 reorg_offset = tmp_pkt.offset;
886 u8 reorg_worden = badworden;
887
888 efuse_pg_packet_write(hw, reorg_offset,
889 reorg_worden,
890 originaldata);
891 *efuse_addr = efuse_get_current_size(hw);
892 } else {
893 *efuse_addr = *efuse_addr +
894 (tmp_word_cnts * 2) + 1;
895 }
896 } else {
897 *efuse_addr = *efuse_addr + (tmp_word_cnts * 2) + 1;
898 }
899
900 *write_state = PG_STATE_HEADER;
901 *repeat_times += 1;
902 if (*repeat_times > EFUSE_REPEAT_THRESHOLD_) {
903 *continual = false;
904 *result = false;
905 }
906
907 RTPRINT(rtlpriv, FEEPROM, EFUSE_PG,
908 "efuse PG_STATE_HEADER-2\n");
909 }
910 }
911
912 static int efuse_pg_packet_write(struct ieee80211_hw *hw,
913 u8 offset, u8 word_en, u8 *data)
914 {
915 struct rtl_priv *rtlpriv = rtl_priv(hw);
916 struct pgpkt_struct target_pkt;
917 u8 write_state = PG_STATE_HEADER;
918 int continual = true, dataempty = true, result = true;
919 u16 efuse_addr = 0;
920 u8 efuse_data;
921 u8 target_word_cnts = 0;
922 u8 badworden = 0x0F;
923 static int repeat_times;
924
925 if (efuse_get_current_size(hw) >= (EFUSE_MAX_SIZE -
926 rtlpriv->cfg->maps[EFUSE_OOB_PROTECT_BYTES_LEN])) {
927 RTPRINT(rtlpriv, FEEPROM, EFUSE_PG,
928 "efuse_pg_packet_write error\n");
929 return false;
930 }
931
932 target_pkt.offset = offset;
933 target_pkt.word_en = word_en;
934
935 memset(target_pkt.data, 0xFF, 8 * sizeof(u8));
936
937 efuse_word_enable_data_read(word_en, data, target_pkt.data);
938 target_word_cnts = efuse_calculate_word_cnts(target_pkt.word_en);
939
940 RTPRINT(rtlpriv, FEEPROM, EFUSE_PG, "efuse Power ON\n");
941
942 while (continual && (efuse_addr < (EFUSE_MAX_SIZE -
943 rtlpriv->cfg->maps[EFUSE_OOB_PROTECT_BYTES_LEN]))) {
944 if (write_state == PG_STATE_HEADER) {
945 dataempty = true;
946 badworden = 0x0F;
947 RTPRINT(rtlpriv, FEEPROM, EFUSE_PG,
948 "efuse PG_STATE_HEADER\n");
949
950 if (efuse_one_byte_read(hw, efuse_addr, &efuse_data) &&
951 (efuse_data != 0xFF))
952 efuse_write_data_case1(hw, &efuse_addr,
953 efuse_data, offset,
954 &continual,
955 &write_state,
956 &target_pkt,
957 &repeat_times, &result,
958 word_en);
959 else
960 efuse_write_data_case2(hw, &efuse_addr,
961 &continual,
962 &write_state,
963 target_pkt,
964 &repeat_times,
965 &result);
966
967 } else if (write_state == PG_STATE_DATA) {
968 RTPRINT(rtlpriv, FEEPROM, EFUSE_PG,
969 "efuse PG_STATE_DATA\n");
970 badworden =
971 enable_efuse_data_write(hw, efuse_addr + 1,
972 target_pkt.word_en,
973 target_pkt.data);
974
975 if ((badworden & 0x0F) == 0x0F) {
976 continual = false;
977 } else {
978 efuse_addr =
979 efuse_addr + (2 * target_word_cnts) + 1;
980
981 target_pkt.offset = offset;
982 target_pkt.word_en = badworden;
983 target_word_cnts =
984 efuse_calculate_word_cnts(target_pkt.
985 word_en);
986 write_state = PG_STATE_HEADER;
987 repeat_times++;
988 if (repeat_times > EFUSE_REPEAT_THRESHOLD_) {
989 continual = false;
990 result = false;
991 }
992 RTPRINT(rtlpriv, FEEPROM, EFUSE_PG,
993 "efuse PG_STATE_HEADER-3\n");
994 }
995 }
996 }
997
998 if (efuse_addr >= (EFUSE_MAX_SIZE -
999 rtlpriv->cfg->maps[EFUSE_OOB_PROTECT_BYTES_LEN])) {
1000 RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD,
1001 "efuse_addr(%#x) Out of size!!\n", efuse_addr);
1002 }
1003
1004 return true;
1005 }
1006
1007 static void efuse_word_enable_data_read(u8 word_en, u8 *sourdata,
1008 u8 *targetdata)
1009 {
1010 if (!(word_en & BIT(0))) {
1011 targetdata[0] = sourdata[0];
1012 targetdata[1] = sourdata[1];
1013 }
1014
1015 if (!(word_en & BIT(1))) {
1016 targetdata[2] = sourdata[2];
1017 targetdata[3] = sourdata[3];
1018 }
1019
1020 if (!(word_en & BIT(2))) {
1021 targetdata[4] = sourdata[4];
1022 targetdata[5] = sourdata[5];
1023 }
1024
1025 if (!(word_en & BIT(3))) {
1026 targetdata[6] = sourdata[6];
1027 targetdata[7] = sourdata[7];
1028 }
1029 }
1030
1031 static u8 enable_efuse_data_write(struct ieee80211_hw *hw,
1032 u16 efuse_addr, u8 word_en, u8 *data)
1033 {
1034 struct rtl_priv *rtlpriv = rtl_priv(hw);
1035 u16 tmpaddr;
1036 u16 start_addr = efuse_addr;
1037 u8 badworden = 0x0F;
1038 u8 tmpdata[8];
1039
1040 memset(tmpdata, 0xff, PGPKT_DATA_SIZE);
1041 RT_TRACE(rtlpriv, COMP_EFUSE, DBG_LOUD,
1042 "word_en = %x efuse_addr=%x\n", word_en, efuse_addr);
1043
1044 if (!(word_en & BIT(0))) {
1045 tmpaddr = start_addr;
1046 efuse_one_byte_write(hw, start_addr++, data[0]);
1047 efuse_one_byte_write(hw, start_addr++, data[1]);
1048
1049 efuse_one_byte_read(hw, tmpaddr, &tmpdata[0]);
1050 efuse_one_byte_read(hw, tmpaddr + 1, &tmpdata[1]);
1051 if ((data[0] != tmpdata[0]) || (data[1] != tmpdata[1]))
1052 badworden &= (~BIT(0));
1053 }
1054
1055 if (!(word_en & BIT(1))) {
1056 tmpaddr = start_addr;
1057 efuse_one_byte_write(hw, start_addr++, data[2]);
1058 efuse_one_byte_write(hw, start_addr++, data[3]);
1059
1060 efuse_one_byte_read(hw, tmpaddr, &tmpdata[2]);
1061 efuse_one_byte_read(hw, tmpaddr + 1, &tmpdata[3]);
1062 if ((data[2] != tmpdata[2]) || (data[3] != tmpdata[3]))
1063 badworden &= (~BIT(1));
1064 }
1065
1066 if (!(word_en & BIT(2))) {
1067 tmpaddr = start_addr;
1068 efuse_one_byte_write(hw, start_addr++, data[4]);
1069 efuse_one_byte_write(hw, start_addr++, data[5]);
1070
1071 efuse_one_byte_read(hw, tmpaddr, &tmpdata[4]);
1072 efuse_one_byte_read(hw, tmpaddr + 1, &tmpdata[5]);
1073 if ((data[4] != tmpdata[4]) || (data[5] != tmpdata[5]))
1074 badworden &= (~BIT(2));
1075 }
1076
1077 if (!(word_en & BIT(3))) {
1078 tmpaddr = start_addr;
1079 efuse_one_byte_write(hw, start_addr++, data[6]);
1080 efuse_one_byte_write(hw, start_addr++, data[7]);
1081
1082 efuse_one_byte_read(hw, tmpaddr, &tmpdata[6]);
1083 efuse_one_byte_read(hw, tmpaddr + 1, &tmpdata[7]);
1084 if ((data[6] != tmpdata[6]) || (data[7] != tmpdata[7]))
1085 badworden &= (~BIT(3));
1086 }
1087
1088 return badworden;
1089 }
1090
1091 void efuse_power_switch(struct ieee80211_hw *hw, u8 write, u8 pwrstate)
1092 {
1093 struct rtl_priv *rtlpriv = rtl_priv(hw);
1094 struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
1095 u8 tempval;
1096 u16 tmpv16;
1097
1098 if (pwrstate && (rtlhal->hw_type != HARDWARE_TYPE_RTL8192SE)) {
1099 if (rtlhal->hw_type != HARDWARE_TYPE_RTL8192CE &&
1100 rtlhal->hw_type != HARDWARE_TYPE_RTL8192DE) {
1101 rtl_write_byte(rtlpriv,
1102 rtlpriv->cfg->maps[EFUSE_ACCESS], 0x69);
1103 } else {
1104 tmpv16 =
1105 rtl_read_word(rtlpriv,
1106 rtlpriv->cfg->maps[SYS_ISO_CTRL]);
1107 if (!(tmpv16 & rtlpriv->cfg->maps[EFUSE_PWC_EV12V])) {
1108 tmpv16 |= rtlpriv->cfg->maps[EFUSE_PWC_EV12V];
1109 rtl_write_word(rtlpriv,
1110 rtlpriv->cfg->maps[SYS_ISO_CTRL],
1111 tmpv16);
1112 }
1113 }
1114 tmpv16 = rtl_read_word(rtlpriv,
1115 rtlpriv->cfg->maps[SYS_FUNC_EN]);
1116 if (!(tmpv16 & rtlpriv->cfg->maps[EFUSE_FEN_ELDR])) {
1117 tmpv16 |= rtlpriv->cfg->maps[EFUSE_FEN_ELDR];
1118 rtl_write_word(rtlpriv,
1119 rtlpriv->cfg->maps[SYS_FUNC_EN], tmpv16);
1120 }
1121
1122 tmpv16 = rtl_read_word(rtlpriv, rtlpriv->cfg->maps[SYS_CLK]);
1123 if ((!(tmpv16 & rtlpriv->cfg->maps[EFUSE_LOADER_CLK_EN])) ||
1124 (!(tmpv16 & rtlpriv->cfg->maps[EFUSE_ANA8M]))) {
1125 tmpv16 |= (rtlpriv->cfg->maps[EFUSE_LOADER_CLK_EN] |
1126 rtlpriv->cfg->maps[EFUSE_ANA8M]);
1127 rtl_write_word(rtlpriv,
1128 rtlpriv->cfg->maps[SYS_CLK], tmpv16);
1129 }
1130 }
1131
1132 if (pwrstate) {
1133 if (write) {
1134 tempval = rtl_read_byte(rtlpriv,
1135 rtlpriv->cfg->maps[EFUSE_TEST] +
1136 3);
1137
1138 if (rtlhal->hw_type == HARDWARE_TYPE_RTL8812AE) {
1139 tempval &= ~(BIT(3) | BIT(4) | BIT(5) | BIT(6));
1140 tempval |= (VOLTAGE_V25 << 3);
1141 } else if (rtlhal->hw_type != HARDWARE_TYPE_RTL8192SE) {
1142 tempval &= 0x0F;
1143 tempval |= (VOLTAGE_V25 << 4);
1144 }
1145
1146 rtl_write_byte(rtlpriv,
1147 rtlpriv->cfg->maps[EFUSE_TEST] + 3,
1148 (tempval | 0x80));
1149 }
1150
1151 if (rtlhal->hw_type == HARDWARE_TYPE_RTL8192SE) {
1152 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CLK],
1153 0x03);
1154 }
1155 } else {
1156 if (rtlhal->hw_type != HARDWARE_TYPE_RTL8192CE &&
1157 rtlhal->hw_type != HARDWARE_TYPE_RTL8192DE)
1158 rtl_write_byte(rtlpriv,
1159 rtlpriv->cfg->maps[EFUSE_ACCESS], 0);
1160
1161 if (write) {
1162 tempval = rtl_read_byte(rtlpriv,
1163 rtlpriv->cfg->maps[EFUSE_TEST] +
1164 3);
1165 rtl_write_byte(rtlpriv,
1166 rtlpriv->cfg->maps[EFUSE_TEST] + 3,
1167 (tempval & 0x7F));
1168 }
1169
1170 if (rtlhal->hw_type == HARDWARE_TYPE_RTL8192SE) {
1171 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[EFUSE_CLK],
1172 0x02);
1173 }
1174 }
1175 }
1176 EXPORT_SYMBOL(efuse_power_switch);
1177
1178 static u16 efuse_get_current_size(struct ieee80211_hw *hw)
1179 {
1180 int continual = true;
1181 u16 efuse_addr = 0;
1182 u8 hoffset, hworden;
1183 u8 efuse_data, word_cnts;
1184
1185 while (continual && efuse_one_byte_read(hw, efuse_addr, &efuse_data) &&
1186 (efuse_addr < EFUSE_MAX_SIZE)) {
1187 if (efuse_data != 0xFF) {
1188 hoffset = (efuse_data >> 4) & 0x0F;
1189 hworden = efuse_data & 0x0F;
1190 word_cnts = efuse_calculate_word_cnts(hworden);
1191 efuse_addr = efuse_addr + (word_cnts * 2) + 1;
1192 } else {
1193 continual = false;
1194 }
1195 }
1196
1197 return efuse_addr;
1198 }
1199
1200 static u8 efuse_calculate_word_cnts(u8 word_en)
1201 {
1202 u8 word_cnts = 0;
1203
1204 if (!(word_en & BIT(0)))
1205 word_cnts++;
1206 if (!(word_en & BIT(1)))
1207 word_cnts++;
1208 if (!(word_en & BIT(2)))
1209 word_cnts++;
1210 if (!(word_en & BIT(3)))
1211 word_cnts++;
1212 return word_cnts;
1213 }
1214
1215 int rtl_get_hwinfo(struct ieee80211_hw *hw, struct rtl_priv *rtlpriv,
1216 int max_size, u8 *hwinfo, int *params)
1217 {
1218 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
1219 struct rtl_pci_priv *rtlpcipriv = rtl_pcipriv(hw);
1220 struct device *dev = &rtlpcipriv->dev.pdev->dev;
1221 u16 eeprom_id;
1222 u16 i, usvalue;
1223
1224 switch (rtlefuse->epromtype) {
1225 case EEPROM_BOOT_EFUSE:
1226 rtl_efuse_shadow_map_update(hw);
1227 break;
1228
1229 case EEPROM_93C46:
1230 pr_err("RTL8XXX did not boot from eeprom, check it !!\n");
1231 return 1;
1232
1233 default:
1234 dev_warn(dev, "no efuse data\n");
1235 return 1;
1236 }
1237
1238 memcpy(hwinfo, &rtlefuse->efuse_map[EFUSE_INIT_MAP][0], max_size);
1239
1240 RT_PRINT_DATA(rtlpriv, COMP_INIT, DBG_DMESG, "MAP",
1241 hwinfo, max_size);
1242
1243 eeprom_id = *((u16 *)&hwinfo[0]);
1244 if (eeprom_id != params[0]) {
1245 RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
1246 "EEPROM ID(%#x) is invalid!!\n", eeprom_id);
1247 rtlefuse->autoload_failflag = true;
1248 } else {
1249 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "Autoload OK\n");
1250 rtlefuse->autoload_failflag = false;
1251 }
1252
1253 if (rtlefuse->autoload_failflag)
1254 return 1;
1255
1256 rtlefuse->eeprom_vid = *(u16 *)&hwinfo[params[1]];
1257 rtlefuse->eeprom_did = *(u16 *)&hwinfo[params[2]];
1258 rtlefuse->eeprom_svid = *(u16 *)&hwinfo[params[3]];
1259 rtlefuse->eeprom_smid = *(u16 *)&hwinfo[params[4]];
1260 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
1261 "EEPROMId = 0x%4x\n", eeprom_id);
1262 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
1263 "EEPROM VID = 0x%4x\n", rtlefuse->eeprom_vid);
1264 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
1265 "EEPROM DID = 0x%4x\n", rtlefuse->eeprom_did);
1266 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
1267 "EEPROM SVID = 0x%4x\n", rtlefuse->eeprom_svid);
1268 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
1269 "EEPROM SMID = 0x%4x\n", rtlefuse->eeprom_smid);
1270
1271 for (i = 0; i < 6; i += 2) {
1272 usvalue = *(u16 *)&hwinfo[params[5] + i];
1273 *((u16 *)(&rtlefuse->dev_addr[i])) = usvalue;
1274 }
1275 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "%pM\n", rtlefuse->dev_addr);
1276
1277 rtlefuse->eeprom_channelplan = *&hwinfo[params[6]];
1278 rtlefuse->eeprom_version = *(u16 *)&hwinfo[params[7]];
1279 rtlefuse->txpwr_fromeprom = true;
1280 rtlefuse->eeprom_oemid = *&hwinfo[params[8]];
1281
1282 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
1283 "EEPROM Customer ID: 0x%2x\n", rtlefuse->eeprom_oemid);
1284
1285
1286 rtlefuse->channel_plan = params[9];
1287
1288 return 0;
1289 }
1290 EXPORT_SYMBOL_GPL(rtl_get_hwinfo);
1291
1292 void rtl_fw_block_write(struct ieee80211_hw *hw, const u8 *buffer, u32 size)
1293 {
1294 struct rtl_priv *rtlpriv = rtl_priv(hw);
1295 u8 *pu4byteptr = (u8 *)buffer;
1296 u32 i;
1297
1298 for (i = 0; i < size; i++)
1299 rtl_write_byte(rtlpriv, (START_ADDRESS + i), *(pu4byteptr + i));
1300 }
1301 EXPORT_SYMBOL_GPL(rtl_fw_block_write);
1302
1303 void rtl_fw_page_write(struct ieee80211_hw *hw, u32 page, const u8 *buffer,
1304 u32 size)
1305 {
1306 struct rtl_priv *rtlpriv = rtl_priv(hw);
1307 u8 value8;
1308 u8 u8page = (u8)(page & 0x07);
1309
1310 value8 = (rtl_read_byte(rtlpriv, REG_MCUFWDL + 2) & 0xF8) | u8page;
1311
1312 rtl_write_byte(rtlpriv, (REG_MCUFWDL + 2), value8);
1313 rtl_fw_block_write(hw, buffer, size);
1314 }
1315 EXPORT_SYMBOL_GPL(rtl_fw_page_write);
1316
1317 void rtl_fill_dummy(u8 *pfwbuf, u32 *pfwlen)
1318 {
1319 u32 fwlen = *pfwlen;
1320 u8 remain = (u8)(fwlen % 4);
1321
1322 remain = (remain == 0) ? 0 : (4 - remain);
1323
1324 while (remain > 0) {
1325 pfwbuf[fwlen] = 0;
1326 fwlen++;
1327 remain--;
1328 }
1329
1330 *pfwlen = fwlen;
1331 }
1332 EXPORT_SYMBOL_GPL(rtl_fill_dummy);
1333
1334 void rtl_efuse_ops_init(struct ieee80211_hw *hw)
1335 {
1336 struct rtl_priv *rtlpriv = rtl_priv(hw);
1337
1338 rtlpriv->efuse.efuse_ops = &efuse_ops;
1339 }
1340 EXPORT_SYMBOL_GPL(rtl_efuse_ops_init);