?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / drivers / net / wireless / realtek / rtlwifi / efuse.c
blobcef9f2a9303b6aa064b482199672c6028635e075
1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright(c) 2009-2012 Realtek Corporation.*/
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 /* allocate memory for efuse_tbl and efuse_word */
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 /* Check PG header for section num. */
249 if ((*rtemp8 & 0x1F) == 0x0F) {/* extended header */
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, 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 badworden = 0x0F;
946 RTPRINT(rtlpriv, FEEPROM, EFUSE_PG,
947 "efuse PG_STATE_HEADER\n");
948
949 if (efuse_one_byte_read(hw, efuse_addr, &efuse_data) &&
950 (efuse_data != 0xFF))
951 efuse_write_data_case1(hw, &efuse_addr,
952 efuse_data, offset,
953 &continual,
954 &write_state,
955 &target_pkt,
956 &repeat_times, &result,
957 word_en);
958 else
959 efuse_write_data_case2(hw, &efuse_addr,
960 &continual,
961 &write_state,
962 target_pkt,
963 &repeat_times,
964 &result);
965
966 } else if (write_state == PG_STATE_DATA) {
967 RTPRINT(rtlpriv, FEEPROM, EFUSE_PG,
968 "efuse PG_STATE_DATA\n");
969 badworden =
970 enable_efuse_data_write(hw, efuse_addr + 1,
971 target_pkt.word_en,
972 target_pkt.data);
973
974 if ((badworden & 0x0F) == 0x0F) {
975 continual = false;
976 } else {
977 efuse_addr =
978 efuse_addr + (2 * target_word_cnts) + 1;
979
980 target_pkt.offset = offset;
981 target_pkt.word_en = badworden;
982 target_word_cnts =
983 efuse_calculate_word_cnts(target_pkt.
984 word_en);
985 write_state = PG_STATE_HEADER;
986 repeat_times++;
987 if (repeat_times > EFUSE_REPEAT_THRESHOLD_) {
988 continual = false;
989 result = false;
990 }
991 RTPRINT(rtlpriv, FEEPROM, EFUSE_PG,
992 "efuse PG_STATE_HEADER-3\n");
993 }
994 }
995 }
996
997 if (efuse_addr >= (EFUSE_MAX_SIZE -
998 rtlpriv->cfg->maps[EFUSE_OOB_PROTECT_BYTES_LEN])) {
999 RT_TRACE(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 RT_TRACE(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 RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
1244 "EEPROM ID(%#x) is invalid!!\n", eeprom_id);
1245 rtlefuse->autoload_failflag = true;
1246 } else {
1247 RT_TRACE(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 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
1259 "EEPROMId = 0x%4x\n", eeprom_id);
1260 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
1261 "EEPROM VID = 0x%4x\n", rtlefuse->eeprom_vid);
1262 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
1263 "EEPROM DID = 0x%4x\n", rtlefuse->eeprom_did);
1264 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
1265 "EEPROM SVID = 0x%4x\n", rtlefuse->eeprom_svid);
1266 RT_TRACE(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 RT_TRACE(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 RT_TRACE(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);
Linux with added FPC-III support