1 /******************************************************************************
3 * Copyright(c) 2009-2012 Realtek Corporation.
5 * Tmis program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * Tmis program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * Tme full GNU General Public License is included in this distribution in the
15 * file called LICENSE.
17 * Contact Information:
18 * wlanfae <wlanfae@realtek.com>
19 * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
20 * Hsinchu 300, Taiwan.
22 * Larry Finger <Larry.Finger@lwfinger.net>
24 *****************************************************************************/
28 #include <linux/export.h>
30 static const u8 MAX_PGPKT_SIZE
= 9;
31 static const u8 PGPKT_DATA_SIZE
= 8;
32 static const int EFUSE_MAX_SIZE
= 512;
34 static const struct efuse_map RTL8712_SDIO_EFUSE_TABLE
[] = {
50 static void efuse_shadow_read_1byte(struct ieee80211_hw
*hw
, u16 offset
,
52 static void efuse_shadow_read_2byte(struct ieee80211_hw
*hw
, u16 offset
,
54 static void efuse_shadow_read_4byte(struct ieee80211_hw
*hw
, u16 offset
,
56 static void efuse_shadow_write_1byte(struct ieee80211_hw
*hw
, u16 offset
,
58 static void efuse_shadow_write_2byte(struct ieee80211_hw
*hw
, u16 offset
,
60 static void efuse_shadow_write_4byte(struct ieee80211_hw
*hw
, u16 offset
,
62 static int efuse_one_byte_write(struct ieee80211_hw
*hw
, u16 addr
,
64 static void efuse_read_all_map(struct ieee80211_hw
*hw
, u8
*efuse
);
65 static int efuse_pg_packet_read(struct ieee80211_hw
*hw
, u8 offset
,
67 static int efuse_pg_packet_write(struct ieee80211_hw
*hw
, u8 offset
,
68 u8 word_en
, u8
*data
);
69 static void efuse_word_enable_data_read(u8 word_en
, u8
*sourdata
,
71 static u8
enable_efuse_data_write(struct ieee80211_hw
*hw
,
72 u16 efuse_addr
, u8 word_en
, u8
*data
);
73 static void efuse_power_switch(struct ieee80211_hw
*hw
, u8 write
,
75 static u16
efuse_get_current_size(struct ieee80211_hw
*hw
);
76 static u8
efuse_calculate_word_cnts(u8 word_en
);
78 void efuse_initialize(struct ieee80211_hw
*hw
)
80 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
84 bytetemp
= rtl_read_byte(rtlpriv
, rtlpriv
->cfg
->maps
[SYS_FUNC_EN
] + 1);
85 temp
= bytetemp
| 0x20;
86 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[SYS_FUNC_EN
] + 1, temp
);
88 bytetemp
= rtl_read_byte(rtlpriv
, rtlpriv
->cfg
->maps
[SYS_ISO_CTRL
] + 1);
89 temp
= bytetemp
& 0xFE;
90 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[SYS_ISO_CTRL
] + 1, temp
);
92 bytetemp
= rtl_read_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_TEST
] + 3);
93 temp
= bytetemp
| 0x80;
94 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_TEST
] + 3, temp
);
96 rtl_write_byte(rtlpriv
, 0x2F8, 0x3);
98 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3, 0x72);
102 u8
efuse_read_1byte(struct ieee80211_hw
*hw
, u16 address
)
104 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
109 const u32 efuse_len
=
110 rtlpriv
->cfg
->maps
[EFUSE_REAL_CONTENT_SIZE
];
112 if (address
< efuse_len
) {
113 temp
= address
& 0xFF;
114 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 1,
116 bytetemp
= rtl_read_byte(rtlpriv
,
117 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 2);
118 temp
= ((address
>> 8) & 0x03) | (bytetemp
& 0xFC);
119 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 2,
122 bytetemp
= rtl_read_byte(rtlpriv
,
123 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3);
124 temp
= bytetemp
& 0x7F;
125 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3,
128 bytetemp
= rtl_read_byte(rtlpriv
,
129 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3);
130 while (!(bytetemp
& 0x80)) {
131 bytetemp
= rtl_read_byte(rtlpriv
,
133 maps
[EFUSE_CTRL
] + 3);
140 data
= rtl_read_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
]);
146 EXPORT_SYMBOL(efuse_read_1byte
);
148 void efuse_write_1byte(struct ieee80211_hw
*hw
, u16 address
, u8 value
)
150 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
154 const u32 efuse_len
=
155 rtlpriv
->cfg
->maps
[EFUSE_REAL_CONTENT_SIZE
];
157 RT_TRACE(rtlpriv
, COMP_EFUSE
, DBG_LOUD
, "Addr=%x Data =%x\n",
160 if (address
< efuse_len
) {
161 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
], value
);
163 temp
= address
& 0xFF;
164 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 1,
166 bytetemp
= rtl_read_byte(rtlpriv
,
167 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 2);
169 temp
= ((address
>> 8) & 0x03) | (bytetemp
& 0xFC);
170 rtl_write_byte(rtlpriv
,
171 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 2, temp
);
173 bytetemp
= rtl_read_byte(rtlpriv
,
174 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3);
175 temp
= bytetemp
| 0x80;
176 rtl_write_byte(rtlpriv
,
177 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3, temp
);
179 bytetemp
= rtl_read_byte(rtlpriv
,
180 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3);
182 while (bytetemp
& 0x80) {
183 bytetemp
= rtl_read_byte(rtlpriv
,
185 maps
[EFUSE_CTRL
] + 3);
196 void read_efuse_byte(struct ieee80211_hw
*hw
, u16 _offset
, u8
*pbuf
)
198 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
203 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 1,
205 readbyte
= rtl_read_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 2);
206 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 2,
207 ((_offset
>> 8) & 0x03) | (readbyte
& 0xfc));
209 readbyte
= rtl_read_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3);
210 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3,
214 value32
= rtl_read_dword(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
]);
215 while (!(((value32
>> 24) & 0xff) & 0x80) && (retry
< 10000)) {
216 value32
= rtl_read_dword(rtlpriv
,
217 rtlpriv
->cfg
->maps
[EFUSE_CTRL
]);
222 value32
= rtl_read_dword(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
]);
224 *pbuf
= (u8
) (value32
& 0xff);
226 EXPORT_SYMBOL_GPL(read_efuse_byte
);
228 void read_efuse(struct ieee80211_hw
*hw
, u16 _offset
, u16 _size_byte
, u8
*pbuf
)
230 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
231 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
239 const u16 efuse_max_section
=
240 rtlpriv
->cfg
->maps
[EFUSE_MAX_SECTION_MAP
];
241 const u32 efuse_len
=
242 rtlpriv
->cfg
->maps
[EFUSE_REAL_CONTENT_SIZE
];
244 u16 efuse_utilized
= 0;
247 if ((_offset
+ _size_byte
) > rtlpriv
->cfg
->maps
[EFUSE_HWSET_MAX_SIZE
]) {
248 RT_TRACE(rtlpriv
, COMP_EFUSE
, DBG_LOUD
,
249 "read_efuse(): Invalid offset(%#x) with read bytes(%#x)!!\n",
250 _offset
, _size_byte
);
254 /* allocate memory for efuse_tbl and efuse_word */
255 efuse_tbl
= kzalloc(rtlpriv
->cfg
->maps
[EFUSE_HWSET_MAX_SIZE
] *
256 sizeof(u8
), GFP_ATOMIC
);
259 efuse_word
= kzalloc(EFUSE_MAX_WORD_UNIT
* sizeof(u16
*), GFP_ATOMIC
);
262 for (i
= 0; i
< EFUSE_MAX_WORD_UNIT
; i
++) {
263 efuse_word
[i
] = kzalloc(efuse_max_section
* sizeof(u16
),
269 for (i
= 0; i
< efuse_max_section
; i
++)
270 for (j
= 0; j
< EFUSE_MAX_WORD_UNIT
; j
++)
271 efuse_word
[j
][i
] = 0xFFFF;
273 read_efuse_byte(hw
, efuse_addr
, rtemp8
);
274 if (*rtemp8
!= 0xFF) {
276 RTPRINT(rtlpriv
, FEEPROM
, EFUSE_READ_ALL
,
277 "Addr=%d\n", efuse_addr
);
281 while ((*rtemp8
!= 0xFF) && (efuse_addr
< efuse_len
)) {
282 /* Check PG header for section num. */
283 if ((*rtemp8
& 0x1F) == 0x0F) {/* extended header */
284 u1temp
= ((*rtemp8
& 0xE0) >> 5);
285 read_efuse_byte(hw
, efuse_addr
, rtemp8
);
287 if ((*rtemp8
& 0x0F) == 0x0F) {
289 read_efuse_byte(hw
, efuse_addr
, rtemp8
);
291 if (*rtemp8
!= 0xFF &&
292 (efuse_addr
< efuse_len
)) {
297 offset
= ((*rtemp8
& 0xF0) >> 1) | u1temp
;
298 wren
= (*rtemp8
& 0x0F);
302 offset
= ((*rtemp8
>> 4) & 0x0f);
303 wren
= (*rtemp8
& 0x0f);
306 if (offset
< efuse_max_section
) {
307 RTPRINT(rtlpriv
, FEEPROM
, EFUSE_READ_ALL
,
308 "offset-%d Worden=%x\n", offset
, wren
);
310 for (i
= 0; i
< EFUSE_MAX_WORD_UNIT
; i
++) {
311 if (!(wren
& 0x01)) {
312 RTPRINT(rtlpriv
, FEEPROM
,
314 "Addr=%d\n", efuse_addr
);
316 read_efuse_byte(hw
, efuse_addr
, rtemp8
);
319 efuse_word
[i
][offset
] =
322 if (efuse_addr
>= efuse_len
)
325 RTPRINT(rtlpriv
, FEEPROM
,
327 "Addr=%d\n", efuse_addr
);
329 read_efuse_byte(hw
, efuse_addr
, rtemp8
);
332 efuse_word
[i
][offset
] |=
333 (((u16
)*rtemp8
<< 8) & 0xff00);
335 if (efuse_addr
>= efuse_len
)
343 RTPRINT(rtlpriv
, FEEPROM
, EFUSE_READ_ALL
,
344 "Addr=%d\n", efuse_addr
);
345 read_efuse_byte(hw
, efuse_addr
, rtemp8
);
346 if (*rtemp8
!= 0xFF && (efuse_addr
< efuse_len
)) {
352 for (i
= 0; i
< efuse_max_section
; i
++) {
353 for (j
= 0; j
< EFUSE_MAX_WORD_UNIT
; j
++) {
354 efuse_tbl
[(i
* 8) + (j
* 2)] =
355 (efuse_word
[j
][i
] & 0xff);
356 efuse_tbl
[(i
* 8) + ((j
* 2) + 1)] =
357 ((efuse_word
[j
][i
] >> 8) & 0xff);
361 for (i
= 0; i
< _size_byte
; i
++)
362 pbuf
[i
] = efuse_tbl
[_offset
+ i
];
364 rtlefuse
->efuse_usedbytes
= efuse_utilized
;
365 efuse_usage
= (u8
) ((efuse_utilized
* 100) / efuse_len
);
366 rtlefuse
->efuse_usedpercentage
= efuse_usage
;
367 rtlpriv
->cfg
->ops
->set_hw_reg(hw
, HW_VAR_EFUSE_BYTES
,
368 (u8
*)&efuse_utilized
);
369 rtlpriv
->cfg
->ops
->set_hw_reg(hw
, HW_VAR_EFUSE_USAGE
,
372 for (i
= 0; i
< EFUSE_MAX_WORD_UNIT
; i
++)
373 kfree(efuse_word
[i
]);
379 bool efuse_shadow_update_chk(struct ieee80211_hw
*hw
)
381 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
382 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
383 u8 section_idx
, i
, Base
;
384 u16 words_need
= 0, hdr_num
= 0, totalbytes
, efuse_used
;
385 bool wordchanged
, result
= true;
387 for (section_idx
= 0; section_idx
< 16; section_idx
++) {
388 Base
= section_idx
* 8;
391 for (i
= 0; i
< 8; i
= i
+ 2) {
392 if ((rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][Base
+ i
] !=
393 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][Base
+ i
]) ||
394 (rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][Base
+ i
+ 1] !=
395 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][Base
+ i
+
406 totalbytes
= hdr_num
+ words_need
* 2;
407 efuse_used
= rtlefuse
->efuse_usedbytes
;
409 if ((totalbytes
+ efuse_used
) >=
410 (EFUSE_MAX_SIZE
- rtlpriv
->cfg
->maps
[EFUSE_OOB_PROTECT_BYTES_LEN
]))
413 RT_TRACE(rtlpriv
, COMP_EFUSE
, DBG_LOUD
,
414 "efuse_shadow_update_chk(): totalbytes(%#x), hdr_num(%#x), words_need(%#x), efuse_used(%d)\n",
415 totalbytes
, hdr_num
, words_need
, efuse_used
);
420 void efuse_shadow_read(struct ieee80211_hw
*hw
, u8 type
,
421 u16 offset
, u32
*value
)
424 efuse_shadow_read_1byte(hw
, offset
, (u8
*)value
);
426 efuse_shadow_read_2byte(hw
, offset
, (u16
*)value
);
428 efuse_shadow_read_4byte(hw
, offset
, value
);
431 EXPORT_SYMBOL(efuse_shadow_read
);
433 void efuse_shadow_write(struct ieee80211_hw
*hw
, u8 type
, u16 offset
,
437 efuse_shadow_write_1byte(hw
, offset
, (u8
) value
);
439 efuse_shadow_write_2byte(hw
, offset
, (u16
) value
);
441 efuse_shadow_write_4byte(hw
, offset
, value
);
445 bool efuse_shadow_update(struct ieee80211_hw
*hw
)
447 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
448 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
453 RT_TRACE(rtlpriv
, COMP_EFUSE
, DBG_LOUD
, "\n");
455 if (!efuse_shadow_update_chk(hw
)) {
456 efuse_read_all_map(hw
, &rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][0]);
457 memcpy(&rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][0],
458 &rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][0],
459 rtlpriv
->cfg
->maps
[EFUSE_HWSET_MAX_SIZE
]);
461 RT_TRACE(rtlpriv
, COMP_EFUSE
, DBG_LOUD
,
462 "efuse out of capacity!!\n");
465 efuse_power_switch(hw
, true, true);
467 for (offset
= 0; offset
< 16; offset
++) {
472 for (i
= 0; i
< 8; i
++) {
474 word_en
&= ~(BIT(i
/ 2));
476 rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][base
+ i
] =
477 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][base
+ i
];
480 if (rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][base
+ i
] !=
481 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][base
+ i
]) {
482 word_en
&= ~(BIT(i
/ 2));
484 rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][base
+ i
] =
485 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][base
+ i
];
490 if (word_en
!= 0x0F) {
493 &rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][base
],
495 RT_PRINT_DATA(rtlpriv
, COMP_INIT
, DBG_LOUD
,
496 "U-efuse\n", tmpdata
, 8);
498 if (!efuse_pg_packet_write(hw
, (u8
) offset
, word_en
,
500 RT_TRACE(rtlpriv
, COMP_ERR
, DBG_WARNING
,
501 "PG section(%#x) fail!!\n", offset
);
508 efuse_power_switch(hw
, true, false);
509 efuse_read_all_map(hw
, &rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][0]);
511 memcpy(&rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][0],
512 &rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][0],
513 rtlpriv
->cfg
->maps
[EFUSE_HWSET_MAX_SIZE
]);
515 RT_TRACE(rtlpriv
, COMP_EFUSE
, DBG_LOUD
, "\n");
519 void rtl_efuse_shadow_map_update(struct ieee80211_hw
*hw
)
521 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
522 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
524 if (rtlefuse
->autoload_failflag
)
525 memset((&rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][0]),
526 0xFF, rtlpriv
->cfg
->maps
[EFUSE_HWSET_MAX_SIZE
]);
528 efuse_read_all_map(hw
, &rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][0]);
530 memcpy(&rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][0],
531 &rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][0],
532 rtlpriv
->cfg
->maps
[EFUSE_HWSET_MAX_SIZE
]);
535 EXPORT_SYMBOL(rtl_efuse_shadow_map_update
);
537 void efuse_force_write_vendor_Id(struct ieee80211_hw
*hw
)
539 u8 tmpdata
[8] = { 0xFF, 0xFF, 0xEC, 0x10, 0xFF, 0xFF, 0xFF, 0xFF };
541 efuse_power_switch(hw
, true, true);
543 efuse_pg_packet_write(hw
, 1, 0xD, tmpdata
);
545 efuse_power_switch(hw
, true, false);
549 void efuse_re_pg_section(struct ieee80211_hw
*hw
, u8 section_idx
)
553 static void efuse_shadow_read_1byte(struct ieee80211_hw
*hw
,
554 u16 offset
, u8
*value
)
556 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
557 *value
= rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
];
560 static void efuse_shadow_read_2byte(struct ieee80211_hw
*hw
,
561 u16 offset
, u16
*value
)
563 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
565 *value
= rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
];
566 *value
|= rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
+ 1] << 8;
570 static void efuse_shadow_read_4byte(struct ieee80211_hw
*hw
,
571 u16 offset
, u32
*value
)
573 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
575 *value
= rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
];
576 *value
|= rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
+ 1] << 8;
577 *value
|= rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
+ 2] << 16;
578 *value
|= rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
+ 3] << 24;
581 static void efuse_shadow_write_1byte(struct ieee80211_hw
*hw
,
582 u16 offset
, u8 value
)
584 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
586 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
] = value
;
589 static void efuse_shadow_write_2byte(struct ieee80211_hw
*hw
,
590 u16 offset
, u16 value
)
592 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
594 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
] = value
& 0x00FF;
595 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
+ 1] = value
>> 8;
599 static void efuse_shadow_write_4byte(struct ieee80211_hw
*hw
,
600 u16 offset
, u32 value
)
602 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
604 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
] =
605 (u8
) (value
& 0x000000FF);
606 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
+ 1] =
607 (u8
) ((value
>> 8) & 0x0000FF);
608 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
+ 2] =
609 (u8
) ((value
>> 16) & 0x00FF);
610 rtlefuse
->efuse_map
[EFUSE_MODIFY_MAP
][offset
+ 3] =
611 (u8
) ((value
>> 24) & 0xFF);
615 int efuse_one_byte_read(struct ieee80211_hw
*hw
, u16 addr
, u8
*data
)
617 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
621 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 1,
623 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 2,
624 ((u8
) ((addr
>> 8) & 0x03)) |
625 (rtl_read_byte(rtlpriv
,
626 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 2) &
629 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3, 0x72);
631 while (!(0x80 & rtl_read_byte(rtlpriv
,
632 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3))
638 *data
= rtl_read_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
]);
646 EXPORT_SYMBOL(efuse_one_byte_read
);
648 static int efuse_one_byte_write(struct ieee80211_hw
*hw
, u16 addr
, u8 data
)
650 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
653 RT_TRACE(rtlpriv
, COMP_EFUSE
, DBG_LOUD
,
654 "Addr = %x Data=%x\n", addr
, data
);
656 rtl_write_byte(rtlpriv
,
657 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 1, (u8
) (addr
& 0xff));
658 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 2,
659 (rtl_read_byte(rtlpriv
,
660 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] +
661 2) & 0xFC) | (u8
) ((addr
>> 8) & 0x03));
663 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
], data
);
664 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3, 0xF2);
666 while ((0x80 & rtl_read_byte(rtlpriv
,
667 rtlpriv
->cfg
->maps
[EFUSE_CTRL
] + 3))
677 static void efuse_read_all_map(struct ieee80211_hw
*hw
, u8
*efuse
)
679 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
680 efuse_power_switch(hw
, false, true);
681 read_efuse(hw
, 0, rtlpriv
->cfg
->maps
[EFUSE_HWSET_MAX_SIZE
], efuse
);
682 efuse_power_switch(hw
, false, false);
685 static void efuse_read_data_case1(struct ieee80211_hw
*hw
, u16
*efuse_addr
,
686 u8 efuse_data
, u8 offset
, u8
*tmpdata
,
689 bool dataempty
= true;
695 hoffset
= (efuse_data
>> 4) & 0x0F;
696 hworden
= efuse_data
& 0x0F;
697 word_cnts
= efuse_calculate_word_cnts(hworden
);
699 if (hoffset
== offset
) {
700 for (tmpidx
= 0; tmpidx
< word_cnts
* 2; tmpidx
++) {
701 if (efuse_one_byte_read(hw
, *efuse_addr
+ 1 + tmpidx
,
703 tmpdata
[tmpidx
] = efuse_data
;
704 if (efuse_data
!= 0xff)
710 *readstate
= PG_STATE_DATA
;
712 *efuse_addr
= *efuse_addr
+ (word_cnts
* 2) + 1;
713 *readstate
= PG_STATE_HEADER
;
717 *efuse_addr
= *efuse_addr
+ (word_cnts
* 2) + 1;
718 *readstate
= PG_STATE_HEADER
;
722 static int efuse_pg_packet_read(struct ieee80211_hw
*hw
, u8 offset
, u8
*data
)
724 u8 readstate
= PG_STATE_HEADER
;
726 bool continual
= true;
728 u8 efuse_data
, word_cnts
= 0;
737 memset(data
, 0xff, PGPKT_DATA_SIZE
* sizeof(u8
));
738 memset(tmpdata
, 0xff, PGPKT_DATA_SIZE
* sizeof(u8
));
740 while (continual
&& (efuse_addr
< EFUSE_MAX_SIZE
)) {
741 if (readstate
& PG_STATE_HEADER
) {
742 if (efuse_one_byte_read(hw
, efuse_addr
, &efuse_data
)
743 && (efuse_data
!= 0xFF))
744 efuse_read_data_case1(hw
, &efuse_addr
,
746 tmpdata
, &readstate
);
749 } else if (readstate
& PG_STATE_DATA
) {
750 efuse_word_enable_data_read(0, tmpdata
, data
);
751 efuse_addr
= efuse_addr
+ (word_cnts
* 2) + 1;
752 readstate
= PG_STATE_HEADER
;
757 if ((data
[0] == 0xff) && (data
[1] == 0xff) &&
758 (data
[2] == 0xff) && (data
[3] == 0xff) &&
759 (data
[4] == 0xff) && (data
[5] == 0xff) &&
760 (data
[6] == 0xff) && (data
[7] == 0xff))
767 static void efuse_write_data_case1(struct ieee80211_hw
*hw
, u16
*efuse_addr
,
768 u8 efuse_data
, u8 offset
,
769 int *continual
, u8
*write_state
,
770 struct pgpkt_struct
*target_pkt
,
771 int *repeat_times
, int *result
, u8 word_en
)
773 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
774 struct pgpkt_struct tmp_pkt
;
775 int dataempty
= true;
776 u8 originaldata
[8 * sizeof(u8
)];
778 u8 match_word_en
, tmp_word_en
;
780 u8 tmp_header
= efuse_data
;
783 tmp_pkt
.offset
= (tmp_header
>> 4) & 0x0F;
784 tmp_pkt
.word_en
= tmp_header
& 0x0F;
785 tmp_word_cnts
= efuse_calculate_word_cnts(tmp_pkt
.word_en
);
787 if (tmp_pkt
.offset
!= target_pkt
->offset
) {
788 *efuse_addr
= *efuse_addr
+ (tmp_word_cnts
* 2) + 1;
789 *write_state
= PG_STATE_HEADER
;
791 for (tmpindex
= 0; tmpindex
< (tmp_word_cnts
* 2); tmpindex
++) {
792 if (efuse_one_byte_read(hw
,
793 (*efuse_addr
+ 1 + tmpindex
),
795 (efuse_data
!= 0xFF))
800 *efuse_addr
= *efuse_addr
+ (tmp_word_cnts
* 2) + 1;
801 *write_state
= PG_STATE_HEADER
;
803 match_word_en
= 0x0F;
804 if (!((target_pkt
->word_en
& BIT(0)) |
805 (tmp_pkt
.word_en
& BIT(0))))
806 match_word_en
&= (~BIT(0));
808 if (!((target_pkt
->word_en
& BIT(1)) |
809 (tmp_pkt
.word_en
& BIT(1))))
810 match_word_en
&= (~BIT(1));
812 if (!((target_pkt
->word_en
& BIT(2)) |
813 (tmp_pkt
.word_en
& BIT(2))))
814 match_word_en
&= (~BIT(2));
816 if (!((target_pkt
->word_en
& BIT(3)) |
817 (tmp_pkt
.word_en
& BIT(3))))
818 match_word_en
&= (~BIT(3));
820 if ((match_word_en
& 0x0F) != 0x0F) {
822 enable_efuse_data_write(hw
,
827 if (0x0F != (badworden
& 0x0F)) {
828 u8 reorg_offset
= offset
;
829 u8 reorg_worden
= badworden
;
830 efuse_pg_packet_write(hw
, reorg_offset
,
836 if ((target_pkt
->word_en
& BIT(0)) ^
837 (match_word_en
& BIT(0)))
838 tmp_word_en
&= (~BIT(0));
840 if ((target_pkt
->word_en
& BIT(1)) ^
841 (match_word_en
& BIT(1)))
842 tmp_word_en
&= (~BIT(1));
844 if ((target_pkt
->word_en
& BIT(2)) ^
845 (match_word_en
& BIT(2)))
846 tmp_word_en
&= (~BIT(2));
848 if ((target_pkt
->word_en
& BIT(3)) ^
849 (match_word_en
& BIT(3)))
850 tmp_word_en
&= (~BIT(3));
852 if ((tmp_word_en
& 0x0F) != 0x0F) {
853 *efuse_addr
= efuse_get_current_size(hw
);
854 target_pkt
->offset
= offset
;
855 target_pkt
->word_en
= tmp_word_en
;
859 *write_state
= PG_STATE_HEADER
;
861 if (*repeat_times
> EFUSE_REPEAT_THRESHOLD_
) {
866 *efuse_addr
+= (2 * tmp_word_cnts
) + 1;
867 target_pkt
->offset
= offset
;
868 target_pkt
->word_en
= word_en
;
869 *write_state
= PG_STATE_HEADER
;
873 RTPRINT(rtlpriv
, FEEPROM
, EFUSE_PG
, "efuse PG_STATE_HEADER-1\n");
876 static void efuse_write_data_case2(struct ieee80211_hw
*hw
, u16
*efuse_addr
,
877 int *continual
, u8
*write_state
,
878 struct pgpkt_struct target_pkt
,
879 int *repeat_times
, int *result
)
881 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
882 struct pgpkt_struct tmp_pkt
;
885 u8 originaldata
[8 * sizeof(u8
)];
889 pg_header
= ((target_pkt
.offset
<< 4) & 0xf0) | target_pkt
.word_en
;
890 efuse_one_byte_write(hw
, *efuse_addr
, pg_header
);
891 efuse_one_byte_read(hw
, *efuse_addr
, &tmp_header
);
893 if (tmp_header
== pg_header
) {
894 *write_state
= PG_STATE_DATA
;
895 } else if (tmp_header
== 0xFF) {
896 *write_state
= PG_STATE_HEADER
;
898 if (*repeat_times
> EFUSE_REPEAT_THRESHOLD_
) {
903 tmp_pkt
.offset
= (tmp_header
>> 4) & 0x0F;
904 tmp_pkt
.word_en
= tmp_header
& 0x0F;
906 tmp_word_cnts
= efuse_calculate_word_cnts(tmp_pkt
.word_en
);
908 memset(originaldata
, 0xff, 8 * sizeof(u8
));
910 if (efuse_pg_packet_read(hw
, tmp_pkt
.offset
, originaldata
)) {
911 badworden
= enable_efuse_data_write(hw
,
916 if (0x0F != (badworden
& 0x0F)) {
917 u8 reorg_offset
= tmp_pkt
.offset
;
918 u8 reorg_worden
= badworden
;
919 efuse_pg_packet_write(hw
, reorg_offset
,
922 *efuse_addr
= efuse_get_current_size(hw
);
924 *efuse_addr
= *efuse_addr
+
925 (tmp_word_cnts
* 2) + 1;
928 *efuse_addr
= *efuse_addr
+ (tmp_word_cnts
* 2) + 1;
931 *write_state
= PG_STATE_HEADER
;
933 if (*repeat_times
> EFUSE_REPEAT_THRESHOLD_
) {
938 RTPRINT(rtlpriv
, FEEPROM
, EFUSE_PG
,
939 "efuse PG_STATE_HEADER-2\n");
943 static int efuse_pg_packet_write(struct ieee80211_hw
*hw
,
944 u8 offset
, u8 word_en
, u8
*data
)
946 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
947 struct pgpkt_struct target_pkt
;
948 u8 write_state
= PG_STATE_HEADER
;
949 int continual
= true, dataempty
= true, result
= true;
952 u8 target_word_cnts
= 0;
954 static int repeat_times
;
956 if (efuse_get_current_size(hw
) >= (EFUSE_MAX_SIZE
-
957 rtlpriv
->cfg
->maps
[EFUSE_OOB_PROTECT_BYTES_LEN
])) {
958 RTPRINT(rtlpriv
, FEEPROM
, EFUSE_PG
,
959 "efuse_pg_packet_write error\n");
963 target_pkt
.offset
= offset
;
964 target_pkt
.word_en
= word_en
;
966 memset(target_pkt
.data
, 0xFF, 8 * sizeof(u8
));
968 efuse_word_enable_data_read(word_en
, data
, target_pkt
.data
);
969 target_word_cnts
= efuse_calculate_word_cnts(target_pkt
.word_en
);
971 RTPRINT(rtlpriv
, FEEPROM
, EFUSE_PG
, "efuse Power ON\n");
973 while (continual
&& (efuse_addr
< (EFUSE_MAX_SIZE
-
974 rtlpriv
->cfg
->maps
[EFUSE_OOB_PROTECT_BYTES_LEN
]))) {
976 if (write_state
== PG_STATE_HEADER
) {
979 RTPRINT(rtlpriv
, FEEPROM
, EFUSE_PG
,
980 "efuse PG_STATE_HEADER\n");
982 if (efuse_one_byte_read(hw
, efuse_addr
, &efuse_data
) &&
983 (efuse_data
!= 0xFF))
984 efuse_write_data_case1(hw
, &efuse_addr
,
989 &repeat_times
, &result
,
992 efuse_write_data_case2(hw
, &efuse_addr
,
999 } else if (write_state
== PG_STATE_DATA
) {
1000 RTPRINT(rtlpriv
, FEEPROM
, EFUSE_PG
,
1001 "efuse PG_STATE_DATA\n");
1004 enable_efuse_data_write(hw
, efuse_addr
+ 1,
1008 if ((badworden
& 0x0F) == 0x0F) {
1012 efuse_addr
+ (2 * target_word_cnts
) + 1;
1014 target_pkt
.offset
= offset
;
1015 target_pkt
.word_en
= badworden
;
1017 efuse_calculate_word_cnts(target_pkt
.
1019 write_state
= PG_STATE_HEADER
;
1021 if (repeat_times
> EFUSE_REPEAT_THRESHOLD_
) {
1025 RTPRINT(rtlpriv
, FEEPROM
, EFUSE_PG
,
1026 "efuse PG_STATE_HEADER-3\n");
1031 if (efuse_addr
>= (EFUSE_MAX_SIZE
-
1032 rtlpriv
->cfg
->maps
[EFUSE_OOB_PROTECT_BYTES_LEN
])) {
1033 RT_TRACE(rtlpriv
, COMP_EFUSE
, DBG_LOUD
,
1034 "efuse_addr(%#x) Out of size!!\n", efuse_addr
);
1040 static void efuse_word_enable_data_read(u8 word_en
, u8
*sourdata
,
1043 if (!(word_en
& BIT(0))) {
1044 targetdata
[0] = sourdata
[0];
1045 targetdata
[1] = sourdata
[1];
1048 if (!(word_en
& BIT(1))) {
1049 targetdata
[2] = sourdata
[2];
1050 targetdata
[3] = sourdata
[3];
1053 if (!(word_en
& BIT(2))) {
1054 targetdata
[4] = sourdata
[4];
1055 targetdata
[5] = sourdata
[5];
1058 if (!(word_en
& BIT(3))) {
1059 targetdata
[6] = sourdata
[6];
1060 targetdata
[7] = sourdata
[7];
1064 static u8
enable_efuse_data_write(struct ieee80211_hw
*hw
,
1065 u16 efuse_addr
, u8 word_en
, u8
*data
)
1067 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1069 u16 start_addr
= efuse_addr
;
1070 u8 badworden
= 0x0F;
1073 memset(tmpdata
, 0xff, PGPKT_DATA_SIZE
);
1074 RT_TRACE(rtlpriv
, COMP_EFUSE
, DBG_LOUD
,
1075 "word_en = %x efuse_addr=%x\n", word_en
, efuse_addr
);
1077 if (!(word_en
& BIT(0))) {
1078 tmpaddr
= start_addr
;
1079 efuse_one_byte_write(hw
, start_addr
++, data
[0]);
1080 efuse_one_byte_write(hw
, start_addr
++, data
[1]);
1082 efuse_one_byte_read(hw
, tmpaddr
, &tmpdata
[0]);
1083 efuse_one_byte_read(hw
, tmpaddr
+ 1, &tmpdata
[1]);
1084 if ((data
[0] != tmpdata
[0]) || (data
[1] != tmpdata
[1]))
1085 badworden
&= (~BIT(0));
1088 if (!(word_en
& BIT(1))) {
1089 tmpaddr
= start_addr
;
1090 efuse_one_byte_write(hw
, start_addr
++, data
[2]);
1091 efuse_one_byte_write(hw
, start_addr
++, data
[3]);
1093 efuse_one_byte_read(hw
, tmpaddr
, &tmpdata
[2]);
1094 efuse_one_byte_read(hw
, tmpaddr
+ 1, &tmpdata
[3]);
1095 if ((data
[2] != tmpdata
[2]) || (data
[3] != tmpdata
[3]))
1096 badworden
&= (~BIT(1));
1099 if (!(word_en
& BIT(2))) {
1100 tmpaddr
= start_addr
;
1101 efuse_one_byte_write(hw
, start_addr
++, data
[4]);
1102 efuse_one_byte_write(hw
, start_addr
++, data
[5]);
1104 efuse_one_byte_read(hw
, tmpaddr
, &tmpdata
[4]);
1105 efuse_one_byte_read(hw
, tmpaddr
+ 1, &tmpdata
[5]);
1106 if ((data
[4] != tmpdata
[4]) || (data
[5] != tmpdata
[5]))
1107 badworden
&= (~BIT(2));
1110 if (!(word_en
& BIT(3))) {
1111 tmpaddr
= start_addr
;
1112 efuse_one_byte_write(hw
, start_addr
++, data
[6]);
1113 efuse_one_byte_write(hw
, start_addr
++, data
[7]);
1115 efuse_one_byte_read(hw
, tmpaddr
, &tmpdata
[6]);
1116 efuse_one_byte_read(hw
, tmpaddr
+ 1, &tmpdata
[7]);
1117 if ((data
[6] != tmpdata
[6]) || (data
[7] != tmpdata
[7]))
1118 badworden
&= (~BIT(3));
1124 static void efuse_power_switch(struct ieee80211_hw
*hw
, u8 write
, u8 pwrstate
)
1126 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1127 struct rtl_hal
*rtlhal
= rtl_hal(rtl_priv(hw
));
1131 if (pwrstate
&& (rtlhal
->hw_type
!= HARDWARE_TYPE_RTL8192SE
)) {
1133 if (rtlhal
->hw_type
!= HARDWARE_TYPE_RTL8192CE
&&
1134 rtlhal
->hw_type
!= HARDWARE_TYPE_RTL8192DE
) {
1135 rtl_write_byte(rtlpriv
,
1136 rtlpriv
->cfg
->maps
[EFUSE_ACCESS
], 0x69);
1139 rtl_read_word(rtlpriv
,
1140 rtlpriv
->cfg
->maps
[SYS_ISO_CTRL
]);
1141 if (!(tmpV16
& rtlpriv
->cfg
->maps
[EFUSE_PWC_EV12V
])) {
1142 tmpV16
|= rtlpriv
->cfg
->maps
[EFUSE_PWC_EV12V
];
1143 rtl_write_word(rtlpriv
,
1144 rtlpriv
->cfg
->maps
[SYS_ISO_CTRL
],
1148 tmpV16
= rtl_read_word(rtlpriv
,
1149 rtlpriv
->cfg
->maps
[SYS_FUNC_EN
]);
1150 if (!(tmpV16
& rtlpriv
->cfg
->maps
[EFUSE_FEN_ELDR
])) {
1151 tmpV16
|= rtlpriv
->cfg
->maps
[EFUSE_FEN_ELDR
];
1152 rtl_write_word(rtlpriv
,
1153 rtlpriv
->cfg
->maps
[SYS_FUNC_EN
], tmpV16
);
1156 tmpV16
= rtl_read_word(rtlpriv
, rtlpriv
->cfg
->maps
[SYS_CLK
]);
1157 if ((!(tmpV16
& rtlpriv
->cfg
->maps
[EFUSE_LOADER_CLK_EN
])) ||
1158 (!(tmpV16
& rtlpriv
->cfg
->maps
[EFUSE_ANA8M
]))) {
1159 tmpV16
|= (rtlpriv
->cfg
->maps
[EFUSE_LOADER_CLK_EN
] |
1160 rtlpriv
->cfg
->maps
[EFUSE_ANA8M
]);
1161 rtl_write_word(rtlpriv
,
1162 rtlpriv
->cfg
->maps
[SYS_CLK
], tmpV16
);
1168 tempval
= rtl_read_byte(rtlpriv
,
1169 rtlpriv
->cfg
->maps
[EFUSE_TEST
] +
1172 if (rtlhal
->hw_type
== HARDWARE_TYPE_RTL8812AE
) {
1173 tempval
&= ~(BIT(3) | BIT(4) | BIT(5) | BIT(6));
1174 tempval
|= (VOLTAGE_V25
<< 3);
1175 } else if (rtlhal
->hw_type
!= HARDWARE_TYPE_RTL8192SE
) {
1177 tempval
|= (VOLTAGE_V25
<< 4);
1180 rtl_write_byte(rtlpriv
,
1181 rtlpriv
->cfg
->maps
[EFUSE_TEST
] + 3,
1185 if (rtlhal
->hw_type
== HARDWARE_TYPE_RTL8192SE
) {
1186 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CLK
],
1190 if (rtlhal
->hw_type
!= HARDWARE_TYPE_RTL8192CE
&&
1191 rtlhal
->hw_type
!= HARDWARE_TYPE_RTL8192DE
)
1192 rtl_write_byte(rtlpriv
,
1193 rtlpriv
->cfg
->maps
[EFUSE_ACCESS
], 0);
1196 tempval
= rtl_read_byte(rtlpriv
,
1197 rtlpriv
->cfg
->maps
[EFUSE_TEST
] +
1199 rtl_write_byte(rtlpriv
,
1200 rtlpriv
->cfg
->maps
[EFUSE_TEST
] + 3,
1204 if (rtlhal
->hw_type
== HARDWARE_TYPE_RTL8192SE
) {
1205 rtl_write_byte(rtlpriv
, rtlpriv
->cfg
->maps
[EFUSE_CLK
],
1211 static u16
efuse_get_current_size(struct ieee80211_hw
*hw
)
1213 int continual
= true;
1215 u8 hoffset
, hworden
;
1216 u8 efuse_data
, word_cnts
;
1218 while (continual
&& efuse_one_byte_read(hw
, efuse_addr
, &efuse_data
) &&
1219 (efuse_addr
< EFUSE_MAX_SIZE
)) {
1220 if (efuse_data
!= 0xFF) {
1221 hoffset
= (efuse_data
>> 4) & 0x0F;
1222 hworden
= efuse_data
& 0x0F;
1223 word_cnts
= efuse_calculate_word_cnts(hworden
);
1224 efuse_addr
= efuse_addr
+ (word_cnts
* 2) + 1;
1233 static u8
efuse_calculate_word_cnts(u8 word_en
)
1236 if (!(word_en
& BIT(0)))
1238 if (!(word_en
& BIT(1)))
1240 if (!(word_en
& BIT(2)))
1242 if (!(word_en
& BIT(3)))
1247 int rtl_get_hwinfo(struct ieee80211_hw
*hw
, struct rtl_priv
*rtlpriv
,
1248 int max_size
, u8
*hwinfo
, int *params
)
1250 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
1251 struct rtl_pci_priv
*rtlpcipriv
= rtl_pcipriv(hw
);
1252 struct device
*dev
= &rtlpcipriv
->dev
.pdev
->dev
;
1256 switch (rtlefuse
->epromtype
) {
1257 case EEPROM_BOOT_EFUSE
:
1258 rtl_efuse_shadow_map_update(hw
);
1262 RT_TRACE(rtlpriv
, COMP_ERR
, DBG_EMERG
,
1263 "RTL8XXX did not boot from eeprom, check it !!\n");
1267 dev_warn(dev
, "no efuse data\n");
1271 memcpy(hwinfo
, &rtlefuse
->efuse_map
[EFUSE_INIT_MAP
][0], max_size
);
1273 RT_PRINT_DATA(rtlpriv
, COMP_INIT
, DBG_DMESG
, "MAP",
1276 eeprom_id
= *((u16
*)&hwinfo
[0]);
1277 if (eeprom_id
!= params
[0]) {
1278 RT_TRACE(rtlpriv
, COMP_ERR
, DBG_WARNING
,
1279 "EEPROM ID(%#x) is invalid!!\n", eeprom_id
);
1280 rtlefuse
->autoload_failflag
= true;
1282 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_LOUD
, "Autoload OK\n");
1283 rtlefuse
->autoload_failflag
= false;
1286 if (rtlefuse
->autoload_failflag
)
1289 rtlefuse
->eeprom_vid
= *(u16
*)&hwinfo
[params
[1]];
1290 rtlefuse
->eeprom_did
= *(u16
*)&hwinfo
[params
[2]];
1291 rtlefuse
->eeprom_svid
= *(u16
*)&hwinfo
[params
[3]];
1292 rtlefuse
->eeprom_smid
= *(u16
*)&hwinfo
[params
[4]];
1293 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_LOUD
,
1294 "EEPROMId = 0x%4x\n", eeprom_id
);
1295 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_LOUD
,
1296 "EEPROM VID = 0x%4x\n", rtlefuse
->eeprom_vid
);
1297 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_LOUD
,
1298 "EEPROM DID = 0x%4x\n", rtlefuse
->eeprom_did
);
1299 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_LOUD
,
1300 "EEPROM SVID = 0x%4x\n", rtlefuse
->eeprom_svid
);
1301 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_LOUD
,
1302 "EEPROM SMID = 0x%4x\n", rtlefuse
->eeprom_smid
);
1304 for (i
= 0; i
< 6; i
+= 2) {
1305 usvalue
= *(u16
*)&hwinfo
[params
[5] + i
];
1306 *((u16
*)(&rtlefuse
->dev_addr
[i
])) = usvalue
;
1308 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "%pM\n", rtlefuse
->dev_addr
);
1310 rtlefuse
->eeprom_channelplan
= *&hwinfo
[params
[6]];
1311 rtlefuse
->eeprom_version
= *(u16
*)&hwinfo
[params
[7]];
1312 rtlefuse
->txpwr_fromeprom
= true;
1313 rtlefuse
->eeprom_oemid
= *&hwinfo
[params
[8]];
1315 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_LOUD
,
1316 "EEPROM Customer ID: 0x%2x\n", rtlefuse
->eeprom_oemid
);
1318 /* set channel plan to world wide 13 */
1319 rtlefuse
->channel_plan
= params
[9];
1323 EXPORT_SYMBOL_GPL(rtl_get_hwinfo
);