projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge remote-tracking branches 'asoc/topic/pxa', 'asoc/topic/qcom', 'asoc/topic/rcar...
[deliverable/linux.git] / drivers / net / wireless / realtek / rtlwifi / rtl8192ee / fw.c
1 /******************************************************************************
2 *
3 * Copyright(c) 2009-2014 Realtek Corporation.
4 *
5 * This 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.
8 *
9 * This 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
12 * more details.
13 *
14 * The full GNU General Public License is included in this distribution in the
15 * file called LICENSE.
16 *
17 * Contact Information:
18 * wlanfae <wlanfae@realtek.com>
19 * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
20 * Hsinchu 300, Taiwan.
21 *
22 * Larry Finger <Larry.Finger@lwfinger.net>
23 *
24 *****************************************************************************/
25
26 #include "../wifi.h"
27 #include "../pci.h"
28 #include "../base.h"
29 #include "../core.h"
30 #include "reg.h"
31 #include "def.h"
32 #include "fw.h"
33 #include "dm.h"
34
35 static void _rtl92ee_enable_fw_download(struct ieee80211_hw *hw, bool enable)
36 {
37 struct rtl_priv *rtlpriv = rtl_priv(hw);
38 u8 tmp;
39
40 if (enable) {
41 rtl_write_byte(rtlpriv, REG_MCUFWDL, 0x05);
42
43 tmp = rtl_read_byte(rtlpriv, REG_MCUFWDL + 2);
44 rtl_write_byte(rtlpriv, REG_MCUFWDL + 2, tmp & 0xf7);
45 } else {
46 tmp = rtl_read_byte(rtlpriv, REG_MCUFWDL);
47 rtl_write_byte(rtlpriv, REG_MCUFWDL, tmp & 0xfe);
48 }
49 }
50
51 static void _rtl92ee_fw_block_write(struct ieee80211_hw *hw,
52 const u8 *buffer, u32 size)
53 {
54 struct rtl_priv *rtlpriv = rtl_priv(hw);
55 u32 blocksize = sizeof(u32);
56 u8 *bufferptr = (u8 *)buffer;
57 u32 *pu4byteptr = (u32 *)buffer;
58 u32 i, offset, blockcount, remainsize;
59
60 blockcount = size / blocksize;
61 remainsize = size % blocksize;
62
63 for (i = 0; i < blockcount; i++) {
64 offset = i * blocksize;
65 rtl_write_dword(rtlpriv, (FW_8192C_START_ADDRESS + offset),
66 *(pu4byteptr + i));
67 }
68
69 if (remainsize) {
70 offset = blockcount * blocksize;
71 bufferptr += offset;
72 for (i = 0; i < remainsize; i++) {
73 rtl_write_byte(rtlpriv,
74 (FW_8192C_START_ADDRESS + offset + i),
75 *(bufferptr + i));
76 }
77 }
78 }
79
80 static void _rtl92ee_fw_page_write(struct ieee80211_hw *hw, u32 page,
81 const u8 *buffer, u32 size)
82 {
83 struct rtl_priv *rtlpriv = rtl_priv(hw);
84 u8 value8;
85 u8 u8page = (u8)(page & 0x07);
86
87 value8 = (rtl_read_byte(rtlpriv, REG_MCUFWDL + 2) & 0xF8) | u8page;
88 rtl_write_byte(rtlpriv, (REG_MCUFWDL + 2), value8);
89
90 _rtl92ee_fw_block_write(hw, buffer, size);
91 }
92
93 static void _rtl92ee_fill_dummy(u8 *pfwbuf, u32 *pfwlen)
94 {
95 u32 fwlen = *pfwlen;
96 u8 remain = (u8)(fwlen % 4);
97
98 remain = (remain == 0) ? 0 : (4 - remain);
99
100 while (remain > 0) {
101 pfwbuf[fwlen] = 0;
102 fwlen++;
103 remain--;
104 }
105
106 *pfwlen = fwlen;
107 }
108
109 static void _rtl92ee_write_fw(struct ieee80211_hw *hw,
110 enum version_8192e version,
111 u8 *buffer, u32 size)
112 {
113 struct rtl_priv *rtlpriv = rtl_priv(hw);
114 u8 *bufferptr = (u8 *)buffer;
115 u32 pagenums, remainsize;
116 u32 page, offset;
117
118 RT_TRACE(rtlpriv, COMP_FW, DBG_LOUD , "FW size is %d bytes,\n", size);
119
120 _rtl92ee_fill_dummy(bufferptr, &size);
121
122 pagenums = size / FW_8192C_PAGE_SIZE;
123 remainsize = size % FW_8192C_PAGE_SIZE;
124
125 if (pagenums > 8) {
126 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
127 "Page numbers should not greater then 8\n");
128 }
129
130 for (page = 0; page < pagenums; page++) {
131 offset = page * FW_8192C_PAGE_SIZE;
132 _rtl92ee_fw_page_write(hw, page, (bufferptr + offset),
133 FW_8192C_PAGE_SIZE);
134 udelay(2);
135 }
136
137 if (remainsize) {
138 offset = pagenums * FW_8192C_PAGE_SIZE;
139 page = pagenums;
140 _rtl92ee_fw_page_write(hw, page, (bufferptr + offset),
141 remainsize);
142 }
143 }
144
145 static int _rtl92ee_fw_free_to_go(struct ieee80211_hw *hw)
146 {
147 struct rtl_priv *rtlpriv = rtl_priv(hw);
148 int err = -EIO;
149 u32 counter = 0;
150 u32 value32;
151
152 do {
153 value32 = rtl_read_dword(rtlpriv, REG_MCUFWDL);
154 } while ((counter++ < FW_8192C_POLLING_TIMEOUT_COUNT) &&
155 (!(value32 & FWDL_CHKSUM_RPT)));
156
157 if (counter >= FW_8192C_POLLING_TIMEOUT_COUNT) {
158 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
159 "chksum report faill ! REG_MCUFWDL:0x%08x .\n",
160 value32);
161 goto exit;
162 }
163
164 RT_TRACE(rtlpriv, COMP_FW, DBG_TRACE,
165 "Checksum report OK ! REG_MCUFWDL:0x%08x .\n", value32);
166
167 value32 = rtl_read_dword(rtlpriv, REG_MCUFWDL);
168 value32 |= MCUFWDL_RDY;
169 value32 &= ~WINTINI_RDY;
170 rtl_write_dword(rtlpriv, REG_MCUFWDL, value32);
171
172 rtl92ee_firmware_selfreset(hw);
173 counter = 0;
174
175 do {
176 value32 = rtl_read_dword(rtlpriv, REG_MCUFWDL);
177 if (value32 & WINTINI_RDY) {
178 RT_TRACE(rtlpriv, COMP_FW, DBG_LOUD ,
179 "Polling FW ready success!! REG_MCUFWDL:0x%08x. count = %d\n",
180 value32, counter);
181 err = 0;
182 goto exit;
183 }
184
185 udelay(FW_8192C_POLLING_DELAY*10);
186
187 } while (counter++ < FW_8192C_POLLING_TIMEOUT_COUNT);
188
189 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
190 "Polling FW ready fail!! REG_MCUFWDL:0x%08x. count = %d\n",
191 value32, counter);
192
193 exit:
194 return err;
195 }
196
197 int rtl92ee_download_fw(struct ieee80211_hw *hw, bool buse_wake_on_wlan_fw)
198 {
199 struct rtl_priv *rtlpriv = rtl_priv(hw);
200 struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
201 struct rtlwifi_firmware_header *pfwheader;
202 u8 *pfwdata;
203 u32 fwsize;
204 int err;
205 enum version_8192e version = rtlhal->version;
206
207 if (!rtlhal->pfirmware)
208 return 1;
209
210 pfwheader = (struct rtlwifi_firmware_header *)rtlhal->pfirmware;
211 rtlhal->fw_version = le16_to_cpu(pfwheader->version);
212 rtlhal->fw_subversion = pfwheader->subversion;
213 pfwdata = (u8 *)rtlhal->pfirmware;
214 fwsize = rtlhal->fwsize;
215 RT_TRACE(rtlpriv, COMP_FW, DBG_DMESG,
216 "normal Firmware SIZE %d\n" , fwsize);
217
218 if (IS_FW_HEADER_EXIST(pfwheader)) {
219 RT_TRACE(rtlpriv, COMP_FW, DBG_DMESG,
220 "Firmware Version(%d), Signature(%#x),Size(%d)\n",
221 pfwheader->version, pfwheader->signature,
222 (int)sizeof(struct rtlwifi_firmware_header));
223
224 pfwdata = pfwdata + sizeof(struct rtlwifi_firmware_header);
225 fwsize = fwsize - sizeof(struct rtlwifi_firmware_header);
226 } else {
227 RT_TRACE(rtlpriv, COMP_FW, DBG_DMESG,
228 "Firmware no Header, Signature(%#x)\n",
229 pfwheader->signature);
230 }
231
232 if (rtlhal->mac_func_enable) {
233 if (rtl_read_byte(rtlpriv, REG_MCUFWDL) & BIT(7)) {
234 rtl_write_byte(rtlpriv, REG_MCUFWDL, 0);
235 rtl92ee_firmware_selfreset(hw);
236 }
237 }
238 _rtl92ee_enable_fw_download(hw, true);
239 _rtl92ee_write_fw(hw, version, pfwdata, fwsize);
240 _rtl92ee_enable_fw_download(hw, false);
241
242 err = _rtl92ee_fw_free_to_go(hw);
243 if (err) {
244 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
245 "Firmware is not ready to run!\n");
246 } else {
247 RT_TRACE(rtlpriv, COMP_FW, DBG_LOUD ,
248 "Firmware is ready to run!\n");
249 }
250
251 return 0;
252 }
253
254 static bool _rtl92ee_check_fw_read_last_h2c(struct ieee80211_hw *hw, u8 boxnum)
255 {
256 struct rtl_priv *rtlpriv = rtl_priv(hw);
257 u8 val_hmetfr;
258 bool result = false;
259
260 val_hmetfr = rtl_read_byte(rtlpriv, REG_HMETFR);
261 if (((val_hmetfr >> boxnum) & BIT(0)) == 0)
262 result = true;
263 return result;
264 }
265
266 static void _rtl92ee_fill_h2c_command(struct ieee80211_hw *hw, u8 element_id,
267 u32 cmd_len, u8 *cmdbuffer)
268 {
269 struct rtl_priv *rtlpriv = rtl_priv(hw);
270 struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
271 struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
272 u8 boxnum;
273 u16 box_reg = 0, box_extreg = 0;
274 u8 u1b_tmp;
275 bool isfw_read = false;
276 u8 buf_index = 0;
277 bool bwrite_sucess = false;
278 u8 wait_h2c_limmit = 100;
279 u8 boxcontent[4], boxextcontent[4];
280 u32 h2c_waitcounter = 0;
281 unsigned long flag;
282 u8 idx;
283
284 if (ppsc->dot11_psmode != EACTIVE ||
285 ppsc->inactive_pwrstate == ERFOFF) {
286 RT_TRACE(rtlpriv, COMP_CMD, DBG_LOUD ,
287 "FillH2CCommand8192E(): Return because RF is off!!!\n");
288 return;
289 }
290
291 RT_TRACE(rtlpriv, COMP_CMD, DBG_LOUD , "come in\n");
292
293 /* 1. Prevent race condition in setting H2C cmd.
294 * (copy from MgntActSet_RF_State().)
295 */
296 while (true) {
297 spin_lock_irqsave(&rtlpriv->locks.h2c_lock, flag);
298 if (rtlhal->h2c_setinprogress) {
299 RT_TRACE(rtlpriv, COMP_CMD, DBG_LOUD ,
300 "H2C set in progress! Wait to set..element_id(%d).\n",
301 element_id);
302
303 while (rtlhal->h2c_setinprogress) {
304 spin_unlock_irqrestore(&rtlpriv->locks.h2c_lock,
305 flag);
306 h2c_waitcounter++;
307 RT_TRACE(rtlpriv, COMP_CMD, DBG_LOUD ,
308 "Wait 100 us (%d times)...\n",
309 h2c_waitcounter);
310 udelay(100);
311
312 if (h2c_waitcounter > 1000)
313 return;
314 spin_lock_irqsave(&rtlpriv->locks.h2c_lock,
315 flag);
316 }
317 spin_unlock_irqrestore(&rtlpriv->locks.h2c_lock, flag);
318 } else {
319 rtlhal->h2c_setinprogress = true;
320 spin_unlock_irqrestore(&rtlpriv->locks.h2c_lock, flag);
321 break;
322 }
323 }
324
325 while (!bwrite_sucess) {
326 /* 2. Find the last BOX number which has been writen. */
327 boxnum = rtlhal->last_hmeboxnum;
328 switch (boxnum) {
329 case 0:
330 box_reg = REG_HMEBOX_0;
331 box_extreg = REG_HMEBOX_EXT_0;
332 break;
333 case 1:
334 box_reg = REG_HMEBOX_1;
335 box_extreg = REG_HMEBOX_EXT_1;
336 break;
337 case 2:
338 box_reg = REG_HMEBOX_2;
339 box_extreg = REG_HMEBOX_EXT_2;
340 break;
341 case 3:
342 box_reg = REG_HMEBOX_3;
343 box_extreg = REG_HMEBOX_EXT_3;
344 break;
345 default:
346 RT_TRACE(rtlpriv, COMP_ERR, DBG_LOUD,
347 "switch case not process\n");
348 break;
349 }
350
351 /* 3. Check if the box content is empty. */
352 isfw_read = false;
353 u1b_tmp = rtl_read_byte(rtlpriv, REG_CR);
354
355 if (u1b_tmp != 0xea) {
356 isfw_read = true;
357 } else {
358 if (rtl_read_byte(rtlpriv, REG_TXDMA_STATUS) == 0xea ||
359 rtl_read_byte(rtlpriv, REG_TXPKT_EMPTY) == 0xea)
360 rtl_write_byte(rtlpriv, REG_SYS_CFG1 + 3, 0xff);
361 }
362
363 if (isfw_read) {
364 wait_h2c_limmit = 100;
365 isfw_read = _rtl92ee_check_fw_read_last_h2c(hw, boxnum);
366 while (!isfw_read) {
367 wait_h2c_limmit--;
368 if (wait_h2c_limmit == 0) {
369 RT_TRACE(rtlpriv, COMP_CMD, DBG_LOUD ,
370 "Waiting too long for FW read clear HMEBox(%d)!!!\n",
371 boxnum);
372 break;
373 }
374 udelay(10);
375 isfw_read =
376 _rtl92ee_check_fw_read_last_h2c(hw, boxnum);
377 u1b_tmp = rtl_read_byte(rtlpriv, 0x130);
378 RT_TRACE(rtlpriv, COMP_CMD, DBG_LOUD ,
379 "Waiting for FW read clear HMEBox(%d)!!! 0x130 = %2x\n",
380 boxnum, u1b_tmp);
381 }
382 }
383
384 /* If Fw has not read the last
385 * H2C cmd, break and give up this H2C.
386 */
387 if (!isfw_read) {
388 RT_TRACE(rtlpriv, COMP_CMD, DBG_LOUD ,
389 "Write H2C reg BOX[%d] fail,Fw don't read.\n",
390 boxnum);
391 break;
392 }
393 /* 4. Fill the H2C cmd into box */
394 memset(boxcontent, 0, sizeof(boxcontent));
395 memset(boxextcontent, 0, sizeof(boxextcontent));
396 boxcontent[0] = element_id;
397 RT_TRACE(rtlpriv, COMP_CMD, DBG_LOUD ,
398 "Write element_id box_reg(%4x) = %2x\n",
399 box_reg, element_id);
400
401 switch (cmd_len) {
402 case 1:
403 case 2:
404 case 3:
405 /*boxcontent[0] &= ~(BIT(7));*/
406 memcpy((u8 *)(boxcontent) + 1,
407 cmdbuffer + buf_index, cmd_len);
408
409 for (idx = 0; idx < 4; idx++) {
410 rtl_write_byte(rtlpriv, box_reg + idx,
411 boxcontent[idx]);
412 }
413 break;
414 case 4:
415 case 5:
416 case 6:
417 case 7:
418 /*boxcontent[0] |= (BIT(7));*/
419 memcpy((u8 *)(boxextcontent),
420 cmdbuffer + buf_index+3, cmd_len-3);
421 memcpy((u8 *)(boxcontent) + 1,
422 cmdbuffer + buf_index, 3);
423
424 for (idx = 0; idx < 4; idx++) {
425 rtl_write_byte(rtlpriv, box_extreg + idx,
426 boxextcontent[idx]);
427 }
428
429 for (idx = 0; idx < 4; idx++) {
430 rtl_write_byte(rtlpriv, box_reg + idx,
431 boxcontent[idx]);
432 }
433 break;
434 default:
435 RT_TRACE(rtlpriv, COMP_ERR, DBG_LOUD,
436 "switch case not process\n");
437 break;
438 }
439
440 bwrite_sucess = true;
441
442 rtlhal->last_hmeboxnum = boxnum + 1;
443 if (rtlhal->last_hmeboxnum == 4)
444 rtlhal->last_hmeboxnum = 0;
445
446 RT_TRACE(rtlpriv, COMP_CMD, DBG_LOUD ,
447 "pHalData->last_hmeboxnum = %d\n",
448 rtlhal->last_hmeboxnum);
449 }
450
451 spin_lock_irqsave(&rtlpriv->locks.h2c_lock, flag);
452 rtlhal->h2c_setinprogress = false;
453 spin_unlock_irqrestore(&rtlpriv->locks.h2c_lock, flag);
454
455 RT_TRACE(rtlpriv, COMP_CMD, DBG_LOUD , "go out\n");
456 }
457
458 void rtl92ee_fill_h2c_cmd(struct ieee80211_hw *hw,
459 u8 element_id, u32 cmd_len, u8 *cmdbuffer)
460 {
461 struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
462 u32 tmp_cmdbuf[2];
463
464 if (!rtlhal->fw_ready) {
465 RT_ASSERT(false,
466 "return H2C cmd because of Fw download fail!!!\n");
467 return;
468 }
469
470 memset(tmp_cmdbuf, 0, 8);
471 memcpy(tmp_cmdbuf, cmdbuffer, cmd_len);
472 _rtl92ee_fill_h2c_command(hw, element_id, cmd_len, (u8 *)&tmp_cmdbuf);
473 }
474
475 void rtl92ee_firmware_selfreset(struct ieee80211_hw *hw)
476 {
477 u8 u1b_tmp;
478 struct rtl_priv *rtlpriv = rtl_priv(hw);
479
480 u1b_tmp = rtl_read_byte(rtlpriv, REG_RSV_CTRL + 1);
481 rtl_write_byte(rtlpriv, REG_RSV_CTRL + 1, (u1b_tmp & (~BIT(0))));
482
483 u1b_tmp = rtl_read_byte(rtlpriv, REG_SYS_FUNC_EN + 1);
484 rtl_write_byte(rtlpriv, REG_SYS_FUNC_EN + 1, (u1b_tmp & (~BIT(2))));
485
486 udelay(50);
487
488 u1b_tmp = rtl_read_byte(rtlpriv, REG_RSV_CTRL + 1);
489 rtl_write_byte(rtlpriv, REG_RSV_CTRL + 1, (u1b_tmp | BIT(0)));
490
491 u1b_tmp = rtl_read_byte(rtlpriv, REG_SYS_FUNC_EN + 1);
492 rtl_write_byte(rtlpriv, REG_SYS_FUNC_EN + 1, (u1b_tmp | BIT(2)));
493
494 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD ,
495 " _8051Reset92E(): 8051 reset success .\n");
496 }
497
498 void rtl92ee_set_fw_pwrmode_cmd(struct ieee80211_hw *hw, u8 mode)
499 {
500 struct rtl_priv *rtlpriv = rtl_priv(hw);
501 u8 u1_h2c_set_pwrmode[H2C_92E_PWEMODE_LENGTH] = { 0 };
502 struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
503 u8 rlbm , power_state = 0;
504
505 RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD , "FW LPS mode = %d\n", mode);
506
507 SET_H2CCMD_PWRMODE_PARM_MODE(u1_h2c_set_pwrmode, ((mode) ? 1 : 0));
508 rlbm = 0;/*YJ,temp,120316. FW now not support RLBM=2.*/
509 SET_H2CCMD_PWRMODE_PARM_RLBM(u1_h2c_set_pwrmode, rlbm);
510 SET_H2CCMD_PWRMODE_PARM_SMART_PS(u1_h2c_set_pwrmode,
511 (rtlpriv->mac80211.p2p) ?
512 ppsc->smart_ps : 1);
513 SET_H2CCMD_PWRMODE_PARM_AWAKE_INTERVAL(u1_h2c_set_pwrmode,
514 ppsc->reg_max_lps_awakeintvl);
515 SET_H2CCMD_PWRMODE_PARM_ALL_QUEUE_UAPSD(u1_h2c_set_pwrmode, 0);
516 if (mode == FW_PS_ACTIVE_MODE)
517 power_state |= FW_PWR_STATE_ACTIVE;
518 else
519 power_state |= FW_PWR_STATE_RF_OFF;
520 SET_H2CCMD_PWRMODE_PARM_PWR_STATE(u1_h2c_set_pwrmode, power_state);
521
522 RT_PRINT_DATA(rtlpriv, COMP_CMD, DBG_DMESG,
523 "rtl92c_set_fw_pwrmode(): u1_h2c_set_pwrmode\n",
524 u1_h2c_set_pwrmode, H2C_92E_PWEMODE_LENGTH);
525 rtl92ee_fill_h2c_cmd(hw, H2C_92E_SETPWRMODE, H2C_92E_PWEMODE_LENGTH,
526 u1_h2c_set_pwrmode);
527 }
528
529 void rtl92ee_set_fw_media_status_rpt_cmd(struct ieee80211_hw *hw, u8 mstatus)
530 {
531 u8 parm[3] = { 0 , 0 , 0 };
532 /* parm[0]: bit0=0-->Disconnect, bit0=1-->Connect
533 * bit1=0-->update Media Status to MACID
534 * bit1=1-->update Media Status from MACID to MACID_End
535 * parm[1]: MACID, if this is INFRA_STA, MacID = 0
536 * parm[2]: MACID_End
537 */
538
539 SET_H2CCMD_MSRRPT_PARM_OPMODE(parm, mstatus);
540 SET_H2CCMD_MSRRPT_PARM_MACID_IND(parm, 0);
541
542 rtl92ee_fill_h2c_cmd(hw, H2C_92E_MSRRPT, 3, parm);
543 }
544
545 #define BEACON_PG 0 /* ->1 */
546 #define PSPOLL_PG 2
547 #define NULL_PG 3
548 #define PROBERSP_PG 4 /* ->5 */
549
550 #define TOTAL_RESERVED_PKT_LEN 768
551
552 static u8 reserved_page_packet[TOTAL_RESERVED_PKT_LEN] = {
553 /* page 0 beacon */
554 0x80, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
555 0xFF, 0xFF, 0x00, 0xE0, 0x4C, 0x02, 0xB1, 0x78,
556 0xEC, 0x1A, 0x59, 0x0B, 0xAD, 0xD4, 0x20, 0x00,
557 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
558 0x64, 0x00, 0x10, 0x04, 0x00, 0x05, 0x54, 0x65,
559 0x73, 0x74, 0x32, 0x01, 0x08, 0x82, 0x84, 0x0B,
560 0x16, 0x24, 0x30, 0x48, 0x6C, 0x03, 0x01, 0x06,
561 0x06, 0x02, 0x00, 0x00, 0x2A, 0x01, 0x02, 0x32,
562 0x04, 0x0C, 0x12, 0x18, 0x60, 0x2D, 0x1A, 0x6C,
563 0x09, 0x03, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00,
564 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
565 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
566 0x00, 0x3D, 0x00, 0xDD, 0x07, 0x00, 0xE0, 0x4C,
567 0x02, 0x02, 0x00, 0x00, 0xDD, 0x18, 0x00, 0x50,
568 0xF2, 0x01, 0x01, 0x00, 0x00, 0x50, 0xF2, 0x04,
569 0x01, 0x00, 0x00, 0x50, 0xF2, 0x04, 0x01, 0x00,
570
571 /* page 1 beacon */
572 0x00, 0x50, 0xF2, 0x02, 0x00, 0x00, 0x00, 0x00,
573 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
574 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
575 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
576 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
577 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
578 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
579 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
580 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
581 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
582 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
583 0x10, 0x00, 0x28, 0x8C, 0x00, 0x12, 0x00, 0x00,
584 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00,
585 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
586 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
587 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
588
589 /* page 2 ps-poll */
590 0xA4, 0x10, 0x01, 0xC0, 0xEC, 0x1A, 0x59, 0x0B,
591 0xAD, 0xD4, 0x00, 0xE0, 0x4C, 0x02, 0xB1, 0x78,
592 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
593 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
594 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
595 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
596 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
597 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
598 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
599 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
600 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
601 0x18, 0x00, 0x28, 0x8C, 0x00, 0x12, 0x00, 0x00,
602 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
603 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
604 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
605 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
606
607 /* page 3 null */
608 0x48, 0x01, 0x00, 0x00, 0xEC, 0x1A, 0x59, 0x0B,
609 0xAD, 0xD4, 0x00, 0xE0, 0x4C, 0x02, 0xB1, 0x78,
610 0xEC, 0x1A, 0x59, 0x0B, 0xAD, 0xD4, 0x00, 0x00,
611 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
612 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
613 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
614 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
615 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
616 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
617 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
618 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
619 0x72, 0x00, 0x28, 0x8C, 0x00, 0x12, 0x00, 0x00,
620 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
621 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
622 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
623 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
624
625 /* page 4 probe_resp */
626 0x50, 0x00, 0x00, 0x00, 0x00, 0x40, 0x10, 0x10,
627 0x00, 0x03, 0x00, 0xE0, 0x4C, 0x76, 0x00, 0x42,
628 0x00, 0x40, 0x10, 0x10, 0x00, 0x03, 0x00, 0x00,
629 0x9E, 0x46, 0x15, 0x32, 0x27, 0xF2, 0x2D, 0x00,
630 0x64, 0x00, 0x00, 0x04, 0x00, 0x0C, 0x6C, 0x69,
631 0x6E, 0x6B, 0x73, 0x79, 0x73, 0x5F, 0x77, 0x6C,
632 0x61, 0x6E, 0x01, 0x04, 0x82, 0x84, 0x8B, 0x96,
633 0x03, 0x01, 0x01, 0x06, 0x02, 0x00, 0x00, 0x2A,
634 0x01, 0x00, 0x32, 0x08, 0x24, 0x30, 0x48, 0x6C,
635 0x0C, 0x12, 0x18, 0x60, 0x2D, 0x1A, 0x6C, 0x18,
636 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
637 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
638 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
639 0x3D, 0x00, 0xDD, 0x06, 0x00, 0xE0, 0x4C, 0x02,
640 0x01, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
641 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
642
643 /* page 5 probe_resp */
644 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
645 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
646 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
647 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
648 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
649 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
650 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
651 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
652 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
653 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
654 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
655 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
656 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
657 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
658 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
659 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
660 };
661
662 void rtl92ee_set_fw_rsvdpagepkt(struct ieee80211_hw *hw, bool b_dl_finished)
663 {
664 struct rtl_priv *rtlpriv = rtl_priv(hw);
665 struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
666 struct sk_buff *skb = NULL;
667
668 u32 totalpacketlen;
669 u8 u1rsvdpageloc[5] = { 0 };
670 bool b_dlok = false;
671
672 u8 *beacon;
673 u8 *p_pspoll;
674 u8 *nullfunc;
675 u8 *p_probersp;
676 /*---------------------------------------------------------
677 * (1) beacon
678 *---------------------------------------------------------
679 */
680 beacon = &reserved_page_packet[BEACON_PG * 128];
681 SET_80211_HDR_ADDRESS2(beacon, mac->mac_addr);
682 SET_80211_HDR_ADDRESS3(beacon, mac->bssid);
683
684 /*-------------------------------------------------------
685 * (2) ps-poll
686 *--------------------------------------------------------
687 */
688 p_pspoll = &reserved_page_packet[PSPOLL_PG * 128];
689 SET_80211_PS_POLL_AID(p_pspoll, (mac->assoc_id | 0xc000));
690 SET_80211_PS_POLL_BSSID(p_pspoll, mac->bssid);
691 SET_80211_PS_POLL_TA(p_pspoll, mac->mac_addr);
692
693 SET_H2CCMD_RSVDPAGE_LOC_PSPOLL(u1rsvdpageloc, PSPOLL_PG);
694
695 /*--------------------------------------------------------
696 * (3) null data
697 *---------------------------------------------------------
698 */
699 nullfunc = &reserved_page_packet[NULL_PG * 128];
700 SET_80211_HDR_ADDRESS1(nullfunc, mac->bssid);
701 SET_80211_HDR_ADDRESS2(nullfunc, mac->mac_addr);
702 SET_80211_HDR_ADDRESS3(nullfunc, mac->bssid);
703
704 SET_H2CCMD_RSVDPAGE_LOC_NULL_DATA(u1rsvdpageloc, NULL_PG);
705
706 /*---------------------------------------------------------
707 * (4) probe response
708 *----------------------------------------------------------
709 */
710 p_probersp = &reserved_page_packet[PROBERSP_PG * 128];
711 SET_80211_HDR_ADDRESS1(p_probersp, mac->bssid);
712 SET_80211_HDR_ADDRESS2(p_probersp, mac->mac_addr);
713 SET_80211_HDR_ADDRESS3(p_probersp, mac->bssid);
714
715 SET_H2CCMD_RSVDPAGE_LOC_PROBE_RSP(u1rsvdpageloc, PROBERSP_PG);
716
717 totalpacketlen = TOTAL_RESERVED_PKT_LEN;
718
719 RT_PRINT_DATA(rtlpriv, COMP_CMD, DBG_LOUD ,
720 "rtl92ee_set_fw_rsvdpagepkt(): HW_VAR_SET_TX_CMD: ALL\n",
721 &reserved_page_packet[0], totalpacketlen);
722 RT_PRINT_DATA(rtlpriv, COMP_CMD, DBG_LOUD ,
723 "rtl92ee_set_fw_rsvdpagepkt(): HW_VAR_SET_TX_CMD: ALL\n",
724 u1rsvdpageloc, 3);
725
726 skb = dev_alloc_skb(totalpacketlen);
727 memcpy((u8 *)skb_put(skb, totalpacketlen),
728 &reserved_page_packet, totalpacketlen);
729
730 b_dlok = true;
731
732 if (b_dlok) {
733 RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD ,
734 "Set RSVD page location to Fw.\n");
735 RT_PRINT_DATA(rtlpriv, COMP_CMD, DBG_LOUD ,
736 "H2C_RSVDPAGE:\n", u1rsvdpageloc, 3);
737 rtl92ee_fill_h2c_cmd(hw, H2C_92E_RSVDPAGE,
738 sizeof(u1rsvdpageloc), u1rsvdpageloc);
739 } else {
740 RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
741 "Set RSVD page location to Fw FAIL!!!!!!.\n");
742 }
743 }
744
745 /*Shoud check FW support p2p or not.*/
746 static void rtl92ee_set_p2p_ctw_period_cmd(struct ieee80211_hw *hw, u8 ctwindow)
747 {
748 u8 u1_ctwindow_period[1] = {ctwindow};
749
750 rtl92ee_fill_h2c_cmd(hw, H2C_92E_P2P_PS_CTW_CMD, 1, u1_ctwindow_period);
751 }
752
753 void rtl92ee_set_p2p_ps_offload_cmd(struct ieee80211_hw *hw, u8 p2p_ps_state)
754 {
755 struct rtl_priv *rtlpriv = rtl_priv(hw);
756 struct rtl_ps_ctl *rtlps = rtl_psc(rtl_priv(hw));
757 struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
758 struct rtl_p2p_ps_info *p2pinfo = &rtlps->p2p_ps_info;
759 struct p2p_ps_offload_t *p2p_ps_offload = &rtlhal->p2p_ps_offload;
760 u8 i;
761 u16 ctwindow;
762 u32 start_time, tsf_low;
763
764 switch (p2p_ps_state) {
765 case P2P_PS_DISABLE:
766 RT_TRACE(rtlpriv, COMP_FW, DBG_LOUD , "P2P_PS_DISABLE\n");
767 memset(p2p_ps_offload, 0, sizeof(*p2p_ps_offload));
768 break;
769 case P2P_PS_ENABLE:
770 RT_TRACE(rtlpriv, COMP_FW, DBG_LOUD , "P2P_PS_ENABLE\n");
771 /* update CTWindow value. */
772 if (p2pinfo->ctwindow > 0) {
773 p2p_ps_offload->ctwindow_en = 1;
774 ctwindow = p2pinfo->ctwindow;
775 rtl92ee_set_p2p_ctw_period_cmd(hw, ctwindow);
776 }
777 /* hw only support 2 set of NoA */
778 for (i = 0 ; i < p2pinfo->noa_num ; i++) {
779 /* To control the register setting for which NOA*/
780 rtl_write_byte(rtlpriv, 0x5cf, (i << 4));
781 if (i == 0)
782 p2p_ps_offload->noa0_en = 1;
783 else
784 p2p_ps_offload->noa1_en = 1;
785 /* config P2P NoA Descriptor Register */
786 rtl_write_dword(rtlpriv, 0x5E0,
787 p2pinfo->noa_duration[i]);
788 rtl_write_dword(rtlpriv, 0x5E4,
789 p2pinfo->noa_interval[i]);
790
791 /*Get Current TSF value */
792 tsf_low = rtl_read_dword(rtlpriv, REG_TSFTR);
793
794 start_time = p2pinfo->noa_start_time[i];
795 if (p2pinfo->noa_count_type[i] != 1) {
796 while (start_time <= (tsf_low + (50 * 1024))) {
797 start_time += p2pinfo->noa_interval[i];
798 if (p2pinfo->noa_count_type[i] != 255)
799 p2pinfo->noa_count_type[i]--;
800 }
801 }
802 rtl_write_dword(rtlpriv, 0x5E8, start_time);
803 rtl_write_dword(rtlpriv, 0x5EC,
804 p2pinfo->noa_count_type[i]);
805 }
806 if ((p2pinfo->opp_ps == 1) || (p2pinfo->noa_num > 0)) {
807 /* rst p2p circuit */
808 rtl_write_byte(rtlpriv, REG_DUAL_TSF_RST, BIT(4));
809 p2p_ps_offload->offload_en = 1;
810
811 if (P2P_ROLE_GO == rtlpriv->mac80211.p2p) {
812 p2p_ps_offload->role = 1;
813 p2p_ps_offload->allstasleep = 0;
814 } else {
815 p2p_ps_offload->role = 0;
816 }
817 p2p_ps_offload->discovery = 0;
818 }
819 break;
820 case P2P_PS_SCAN:
821 RT_TRACE(rtlpriv, COMP_FW, DBG_LOUD , "P2P_PS_SCAN\n");
822 p2p_ps_offload->discovery = 1;
823 break;
824 case P2P_PS_SCAN_DONE:
825 RT_TRACE(rtlpriv, COMP_FW, DBG_LOUD , "P2P_PS_SCAN_DONE\n");
826 p2p_ps_offload->discovery = 0;
827 p2pinfo->p2p_ps_state = P2P_PS_ENABLE;
828 break;
829 default:
830 break;
831 }
832 rtl92ee_fill_h2c_cmd(hw, H2C_92E_P2P_PS_OFFLOAD, 1,
833 (u8 *)p2p_ps_offload);
834 }
835
836 static void _rtl92ee_c2h_ra_report_handler(struct ieee80211_hw *hw,
837 u8 *cmd_buf, u8 cmd_len)
838 {
839 u8 rate = cmd_buf[0] & 0x3F;
840 bool collision_state = cmd_buf[3] & BIT(0);
841
842 rtl92ee_dm_dynamic_arfb_select(hw, rate, collision_state);
843 }
844
845 static void _rtl92ee_c2h_content_parsing(struct ieee80211_hw *hw, u8 c2h_cmd_id,
846 u8 c2h_cmd_len, u8 *tmp_buf)
847 {
848 struct rtl_priv *rtlpriv = rtl_priv(hw);
849
850 switch (c2h_cmd_id) {
851 case C2H_8192E_DBG:
852 RT_TRACE(rtlpriv, COMP_FW, DBG_TRACE,
853 "[C2H], C2H_8723BE_DBG!!\n");
854 break;
855 case C2H_8192E_TXBF:
856 RT_TRACE(rtlpriv, COMP_FW, DBG_TRACE,
857 "[C2H], C2H_8192E_TXBF!!\n");
858 break;
859 case C2H_8192E_TX_REPORT:
860 RT_TRACE(rtlpriv, COMP_FW, DBG_TRACE ,
861 "[C2H], C2H_8723BE_TX_REPORT!\n");
862 break;
863 case C2H_8192E_BT_INFO:
864 RT_TRACE(rtlpriv, COMP_FW, DBG_TRACE,
865 "[C2H], C2H_8723BE_BT_INFO!!\n");
866 rtlpriv->btcoexist.btc_ops->btc_btinfo_notify(rtlpriv, tmp_buf,
867 c2h_cmd_len);
868 break;
869 case C2H_8192E_BT_MP:
870 RT_TRACE(rtlpriv, COMP_FW, DBG_TRACE,
871 "[C2H], C2H_8723BE_BT_MP!!\n");
872 break;
873 case C2H_8192E_RA_RPT:
874 _rtl92ee_c2h_ra_report_handler(hw, tmp_buf, c2h_cmd_len);
875 break;
876 default:
877 RT_TRACE(rtlpriv, COMP_FW, DBG_TRACE,
878 "[C2H], Unknown packet!! CmdId(%#X)!\n", c2h_cmd_id);
879 break;
880 }
881 }
882
883 void rtl92ee_c2h_packet_handler(struct ieee80211_hw *hw, u8 *buffer, u8 len)
884 {
885 struct rtl_priv *rtlpriv = rtl_priv(hw);
886 u8 c2h_cmd_id = 0, c2h_cmd_seq = 0, c2h_cmd_len = 0;
887 u8 *tmp_buf = NULL;
888
889 c2h_cmd_id = buffer[0];
890 c2h_cmd_seq = buffer[1];
891 c2h_cmd_len = len - 2;
892 tmp_buf = buffer + 2;
893
894 RT_TRACE(rtlpriv, COMP_FW, DBG_TRACE,
895 "[C2H packet], c2hCmdId=0x%x, c2hCmdSeq=0x%x, c2hCmdLen=%d\n",
896 c2h_cmd_id, c2h_cmd_seq, c2h_cmd_len);
897
898 RT_PRINT_DATA(rtlpriv, COMP_FW, DBG_TRACE,
899 "[C2H packet], Content Hex:\n", tmp_buf, c2h_cmd_len);
900
901 _rtl92ee_c2h_content_parsing(hw, c2h_cmd_id, c2h_cmd_len, tmp_buf);
902 }
Linux kernel - Deliverables
This page took 0.051687 seconds and 6 git commands to generate.