This source file includes following definitions.
- efuse_reg_ctrl
- r8712_efuse_reg_init
- r8712_efuse_reg_uninit
- efuse_one_byte_read
- efuse_one_byte_write
- efuse_one_byte_rw
- efuse_is_empty
- r8712_efuse_change_max_size
- r8712_efuse_get_max_size
- calculate_word_cnts
- pgpacket_copy_data
- r8712_efuse_get_current_size
- r8712_efuse_pg_packet_read
- fix_header
- r8712_efuse_pg_packet_write
- r8712_efuse_access
- r8712_efuse_map_read
- r8712_efuse_map_write
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 #define _RTL8712_EFUSE_C_
18
19 #include "osdep_service.h"
20 #include "drv_types.h"
21 #include "rtl8712_efuse.h"
22
23
24 static int efuse_available_max_size = EFUSE_MAX_SIZE - 3 ;
25
26 static void efuse_reg_ctrl(struct _adapter *adapter, u8 bPowerOn)
27 {
28 u8 tmpu8 = 0;
29
30 if (bPowerOn) {
31
32
33
34 tmpu8 = r8712_read8(adapter, EFUSE_TEST + 3);
35 tmpu8 |= 0x80;
36 r8712_write8(adapter, EFUSE_TEST + 3, tmpu8);
37 msleep(20);
38
39 r8712_write8(adapter, EFUSE_CLK_CTRL, 0x03);
40 msleep(20);
41 } else {
42
43
44
45 tmpu8 = r8712_read8(adapter, EFUSE_TEST + 3);
46 tmpu8 &= 0x7F;
47 r8712_write8(adapter, EFUSE_TEST + 3, tmpu8);
48
49 r8712_write8(adapter, EFUSE_CLK_CTRL, 0x02);
50 }
51 }
52
53
54
55
56 u8 r8712_efuse_reg_init(struct _adapter *adapter)
57 {
58 return true;
59 }
60
61 void r8712_efuse_reg_uninit(struct _adapter *adapter)
62 {
63 efuse_reg_ctrl(adapter, false);
64 }
65
66 static u8 efuse_one_byte_read(struct _adapter *adapter, u16 addr, u8 *data)
67 {
68 u8 tmpidx = 0, bResult;
69
70
71 r8712_write8(adapter, EFUSE_CTRL + 1, (u8)(addr & 0xFF));
72 r8712_write8(adapter, EFUSE_CTRL + 2, ((u8)((addr >> 8) & 0x03)) |
73 (r8712_read8(adapter, EFUSE_CTRL + 2) & 0xFC));
74 r8712_write8(adapter, EFUSE_CTRL + 3, 0x72);
75
76 while (!(0x80 & r8712_read8(adapter, EFUSE_CTRL + 3)) &&
77 (tmpidx < 100))
78 tmpidx++;
79 if (tmpidx < 100) {
80 *data = r8712_read8(adapter, EFUSE_CTRL);
81 bResult = true;
82 } else {
83 *data = 0xff;
84 bResult = false;
85 }
86 return bResult;
87 }
88
89 static u8 efuse_one_byte_write(struct _adapter *adapter, u16 addr, u8 data)
90 {
91 u8 tmpidx = 0, bResult;
92
93
94 r8712_write8(adapter, EFUSE_CTRL + 1, (u8)(addr & 0xFF));
95 r8712_write8(adapter, EFUSE_CTRL + 2, ((u8)((addr >> 8) & 0x03)) |
96 (r8712_read8(adapter, EFUSE_CTRL + 2) & 0xFC));
97 r8712_write8(adapter, EFUSE_CTRL, data);
98 r8712_write8(adapter, EFUSE_CTRL + 3, 0xF2);
99
100 while ((0x80 & r8712_read8(adapter, EFUSE_CTRL + 3)) &&
101 (tmpidx < 100))
102 tmpidx++;
103 if (tmpidx < 100)
104 bResult = true;
105 else
106 bResult = false;
107 return bResult;
108 }
109
110 static u8 efuse_one_byte_rw(struct _adapter *adapter, u8 bRead, u16 addr,
111 u8 *data)
112 {
113 u8 tmpidx = 0, tmpv8 = 0, bResult;
114
115
116 r8712_write8(adapter, EFUSE_CTRL + 1, (u8)(addr & 0xFF));
117 tmpv8 = ((u8)((addr >> 8) & 0x03)) |
118 (r8712_read8(adapter, EFUSE_CTRL + 2) & 0xFC);
119 r8712_write8(adapter, EFUSE_CTRL + 2, tmpv8);
120 if (bRead) {
121 r8712_write8(adapter, EFUSE_CTRL + 3, 0x72);
122 while (!(0x80 & r8712_read8(adapter, EFUSE_CTRL + 3)) &&
123 (tmpidx < 100))
124 tmpidx++;
125 if (tmpidx < 100) {
126 *data = r8712_read8(adapter, EFUSE_CTRL);
127 bResult = true;
128 } else {
129 *data = 0;
130 bResult = false;
131 }
132 } else {
133 r8712_write8(adapter, EFUSE_CTRL, *data);
134 r8712_write8(adapter, EFUSE_CTRL + 3, 0xF2);
135 while ((0x80 & r8712_read8(adapter, EFUSE_CTRL + 3)) &&
136 (tmpidx < 100))
137 tmpidx++;
138 if (tmpidx < 100)
139 bResult = true;
140 else
141 bResult = false;
142 }
143 return bResult;
144 }
145
146 static u8 efuse_is_empty(struct _adapter *adapter, u8 *empty)
147 {
148 u8 value, ret = true;
149
150
151 if (efuse_one_byte_rw(adapter, true, 0, &value)) {
152 if (value == 0xFF)
153 *empty = true;
154 else
155 *empty = false;
156 } else {
157 ret = false;
158 }
159 return ret;
160 }
161
162 void r8712_efuse_change_max_size(struct _adapter *adapter)
163 {
164 u16 pre_pg_data_saddr = 0x1FB;
165 u16 i;
166 u16 pre_pg_data_size = 5;
167 u8 pre_pg_data[5];
168
169 for (i = 0; i < pre_pg_data_size; i++)
170 efuse_one_byte_read(adapter, pre_pg_data_saddr + i,
171 &pre_pg_data[i]);
172 if ((pre_pg_data[0] == 0x03) && (pre_pg_data[1] == 0x00) &&
173 (pre_pg_data[2] == 0x00) && (pre_pg_data[3] == 0x00) &&
174 (pre_pg_data[4] == 0x0C))
175 efuse_available_max_size -= pre_pg_data_size;
176 }
177
178 int r8712_efuse_get_max_size(struct _adapter *adapter)
179 {
180 return efuse_available_max_size;
181 }
182
183 static u8 calculate_word_cnts(const u8 word_en)
184 {
185 u8 word_cnts = 0;
186 u8 word_idx;
187
188 for (word_idx = 0; word_idx < PGPKG_MAX_WORDS; word_idx++)
189 if (!(word_en & BIT(word_idx)))
190 word_cnts++;
191 return word_cnts;
192 }
193
194 static void pgpacket_copy_data(const u8 word_en, const u8 *sourdata,
195 u8 *targetdata)
196 {
197 u8 tmpindex = 0;
198 u8 word_idx, byte_idx;
199
200 for (word_idx = 0; word_idx < PGPKG_MAX_WORDS; word_idx++) {
201 if (!(word_en & BIT(word_idx))) {
202 byte_idx = word_idx * 2;
203 targetdata[byte_idx] = sourdata[tmpindex++];
204 targetdata[byte_idx + 1] = sourdata[tmpindex++];
205 }
206 }
207 }
208
209 u16 r8712_efuse_get_current_size(struct _adapter *adapter)
210 {
211 int bContinual = true;
212 u16 efuse_addr = 0;
213 u8 hworden = 0;
214 u8 efuse_data, word_cnts = 0;
215
216 while (bContinual && efuse_one_byte_read(adapter, efuse_addr,
217 &efuse_data) && (efuse_addr < efuse_available_max_size)) {
218 if (efuse_data != 0xFF) {
219 hworden = efuse_data & 0x0F;
220 word_cnts = calculate_word_cnts(hworden);
221
222 efuse_addr = efuse_addr + (word_cnts * 2) + 1;
223 } else {
224 bContinual = false;
225 }
226 }
227 return efuse_addr;
228 }
229
230 u8 r8712_efuse_pg_packet_read(struct _adapter *adapter, u8 offset, u8 *data)
231 {
232 u8 hoffset = 0, hworden = 0, word_cnts = 0;
233 u16 efuse_addr = 0;
234 u8 efuse_data;
235 u8 tmpidx = 0;
236 u8 tmpdata[PGPKT_DATA_SIZE];
237 u8 ret = true;
238
239 if (!data)
240 return false;
241 if (offset > 0x0f)
242 return false;
243 memset(data, 0xFF, sizeof(u8) * PGPKT_DATA_SIZE);
244 while (efuse_addr < efuse_available_max_size) {
245 if (efuse_one_byte_read(adapter, efuse_addr, &efuse_data)) {
246 if (efuse_data == 0xFF)
247 break;
248 hoffset = (efuse_data >> 4) & 0x0F;
249 hworden = efuse_data & 0x0F;
250 word_cnts = calculate_word_cnts(hworden);
251 if (hoffset == offset) {
252 memset(tmpdata, 0xFF, PGPKT_DATA_SIZE);
253 for (tmpidx = 0; tmpidx < word_cnts * 2;
254 tmpidx++) {
255 if (efuse_one_byte_read(adapter,
256 efuse_addr + 1 + tmpidx,
257 &efuse_data)) {
258 tmpdata[tmpidx] = efuse_data;
259 } else {
260 ret = false;
261 }
262 }
263 pgpacket_copy_data(hworden, tmpdata, data);
264 }
265 efuse_addr += 1 + (word_cnts * 2);
266 } else {
267 ret = false;
268 break;
269 }
270 }
271 return ret;
272 }
273
274 static u8 fix_header(struct _adapter *adapter, u8 header, u16 header_addr)
275 {
276 struct PGPKT_STRUCT pkt;
277 u8 offset, word_en, value;
278 u16 addr;
279 int i;
280 u8 ret = true;
281
282 pkt.offset = GET_EFUSE_OFFSET(header);
283 pkt.word_en = GET_EFUSE_WORD_EN(header);
284 addr = header_addr + 1 + calculate_word_cnts(pkt.word_en) * 2;
285 if (addr > efuse_available_max_size)
286 return false;
287
288 addr = 0;
289 while (addr < header_addr) {
290 if (!efuse_one_byte_read(adapter, addr++, &value)) {
291 ret = false;
292 break;
293 }
294 offset = GET_EFUSE_OFFSET(value);
295 word_en = GET_EFUSE_WORD_EN(value);
296 if (pkt.offset != offset) {
297 addr += calculate_word_cnts(word_en) * 2;
298 continue;
299 }
300 for (i = 0; i < PGPKG_MAX_WORDS; i++) {
301 if (BIT(i) & word_en) {
302 if (BIT(i) & pkt.word_en) {
303 if (efuse_one_byte_read(
304 adapter, addr,
305 &value))
306 pkt.data[i * 2] = value;
307 else
308 return false;
309 if (efuse_one_byte_read(
310 adapter,
311 addr + 1,
312 &value))
313 pkt.data[i * 2 + 1] =
314 value;
315 else
316 return false;
317 }
318 addr += 2;
319 }
320 }
321 }
322 if (addr != header_addr)
323 return false;
324 addr++;
325
326 for (i = 0; i < PGPKG_MAX_WORDS; i++) {
327 if (BIT(i) & pkt.word_en) {
328 efuse_one_byte_write(adapter, addr, pkt.data[i * 2]);
329 efuse_one_byte_write(adapter, addr + 1,
330 pkt.data[i * 2 + 1]);
331
332 if (!efuse_one_byte_read(adapter, addr, &value)) {
333 ret = false;
334 } else if (pkt.data[i * 2] != value) {
335 ret = false;
336 if (value == 0xFF)
337 efuse_one_byte_write(adapter, addr,
338 pkt.data[i * 2]);
339 }
340 if (!efuse_one_byte_read(adapter, addr + 1, &value)) {
341 ret = false;
342 } else if (pkt.data[i * 2 + 1] != value) {
343 ret = false;
344 if (value == 0xFF)
345 efuse_one_byte_write(adapter, addr + 1,
346 pkt.data[i * 2 +
347 1]);
348 }
349 }
350 addr += 2;
351 }
352 return ret;
353 }
354
355 u8 r8712_efuse_pg_packet_write(struct _adapter *adapter, const u8 offset,
356 const u8 word_en, const u8 *data)
357 {
358 u8 pg_header = 0;
359 u16 efuse_addr = 0, curr_size = 0;
360 u8 efuse_data, target_word_cnts = 0;
361 int repeat_times;
362 int sub_repeat;
363 u8 bResult = true;
364
365
366 efuse_data = r8712_read8(adapter, EFUSE_CLK_CTRL);
367 if (efuse_data != 0x03)
368 return false;
369 pg_header = MAKE_EFUSE_HEADER(offset, word_en);
370 target_word_cnts = calculate_word_cnts(word_en);
371 repeat_times = 0;
372 efuse_addr = 0;
373 while (efuse_addr < efuse_available_max_size) {
374 curr_size = r8712_efuse_get_current_size(adapter);
375 if ((curr_size + 1 + target_word_cnts * 2) >
376 efuse_available_max_size)
377 return false;
378 efuse_addr = curr_size;
379 efuse_one_byte_write(adapter, efuse_addr, pg_header);
380 sub_repeat = 0;
381
382 while (!efuse_one_byte_read(adapter, efuse_addr,
383 &efuse_data)) {
384 if (++sub_repeat > _REPEAT_THRESHOLD_) {
385 bResult = false;
386 break;
387 }
388 }
389 if ((sub_repeat > _REPEAT_THRESHOLD_) ||
390 (pg_header == efuse_data)) {
391
392 u8 i;
393
394
395 efuse_addr++;
396 for (i = 0; i < target_word_cnts * 2; i++) {
397 efuse_one_byte_write(adapter,
398 efuse_addr + i,
399 *(data + i));
400 if (!efuse_one_byte_read(adapter,
401 efuse_addr + i,
402 &efuse_data))
403 bResult = false;
404 else if (*(data + i) != efuse_data)
405 bResult = false;
406 }
407 break;
408 }
409
410 bResult = false;
411 if (efuse_data == 0xFF)
412 return bResult;
413
414 if (!fix_header(adapter, efuse_data, efuse_addr))
415 return false;
416
417 if (++repeat_times > _REPEAT_THRESHOLD_)
418 break;
419
420 }
421 return bResult;
422 }
423
424 u8 r8712_efuse_access(struct _adapter *adapter, u8 bRead, u16 start_addr,
425 u16 cnts, u8 *data)
426 {
427 int i;
428 u8 res = true;
429
430 if (start_addr > EFUSE_MAX_SIZE)
431 return false;
432 if (!bRead && ((start_addr + cnts) >
433 efuse_available_max_size))
434 return false;
435 if (!bRead && !r8712_efuse_reg_init(adapter))
436 return false;
437
438 for (i = 0; i < cnts; i++) {
439 if ((start_addr + i) > EFUSE_MAX_SIZE) {
440 res = false;
441 break;
442 }
443 res = efuse_one_byte_rw(adapter, bRead, start_addr + i,
444 data + i);
445 if (!bRead && !res)
446 break;
447 }
448 if (!bRead)
449 r8712_efuse_reg_uninit(adapter);
450 return res;
451 }
452
453 u8 r8712_efuse_map_read(struct _adapter *adapter, u16 addr, u16 cnts, u8 *data)
454 {
455 u8 offset, ret = true;
456 u8 pktdata[PGPKT_DATA_SIZE];
457 int i, idx;
458
459 if ((addr + cnts) > EFUSE_MAP_MAX_SIZE)
460 return false;
461 if (efuse_is_empty(adapter, &offset) && offset) {
462 for (i = 0; i < cnts; i++)
463 data[i] = 0xFF;
464 return ret;
465 }
466 offset = (addr >> 3) & 0xF;
467 ret = r8712_efuse_pg_packet_read(adapter, offset, pktdata);
468 i = addr & 0x7;
469 idx = 0;
470
471 do {
472 for (; i < PGPKT_DATA_SIZE; i++) {
473 data[idx++] = pktdata[i];
474 if (idx == cnts)
475 return ret;
476 }
477 offset++;
478 if (!r8712_efuse_pg_packet_read(adapter, offset, pktdata))
479 ret = false;
480 i = 0;
481 } while (1);
482 return ret;
483 }
484
485 u8 r8712_efuse_map_write(struct _adapter *adapter, u16 addr, u16 cnts,
486 u8 *data)
487 {
488 u8 offset, word_en, empty;
489 u8 pktdata[PGPKT_DATA_SIZE], newdata[PGPKT_DATA_SIZE];
490 int i, j, idx;
491
492 if ((addr + cnts) > EFUSE_MAP_MAX_SIZE)
493 return false;
494
495 empty = r8712_read8(adapter, EFUSE_CLK_CTRL);
496 if (empty != 0x03)
497 return false;
498 if (efuse_is_empty(adapter, &empty)) {
499 if (empty)
500 memset(pktdata, 0xFF, PGPKT_DATA_SIZE);
501 } else {
502 return false;
503 }
504 offset = (addr >> 3) & 0xF;
505 if (!empty)
506 if (!r8712_efuse_pg_packet_read(adapter, offset, pktdata))
507 return false;
508 word_en = 0xF;
509 memset(newdata, 0xFF, PGPKT_DATA_SIZE);
510 i = addr & 0x7;
511 j = 0;
512 idx = 0;
513
514 if (i & 0x1) {
515
516 if (data[idx] != pktdata[i]) {
517 word_en &= ~BIT(i >> 1);
518 newdata[j++] = pktdata[i - 1];
519 newdata[j++] = data[idx];
520 }
521 i++;
522 idx++;
523 }
524 do {
525 for (; i < PGPKT_DATA_SIZE; i += 2) {
526 if ((cnts - idx) == 1) {
527 if (data[idx] != pktdata[i]) {
528 word_en &= ~BIT(i >> 1);
529 newdata[j++] = data[idx];
530 newdata[j++] = pktdata[1 + 1];
531 }
532 idx++;
533 break;
534 }
535
536 if ((data[idx] != pktdata[i]) || (data[idx + 1] !=
537 pktdata[i + 1])) {
538 word_en &= ~BIT(i >> 1);
539 newdata[j++] = data[idx];
540 newdata[j++] = data[idx + 1];
541 }
542 idx += 2;
543
544 if (idx == cnts)
545 break;
546 }
547
548 if (word_en != 0xF)
549 if (!r8712_efuse_pg_packet_write(adapter, offset,
550 word_en, newdata))
551 return false;
552 if (idx == cnts)
553 break;
554 offset++;
555 if (!empty)
556 if (!r8712_efuse_pg_packet_read(adapter, offset,
557 pktdata))
558 return false;
559 i = 0;
560 j = 0;
561 word_en = 0xF;
562 memset(newdata, 0xFF, PGPKT_DATA_SIZE);
563 } while (1);
564
565 return true;
566 }